ListenableFuture<SessionDescription> createOffer() {
    return Futures.transformAsync(getPeerConnectionFuture(), peerConnection -> {
        final SettableFuture<SessionDescription> future = SettableFuture.create();
        peerConnection.createOffer(new CreateSdpObserver() {
            @Override
            public void onCreateSuccess(SessionDescription sessionDescription) {
                future.set(sessionDescription);
            }

            @Override
            public void onCreateFailure(String s) {
                future.setException(new IllegalStateException("Unable to create offer: " + s));
            }
        }, new MediaConstraints());
        return future;
    }, MoreExecutors.directExecutor());
}
 

/**
 * Clean up the internal state of this context. This will normally happen on a
 * session close
 */
public void reset() {

  // TODO clean text editor
  for (WaveContext wc : waveRegistry.values())
    wc.close();

  waveRegistry.clear();

  if (websocketClient != null) {
    websocketClient.stop(false);
    websocketClient = null;
  }

  serviceMultiplexerFuture = SettableFuture.<RemoteViewServiceMultiplexer> create();

  if (serviceSession != null) {
    serviceSession.destroy();
    serviceSession = null;
  }

}
 

private void waitForSomeNetworkToConnect() throws Exception {
  final SettableFuture<Void> future = SettableFuture.create();

  ConnectivityManager.NetworkCallback cb =
      new ConnectivityManager.NetworkCallback() {
        @Override
        public void onAvailable(Network network) {
          NetworkInfo netInfo = connManager.getNetworkInfo(network);
          if (netInfo != null && netInfo.isConnected()) {
            future.set(null);
          }
        }
      };

  connManager.requestNetwork(
      new NetworkRequest.Builder().addCapability(NET_CAPABILITY_INTERNET).build(), cb);

  try {
    future.get(NETWORK_STATE_CHANGE_TIMEOUT_SECONDS, TimeUnit.SECONDS);
  } finally {
    connManager.unregisterNetworkCallback(cb);
  }
}
 

@Test
public void invokeServiceByteRequestObjectTest() throws Exception {
  MyObject resultObj = new MyObject(1, "Value");
  SettableFuture<CommonProtos.InvokeResponse> settableFuture = SettableFuture.create();
  MockCallback<CommonProtos.InvokeResponse> callback =
      new MockCallback<CommonProtos.InvokeResponse>(CommonProtos.InvokeResponse.newBuilder()
          .setData(getAny(resultObj)).build());
  addCallback(settableFuture, callback, directExecutor());
  settableFuture.set(CommonProtos.InvokeResponse.newBuilder().setData(getAny(resultObj)).build());
  when(client.invokeService(any(DaprProtos.InvokeServiceRequest.class)))
      .thenReturn(settableFuture);
  String request = "Request";
  byte[] byteRequest = serializer.serialize(request);
  Mono<byte[]> result = adapter.invokeService(Verb.GET, "appId", "method", byteRequest, byte[].class);
  byte[] byteOutput = result.block();
  assertEquals(resultObj, serializer.deserialize(byteOutput, MyObject.class));
}
 

public ESDeleteTask(UUID jobId,
                    ESDeleteNode node,
                    TransportDeleteAction transport,
                    JobContextService jobContextService) {
    super(jobId, node.executionPhaseId(), node.docKeys().size(), jobContextService);
    List<DeleteRequest> requests = new ArrayList<>(node.docKeys().size());
    List<ActionListener> listeners = new ArrayList<>(node.docKeys().size());
    for (DocKeys.DocKey docKey : node.docKeys()) {
        DeleteRequest request = new DeleteRequest(
                ESGetTask.indexName(node.tableInfo(), docKey.partitionValues()),
                Constants.DEFAULT_MAPPING_TYPE, docKey.id());
        request.routing(docKey.routing());
        if (docKey.version().isPresent()) {
            request.version(docKey.version().get());
        }
        requests.add(request);
        SettableFuture<TaskResult> result = SettableFuture.create();
        results.add(result);
        listeners.add(new DeleteResponseListener(result));
    }

    createContext("delete", requests, listeners, transport, null);
}
 

