checkArgument(
        others.length <= Integer.MAX_VALUE - 6, "the total number of elements must fit in an int");
    SetBuilderImpl<E> builder = new RegularSetBuilderImpl<>(6 + others.length);
    builder = builder.add(e1).add(e2).add(e3).add(e4).add(e5).add(e6);
    for (int i = 0; i < others.length; i++) {
      builder = builder.add(others[i]);
    }

        multiset1.add("only1");
        multiset2.add("only2");
        for (int i = 0; i < elements.length; i++) {
          multiset1.add(elements[i]);
          multiset2.add(elements[elements.length - 1 - i]);
        }
        if (elements.length > 0) {
          multiset1.add(elements[0]);
        }
        if (elements.length > 1) {
          /*
           * When a test requests a multiset with duplicates, our plan of

        // State 2: Process Type 2 and generate Type 3
        byte[] type3Token = context.initSecContext(type2Token, 0, type2Token.length);

        assertNotNull(type3Token);
        assertTrue(type3Token.length > 0);
        assertTrue(context.isEstablished());
        assertArrayEquals(serverChallenge, context.getServerChallenge());

    return CompactHashSet.create();
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we

              public Integer call() {
                return Thread.currentThread().getStackTrace().length;
              }
            },
            directExecutor());
    settableFuture.set(null);
    assertThat(getDone(stackDepthCheck))
        .isLessThan(Thread.currentThread().getStackTrace().length + 100);
  }

  public void testAvoidsStackOverflow_alternatingCancelledAndSubmitted() throws Exception {

                configConfigMap.put(key.substring(CONFIG_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(CLIENT_PREFIX)) {
                clientConfigMap.put(key.substring(CLIENT_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(XPATH_PREFIX)) {
                xpathConfigMap.put(key.substring(XPATH_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(META_PREFIX)) {

  }

  public void testNewReferenceArray_withLength() throws Exception {
    int length = 42;
    AtomicReferenceArray<String> refArray = Atomics.newReferenceArray(length);
    for (int i = 0; i < length; ++i) {
      assertEquals(null, refArray.get(i));
    }
    assertThrows(IndexOutOfBoundsException.class, () -> refArray.get(length));
  }

  public void testNewReferenceArray_withNegativeLength() throws Exception {

      // Since index and (dataset.length - 1) are non-negative ints, their product can be expressed
      // as a long, without risk of overflow:
      long numerator = (long) index * (dataset.length - 1);
      // Since scale is a positive int, index is in [0, scale], and (dataset.length - 1) is a
      // non-negative int, we can do long-arithmetic on index * (dataset.length - 1) / scale to get

        int byteCountValue = 8 + domainBytes.length;
        setByteCount(response, byteCountValue);
        byte[] buffer = new byte[byteCountValue];
        int bufferIndex = 0;
        byte[] key = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
        System.arraycopy(key, 0, buffer, bufferIndex, key.length);
        bufferIndex += key.length;

    inbound: Boolean,
    streamId: Int,
    length: Int,
    type: Int,
    flags: Int,
  ): String {
    val formattedType = formattedType(type)
    val formattedFlags = formatFlags(type, flags)
    val direction = if (inbound) "<<" else ">>"
    return format(
      "%s 0x%08x %5d %-13s %s",
      direction,
      streamId,
      length,
      formattedType,
      formattedFlags,
    )
  }