*/
    internal val ORDER_BY_NAME =
      object : Comparator<String> {
        override fun compare(
          a: String,
          b: String,
        ): Int {
          var i = 4
          val limit = minOf(a.length, b.length)
          while (i < limit) {
            val charA = a[i]
            val charB = b[i]
            if (charA != charB) return if (charA < charB) -1 else 1

import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension

@Suppress("deprecation")
@Timeout(30)
@Tag("Slow")
class MockWebServerTest {
  @RegisterExtension
  var platform = PlatformRule()

  private val server = MockWebServer()

  @BeforeEach
  fun setUp() {
    server.start()
  }

  @AfterEach
  fun tearDown() {
    server.close()
  }

  @Test

        void testNullAndEmptyKeys(String key) {
            referralData.setKey(key);
            assertEquals(key, referralData.getKey());
        }

        @Test
        @DisplayName("Should handle very long paths")
        void testVeryLongPaths() {
            StringBuilder longPath = new StringBuilder("\\server\\share");
            for (int i = 0; i < 100; i++) {
                longPath.append("\\subfolder").append(i);

 * {@link ImmutableList}) instead of the general collection interface type (such as {@link List}).
 * This communicates to your callers all of the semantic guarantees listed above, which is almost
 * always very useful information.
 *
 * <p>On the other hand, a <i>parameter</i> type of {@link ImmutableList} is generally a nuisance to
 * callers. Instead, accept {@link Iterable} and have your method or constructor body pass it to the

* list-resources: don't fail if the grep fails to match any resources ([#4193...

    }

    assertMoreInvariants(map);
  }

  @SuppressWarnings("CollectionIncompatibleType")
  private void assertEntrySetNotContainsString(Set<Entry<K, V>> entrySet) {
    // Very unlikely that a buggy collection would ever return true. It might accidentally throw.
    assertFalse(entrySet.contains("foo"));
  }

  /**

- Fixes a bug where `MutatingAdmissionPolicy` would fail to apply to objects with duplicate list items (like env vars). ([#135560](https://github.com/kubernetes/kubernetes/pull/135560), [@lalitc375](https://github.com/lalitc375) [SIG API Machinery]

        assertEquals(0, buffer[1]);
    }

    @Test
    @DisplayName("Test writeBytesWireFormat with long path")
    void testWriteBytesWireFormatLongPath() {
        String longPath = "very\\long\\path\\to\\some\\deeply\\nested\\file\\in\\directory\\structure.txt";
        request = new Smb2CreateRequest(mockConfig, longPath);

        byte[] buffer = new byte[2048];

    return file(new File(first), more);
  }

  /** Returns a {@code File} object for the given path parts. */
  private static File file(File first, String... more) {
    // not very efficient, but should definitely be correct
    File file = first;
    for (String name : more) {
      file = new File(file, name);
    }
    return file;
  }

   *       simply switch over to use the JDK implementation wholesale if probable hash flooding is
   *       detected, sacrificing the compactness guarantee in very rare cases in exchange for much
   *       more reliable worst-case behavior.
   *   <li>null, if no entries have yet been added to the map
   * </ul>
   */
  private transient @Nullable Object table;

  /**