/** Converts an {@see ApiFuture} to a {@see ListenableFuture}. */
public static <T> ListenableFuture<T> apiFutureToListenableFuture(final ApiFuture<T> apiFuture) {
  SettableFuture<T> settableFuture = SettableFuture.create();
  ApiFutures.addCallback(
      apiFuture,
      new ApiFutureCallback<T>() {
        @Override
        public void onFailure(Throwable t) {
          settableFuture.setException(t);
        }

        @Override
        public void onSuccess(T result) {
          settableFuture.set(result);
        }
      });
  return settableFuture;
}
 

@NotNull
@Override
public ListenableFuture<Void> distributeToNonSharedSubscribers(@NotNull final Map<String, SubscriberWithIdentifiers> subscribers,
                                                               @NotNull final PUBLISH publish, @NotNull final ExecutorService executorService) {

    final ImmutableList.Builder<ListenableFuture<Void>> publishResultFutureBuilder = ImmutableList.builder();

    for (final Map.Entry<String, SubscriberWithIdentifiers> entry : subscribers.entrySet()) {
        final SubscriberWithIdentifiers subscriber = entry.getValue();

        final ListenableFuture<PublishStatus> publishFuture = sendMessageToSubscriber(publish, entry.getKey(), subscriber.getQos(),
                false, subscriber.isRetainAsPublished(), subscriber.getSubscriptionIdentifier());

        final SettableFuture<Void> publishFinishedFuture = SettableFuture.create();
        publishResultFutureBuilder.add(publishFinishedFuture);
        Futures.addCallback(publishFuture, new StandardPublishCallback(entry.getKey(), publish, publishFinishedFuture), executorService);
    }

    return FutureUtils.voidFutureFromList(publishResultFutureBuilder.build());
}
 

private ListenableFuture<T> future(Matcher<? super T> matcher) {
  SettableFuture<T> finished = SettableFuture.create();

  fiber.execute(() -> {
    synchronized (messageLog) {
      for (T element : messageLog) {
        if (matcher.matches(element)) {
          finished.set(element);
          return;
        }
      }
    }
    waitingToMatch.put(matcher, finished);
  });

  return finished;
}
 

@Test
public void test_void_future_from_list() throws Exception {
    final SettableFuture<Void> future1 = SettableFuture.create();
    final SettableFuture<Void> future2 = SettableFuture.create();

    final ImmutableList.Builder<ListenableFuture<Void>> builder = ImmutableList.builder();


    builder.add(future1).add(future2);
    final ListenableFuture<Void> resultFuture = FutureUtils.voidFutureFromList(builder.build());
    assertEquals(false, resultFuture.isDone());
    future1.set(null);
    assertEquals(false, resultFuture.isDone());
    future2.set(null);
    assertEquals(true, resultFuture.isDone());
}
 

@Test
public void testTraverseExceptionInDeleteQueueItems() throws Exception {
  SettableFuture<Operation> result = SettableFuture.create();
  result.setException(new ExecutionException("outer", new IOException("inner")));
  doAnswer(invocation -> result).when(indexingServiceMock).deleteQueueItems(any());
  when(repositoryMock.getAllDocs(null))
      .thenReturn(
          new CheckpointCloseableIterableImpl.Builder<>(Collections.<ApiOperation>emptyList())
          .build());
  setConfig("0", DefaultAclChoices.PUBLIC);
  FullTraversalConnector connector =
      new FullTraversalConnector(repositoryMock, checkpointHandlerMock);
  connector.init(connectorContextMock);
  // No exception thrown.
  connector.traverse();
}
 

@Test
public void shouldNotBlockOnUnterminatedInputFuture() throws Exception {
  Input<String> nonTerminating = Input.named("nonTerminating");
  Input<String> failing = Input.named("failing");

  RuntimeException expected = new RuntimeException("expected");

  SettableFuture<String> nonFuture = SettableFuture.create();
  ListenableFuture<String> failFuture = immediateFailedFuture(expected);

  Func2<String, String, String> func = new Func2<String, String, String>() {
    @Override
    public ListenableFuture<String> run(@Nullable String arg1, @Nullable String arg2) {
      return immediateFuture(arg1 + arg2);
    }
  };

  Graph<String> g = call(func).with(nonTerminating, failing);

  thrown.expect(hasAncestor(expected));

  g.bind(failing, failFuture).bind(nonTerminating, nonFuture).run().get();
}
 

