* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import static com.google.common.collect.Tables.transformValues;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.TableCollectionTest.RowTests;
import java.util.Map;
import org.jspecify.annotations.NullMarked;

@GwtCompatible

                        .stream()
                        .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                        .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieves a specific stemmer override dictionary item by ID.
     *
     * @param dictId the dictionary ID

            } catch (final Exception e) {
                logger.warn("Failed to load {}", jarFile.getAbsolutePath(), e);
            }
        }
        return nameSet.stream().sorted().collect(Collectors.toList());
    }

    assertEquals(map.size(), entrySetToArray1.length);
    assertTrue(asList(entrySetToArray1).containsAll(entrySet));

    Entry<?, ?>[] entrySetToArray2 = new Entry<?, ?>[map.size() + 2];
    entrySetToArray2[map.size()] = mapEntry("foo", 1);
    assertSame(entrySetToArray2, entrySet.toArray(entrySetToArray2));
    assertNull(entrySetToArray2[map.size()]);
    assertTrue(asList(entrySetToArray2).containsAll(entrySet));

```kotlin
val client = OkHttpClient.Builder()
    .dns { hostname -> InetAddress.getAllByName(hostname).toList() }
    .build()
```

Kotlin calling OkHttp 4.x:

```kotlin
val client = OkHttpClient.Builder()
    .dns(object : Dns {
      override fun lookup(hostname: String) =
          InetAddress.getAllByName(hostname).toList()
    })
    .build()
```

SAM conversion impacts these APIs:

        return asJson(new ApiResult.ApiConfigsResponse<ListBody>()
                .settings(Stream.of(dictFiles).map(this::createListBody).collect(Collectors.toList()))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a ListBody from a DictionaryFile for API responses.
     *

  public static Collection<Object[]> parameters() {
    ElementOrder<?> naturalElementOrder = ElementOrder.sorted(Ordering.natural());

    return Arrays.asList(
        new Object[][] {
          {false, false, ElementOrder.insertion(), ElementOrder.insertion()},
          {true, false, ElementOrder.insertion(), ElementOrder.insertion()},

      this.keyIndex = keyIndex;
    }

    @Override
    public Set<K> keySet() {
      return keyIndex.keySet();
    }

    K getKey(int index) {
      return keyIndex.keySet().asList().get(index);
    }

    abstract String getKeyRole();

    @ParametricNullness
    abstract V getValue(int index);

    @ParametricNullness

                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieve a single character mapping entry by ID for the specified dictionary.
     *
     * @param dictId identifier of the dictionary

  private val requestCookies: Deque<List<Cookie>> = ArrayDeque()
  private val responseCookies: Deque<List<Cookie>> = ArrayDeque()

  fun enqueueRequestCookies(vararg cookies: Cookie) {
    requestCookies.add(cookies.toList())
  }

  fun takeResponseCookies(): List<Cookie> = responseCookies.removeFirst()

  fun assertResponseCookies(vararg cookies: String?) {