StringRef(content.data(), content.size()));
}

LogicalResult BuildOption(flexbuffers::Builder* fbb, Operation* op,
                          NamedAttribute pair) {
  const char* key = pair.getName().data();
  const auto attr = pair.getValue();

  if (mlir::isa<::mlir::IntegerAttr>(attr)) {
    fbb->Int(key, mlir::dyn_cast<mlir::IntegerAttr>(attr).getInt());
    return success();
  }

            assertNotClosed();
            IndexedCache<?, ?> indexedCache = caches.get(Pair.of(cacheDir, name));
            if (indexedCache == null) {
                indexedCache = new TestInMemoryIndexedCache<K, V>(valueSerializer);
                caches.put(Pair.of(cacheDir, name), indexedCache);
            }
            return Cast.uncheckedCast(indexedCache);
        }

  for (const auto& pair : clusters) {
    if (pair.first == kNoCluster) {
      absl::StrAppend(&result, "unclustered");
    } else {
      absl::StrAppend(&result, "cluster ", pair.first);
    }

    absl::StrAppend(&result, " size ", cluster_size[pair.first], "\n");

    for (const auto& ops_and_counts : pair.second) {
      absl::StrAppend(&result, " ", ops_and_counts.first, " ",

                value = value.replace("${" + entry.getKey() + "}", entry.getValue());
            }
            return new Pair<>(key, value);
        }).collect(Collectors.toMap(Pair<String, String>::getFirst, Pair<String, String>::getSecond));
        final Map<String, String> configScriptMap = config.getHandlerScriptMap();

        initParamMap.putAll(configParamMap);

    }

    @Override
    @Nullable
    public MetaProperty getMetaProperty(String name) {
        MetaProperty original = adaptee.getMetaProperty(name);
        Pair<String, CallInterceptor> getterCallerAndInterceptor = findGetterCallerAndInterceptor(name);
        Pair<String, CallInterceptor> setterCallerAndInterceptor = getterCallerAndInterceptor != null ? null : findSetterCallerAndInterceptor(name);

    }

    def "partitioning"() {
        when:
        def pair = partition([1, 2, 3], { it % 2 == 0 })

        then:
        pair.left == [2]
        pair.right == [1, 3]
    }

    def "partitioning empty collection"() {
        when:
        def pair = partition([], { it })

        then:
        pair.left == []
        pair.right == []
    }

   * }
   * ```
   *
   * The first property of the pair is the adapter that was used, the second property is the value.
   */
  internal val generalNameDnsName = Adapters.IA5_STRING.withTag(tag = 2L)
  internal val generalNameIpAddress = Adapters.OCTET_STRING.withTag(tag = 7L)
  internal val generalName: DerAdapter<Pair<DerAdapter<*>, Any?>> =
    Adapters.choice(
      generalNameDnsName,

import java.util.List;
import java.util.regex.Pattern;

import org.codelibs.core.misc.Pair;
import org.codelibs.fess.unit.UnitFessTestCase;

public class FessCrawlerThreadTest extends UnitFessTestCase {

    public void test_getClientRuleList() {
        FessCrawlerThread crawlerThread = new FessCrawlerThread();

        List<Pair<String, Pattern>> list = crawlerThread.getClientRuleList(null);
        assertEquals(0, list.size());

#include "tensorflow/compiler/mlir/quantization/stablehlo/cc/types.h"

namespace mlir::quant::stablehlo {
namespace {

using ::testing::IsEmpty;
using ::testing::Pair;
using ::testing::UnorderedElementsAre;

using UpdateFunctionAliasesTest = ::mlir::quant::QuantizationTestBase;

TEST_F(UpdateFunctionAliasesTest, NoAliasesReturnsEmptyMap) {

  private lateinit var server: MockWebServer
  private lateinit var client: OkHttpClient

  val listener = RecordingEventListener()

  fun setUp(mode: Pair<CancelMode, ConnectionType>) {
    this.cancelMode = mode.first
    this.connectionType = mode.second

    if (connectionType == H2) {
      platform.assumeHttp2Support()
    }