@Test(timeout = 10_000)
public void verifyFolderIsIgnored() throws Exception {
	CloseableHttpResponse response = mock(CloseableHttpResponse.class);
	when(response.getFirstHeader(eq("X-Consul-Index"))).thenReturn(new BasicHeader("X-Consul-Index", "1000"));
	when(response.getStatusLine()).thenReturn(createStatus(200, "OK"));
	when(response.getEntity()).thenReturn(toJson(ImmutableMap.of("some-prefix/oauth/", "some-value",
			"some-prefix/oauth/some.key", "some-value")));

	when(http.execute(any())).thenReturn(response);

	SettableFuture<Properties> future = SettableFuture.create();
	ConfigUpdater updater = new ConfigUpdater(executor, http, null, null, id, objectMapper, null, future::set,
			"some-prefix");

	updater.run();

	Properties properties = future.get();
	assertEquals(properties.keySet(), Sets.newHashSet("some.key"));
}
 

@Override
public SettableFuture<String> method(List<String> methods) {
    final SettableFuture<String> future = SettableFuture.create();
    if (methods.size() == 1) {
        future.set(methods.get(0));
    } else {
        final MaterialDialog.Builder builder = UI.popup(activity, R.string.id_choose_method_to_authorize_the)
                                               .cancelable(false)
                                               .items(methods)
                                               .itemsCallbackSingleChoice(0, (dialog, v, which, text) -> {
            Log.d("RSV", "PopupMethodResolver CHOOSE callback");
            future.set(methods.get(which));
            return true;
        })
                                               .onNegative((dialog, which) -> {
            Log.d("RSV", "PopupMethodResolver CANCEL callback");
            future.set(null);
        });
        activity.runOnUiThread(() -> {
            Log.d("RSV", "PopupMethodResolver dialog show");
            builder.show();
        });
    }
    return future;
}
 

@Test
public void testWriteEditsOneSlow() throws Exception {
  EditLogOutputStream stm = createLogSegment();
  writeOp(stm, 1);
  stm.setReadyToFlush();
  
  // Make the first two logs respond immediately
  futureReturns(null).when(spyLoggers.get(0)).sendEdits(
      anyLong(), eq(1L), eq(1), Mockito.<byte[]>any());
  futureReturns(null).when(spyLoggers.get(1)).sendEdits(
      anyLong(), eq(1L), eq(1), Mockito.<byte[]>any());
  
  // And the third log not respond
  SettableFuture<Void> slowLog = SettableFuture.create();
  Mockito.doReturn(slowLog).when(spyLoggers.get(2)).sendEdits(
      anyLong(), eq(1L), eq(1), Mockito.<byte[]>any());
  stm.flush();
  
  Mockito.verify(spyLoggers.get(0)).setCommittedTxId(1L);
}
 

@Override
public ListenableFuture<Void> onParticipantAdded(WaveletName waveletName, ParticipantId user) {
  Multimap<WaveId, WaveletId> perUserView = explicitPerUserWaveViews.getIfPresent(user);
  if (perUserView != null) {
    if (!perUserView.containsEntry(waveletName.waveId, waveletName.waveletId)) {
      perUserView.put(waveletName.waveId, waveletName.waveletId);
      if(LOG.isFineLoggable()) {
        LOG.fine("Added wavelet: " + waveletName + " to the view of user: " + user.getAddress());
        LOG.fine("View size is now: " + perUserView.size());
      }
    }
  }
  SettableFuture<Void> task = SettableFuture.create();
  task.set(null);
  return task;
}
 

public SettableFuture<Tuple2<Map<String, Long>, Map<String, Long>>> getFees(FeeProvider provider) {
    final SettableFuture<Tuple2<Map<String, Long>, Map<String, Long>>> resultFuture = SettableFuture.create();
    ListenableFuture<Tuple2<Map<String, Long>, Map<String, Long>>> future = executorService.submit(() -> {
        Thread.currentThread().setName("FeeRequest-" + provider.toString());
        return provider.getFees();
    });

    Futures.addCallback(future, new FutureCallback<Tuple2<Map<String, Long>, Map<String, Long>>>() {
        public void onSuccess(Tuple2<Map<String, Long>, Map<String, Long>> feeData) {
            log.debug("Received feeData of {}\nfrom provider {}", feeData, provider);
            resultFuture.set(feeData);
        }

        public void onFailure(@NotNull Throwable throwable) {
            resultFuture.setException(throwable);
        }
    });

    return resultFuture;
}
 

