StringRef caller_name = mlir::cast<NameLoc>(caller).getName().strref();
    const size_t start_index = kQuantizationUnitPrefix.size();
    const size_t end_index = caller_name.rfind(kQuantizationUnitSuffix);
    std::string serialized_proto =
        caller_name.substr(start_index, end_index - start_index).str();
    QuantizationUnitLoc::QuantizationUnit quant_unit;

  explicit MockFailurePass() = default;

 private:
  void runOnOperation() override {
    getOperation().walk([](Operation* nestedOp) {
      if (nestedOp->getName().getStringRef().str().rfind("tf.") != -1) {
        AttachErrorCode(
            nestedOp->emitError()
                << "Failed at " << nestedOp->getName().getStringRef().str()
                << " op",

    result = result.substr(sizeof("external/") - 1);
    pos = result.find('/');
    if (pos != string::npos) {
      result = result.substr(pos + 1);
    }
  }
  return result;
}

string GetFilename(StringPiece path) {
  size_t slash_pos = path.rfind('/');
  if (slash_pos == path.npos) slash_pos = -1;
  size_t dot_pos = path.rfind('.');
  return string(path.substr(slash_pos + 1, dot_pos - (slash_pos + 1)));
}

  return absl::StrCat(path, ":", singleprint);
}

absl::StatusOr<std::pair<std::string, std::string>>
ParseSavedModelPathAndSingleprint(std::string path_and_singleprint) {
  size_t delimiter = path_and_singleprint.rfind(':');
  if (delimiter == std::string::npos) {
    return absl::InvalidArgumentError(
        "Invalid path_and_singleprint argument. Found no delimeter.");
  }

        def mainDirAttributes = project.sourceDirectories.find { it.path == 'src/main/java' }.classpathAttributes
        def testDirAttributes = project.sourceDirectories.find { it.path == 'src/test/java' }.classpathAttributes

        then:
        mainDirAttributes.find { it.name == 'gradle_scope' && it.value == 'main' }
        mainDirAttributes.find { it.name == 'gradle_used_by_scope' && it.value == 'main,test' }

	if err := DB.First(&User{}, "name = ?", user.Name).Error; err != nil {
		t.Fatalf("Should find saved record")
	}

	if err := DB.First(&User{}, "name = ?", user1.Name).Error; err == nil {
		t.Fatalf("Should not find rollbacked record")
	}

	if err := DB.First(&User{}, "name = ?", user2.Name).Error; err != nil {
		t.Fatalf("Should find saved record")
	}
}

func TestNestedTransactionWithBlock(t *testing.T) {
	var (

        EclipseProjectDependency depC = projectA.projectDependencies.find { it.path == 'c' }
        EclipseProjectDependency depD = projectA.projectDependencies.find { it.path == 'd' }

        then:
        !depB.classpathAttributes.find { it.name == 'test' && it.value == 'true' }
        !depB.classpathAttributes.find { it.name == 'without_test_code' && it.value == 'false' }

			test.find(find) // Now we should be able to find things.
			find(0, 0)      // The test should always fully exhaust the index.
		})
		t.Run("Force/"+test.name, func(t *testing.T) {
			mark, find, _ := setup(t, true)
			test.mark(mark)
			test.find(find) // Finding should always work when forced.
			find(0, 0)      // The test should always fully exhaust the index.
		})
	}
	t.Run("Bg/MarkInterleaved", func(t *testing.T) {

        expect:
        !empty.find("")
        !empty.find("alma")
    }

    def "can find exact match"() {
        def trie = Trie.from("aaa", "bbb")
        expect:
        trie.find("aaa")
        trie.find("bbb")
        !trie.find("ccc")
    }

    def "can find prefix match"() {
        def trie = Trie.from("aaa", "bbb")
        expect:
        !trie.find("a")
        !trie.find("aa")

        ideaProject.modules.find { it.name == 'root' }.javaLanguageSettings == null
        ideaProject.modules.find { it.name == 'child1' }.javaLanguageSettings == null
        ideaProject.modules.find { it.name == 'child2' }.javaLanguageSettings.languageLevel == JavaVersion.VERSION_1_2
        ideaProject.modules.find { it.name == 'child3' }.javaLanguageSettings.languageLevel == null // inherited
    }