actions {}

        when:
        visit()

        then:
        2 * delegateAction.processFile({ it.relativePath.pathString == '/root/path/file1.txt' })
        1 * delegateAction.processFile({ it.relativePath.pathString == '/root/path/file2.txt' })
    }

    def duplicatesExcludedByPerFileConfiguration() {
        given:
        files 'path/file1.txt', 'path/file2.txt', 'path/file1.txt'

        when:
        executer.execute(copySpec, copyAction)

        then:
        1 * action.processFile({ it.relativePath.pathString == "a" })
        0 * action.processFile(_)
    }

    Closure path(path) {
        return { println it.relativePath.pathString; it.relativePath.pathString == path }
    }

    val properties = propertiesSupplier.get()
    for (p in properties) {
        when (jvmSignature) {
            p.fieldSignature?.asString() -> return predicate(p.flags)
            p.getterSignature?.asString() -> return predicate(p.getterFlags)
            p.setterSignature?.asString() -> return predicate(p.setterFlags)
        }
    }
    return false

                    if (details.relativePath.parent.parent) {
                        assertThat(dirs, hasItem(details.relativePath.parent.pathString))
                    }
                    assertTrue(files.add(details.relativePath.pathString))
                    assertTrue(details.relativePath.isFile())
                    assertTrue(details.file.file)

					Field: []dwarf.Field{
						{Attr: dwarf.AttrProducer, Val: "GNU C 4.4.1", Class: dwarf.ClassString},
						{Attr: dwarf.AttrLanguage, Val: int64(1), Class: dwarf.ClassConstant},
						{Attr: dwarf.AttrName, Val: "go-relocation-test.c", Class: dwarf.ClassString},
						{Attr: dwarf.AttrCompDir, Val: "/tmp", Class: dwarf.ClassString},
						{Attr: dwarf.AttrLowpc, Val: uint64(0x0), Class: dwarf.ClassAddress},

  auto sub_type = mlir::dyn_cast<mlir::TF::TensorFlowTypeWithSubtype>(type);
  if (!sub_type) return false;

  bool has_string = llvm::any_of(sub_type.GetSubtypes(), [](TensorType type) {
    return mlir::isa<mlir::TF::StringType>(type.getElementType());
  });
  return has_string;
}

bool HasStringOperand(Operation& op) {
  for (auto operand : op.getOperands()) {

#include "mlir/IR/Attributes.h"  // from @llvm-project
#include "mlir/IR/Operation.h"  // from @llvm-project

namespace tensorflow {

// Return a string form of `op` including debug information.
std::string OpAsString(mlir::Operation& op) {
  std::string out;
  llvm::raw_string_ostream op_stream(out);
  op.print(op_stream, mlir::OpPrintingFlags()
                          .elideLargeElementsAttrs()

        int andRecordCount = JsonPath.from(andResponse).getInt("record_count");

        Map<String, String> params = new HashMap<>();
        params.put("q", query);
        params.put("num", "100");
        String response = checkMethodBase(new HashMap<>()).params(params).get("/api/v1/documents").asString();

        // logger.debug(response.asString());
        return response;
    }

    protected Response checkPutMethod(final Map<String, Object> body, final String path) {
        Response response = checkMethodBase(body).put(getApiPath() + "/" + path);
        // logger.debug(response.asString());
        return response;
    }

	asSlice(*&slice)
	isSlice(*&slice)

	asString(str)
	isString(str)
	asString(str + "a")
	isString(str + "a")
	asString("a" + str)
	isString("a" + str)
	asString(str + str)
	isString(str + str)
	str += "a"
	str += str
	asString(String('a'))
	isString(String('a'))
	asString(String([]byte(slice)))
	isString(String([]byte(slice)))
	asString(String([]byte(nil)))
	isString(String([]byte(nil)))