new RegularImmutableSet<>(EMPTY_ARRAY, 0, EMPTY_ARRAY, 0);

  private final transient Object[] elements;
  private final transient int hashCode;
  // the same values as `elements` in hashed positions (plus nulls)
  @VisibleForTesting final transient @Nullable Object[] table;
  // 'and' with an int to get a valid table index.
  private final transient int mask;

        assertTrue(result instanceof Object[]);
        Object[] resultArray = (Object[]) result;
        assertEquals(6, resultArray.length);

        // Verify all values are in correct positions
        assertEquals("initial", resultArray[0]);
        assertEquals("item1", resultArray[1]);
        assertEquals("item2", resultArray[2]);
        assertEquals("item3", resultArray[3]);

        @Test
        @DisplayName("Should encode at different buffer positions")
        void testEncodeAtDifferentPositions() {
            int[] hashAlgos = { 1, 2 };
            byte[] salt = new byte[8];
            Arrays.fill(salt, (byte) 0xFF);

            context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Encode at position 100
            int encoded = context.encode(buffer, 100);

   * equivalent to RegularImmutableSet, save that instead of having a hash table containing the
   * elements directly and null for empty positions, we store indices of the keys in the hash table,
   * and ABSENT for empty positions.  We then look up the keys in alternatingKeysAndValues.
   *
   * (The index actually stored is the index of the key in alternatingKeysAndValues, which is

		if offsetBeginString[0] == '+' {
			return nil, fmt.Errorf("Byte position ('%s') must not have a sign", offsetBeginString)
		} else if offsetBegin, err = strconv.ParseInt(offsetBeginString, 10, 64); err != nil {
			return nil, fmt.Errorf("'%s' does not have a valid first byte position value", rangeString)
		} else if offsetBegin < 0 {
			return nil, fmt.Errorf("First byte position is negative ('%d')", offsetBegin)
		}
	}

        @Test
        @DisplayName("Should encode at different buffer positions")
        void testEncodingAtDifferentPositions() {
            long offset = 1000L;
            long length = 2000L;
            int flags = Smb2Lock.SMB2_LOCKFLAG_UNLOCK;

            lock = new Smb2Lock(offset, length, flags);

            // Test encoding at position 10
            int encoded = lock.encode(buffer, 10);

        assertEquals(SmbComTransaction.TRANS2_GET_DFS_REFERRAL, dst[0]);
        assertEquals((byte) 0x00, dst[1]);
    }

    @Test
    @DisplayName("writeSetupWireFormat should handle different buffer positions")
    void testWriteSetupWireFormatWithOffset() {
        // Given
        trans2GetDfsReferral = new Trans2GetDfsReferral(mockConfig, "test");
        byte[] dst = new byte[20];
        int dstIndex = 5;

        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 50, 99 })
        @DisplayName("Should handle various buffer positions correctly")
        void testWireFormatMethodsWithDifferentPositions(int position) throws Exception {
            // Given
            byte[] buffer = new byte[100];

            // Test write parameter words

                int separatorLength = separator.length();

                positions:
                for (int p = start, last = toSplit.length() - separatorLength; p <= last; p++) {
                  for (int i = 0; i < separatorLength; i++) {
                    if (toSplit.charAt(i + p) != separator.charAt(i)) {
                      continue positions;
                    }
                  }
                  return p;

        // Verify bytes written
        assertEquals(8, bytesWritten);

        // Verify FID (2 bytes)
        assertEquals(fid, SMBUtil.readInt2(dst, dstIndex));

        // Verify reserved bytes (2 bytes at positions 2-3)
        assertEquals(0x00, dst[dstIndex + 2]);
        assertEquals(0x00, dst[dstIndex + 3]);

        // Verify security information (4 bytes)