byte[] eolData = createEolData();

        // Combine all data
        int totalLength = avFlagsData.length + avTimestampData.length + avTargetNameData.length + eolData.length;
        byte[] fullData = new byte[totalLength];
        int pos = 0;
        System.arraycopy(avFlagsData, 0, fullData, pos, avFlagsData.length);
        pos += avFlagsData.length;

        }
        if (mechToken != null) {
            fields.add(new DERTaggedObject(true, 2, new DEROctetString(mechToken)));
        }
        if (mic != null) {
            int tag = micInTag4 ? 4 : 3;
            fields.add(new DERTaggedObject(true, tag, new DEROctetString(mic)));
        }
        if (extraField != null) {
            fields.add(extraField);
        }

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

@GwtCompatible
abstract class CommonMatcher {
  public abstract boolean matches();

  public abstract boolean find();

  public abstract boolean find(int index);

  public abstract String replaceAll(String replacement);

  public abstract int end();

  public abstract int start();

  private final Random random;

  public RandomAmountInputStream(InputStream in, Random random) {
    super(checkNotNull(in));
    this.random = checkNotNull(random);
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    return super.read(b, off, random.nextInt(len) + 1);
  }

  @JvmField val clientMaxWindowBits: Int? = null,
  /** True if the agreed upon extension parameters includes "client_no_context_takeover". */
  @JvmField val clientNoContextTakeover: Boolean = false,
  /** Should be a value in [8..15]. Any value in that range is acceptable by OkHttp. */
  @JvmField val serverMaxWindowBits: Int? = null,

     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read(final byte[] b, final int off, final int len) throws IOException {
        return inputStream.read(b, off, len);
    }

    /**
     * Reads some number of bytes from the input stream and stores them into the buffer array b.
     *

        return AbstractValueGraph.this.successors(node);
      }

      @Override
      public int degree(N node) {
        return AbstractValueGraph.this.degree(node);
      }

      @Override
      public int inDegree(N node) {
        return AbstractValueGraph.this.inDegree(node);
      }

      @Override
      public int outDegree(N node) {
        return AbstractValueGraph.this.outDegree(node);
      }
    };

        private final String name;
        private final int value;

        public CustomTestObject(String name, int value) {
            this.name = name;
            this.value = value;
        }

        public String getName() {
            return name;
        }

        public int getValue() {
            return value;
        }

        @Override

    }

    public void test_setIndexUpdaterPriority() {
        int priority = Thread.MAX_PRIORITY;
        webFsIndexHelper.setIndexUpdaterPriority(priority);
        assertEquals(priority, webFsIndexHelper.indexUpdaterPriority);
    }

    public void test_setIndexUpdaterPriority_withMinValue() {
        int priority = Thread.MIN_PRIORITY;
        webFsIndexHelper.setIndexUpdaterPriority(priority);