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);

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) {

go list -m -f '{{.Dir}}' all
stdout '^'$WORK'[/\\]auto$'
stdout '^'$GOPATH'[/\\]pkg[/\\]mod[/\\]example.com[/\\]printversion@v1.0.0$'
stdout '^'$WORK'[/\\]auto[/\\]replacement-version$'

# 'go mod vendor' should repair vendor/modules.txt so that the implicit
# -mod=vendor works again.
env GOFLAGS=

go mod edit -go=1.14
go mod vendor

go list -f {{.Dir}} -tags tools -e all
stdout '^'$WORK'[/\\]auto$'

fun foo(): Pair<Int, Int> {
    return x to y
}

    /**
     * Locates the log content starting with the first line that matches the given pattern, or null if no such line.
     *
     * @return a pair containing (content-before-matching-line, content-from-matching-line) or null if no match.
     */
    public @Nullable
    Pair<LogContent, LogContent> splitOnFirstMatchingLine(Pattern pattern) {
        for (int i = 0; i < lines.size(); i++) {
            String line = lines.get(i);

    // TODO(chky): Support cases where index_path is not a single string.
    return mlir::cast<mlir::StringAttr>(index_path[0]).getValue();
  }
  return "";
}

absl::StatusOr<std::pair<tensorflow::DataType, tensorflow::PartialTensorShape>>
ProcessTensorSpec(mlir::TensorType type) {
  tensorflow::DataType dtype;
  TF_RETURN_IF_ERROR(
      ConvertScalarTypeToDataType(type.getElementType(), &dtype));