@Test public void runTestWithFailBeforeAsync() throws Exception { AtomicReference<AssertionError> failure = new AtomicReference<>(); BlockingQueue<Async> queue = new ArrayBlockingQueue<>(1); TestSuite suite = TestSuite.create("my_suite") .test( "my_test", context -> { try { context.fail(); } catch (AssertionError e) { failure.set(e); } queue.add(context.async()); }); TestReporter reporter = new TestReporter(); run(suite, reporter); reporter.await(); Async async = queue.poll(2, TimeUnit.SECONDS); async.complete(); assertTrue(reporter.completed()); assertEquals(0, reporter.exceptions.size()); assertEquals(1, reporter.results.size()); TestResult result = reporter.results.get(0); assertEquals("my_test", result.name()); assertFalse(result.succeeded()); assertTrue(result.failed()); assertNotNull(result.failure()); assertSame(failure.get(), result.failure().cause()); }
private void registerWrite() throws CancelledKeyException { int size = oqueue.size(); for (int i = 0; i < size; i++) { WebSocketImpl conn = oqueue.remove(); conn.key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE); } }
public static void main(String[] args) { final BlockingQueue<Character> bq; bq = new ArrayBlockingQueue<Character>(26); final ExecutorService executor = Executors.newFixedThreadPool(2); Runnable producer = () -> { for (char ch = 'A'; ch <= 'Z'; ch++) { try { bq.put(ch); System.out.printf("%c produced by " + "producer.%n", ch); } catch (InterruptedException ie) { } } }; executor.execute(producer); Runnable consumer = () -> { char ch = '\0'; do { try { ch = bq.take(); System.out.printf("%c consumed by " + "consumer.%n", ch); } catch (InterruptedException ie) { } } while (ch != 'Z'); executor.shutdownNow(); }; executor.execute(consumer); }
public static boolean tryWaitZkEventsCleaned(ZkClient zkclient) throws Exception { java.lang.reflect.Field field = getField(zkclient.getClass(), "_eventThread"); field.setAccessible(true); Object eventThread = field.get(zkclient); // System.out.println("field: " + eventThread); java.lang.reflect.Field field2 = getField(eventThread.getClass(), "_events"); field2.setAccessible(true); BlockingQueue queue = (BlockingQueue) field2.get(eventThread); // System.out.println("field2: " + queue + ", " + queue.size()); if (queue == null) { LOG.error("fail to get event-queue from zkclient. skip waiting"); return false; } for (int i = 0; i < 20; i++) { if (queue.size() == 0) { return true; } Thread.sleep(100); System.out.println("pending zk-events in queue: " + queue); } return false; }
@Test public void testLateRegisterSuccess() throws Exception { TestEventLoopGroup group = new TestEventLoopGroup(); try { ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.group(group); bootstrap.channel(LocalServerChannel.class); bootstrap.childHandler(new DummyHandler()); bootstrap.localAddress(new LocalAddress("1")); ChannelFuture future = bootstrap.bind(); assertFalse(future.isDone()); group.promise.setSuccess(); final BlockingQueue<Boolean> queue = new LinkedBlockingQueue<Boolean>(); future.addListener( new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { queue.add(future.channel().eventLoop().inEventLoop(Thread.currentThread())); queue.add(future.isSuccess()); } }); assertTrue(queue.take()); assertTrue(queue.take()); } finally { group.shutdownGracefully(); group.terminationFuture().sync(); } }
public void run() { while (true) { String message; try { message = messages.take(); for (Socket socket : sockets) { // if (socket.isClosed()); try { OutputStream out = socket.getOutputStream(); PrintWriter writer = new PrintWriter(out); writer.println(message); writer.flush(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } messages.clear(); } }
@Test public void receiveMessagesAckCheck() throws Exception { BlockingQueue<MmsMessage> q = new LinkedBlockingQueue<>(); Session s = connectNormally(msg -> q.add(msg)); t.send(new Broadcast().setSenderId("abc"), 1, 0); MmsMessage mm = q.poll(2, TimeUnit.SECONDS); assertEquals(1, mm.getMessageId()); assertEquals(0, mm.getLatestReceivedId()); assertEquals("abc", mm.cast(Broadcast.class).getSenderId()); // We need to acquire this lock to make sure we are out of the receiving loop (last ack adjusted s.receiveLock.lock(); s.receiveLock.unlock(); CompletableFuture<Void> cf = new CompletableFuture<>(); s.sendMessage(new Broadcast().setSenderId("cba"), cf); mm = t.t(); assertEquals(1, mm.getMessageId()); assertEquals(1, mm.getLatestReceivedId()); assertEquals("cba", mm.cast(Broadcast.class).getSenderId()); s.closeSession(MmsConnectionClosingCode.NORMAL); }
@Test(timeout = TIMEOUT) public void connectToLocalhost() throws InterruptedException { final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>(); socket = new Socket(createOptions()); socket.on( Socket.EVENT_OPEN, new Emitter.Listener() { @Override public void call(Object... args) { socket.on( Socket.EVENT_MESSAGE, new Emitter.Listener() { @Override public void call(Object... args) { values.offer(args[0]); socket.close(); } }); } }); socket.open(); assertThat((String) values.take(), is("hi")); }
@Test(timeout = TIMEOUT) public void receiveMultibyteUTF8StringsWithPolling() throws InterruptedException { final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>(); socket = new Socket(createOptions()); socket.on( Socket.EVENT_OPEN, new Emitter.Listener() { @Override public void call(Object... args) { socket.send("cash money €€€"); socket.on( Socket.EVENT_MESSAGE, new Emitter.Listener() { @Override public void call(Object... args) { if ("hi".equals(args[0])) return; values.offer(args[0]); socket.close(); } }); } }); socket.open(); assertThat((String) values.take(), is("cash money €€€")); }
@Override protected long runQueuePass() throws Exception { final CountDownLatch latch = new CountDownLatch(1); fizzBuzzQueueProcessor.reset(latch); Future<?>[] futures = new Future[NUM_EVENT_PROCESSORS]; futures[0] = executor.submit(fizzQueueProcessor); futures[1] = executor.submit(buzzQueueProcessor); futures[2] = executor.submit(fizzBuzzQueueProcessor); long start = System.currentTimeMillis(); for (long i = 0; i < ITERATIONS; i++) { Long value = Long.valueOf(i); fizzInputQueue.put(value); buzzInputQueue.put(value); } latch.await(); long opsPerSecond = (ITERATIONS * 1000L) / (System.currentTimeMillis() - start); fizzQueueProcessor.halt(); buzzQueueProcessor.halt(); fizzBuzzQueueProcessor.halt(); for (Future<?> future : futures) { future.cancel(true); } Assert.assertEquals(expectedResult, fizzBuzzQueueProcessor.getFizzBuzzCounter()); return opsPerSecond; }
@Test(timeout = TIMEOUT) public void notSendPacketsIfSocketCloses() throws InterruptedException { final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>(); socket = new Socket(createOptions()); socket.on( Socket.EVENT_OPEN, new Emitter.Listener() { @Override public void call(Object... args) { final boolean[] noPacket = new boolean[] {true}; socket.on( Socket.EVENT_PACKET_CREATE, new Emitter.Listener() { @Override public void call(Object... args) { noPacket[0] = false; } }); socket.close(); Timer timer = new Timer(); timer.schedule( new TimerTask() { @Override public void run() { values.offer(noPacket[0]); } }, 1200); } }); socket.open(); assertThat((Boolean) values.take(), is(true)); }
/** {@inheritDoc} */ public void destroy() { started.set(false); destroyed.set(true); releaseExternalResources(); if (notifierFuture != null) { notifierFuture.cancel(true); } if (asyncWriteFuture != null) { asyncWriteFuture.cancel(true); } if (bc != null) { bc.destroy(); } if (broadcasterCache != null) { broadcasterCache.stop(); } resources.clear(); broadcastOnResume.clear(); messages.clear(); asyncWriteQueue.clear(); delayedBroadcast.clear(); broadcasterCache = null; if (BroadcasterFactory.getDefault() != null) { BroadcasterFactory.getDefault().remove(this, name); } if (currentLifecycleTask != null) { currentLifecycleTask.cancel(true); } }
@Test public void testAssertAsyncFailureHandlerSucceededAsync() throws Exception { BlockingQueue<Handler<AsyncResult<String>>> handlerQueue = new ArrayBlockingQueue<>(1); BlockingQueue<Async> resultQueue = new ArrayBlockingQueue<>(1); TestSuite suite = TestSuite.create("my_suite") .test( "my_test", context -> { handlerQueue.add( context.<String>asyncAssertFailure( r -> { resultQueue.add(context.async()); })); }); TestReporter reporter = new TestReporter(); run(suite, reporter); Handler<AsyncResult<String>> handler = handlerQueue.poll(2, TimeUnit.SECONDS); handler.handle(Future.failedFuture(new Throwable())); Async result = resultQueue.poll(2, TimeUnit.SECONDS); assertFalse(reporter.completed()); result.complete(); reporter.await(); assertEquals(0, reporter.exceptions.size()); assertEquals(1, reporter.results.size()); assertEquals("my_test", reporter.results.get(0).name()); assertFalse(reporter.results.get(0).failed()); }
@Test public void runTestWithAsyncCompletion() throws Exception { BlockingQueue<Async> queue = new ArrayBlockingQueue<>(1); AtomicInteger count = new AtomicInteger(); TestSuite suite = TestSuite.create("my_suite") .test( "my_test", context -> { count.compareAndSet(0, 1); queue.add(context.async()); }); TestReporter reporter = new TestReporter(); run(suite, reporter); Async async = queue.poll(2, TimeUnit.SECONDS); assertEquals(1, count.get()); assertFalse(reporter.completed()); completeAsync.accept(async); reporter.await(); assertTrue(reporter.completed()); assertEquals(0, reporter.exceptions.size()); assertEquals(1, reporter.results.size()); TestResult result = reporter.results.get(0); assertEquals("my_test", result.name()); assertTrue(result.succeeded()); assertFalse(result.failed()); assertNull(result.failure()); }
@Test public void testBasicHandling() throws IOException, InterruptedException { final List<String> messages = new ArrayList<>(); messages.add("1 syslog 20 this is message 1234\n"); messages.add("2 syslog 22 this is message 456789\n"); messages.add("3 syslog 21 this is message ABCDE\n"); run(messages); Assert.assertEquals(messages.size(), events.size()); boolean found1 = false; boolean found2 = false; boolean found3 = false; TestEvent event; while ((event = events.poll()) != null) { Map<String, String> metadata = event.metadata; Assert.assertTrue(metadata.containsKey(RELPMetadata.TXNR_KEY)); final String txnr = metadata.get(RELPMetadata.TXNR_KEY); if (txnr.equals("1")) { found1 = true; } else if (txnr.equals("2")) { found2 = true; } else if (txnr.equals("3")) { found3 = true; } } Assert.assertTrue(found1); Assert.assertTrue(found2); Assert.assertTrue(found3); }
@Test(timeout = TIMEOUT) public void receiveEmoji() throws InterruptedException { final BlockingQueue<Object> values = new LinkedBlockingQueue<Object>(); socket = new Socket(createOptions()); socket.on( Socket.EVENT_OPEN, new Emitter.Listener() { @Override public void call(Object... args) { socket.send("\uD800-\uDB7F\uDB80-\uDBFF\uDC00-\uDFFF\uE000-\uF8FF"); socket.on( Socket.EVENT_MESSAGE, new Emitter.Listener() { @Override public void call(Object... args) { if ("hi".equals(args[0])) return; values.offer(args[0]); socket.close(); } }); } }); socket.open(); assertThat((String) values.take(), is("\uD800-\uDB7F\uDB80-\uDBFF\uDC00-\uDFFF\uE000-\uF8FF")); }
/** * Passes image to fully-qualified name. * * @param instanceId * @param fullInName * @param image */ public void put(String instanceId, String outName, String fullInName, ItemWrapper item) { // show debugging information if (null != m_debugger) { String inName = fullInName; int index = fullInName.indexOf('.'); if (index > 0) { inName = fullInName.substring(++index); } DebugInfo debugInfo = new DebugInfo(instanceId, outName + " to " + inName, item); m_debugger.addDebugInfo(debugInfo); } boolean success = false; BlockingQueue<ItemWrapper> queue = getQueue(fullInName); // TODO currently using an unlimited LinkedBlockingQueue, so will never block while (!success) { try { success = queue.offer(item, 100, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException("Put interrupted"); } if (m_quit) { throw new TeardownException("Teardown"); } } }
/** * Drains the queue as {@link java.util.concurrent.BlockingQueue#drainTo(java.util.Collection, * int)}, but if the requested {@code numElements} elements are not available, it will wait for * them up to the specified timeout. * * @param q the blocking queue to be drained * @param buffer where to add the transferred elements * @param numElements the number of elements to be waited for * @param timeout how long to wait before giving up, in units of {@code unit} * @param unit a {@code TimeUnit} determining how to interpret the timeout parameter * @return the number of elements transferred * @throws InterruptedException if interrupted while waiting */ @Beta public static <E> int drain( BlockingQueue<E> q, Collection<? super E> buffer, int numElements, long timeout, TimeUnit unit) throws InterruptedException { Preconditions.checkNotNull(buffer); /* * This code performs one System.nanoTime() more than necessary, and in return, the time to * execute Queue#drainTo is not added *on top* of waiting for the timeout (which could make * the timeout arbitrarily inaccurate, given a queue that is slow to drain). */ long deadline = System.nanoTime() + unit.toNanos(timeout); int added = 0; while (added < numElements) { // we could rely solely on #poll, but #drainTo might be more efficient when there are multiple // elements already available (e.g. LinkedBlockingQueue#drainTo locks only once) added += q.drainTo(buffer, numElements - added); if (added < numElements) { // not enough elements immediately available; will have to poll E e = q.poll(deadline - System.nanoTime(), TimeUnit.NANOSECONDS); if (e == null) { break; // we already waited enough, and there are no more elements in sight } buffer.add(e); added++; } } return added; }
@Test public void sendMessageCompletable() throws Exception { BlockingQueue<MmsMessage> q = new LinkedBlockingQueue<>(); Session s = connectNormally(msg -> q.add(msg)); CompletableFuture<Void> cf = new CompletableFuture<>(); s.sendMessage(new Broadcast().setSenderId("abc"), cf); t.t(); // take and ignore t.send(new Broadcast().setSenderId("abc"), 1, 1); cf.get(2, TimeUnit.SECONDS); for (int i = 2; i < 100; i++) { cf = new CompletableFuture<>(); s.sendMessage(new Broadcast().setSenderId("abc" + i), cf); MmsMessage mm = t.t(); assertEquals(i, mm.getMessageId()); t.send(new Broadcast().setSenderId("abc"), i, mm.getMessageId()); cf.get(2, TimeUnit.SECONDS); } // if this breaks it is a timeing issue, just keep trying until its 99 assertEquals(99, s.latestReceivedId); s.closeSession(MmsConnectionClosingCode.NORMAL); }
/** * Updates concerning switch disconnect and port down are not processed. LinkDiscoveryManager is * expected to process those messages and send multiple link removed messages. However, all the * updates from LinkDiscoveryManager would be propagated to the listeners of topology. */ @LogMessageDoc( level = "ERROR", message = "Error reading link discovery update.", explanation = "Unable to process link discovery update", recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG) public void applyUpdates() { appliedUpdates.clear(); LDUpdate update = null; while (ldUpdates.peek() != null) { try { update = ldUpdates.take(); } catch (Exception e) { log.error("Error reading link discovery update.", e); } if (log.isTraceEnabled()) { log.trace("Applying update: {}", update); } if (update.getOperation() == UpdateOperation.LINK_UPDATED) { addOrUpdateLink( update.getSrc(), update.getSrcPort(), update.getDst(), update.getDstPort(), update.getType()); } else if (update.getOperation() == UpdateOperation.LINK_REMOVED) { removeLink( update.getSrc(), update.getSrcPort(), update.getDst(), update.getDstPort()); } // Add to the list of applied updates. appliedUpdates.add(update); } }
@Listener public void onGamePreInitializationEvent(GamePreInitializationEvent event) { if (game.getPlatform().getType() == Platform.Type.SERVER) { try { game.getServiceManager() .setProvider(this, IRegistrationService.class, new SimpleRegistrationService()); } catch (IllegalArgumentException e) { e.printStackTrace(); } game.getScheduler() .createTaskBuilder() .execute( (task) -> { try { if (!requestQueue.isEmpty()) requestQueue.take().run(); } catch (InterruptedException e) { e.printStackTrace(); } }) .name("FDS-WSAPI - CheckRequestsTask") .delayTicks(50) .interval(1, TimeUnit.MILLISECONDS) .submit(this); } }
public static void streaming(String... track) throws InterruptedException { BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10000); StatusesFilterEndpoint endpoint = new StatusesFilterEndpoint(); // add some track terms endpoint.trackTerms(Lists.newArrayList(track)); // Create a new BasicClient. By default gzip is enabled. Client client = new ClientBuilder() .hosts(Constants.STREAM_HOST) .endpoint(endpoint) .authentication(auth) .processor(new StringDelimitedProcessor(queue)) .build(); // Establish a connection client.connect(); // Do whatever needs to be done with messages for (int msgRead = 0; msgRead < 1000; msgRead++) { String msg = queue.take(); System.out.println(msg); } client.stop(); }
/** * Data event callback. * * @param data The data object * @param workerThreadId The worker thread identifier */ @Override public synchronized void onDataArrival(Object data, String workerThreadId) { Guard.check(data, workerThreadId); LocalControllerDataTransporter monitoringData = (LocalControllerDataTransporter) data; String localControllerId = monitoringData.getLocalControllerId(); if (localControllerIds_.get(workerThreadId) == null) { log_.debug( String.format( "No mapping exists for this worker thread! Adding %s to %s mapping", workerThreadId, localControllerId)); localControllerIds_.put(workerThreadId, localControllerId); } if (monitoringData.getData() == null) { // log_.debug(String.format("Ignoring received heartbeat data from %s!", workerThreadId)); dataQueue_.add(monitoringData); // return; } log_.debug( String.format( "Worker thread: %s received local controller summary information from: %s", workerThreadId, localControllerId)); if (stateMachine_.isBusy() && !monitoringData.getState().equals(LocalControllerState.STABLE)) { log_.debug( "System is BUSY! Skipping overloaded/underloaded local controller monitoring data!"); return; } log_.debug( String.format( "Adding local controller %s summary information for to the queue", localControllerId)); dataQueue_.add(monitoringData); }
public void testConsumerCancellationInterruptsQueuingConsumerWait() throws IOException, InterruptedException { final BlockingQueue<Boolean> result = new ArrayBlockingQueue<Boolean>(1); channel.queueDeclare(queue, false, true, false, null); final QueueingConsumer consumer = new QueueingConsumer(channel); Runnable receiver = new Runnable() { public void run() { try { try { consumer.nextDelivery(); } catch (ConsumerCancelledException e) { result.put(true); return; } catch (ShutdownSignalException e) { } catch (InterruptedException e) { } result.put(false); } catch (InterruptedException e) { fail(); } } }; Thread t = new Thread(receiver); t.start(); channel.basicConsume(queue, consumer); channel.queueDelete(queue); assertTrue(result.take()); t.join(); }
@Test public void testPoll3() throws InterruptedException { // 插入1条消息 String myType = TYPE + "_"; SwallowMessage myTypeMsg = createMessage(); myTypeMsg.setType(myType); messageDAO.saveMessage(TOPIC_NAME, myTypeMsg); Set<String> messageTypeSet = new HashSet<String>(); messageTypeSet.add(myType); ConsumerInfo consumerInfo = new ConsumerInfo( "consumerId", Destination.topic(TOPIC_NAME), ConsumerType.DURABLE_AT_LEAST_ONCE); BlockingQueue<SwallowMessage> queue = swallowBuffer.createMessageQueue( consumerInfo, tailMessageId, tailMessageId, MessageFilter.createInSetMessageFilter(messageTypeSet)); SwallowMessage m = queue.poll(500, TimeUnit.MILLISECONDS); while (m == null) { m = queue.poll(50, TimeUnit.MILLISECONDS); } Assert.assertEquals(myType, m.getType()); }
public boolean putMessage(String message, long timeout) { BufferListener listener = listenerRef.get(); if (listener != null) { try { if (queue.size() == 0) { return listener.onMessage(message); } else { ArrayList<String> messages = new ArrayList<String>(queue.size() + 1); queue.drainTo(messages); messages.add(message); return listener.onMessages(messages); } } catch (Throwable t) { return false; } } else { try { if (!inputSemaphore.tryAcquire(message.length(), timeout, TimeUnit.MILLISECONDS)) { return false; } queue.offer(message); return true; } catch (InterruptedException e) { return false; } } }
/** 将数据提交到运营商 */ private void startSubmitData() { while (isContinue) { List<SmQueue> tempList = new LinkedList<SmQueue>(); try { // 每晚23:58分暂停操作 if (ConstantUtils.isPause_23_58()) { Thread.sleep(10 * 60 * 1000); } if (queue.size() >= (smgFlowLimit / 2) || isDrainTo()) { int num = queue.drainTo(tempList, (smgFlowLimit / 2)); lastDrainToTime = System.currentTimeMillis(); if (num > 0) { submitDataThreadPool.execute(new SubmitChildThread(tempList, channel)); } } else { Thread.sleep(1000); } } catch (InterruptedException e1) { } } }
@Test(timeout = 60000) public void testAppRejectionWithCancelledDelegationToken() throws Exception { MyFS dfs = (MyFS) FileSystem.get(conf); LOG.info("dfs=" + (Object) dfs.hashCode() + ";conf=" + conf.hashCode()); MyToken token = dfs.getDelegationToken(new Text("user1")); token.cancelToken(); Credentials ts = new Credentials(); ts.addToken(token.getKind(), token); // register the tokens for renewal ApplicationId appId = BuilderUtils.newApplicationId(0, 0); delegationTokenRenewer.addApplication(appId, ts, true, false); int waitCnt = 20; while (waitCnt-- > 0) { if (!eventQueue.isEmpty()) { Event evt = eventQueue.take(); if (evt.getType() == RMAppEventType.APP_REJECTED) { Assert.assertTrue(((RMAppEvent) evt).getApplicationId().equals(appId)); return; } } else { Thread.sleep(500); } } fail("App submission with a cancelled token should have failed"); }
@Override public void observe(Event event) { if (event instanceof MoveSelectedEvent) { Move theMove = ((MoveSelectedEvent) event).getMove(); if (theQueue.size() < 2) { theQueue.add(theMove); } } else if (event instanceof ServerNewGameStateEvent) { stateFromServer = ((ServerNewGameStateEvent) event).getState(); } else if (event instanceof ServerCompletedMatchEvent) { theGUI.updateGameState(stateFromServer); List<Role> theRoles = getStateMachine().getRoles(); List<Integer> theGoals = ((ServerCompletedMatchEvent) event).getGoals(); StringBuilder finalMessage = new StringBuilder(); finalMessage.append("Goals: "); for (int i = 0; i < theRoles.size(); i++) { finalMessage.append(theRoles.get(i)); finalMessage.append(" = "); finalMessage.append(theGoals.get(i)); if (i < theRoles.size() - 1) { finalMessage.append(", "); } } theGUI.showFinalMessage(finalMessage.toString()); } }
@Test public void runTestWithFailAfterAsync() throws Exception { RuntimeException failure = new RuntimeException(); BlockingQueue<Async> queue = new ArrayBlockingQueue<>(1); TestSuite suite = TestSuite.create("my_suite") .test( "my_test", context -> { queue.add(context.async()); throw failure; }); TestReporter reporter = new TestReporter(); run(suite, reporter); reporter.await(); Async async = queue.poll(2, TimeUnit.SECONDS); async.complete(); assertTrue(reporter.completed()); assertEquals(0, reporter.exceptions.size()); assertEquals(1, reporter.results.size()); TestResult result = reporter.results.get(0); assertEquals("my_test", result.name()); assertFalse(result.succeeded()); assertTrue(result.failed()); assertNotNull(result.failure()); assertSame(failure, result.failure().cause()); }