}

  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) {

          }

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

    <name>formatDuration</name>
    <function-class>org.codelibs.fess.taglib.FessFunctions</function-class>
    <function-signature>java.lang.String formatDuration(long)</function-signature>
    <example>
      ${fe:formatDuration(1234)}
    </example>
  </function>

  <function>
    <description>
      Returns formatted date from a given value.
    </description>
    <name>formatDate</name>

        void shouldIdentifyFailedStates() {
            // Failed states: 5=disconnecting, 6=disconnected/invalid
            int[] failedStates = { 5, 6 };
            int[] nonFailedStates = { 0, 1, 2, 3, 4 };

            for (int state : failedStates) {
                transport.setState(state);
                assertTrue(transport.isFailed(), "State " + state + " should be failed");
            }

		{"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 != "" {

        // Test different sizes
        assertEquals("00", Hexdump.toHexString(0, 2));
        assertEquals("FF", Hexdump.toHexString(255, 2));
        assertEquals("1234", Hexdump.toHexString(0x1234, 4));
    }

    @Test
    @DisplayName("Should convert long to hex string with padding")
    void testLongToHexString() {
        // Test various long values

        ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4));
    Set<Integer> values = bimap.values();
    assertEquals(newHashSet(1, 2, 3, 4), values);
    assertThat(values).containsExactly(1, 2, 3, 4).inOrder();
  }

  public void testDoubleInverse() {
    ImmutableBiMap<String, Integer> bimap =
        ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2));

  }

  private class FakeSocket(
    private val localAddress: InetAddress,
    private val localPort: Int,
    private val remoteAddress: InetAddress = localAddress,
    private val remotePort: Int = 1234,
  ) : Socket() {
    override fun getInputStream() = Buffer().inputStream()

    override fun getOutputStream() = Buffer().outputStream()

    override fun getInetAddress() = remoteAddress

        // Arrange
        WriterThread w = new WriterThread();
        SmbFileOutputStream out = mock(SmbFileOutputStream.class);
        byte[] payload = new byte[] { 1, 2, 3, 4 };

        w.start();

        // Wait until writer thread signals readiness
        synchronized (w) {
            long deadline = System.currentTimeMillis() + 2000;

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