}

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        PacDataInputStream pacStream = new PacDataInputStream(bais);

        String result = pacStream.readString();
        assertEquals(testString, result);
    }

    @Test
    @DisplayName("Test PacDataInputStream readString with empty string")
    void testReadEmptyString() throws Exception {

     * @param seed the seed value for popular word generation
     * @param tags array of tags to filter results
     * @param roles array of roles to filter results
     * @param fields array of fields to search in
     * @param excludes array of words to exclude from results
     * @return list of popular words matching the criteria
     */

    return delegate().submit(task);
  }

  @Override
  public <T extends @Nullable Object> ListenableFuture<T> submit(
      Runnable task, @ParametricNullness T result) {
    return delegate().submit(task, result);
  }

      ImmediateExecutionTensorHandle** result) override {
    handle->Ref();
    TF_Status status;
    TFE_TensorHandle* result_handle = device_.copy_tensor_to_device(
        context_, tensorflow::wrap(handle), &status, info_);
    handle->Unref();
    if (!status.status.ok()) return status.status;
    *result = tensorflow::unwrap(result_handle);
    (*result)->Ref();
    TFE_DeleteTensorHandle(result_handle);

  public int addAndGet(int delta) {
    return value += delta;
  }

  public void set(int newValue) {
    value = newValue;
  }

  public int getAndSet(int newValue) {
    int result = value;
    value = newValue;
    return result;
  }

  @Override
  public int hashCode() {
    return value;
  }

  @Override
  public boolean equals(@Nullable Object obj) {

    } else {
      // This is a generalized version of the calculation in add(double, double) above. Note that
      // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result
      // in NaN naturally.
      sumOfProductsOfDeltas +=
          values.sumOfProductsOfDeltas()
              + (values.xStats().mean() - xStats.mean())
                  * (values.yStats().mean() - yStats.mean())

            return toolchains;
        }

        PersistedToolchains result;
        try {
            Map<String, ?> options = Collections.singletonMap(ToolchainsReader.IS_STRICT, Boolean.FALSE);

            result = toolchainsReader.read(new StringReader(serializedToolchains), options);
        } catch (IOException e) {

    final Chopper or(Chopper you) {
      Chopper i = this;
      return new Chopper() {
        @Override
        @Nullable String chop(String str) {
          String result = i.chop(str);
          return result != null ? result : you.chop(str);
        }
      };
    }

    abstract @Nullable String chop(String str);

    static Chopper suffix(String suffix) {
      return new Chopper() {

  @LazyInit @RetainedWith private transient @Nullable ImmutableList<E> asList;

  @Override
  public ImmutableList<E> asList() {
    ImmutableList<E> result = asList;
    return (result == null) ? asList = createAsList() : result;
  }

  ImmutableList<E> createAsList() {
    return asImmutableList(toArray());
  }

  /*
   * This class is used to serialize all ImmutableSet instances, except for

    }
  }

  private static Float[] concat(Float[] left, Float[] right) {
    Float[] result = new Float[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);
    return result;
  }

  public abstract static class TestFloatListGenerator implements TestListGenerator<Float> {
    @Override