public class CallablesTest extends TestCase {

  @J2ktIncompatible // TODO(b/324550390): Enable
  public void testReturning() throws Exception {
    assertThat(Callables.returning(null).call()).isNull();

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertThat(callable.call()).isEqualTo(value);
    // Expect the same value on subsequent calls
    assertThat(callable.call()).isEqualTo(value);
  }

  ImmutableMapValues(ImmutableMap<K, V> map) {
    this.map = map;
  }

  @Override
  public int size() {
    return map.size();
  }

  @Override
  public UnmodifiableIterator<V> iterator() {
    return new UnmodifiableIterator<V>() {
      final UnmodifiableIterator<Entry<K, V>> entryItr = map.entrySet().iterator();

      @Override
      public boolean hasNext() {
        return entryItr.hasNext();
      }

  private final char[] buf = cbuf.array();

  private final Queue<String> lines = new ArrayDeque<>();
  private final LineBuffer lineBuf =
      new LineBuffer() {
        @Override
        protected void handleLine(String line, String end) {
          lines.add(line);
        }
      };

  /** Creates a new instance that will read lines from the given {@code Readable} object. */
  public LineReader(Readable readable) {

  int datasetSize;

  @Param QuantilesAlgorithm algorithm;

  private final double[][] datasets = new double[0x100][];

  @BeforeExperiment
  void setUp() {
    Random rng = new Random();
    for (int i = 0; i < 0x100; i++) {
      datasets[i] = new double[datasetSize];
      for (int j = 0; j < datasetSize; j++) {
        datasets[i][j] = rng.nextDouble();
      }
    }
  }

public class CallablesTest extends TestCase {

  @J2ktIncompatible // TODO(b/324550390): Enable
  public void testReturning() throws Exception {
    assertThat(Callables.returning(null).call()).isNull();

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertThat(callable.call()).isEqualTo(value);
    // Expect the same value on subsequent calls
    assertThat(callable.call()).isEqualTo(value);
  }

  private final long size;

  static <E> ImmutableMultiset<E> create(Collection<? extends Entry<? extends E>> entries) {
    @SuppressWarnings("unchecked")
    Entry<E>[] entriesArray = entries.toArray((Entry<E>[]) new Entry<?>[0]);
    Map<E, Integer> delegateMap = Maps.newHashMapWithExpectedSize(entriesArray.length);
    long size = 0;
    for (int i = 0; i < entriesArray.length; i++) {
      Entry<E> entry = entriesArray[i];

        final int nameLen = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        final byte[] nameBytes = new byte[nameLen];
        System.arraycopy(buffer, bufferIndex, nameBytes, 0, nameBytes.length);
        bufferIndex += nameLen;
        this.fileName = new String(nameBytes, StandardCharsets.UTF_16LE);
        return bufferIndex - start;
    }

    /**
     * {@inheritDoc}
     *

    public CIFSContext withCredentials(final Credentials creds) {
        return new CIFSContextCredentialWrapper(this, creds);
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#withAnonymousCredentials()
     */
    @Override
    public CIFSContext withAnonymousCredentials() {
        return withCredentials(new NtlmPasswordAuthenticator());
    }

    /**
     * {@inheritDoc}
     *

        Map<String, List<String>> goals = new HashMap<>();
        lifecycle.allPhases().forEach(phase -> phase.plugins()
                .forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
                        .forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())

    //                                                                            ========
    public DocMeta asDocMeta() {
        if (docMeta == null) {
            docMeta = new DocMeta();
        }
        return docMeta;
    }

    // ===================================================================================