@Override
public void userEventTriggered(final ChannelHandlerContext ctx, final Object evt) throws Exception {

    final PUBLISH publish;
    final SettableFuture<PublishStatus> statusFuture;
    if (evt instanceof PublishWithFuture) {
        publish = ((PublishWithFuture) evt);
        statusFuture = ((PublishWithFuture) evt).getFuture();
        writePublish(ctx, publish, statusFuture);
    } else if (evt instanceof PUBLISH) {
        publish = (PUBLISH) evt;
        writePublish(ctx, publish, null);
    } else {
        super.userEventTriggered(ctx, evt);
    }

}
 

@Override
public ListenableFuture<List<Client>> startClients() {
  SettableFuture<List<Client>> future = SettableFuture.create();
  executor.execute(
      () -> {
        List<Client> toReturn = new ArrayList<>();
        for (int i = 0; i < numWorkers; i++) {
          try {
            Integer port = getPort();
            runClientProcess(params.getClientType(), port);
            toReturn.add(new Client("localhost", params, executor, port));
          } catch (Exception e) {
            future.setException(e);
            return;
          }
        }

        future.set(toReturn);
      });
  return future;
}
 

@Test
public void testGetDocRepositoryDoc() throws Exception {
  setDefaultConfig();
  Item polledItem = new Item().setName("docId");
  SettableFuture<Item> updateFuture = SettableFuture.create();
  doAnswer(
          invocation -> {
            updateFuture.set(new Item());
            return updateFuture;
          })
      .when(mockIndexingService)
      .indexItem(polledItem, RequestMode.UNSPECIFIED);
  when(mockRepository.getDoc(polledItem))
      .thenReturn(new RepositoryDoc.Builder().setItem(polledItem).build());
  ListingConnector connector = new ListingConnector(mockRepository);
  connector.init(mockConnectorContext);
  connector.process(polledItem);
  verify(mockIndexingService).indexItem(polledItem, RequestMode.UNSPECIFIED);
}
 

@Test(timeOut = 10_000)
public void testCreateFrom()
{
    SettableFuture<?> future = SettableFuture.create();
    List<ProcessState<Integer>> scenario = ImmutableList.of(
            ProcessState.yield(),
            ProcessState.ofResult(1),
            ProcessState.blocked(future),
            ProcessState.yield(),
            ProcessState.ofResult(2),
            ProcessState.finished());
    WorkProcessor<Integer> processor = processorFrom(scenario);

    // before
    assertFalse(processor.isBlocked());
    assertFalse(processor.isFinished());

    assertYields(processor);
    assertResult(processor, 1);
    assertBlocks(processor);
    assertUnblocks(processor, future);
    assertYields(processor);
    assertResult(processor, 2);
    assertFinishes(processor);
}
 

public synchronized ListenableFuture<?> offer(T element)
{
    requireNonNull(element);

    if (finishing && borrowerCount == 0) {
        return immediateFuture(null);
    }
    elements.add(element);
    int newSize = elements.size();
    if (newSize == 1) {
        completeAsync(executor, notEmptySignal);
        notEmptySignal = SettableFuture.create();
    }
    if (newSize >= targetQueueSize) {
        return notFullSignal;
    }
    return immediateFuture(null);
}
 

default <T> ListenableFuture<T> submit(ThrowingRunnable<?> task, T result, @Nullable StackTrace source) {
    final SettableFuture<T> future = SettableFuture.create();
    executeCatch(() -> {
        try {
            task.runThrows();
        } catch(Throwable ex) {
            future.setException(ex);
            throw ex;
        }
        future.set(result);
    }, source);
    return future;
}
 

@Test
public void testCancel() throws Exception {
	stageAlerting(PanicAlarm.NAME);
	expectCancelIncidentAndReturn(SettableFuture.<Void>create(), stageAlarmIncident(PanicAlarm.NAME));
	start();
	
	cancel();
	assertQuietSent();
}
 

