}
    }

    @Nested
    @DisplayName("Edge cases and special scenarios")
    class EdgeCases {

        @Test
        @DisplayName("Should handle multiple extensions for same mime type")
        void testMultipleExtensionsForSameMimeType() throws IOException {
            // Both jpg and jpeg should map to image/jpeg
            String jpgMime = mimeMap.getMimeType("jpg");

   * problematic AtomicReferenceFieldUpdaterAtomicHelper code path. However, the same problem *does*
   * matter with AggregateFutureState, which does not have an Unsafe-based helper.
   *
   * This same problem is one of the reasons for us to likewise use package-private for the fields
   * in Waiter.
   */

  /**

 * {@link #at}, {@link #set}, {@link #toArray}, {@link #rowKeyList}, and {@link #columnKeyList}
 * methods for more details.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access the same cell of
 * an {@code ArrayTable} concurrently and one of the threads modifies its value, there is no
 * guarantee that the new value will be fully visible to the other threads. To guarantee that

        assertEquals((byte) 0x00, encoded[3], "Second byte of second character");
    }

    @Test
    public void testAsciiEncoding() throws Exception {
        String msg = "\u00A1\u00A2"; // same Unicode string
        byte[] asciiBytes = msg.getBytes(SmbConstants.DEFAULT_OEM_ENCODING);
        assertTrue(asciiBytes.length > 0, "ASCII encoding should produce bytes");
    }

    @Test

 * </ol>
 * <p>By caching artifacts in the local repository, Maven minimizes the need to repeatedly download the same artifacts, thus optimizing the build process.</p>
 *
 * <h2>Repository Configuration</h2>
 *
 * <p>Repositories can be configured at various levels:<ol>

      }
      if (component[toAndFromUri!!] != codePointString) {
        fail("Encoding $component $codePoint using $encoding")
      }
      return
    }

    // Check that the URI and HttpURL have the exact same escaping.
    if (toAndFromUri != httpUrl) {
      fail("Encoding $component $codePoint using $encoding")
    }
    if (uri.toString() != httpUrl.toString()) {
      fail("Encoding $component $codePoint using $encoding")

        // Arrange
        SmbPipeOutputStream out = newStream();

        // Act
        SmbPipeHandleImpl got = out.getHandle();

        // Assert
        assertSame(handle, got, "getHandle should expose the same instance passed to constructor");
    }

    @Test
    @DisplayName("close does nothing and does not touch handle")
    void close_doesNothing() throws Exception {
        // Arrange

import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import junit.framework.TestCase;
import org.junit.Test;

/**
 * Automatically runs sanity checks against top level classes in the same package of the test that
 * extends {@code AbstractPackageSanityTests}. Currently sanity checks include {@link
 * NullPointerTester}, {@link EqualsTester} and {@link SerializableTester}. For example:
 *
 * <pre>

        .containsExactly(0L, 1L, 3L, 6L, 10L, 15L, 21L)
        .inOrder();
  }

  public void testCopyOf_array_empty() {
    /*
     * We don't guarantee the same-as property, so we aren't obligated to test it. However, it's
     * useful in testing - when two things are the same then one can't have bugs the other doesn't.
     */
    assertThat(ImmutableLongArray.copyOf(new long[0])).isSameInstanceAs(ImmutableLongArray.of());
  }

            assertEquals(TEST_STRING.getBytes(StandardCharsets.UTF_16LE).length, result.length, "Length should match UTF-16LE encoding");
            assertArrayEquals(TEST_STRING.getBytes(StandardCharsets.UTF_16LE), result, "Should produce same bytes as UTF-16LE encoding");
        }

        @Test
        @DisplayName("getUNIBytes should handle Unicode characters correctly")
        void testGetUNIBytesWithUnicode() {
            // When