writeOrCountBytes(sink, false)
  }

  /**
   * Either writes this request to [sink] or measures its content length. We have one method
   * do double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the
   * length-in-digits of an encoded integer.
   */
  private fun writeOrCountBytes(
    sink: BufferedSink?,

    Hasher[] hashers = new Hasher[functions.length];
    for (int i = 0; i < hashers.length; i++) {
      hashers[i] = functions[i].newHasher();
    }
    return fromHashers(hashers);
  }

  @Override
  public Hasher newHasher(int expectedInputSize) {
    checkArgument(expectedInputSize >= 0);
    Hasher[] hashers = new Hasher[functions.length];
    for (int i = 0; i < hashers.length; i++) {

  }

  public void testLength() throws IOException {
    assertEquals(expected.length(), source.length());
  }

  public void testLengthIfKnown() throws IOException {
    Optional<Long> lengthIfKnown = source.lengthIfKnown();
    if (lengthIfKnown.isPresent()) {
      assertEquals(expected.length(), (long) lengthIfKnown.get());
    }
  }

    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Set<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /**
   * {@inheritDoc}
   *

    Integer[] array = new Integer[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Integer) e;
    }
    return create(array);
  }

  protected abstract Set<Integer> create(Integer[] elements);

  @Override
  public Integer[] createArray(int length) {
    return new Integer[length];
  }

  /**
   * {@inheritDoc}
   *

    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Set<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /**
   * {@inheritDoc}
   *

        return this.fp;
    }


    @Override
    public void seek ( long pos ) {
        this.fp = pos;
    }


    @Override
    public long length () throws SmbException {
        return this.file.length();
    }


    @Override
    public void setLength ( long newLength ) throws SmbException {
        try ( SmbFileHandleImpl fh = ensureOpen();

		}

		start, length, err1 := rs.GetOffsetLength(objectSize)
		if err1 != nil {
			t.Fatalf("expected: <nil>, got: %s", err1)
		}

		if start != successCase.offsetBegin {
			t.Fatalf("expected: %d, got: %d", successCase.offsetBegin, start)
		}

		if start+length-1 != successCase.offsetEnd {
			t.Fatalf("expected: %d, got: %d", successCase.offsetEnd, start+length-1)
		}
	}

        sb.append(dm).append(regularName);
        sb.append(dm).append(sortOrder);
        sb.append(dm).append(updatedBy);
        sb.append(dm).append(updatedTime);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

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

        assertArgumentNotNull("iterables", iterables);

        @SuppressWarnings("unchecked")
        final Iterator<E>[] iterators = new Iterator[iterables.length];
        for (int i = 0; i < iterables.length; ++i) {
            iterators[i] = iterables[i].iterator();
        }
        return iterable(iterators);
    }

    /**