private final int scale;

    private Scale(int scale) {
      checkArgument(scale > 0, "Quantile scale must be positive");
      this.scale = scale;
    }

    /**
     * Specifies a single quantile index to be calculated, i.e. the k in the kth q-quantile.
     *
     * @param index the quantile index, which must be in the inclusive range [0, q] for q-quantiles
     */
    public ScaleAndIndex index(int index) {

            throw new SMBProtocolDecodingException("Invalid maxTransactSize: " + this.maxTransactSize + " (must be 0-16777216)");
        }
        if (this.maxReadSize < 0 || this.maxReadSize > 16777216) { // 16MB max
            throw new SMBProtocolDecodingException("Invalid maxReadSize: " + this.maxReadSize + " (must be 0-16777216)");
        }
        if (this.maxWriteSize < 0 || this.maxWriteSize > 16777216) { // 16MB max

    } catch (AssertionFailedError expected) {
      assertThat(expected)
          .hasMessageThat()
          .contains(
              "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to "
                  + "TestObject{group=1, item=1} [group 1, item 1]");
      return;
    }
    fail();
  }

  public void testTest_transitive() {

    } catch (AssertionFailedError expected) {
      assertThat(expected)
          .hasMessageThat()
          .contains(
              "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to "
                  + "TestObject{group=1, item=1} [group 1, item 1]");
      return;
    }
    fail();
  }

  public void testTest_transitive() {

 * method equivalent to {@link java.util.concurrent.locks.ReentrantLock#hasQueuedThread(Thread)}. If
 * the {@link #callAndAssertWaits} method is ever called in a test, the lock-like object must have a
 * method equivalent to {@link
 * java.util.concurrent.locks.ReentrantLock#hasWaiters(java.util.concurrent.locks.Condition)},

        }
    }

    /**
     * Returns an input stream to read the contents of the specified JAR file entry.
     *
     * @param file the JAR file (must not be {@literal null})
     * @param entry the JAR file entry (must not be {@literal null})
     * @return the input stream to read the entry
     */
    public static InputStream getInputStream(final JarFile file, final ZipEntry entry) {

     */
    protected DocumentBuilderUtil() {
    }

    /**
     * Parses the XML.
     *
     * @param builder
     *            {@link DocumentBuilder}; must not be {@literal null}.
     * @param is
     *            Input stream; must not be {@literal null}.
     * @return {@link Document}
     */
    public static Document parse(final DocumentBuilder builder, final InputStream is) {

    /**
     * Returns an {@link Iterable} that wraps a {@link MultiIterator} for use in a for-each statement.
     *
     * @param <E> the element type
     * @param iterables the array of {@link Iterable} (must not be {@literal null})
     * @return an {@link Iterable} wrapping a {@link MultiIterator}
     */
    public static <E> Iterable<E> iterable(final Iterable<E>... iterables) {

     */
    protected WriterUtil() {
    }

    /**
     * Creates a {@link Writer} to output to a stream with the specified encoding.
     *
     * @param os the stream (must not be {@literal null})
     * @param encoding the encoding (must not be {@literal null} or empty)
     * @return a {@link Writer} to output to the stream
     */
    public static Writer create(final OutputStream os, final String encoding) {

        // Act
        int written = enc.encode(dst, dstIndex);

        // Assert: reported written bytes matches size() and requested len.
        assertEquals(len, enc.size(), "size() must equal provided length");
        assertEquals(len, written, "encode() must return number of bytes written");

        // Assert: copied region equals the source slice.
        for (int i = 0; i < len; i++) {