assertSame(Ordering.natural(), copy.comparator());
  }

  public void testCopyOf() {
    Map<String, Integer> original = new LinkedHashMap<>();
    original.put("one", 1);
    original.put("two", 2);
    original.put("three", 3);

    ImmutableSortedMap<String, Integer> copy = ImmutableSortedMap.copyOf(original);
    assertMapEquals(copy, "one", 1, "three", 3, "two", 2);
    assertSame(copy, ImmutableSortedMap.copyOf(copy));

        NtlmPasswordAuthenticator original = new NtlmPasswordAuthenticator("DOMAIN", "testuser", testPassword);

        NtlmPasswordAuthenticator cloned = original.clone();

        // Verify cloned values
        assertEquals(original.getUserDomain(), cloned.getUserDomain());
        assertEquals(original.getUsername(), cloned.getUsername());
        assertEquals(original.getPassword(), cloned.getPassword());

        SmbOperationException original = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_TIMEOUT, "Timeout");
        original.withContext("attempt", 1);

        // When
        SmbOperationException retry = SmbOperationException.forRetry(original, 2);

        // Then
        assertEquals(original.getErrorCode(), retry.getErrorCode());
        assertEquals(original.getMessage(), retry.getMessage());

        ? ((TransposeTable<R, C, V>) table).original
        : new TransposeTable<C, R, V>(table);
  }

  private static final class TransposeTable<
          C extends @Nullable Object, R extends @Nullable Object, V extends @Nullable Object>
      extends AbstractTable<C, R, V> {
    final Table<R, C, V> original;

    TransposeTable(Table<R, C, V> original) {
      this.original = checkNotNull(original);
    }

        try {
            String result = SystemUtil.getSearchEngineHttpAddress();
            assertNull(result);
        } finally {
            // Restore original value if it existed
            if (originalValue != null) {
                System.setProperty(Constants.FESS_SEARCH_ENGINE_HTTP_ADDRESS, originalValue);
            }
        }
    }

  }

  companion object {
    fun uppercase(original: ResponseBody): ResponseBody =
      object : ResponseBody() {
        override fun contentType() = original.contentType()

        override fun contentLength() = original.contentLength()

        override fun source() = uppercase(original.source()).buffer()
      }

    private fun uppercase(original: Source): Source {

        assertEquals(36, decodedBytes); // decode reads 36 bytes (no padding)
        assertEquals(original.getCreateTime(), decoded.getCreateTime());
        assertEquals(original.getLastAccessTime(), decoded.getLastAccessTime());
        assertEquals(original.getLastWriteTime(), decoded.getLastWriteTime());
        assertEquals(original.getAttributes(), decoded.getAttributes());
    }

    @Test
    @DisplayName("Test toString method")

        for (long testValue : testValues) {
            // Create and encode
            FileEndOfFileInformation original = new FileEndOfFileInformation(testValue);
            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

            assertEquals(8, encoded);

            // Decode into new instance

            String originalMessage = "Original error";
            TransportException original = new TransportException(originalMessage);

            // Wrap in another exception
            TransportException wrapper = new TransportException("Wrapper", original);

            assertEquals("Wrapper", wrapper.getMessage());
            assertEquals(original, wrapper.getRootCause());

    }

    public void test_toLineString() {
        // Test toLineString method
        StopwordsItem item = new StopwordsItem(1, "original");
        assertEquals("original", item.toLineString());

        // When updated, should return newInput
        item.setNewInput("updated");
        assertEquals("updated", item.toLineString());