HashBiMap<String, String> bimap = HashBiMap.create(map);
    assertEquals("dollar", bimap.get("canada"));
    assertEquals("canada", bimap.inverse().get("dollar"));
  }

  private static final int N = 1000;

  public void testBashIt() throws Exception {
    BiMap<Integer, Integer> bimap = HashBiMap.create(N);
    BiMap<Integer, Integer> inverse = bimap.inverse();

    for (int i = 0; i < N; i++) {

          // passes, and there is still a little endianness bug lurking around.
        }
      }

      Control control = new Control();
      Hasher controlSink = control.newHasher(1024);

      Iterable<Hasher> sinksAndControl =
          Iterables.concat(sinks, Collections.singleton(controlSink));
      for (int insertion = 0; insertion < totalInsertions; insertion++) {

	{file: "myobject", offset: 2, length: 100, algorithm: SHA256, expError: errFileCorrupt},     // 6
	{file: "myobject", offset: 1000, length: 1001, algorithm: SHA256, expError: nil},            // 7
	{file: "myobject", offset: 0, length: 100, algorithm: BLAKE2b512, expError: errFileCorrupt}, // 8

        // Arrange
        byte[] largeData = new byte[1000];
        for (int i = 0; i < largeData.length; i++) {
            largeData[i] = (byte) (i % 256);
        }
        int offset = 990;
        int length = 10;

        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, largeData, offset, length);
        byte[] dst = new byte[100];

        // Act

            manager.stopAsync().awaitStopped();
          }
        };
    stoppingThread.start();
    // this should be super fast since the only non-stopped service is a NoOpService
    stoppingThread.join(1000);
    assertFalse("stopAsync has deadlocked!.", stoppingThread.isAlive());
    failLeave.countDown(); // release the background thread
  }

  /**

    // Check the first 100,000 integers
    for (int i = 0; i < 100000; i++) {
      assertEquals(LongMath.isPrime(i), IntMath.isPrime(i));
    }

    // Then check 1000 deterministic pseudo-random int values.
    Random rand = new Random(1);
    for (int i = 0; i < 1000; i++) {
      int n = rand.nextInt(Integer.MAX_VALUE);
      assertEquals(LongMath.isPrime(n), IntMath.isPrime(n));
    }
  }

    @Test
    public void testLargeThreshold() throws IOException {
        // Test with very large threshold
        ContentOutputStream cos = new ContentOutputStream(1024 * 1024, Curl.tmpDir);
        cos.write(new byte[1000]);
        assertTrue(cos.isInMemory());
        cos.close();
    }

    @Test
    public void testMultipleGetFile() throws IOException {
        // Calling getFile() multiple times should return the same file

        // Test toString
        String str = fileInfoWithEof.toString();
        assertNotNull(str);
        assertTrue(str.contains("EndOfFileInformation"));
        assertTrue(str.contains("1024"));
    }

    /**
     * Test FileEndOfFileInformation encode/decode round trip
     */
    @Test
    @DisplayName("Test FileEndOfFileInformation encode/decode round trip")

     *
     * @return interface score
     */
    public int getScore() {
        int score = linkSpeed; // Base score is link speed

        if (rssCapable)
            score += 1000; // Prefer RSS-capable
        if (rdmaCapable)
            score += 2000; // Prefer RDMA-capable
        // Note: No IPv4 preference bonus to keep base score equal to link speed

        return score;
    }

        public FailoverState(String channelId) {
            this.channelId = channelId;
            this.failureTime = System.currentTimeMillis();
            this.retryCount = 0;
            this.nextRetryTime = failureTime + 1000; // Initial 1 second delay
        }

        /**
         * Get channel ID
         *
         * @return channel identifier
         */
        public String getChannelId() {