}

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

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

        // 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

		wantErr: ErrHeader,
	}, {
		input:    makeInput(FormatGNU, "1234", "fewa"),
		wantSize: 01234,
		wantErr:  ErrHeader,
	}, {
		input:    makeInput(FormatGNU, "0031"),
		wantSize: 031,
	}, {
		input:   makeInput(FormatGNU, "80"),
		wantErr: ErrHeader,
	}, {
		input: makeInput(FormatGNU, "1234",
			makeSparseStrings(sparseDatas{{0, 0}, {1, 1}})...),

            });

    List<Integer> actual = newArrayList(result);
    List<Integer> expected = asList(1, 2, 3);
    assertEquals(expected, actual);
    assertCanIterateAgain(result);
    assertEquals("[1, 2, 3]", result.toString());
  }

  public void testTransform_forEach() {
    List<Integer> input = asList(1, 2, 3, 4);
    Iterable<String> result =
        Iterables.transform(
            input,

        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

  }

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

		// Erasure Setup with PathEndpointType
		{
			":1234",
			[]string{"/d1", "/d2", "/d3", "/d4"},
			":1234",
			Endpoints{
				Endpoint{URL: &url.URL{Path: mustAbs("/d1")}, IsLocal: true},
				Endpoint{URL: &url.URL{Path: mustAbs("/d2")}, IsLocal: true},

    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(
            4, MODIFIABLE, newArrayList(1, 2, 3), IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override
          protected Iterator<Integer> newTargetIterator() {
            return Lists.newArrayList(1, 2, 3, 4).iterator();
          }
        };
    assertFailure(tester);
  }

  public void testCanCatchDifferentContents() {