{"10000000000000000", 0, "http chunk length too large"},
		{"00000000000000001", 0, "http chunk length too large"}, // could accept if we wanted
	}
	for i := uint64(0); i <= 1234; i++ {
		tests = append(tests, testCase{in: fmt.Sprintf("%x", i), want: i})
	}
	for _, tt := range tests {
		got, err := parseHexUint([]byte(tt.in))
		if tt.wantErr != "" {

            return len;
        }
    }

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getPid()).thenReturn(1234);
        when(mockConfig.getMaximumBufferSize()).thenReturn(65535);
        when(mockConfig.getMinimumVersion()).thenReturn(DialectVersion.SMB1);
        when(mockConfig.getMaximumVersion()).thenReturn(DialectVersion.SMB311);

        when(nego.getServerData()).thenReturn(serverData);
        when(transport.getNegotiateResponse()).thenReturn(nego);

        // Mock config methods needed for SMB1
        when(config.getPid()).thenReturn(1234);

        SmbComTreeConnectAndXResponse response = mock(SmbComTreeConnectAndXResponse.class);
        when(response.getService()).thenReturn("A:");
        when(response.isValidTid()).thenReturn(true);

        // Arrange
        Smb2LogoffRequest req = newRequest();

        // Act
        int resultWithNull = req.readBytesWireFormat(null, 0);
        int resultWithData = req.readBytesWireFormat(new byte[] { 1, 2, 3 }, 1);

        // Assert
        assertEquals(0, resultWithNull, "Should return 0 for null buffer");
        assertEquals(0, resultWithData, "Should return 0 regardless of input data");
    }

    @Nested

  }

  private Iterable<BinaryNode> view;

  @Param Topology topology;

  @Param({"1", "100", "10000", "1000000"})
  int size;

  @Param Traversal traversal;

  @Param({"1234"})
  SpecialRandom rng;

  @BeforeExperiment
  void setUp() {
    this.view = traversal.view(topology.createTree(size, rng).get(), VIEWER);
  }

  @Benchmark
  int traversal(int reps) {

    assertThat(set.headSet(4)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(Integer.MAX_VALUE)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(1, true)).containsExactly(1).inOrder();
    assertThat(set.headSet(2, true)).containsExactly(1, 2).inOrder();
    assertThat(set.headSet(3, true)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(4, true)).containsExactly(1, 2, 3).inOrder();

        assertTrue(result.contains("TestScoreBooster : 300"));
    }

    // Test execute result format
    public void test_execute_resultFormat() {
        TestScoreBooster booster1 = new TestScoreBooster(123L);
        TestScoreBooster booster2 = new TestScoreBooster(456L);

        scoreUpdater.addScoreBooster(booster1);
        scoreUpdater.addScoreBooster(booster2);

        String result = scoreUpdater.execute();

          }

          @Override
          public void invalidate(Object key) {
            invalidated.add(key);
          }
        };

    List<Integer> toInvalidate = ImmutableList.of(1, 2, 3, 4);
    cache.invalidateAll(toInvalidate);
    assertEquals(toInvalidate, invalidated);
  }

  public void testEmptySimpleStats() {
    StatsCounter counter = new SimpleStatsCounter();

        assertNull(StringConversionUtil.fromWindowsMapping(null));
        assertEquals("", StringConversionUtil.fromWindowsMapping(""));
        assertEquals("abc 123", StringConversionUtil.fromWindowsMapping("abc 123"));
        assertEquals("abc\uFF5E\u2225\uFF0D\uFFE0\uFFE1\uFFE2",
                StringConversionUtil.fromWindowsMapping("abc\u301C\u2016\u2212\u00A2\u00A3\u00AC"));
    }

    /**

    }

    @Test
    void constructor_shouldOpenPolicySuccessfully() throws IOException {
        // Arrange
        String server = "testServer";
        int access = 123;

        // Mock the behavior of sendrecv for MsrpcLsarOpenPolicy2
        doAnswer(invocation -> {
            MsrpcLsarOpenPolicy2 rpc = invocation.getArgument(0);
            rpc.retval = 0; // Simulate success