assertNotNull(context);
            assertArrayEquals(ciphers, context.getCiphers());
            assertEquals(0, context.getCiphers().length);
        }

        @Test
        @DisplayName("Should create instance with default constructor")
        void testDefaultConstructor() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext();

    private long h1;
    private long h2;
    private int length;

    Murmur3_128Hasher(int seed) {
      super(CHUNK_SIZE);
      this.h1 = seed;
      this.h2 = seed;
      this.length = 0;
    }

    @Override
    protected void process(ByteBuffer bb) {
      long k1 = bb.getLong();
      long k2 = bb.getLong();
      bmix64(k1, k2);
      length += CHUNK_SIZE;
    }

                ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int length = bis.read(bytes);
            while (length != -1) {
                if (length != 0) {
                    baos.write(bytes, 0, length);
                }
                length = bis.read(bytes);
            }
            return baos.toString(encoding);
        } catch (final Exception e) {

        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());

        // Nonces should have proper size
        assertEquals(16, nonce1.length, "GCM nonce should be 16 bytes");
        assertEquals(16, nonce2.length, "GCM nonce should be 16 bytes");
        assertEquals(16, nonce3.length, "GCM nonce should be 16 bytes");

        // For GCM, last 4 bytes should contain incrementing counter

        if (args == null) {
            return paramTypes.length == 0;
        }
        if (paramTypes.length != args.length) {
            return false;
        }
        for (int i = 0; i < args.length; ++i) {
            if (args[i] == null) {
                continue;
            }

   * #create(Object...)}.
   */
  protected abstract List<Character> create(Character[] elements);

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

  /** Returns the original element list, unchanged. */
  @Override
  public List<Character> order(List<Character> insertionOrder) {
    return insertionOrder;
  }

   * #create(Object...)}.
   */
  protected abstract T create(UnhashableObject[] elements);

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

  @Override
  public Iterable<UnhashableObject> order(List<UnhashableObject> insertionOrder) {
    return insertionOrder;
  }

   * #create(Object...)}.
   */
  protected abstract List<String> create(String[] elements);

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

  /** Returns the original element list, unchanged. */
  @Override
  public List<String> order(List<String> insertionOrder) {
    return insertionOrder;
  }