// Verify that ptype and flags are set correctly using reflection
        try {
            java.lang.reflect.Field ptypeField = jcifs.dcerpc.DcerpcMessage.class.getDeclaredField("ptype");
            ptypeField.setAccessible(true);
            assertEquals(0, ptypeField.get(msrpcSamrOpenAlias), "ptype should be initialized to 0");

        assertEquals((byte) 0xFF, buf[1], "AndX command should be 0xFF when no chaining");
        assertEquals((byte) 0x00, buf[2], "Reserved byte must be 0");
        assertEquals((byte) 0xDE, buf[3], "Sentinel low offset when no chaining");
        assertEquals((byte) 0xDE, buf[4], "Sentinel high offset when no chaining");
        assertNull(block.andx, "andx should be cleared when not chaining");
    }

    @Test

    class ResultManagementTests {

        @Test
        @DisplayName("getResult should return null for success (result=0)")
        void testGetResultSuccess() {
            message.result = 0;
            assertNull(message.getResult());
        }

        @Test
        @DisplayName("getResult should return DcerpcException for non-zero result")
        void testGetResultError() {

  public void testPutIfAbsent_supportedAbsent() {
    assertNull("putIfAbsent(notPresent, value) should return null", putIfAbsent(e3()));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(
        "putIfAbsent(present, value) should return existing value",
        v0(),
        getMap().putIfAbsent(k0(), v3()));

                        timings.add(endTime - startTime);
                        assertFalse(result, "Passwords should not be equal");
                    }
                });
            }

            executor.shutdown();
            assertTrue(executor.awaitTermination(30, TimeUnit.SECONDS), "All threads should complete within timeout");

            // Analyze timing consistency across threads

        // Act: relative path should exercise the 'else if' path in parseURL
        URL rel = new URL(base, "foo/bar", handler);

        // Assert
        assertEquals(SmbConstants.DEFAULT_PORT, rel.getPort(), "Default port should be applied");
        String actualPath = rel.getPath();
        assertNotNull(actualPath, "Path should not be null");

        }
        return QueryBuilders.boolQuery()//
                .should(QueryBuilders.matchPhraseQuery("title", query).boost(titleBoost))//
                .should(QueryBuilders.matchPhraseQuery("content", query).boost(contentBoost))//
                .should(QueryBuilders.fuzzyQuery("title", query).boost(0.01f).maxExpansions(10))//
                .should(QueryBuilders.fuzzyQuery("content", query).boost(0.005f).maxExpansions(10))//
        ;

                "tearDownTwo should have been run before tearDownOne", false, tearDownOne.ran);
          }
        };

    SimpleTearDown tearDownTwo = new SimpleTearDown(callback);
    stack.addTearDown(tearDownTwo);

    assertEquals(false, tearDownOne.ran);
    assertEquals(false, tearDownTwo.ran);

    stack.runTearDown();

    assertEquals("tearDownOne should have run", true, tearDownOne.ran);

                MultiChannelManager.class.getDeclaredMethod("createChannelTransport", InetAddress.class, InetAddress.class);
        method.setAccessible(true);

        // This should fail because localhost doesn't support SMB multi-channel
        // but the method should not throw NullPointerException
        try {
            method.invoke(multiChannelManager, localhost, loopback);
            // If it doesn't throw, that's unexpected for localhost

        List<FileNotifyInformation> result = sut.watch();

        assertNull(result, "Cancelled watch should return null");
        verify(tree, times(1)).close();
    }

    // Error code 0x10C should clear the notify list and return it
    @Test
    @DisplayName("watch() clears notify list on error 0x10C and returns it")