@Test
@Ignore
public void testAddServiceListener() throws Exception {
   Address destination = Address.fromString("PROT:ZWAV-ABC-1234:" + ProtocolDeviceId.fromBytes(new byte [] { 22 }).getRepresentation());
   ProtocolMessage protocolMessage = ProtocolMessage.createProtocolMessage(
         Address.fromString("DRIV:dev:6ff3a5ff-4650-4ce7-82e0-682a58392316"),
         destination,
         ZWaveProtocol.INSTANCE,
         new ZWaveCommandMessage()
   );
   final SettableFuture<Boolean> future = SettableFuture.create();
   ProtocolBusService protocolBusService = ServiceLocator.getInstance(ProtocolBusService.class);
   protocolBusService.addProtocolListener(new ProtocolBusListener() {

      @Override
      public void onMessage(ClientToken ct, ProtocolMessage msg) {
         try {
            Assert.assertEquals("Client Token key should be hub ID", "ABC-1234", ct.getRepresentation());
            Assert.assertEquals("PROT:ZWAV-ABC-1234:FgAAAAAAAAAAAAAAAAAAAAAAAAA=", msg.getDestination().getRepresentation());
            Assert.assertEquals("DRIV:dev:6ff3a5ff-4650-4ce7-82e0-682a58392316", msg.getSource().getRepresentation());
            Assert.assertEquals(destination, msg.getDestination());
            future.set(true);
         }
         catch(Throwable t) {
            future.setException(t);
         }
      }

   });

   protocolBus.send(protocolMessage);
   boolean messageReceivedFlag = future.get(300, TimeUnit.MILLISECONDS);

   Assert.assertTrue("Message should have arrived.", messageReceivedFlag);
}
 

/** Sends a getaddr request to the peer and returns a future that completes with the answer once the peer has replied. */
public ListenableFuture<AddressMessage> getAddr() {
    SettableFuture<AddressMessage> future = SettableFuture.create();
    synchronized (getAddrFutures) {
        getAddrFutures.add(future);
    }
    sendMessage(new GetAddrMessage(params));
    return future;
}
 

private void runProducer() {
	new Thread(new Runnable() {
		@Override
		public void run() {
			Producer p = lookup(Producer.class);

			for (;;) {
				SettableFuture<SendResult> future = (SettableFuture<SendResult>) p.message(TOPIC, null, sendCount.get())
				      .send();

				Futures.addCallback(future, new FutureCallback<SendResult>() {
					@Override
					public void onSuccess(SendResult result) {
						sendCount.addAndGet(1);
					}

					@Override
					public void onFailure(Throwable t) {
						sendCount.addAndGet(1);
					}
				});

				// try {
				// Thread.sleep(1);
				// } catch (InterruptedException e) {
				// e.printStackTrace();
				// }
			}
		}
	}).start();
}
 

@Override
public void online(StatusSource src) {
    synchronized (onlineSwitcher) {
        onlineSwitcher.on(src);
        final SettableFuture<Boolean> future = this.onlineFuture;
        if (future == null) return;
        future.set(true);
    }
    LOGGER.info("pullconsumer online. subject={}, group={}", getSubject(), getConsumerGroup());
    pullEntryMap.values().forEach(pe -> pe.online(src));
}
 

@Test
public void publishEventObjectTest() {
  SettableFuture<Empty> settableFuture = SettableFuture.create();
  MockCallback<Empty> callback = new MockCallback<Empty>(Empty.newBuilder().build());
  addCallback(settableFuture, callback, directExecutor());
  when(client.publishEvent(any(DaprProtos.PublishEventRequest.class)))
      .thenReturn(settableFuture);
  MyObject event = new MyObject(1, "Event");
  Mono<Void> result = adapter.publishEvent("topic", event);
  settableFuture.set(Empty.newBuilder().build());
  result.block();
  assertTrue(callback.wasCalled);
}
 

@Override
public void onResponse(final Response response) throws IOException
{
    final Object tag = response.request().tag();
    checkState(tag != null, "saw a request with null tag");

    final SettableFuture<Void> future = inFlight.remove(tag);
    checkState(future != null, "Saw tag %s but not in in flight map", tag);
    future.set(null);

    LOG.debug("Response %s %s: %d", response.request().method(), response.request().urlString(), response.code());
}
 

@Override
public ListenableFuture<ServerStats> getStats() {
  ServerStats.Builder builder
      = new ServerStats.Builder()
      .setListenSockets(transportServer.getListenSockets());
  serverCallTracer.updateBuilder(builder);
  SettableFuture<ServerStats> ret = SettableFuture.create();
  ret.set(builder.build());
  return ret;
}