}

        private void setLength(int length) {
            try {
                // Use reflection to set the protected length field
                java.lang.reflect.Field lengthField = ServerMessageBlock2.class.getDeclaredField("length");
                lengthField.setAccessible(true);
                lengthField.setInt(this, length);
            } catch (Exception e) {

    checkState(cache.segments.length == 1);
    segment = cache.segments[0];
    checkState(segment.table.length() == capacity);
    for (int i = 0; i < segment.threshold; i++) {
      cache.put(new Object(), new Object());
    }
    checkState(segment.table.length() == capacity);
  }

  @SuppressWarnings("GuardedBy")
  @Benchmark
  int time(int reps) {

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

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

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

  /** Returns the original element list, unchanged. */
  @Override

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

        // Modify returned hash
        if (hash.length > 0) {
            hash[0] = (byte) 0xFF;
        }

        // Get hash again - should be unmodified
        byte[] hash2 = transport.getPreauthIntegrityHash();
        assertNotNull(hash2);

        // If original has data, verify it wasn't modified
        if (hash2.length > 0 && hash.length > 0) {
            assertNotEquals(hash[0], hash2[0]);
        }

        assertEquals(message, exception.getMessage());
        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);
        assertNull(exception.getCause());
    }

    public void test_constructor_withNullMessage() {
        // Test with null message

   * time and space.
   *
   * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
   *     surrogates)
   */
  public static int encodedLength(CharSequence sequence) {
    // Warning to maintainers: this implementation is highly optimized.
    int utf16Length = sequence.length();
    int utf8Length = utf16Length;

            if (setupBuffer != null && setupBuffer.length > 0) {
                System.arraycopy(setupBuffer, 0, dst, dstIndex, setupBuffer.length);
            }
            return setupWireFormatReturn;
        }

        @Override
        protected int writeParametersWireFormat(byte[] dst, int dstIndex) {
            if (parametersBuffer != null && parametersBuffer.length > 0) {

     * @param offset
     *            The starting offset at which the SMB header begins.
     * @param length
     *            The length of the SMB data starting at offset.
     * @param request
     *            request message
     * @param response
     *            response message
     */
    void sign(byte[] data, int offset, int length, CommonServerMessageBlock request, CommonServerMessageBlock response);

    /**

            };

            // Act
            int decodedSize = context.decode(buffer, 0, buffer.length);

            // Assert
            assertEquals(4, decodedSize);
            assertEquals(0, context.getHashAlgos().length);
            assertEquals(0, context.getSalt().length);
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 3, 5, 10 })