expected.add(ImmutableSet.of(2, 3));
    expected.add(ImmutableSet.of(1, 2, 3));

    Set<Set<Integer>> almostPowerSet = new HashSet<>(expected);
    almostPowerSet.remove(ImmutableSet.of(1, 2, 3));
    almostPowerSet.add(ImmutableSet.of(1, 2, 4));

    new EqualsTester()
        .addEqualityGroup(expected, powerSet)
        .addEqualityGroup(ImmutableSet.of(1, 2, 3))
        .addEqualityGroup(almostPowerSet)
        .testEquals();

        buildHeader(buf, headerStart, NtStatus.NT_STATUS_SUCCESS, 0x0001, 0xCAFEBABECAFEF00DL);

        int bodyStart = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;
        byte[] blob = new byte[] { 1, 2, 3 };
        int secBufOffset = Smb2Constants.SMB2_HEADER_LENGTH + 8;
        int sessionFlags = 0; // not guest/null
        buildSessionSetupBody(buf, headerStart, bodyStart, sessionFlags, secBufOffset, blob);

        });
    }

    @Test
    void testEncodeDecode() {
        // Setup SMB with some data
        smb.command = ServerMessageBlock.SMB_COM_ECHO;
        smb.mid = 123;
        smb.pid = 456;
        smb.tid = 789;
        smb.uid = 101;
        smb.flags2 = ServerMessageBlock.FLAGS2_UNICODE;
        smb.useUnicode = true;

        byte[] params = { 0x01, 0x02, 0x03, 0x04 };

            // 4=error, 5=disconnecting, 6=disconnected/invalid
            int[] disconnectedStates = { 0, 4, 5, 6 };
            int[] connectedStates = { 1, 2, 3 };

            for (int state : disconnectedStates) {
                transport.setState(state);
                assertTrue(transport.isDisconnected(), "State " + state + " should be disconnected");
            }

        assertNull(user.getPermissions());

        // Test with complex permission strings
        permissions = new String[] { "admin:*", "user:read", "document:write:123" };
        user = new TestFessUser("testuser", new String[] {}, new String[] {}, permissions);
        assertArrayEquals(permissions, user.getPermissions());
    }

    public void test_isEditable_default() {

        B = FF(B, C, D, A, X[7], 19);
        A = FF(A, B, C, D, X[8], 3);
        D = FF(D, A, B, C, X[9], 7);
        C = FF(C, D, A, B, X[10], 11);
        B = FF(B, C, D, A, X[11], 19);
        A = FF(A, B, C, D, X[12], 3);
        D = FF(D, A, B, C, X[13], 7);
        C = FF(C, D, A, B, X[14], 11);
        B = FF(B, C, D, A, X[15], 19);

        A = GG(A, B, C, D, X[0], 3);
        D = GG(D, A, B, C, X[4], 5);

        .testEquals();
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testForMapWithDefaultSerializable() {
    checkCanReserialize(Functions.forMap(ImmutableMap.of(1, 2), 3));
  }

  public void testForMapWithDefault_null() {
    ImmutableMap<String, Integer> map = ImmutableMap.of("One", 1);
    Function<String, @Nullable Integer> function = Functions.forMap(map, null);

        }
    }

    @Test
    @DisplayName("readn should handle partial reads")
    void testReadnPartial() throws IOException {
        byte[] buffer = new byte[10];
        byte[] data = { 1, 2, 3 };
        ByteArrayInputStream bais = new ByteArrayInputStream(data);

        int bytesRead = SessionServicePacket.readn(bais, buffer, 0, 5);

        assertEquals(3, bytesRead); // Only 3 bytes available
    }

        // Create a temporary lmhosts file with various IP formats
        File lmhostsFile = tempDir.resolve("lmhosts_ips").toFile();
        try (FileWriter writer = new FileWriter(lmhostsFile)) {
            writer.write("1.2.3.4 HOST1\n");
            writer.write("192.168.1.100 HOST2\n");
            writer.write("255.255.255.255 HOST3\n");
            writer.write("10.0.0.1 HOST4\n");
        }

    void gettersAndAcquire() throws Exception {
        // Arrange
        stubAcquireReturnsSelf();
        String wildcard = "*.*";
        int attrs = 123;
        FileEntry initial = entry("first");
        List<FileEntry[]> pages = List.of(new FileEntry[][] { new FileEntry[] {} });

        // Act