String sourceType = "cpp"
    def libObjects = new CompilationOutputsFixture(file("library/build/obj/main/debug"), [".o", ".obj"])
    def appObjects = new CompilationOutputsFixture(file("app/build/obj/main/debug"), [".o", ".obj"])

    def install = installation("app/build/install/main/debug")
    def libraryDebug = tasks(LIBRARY).debug
    def appDebug = tasks(APP).debug
    def installApp = appDebug.install

    def setup() {

Than McIntosh <******@****.***> 1691585441 -0400

`
	const want = `L3 defs func p._()
L4 defs const w untyped int
L5 defs var x int
L5 defs var y int
L6 defs var z int
L6 uses const w untyped int
L6 uses var x int
L7 uses var x int
L7 uses var y int
L7 uses var z int`

	// don't abort at the first error
	conf := Config{Error: func(err error) { t.Log(err) }}
	defs := make(map[*syntax.Name]Object)
	uses := make(map[*syntax.Name]Object)

        assertEquals("dep2", artifactId);

        // Map

        dependency = (Dependency) ReflectionValueExtractor.evaluate("project.dependenciesAsMap(dep1)", project);

        assertNotNull(dependency);

        assertEquals("dep1", dependency.getArtifactId());

        artifactId = (String) ReflectionValueExtractor.evaluate("project.dependenciesAsMap(dep2).artifactId", project);

  os << "\n\n";
  EmitGetBuiltinOpCode(defs, &os);
  os << "\n\n";
  EmitBuildOperator(defs, &os);
  os << "\n\n";
  EmitBuiltinOptionsToAttributes(records, defs, &os, /*builtin_options_id=*/1);
  os << "\n\n";
  EmitBuiltinOptionsToAttributes(records, defs, &os, /*builtin_options_id=*/2);
  os << "\n\n";
  EmitOperandNumbers(records, defs, &os);

  return false;
}

        root.outgoingEdges >> [
            dep(selector1, 1, new RuntimeException()),
            dep(selector2, 1, 3)
        ]
        def dep2 = node(3, "org", "dep2", "2.0")
        def selector3 = selector(12, "org", "dep1", "5.0")
        dep2.outgoingEdges >> [dep(selector3, 3, new RuntimeException())]

        builder.start(root)

        builder.visitNode(root)

        dep1.isEndorsingStrictVersions()

        when:
        dependencyHandler.platform(dep2) { }

        then:
        1 * dependencyFactory.createDependency(dep2) >> dep2
        dep2.attributes.getAttribute(Category.CATEGORY_ATTRIBUTE).name == 'platform'
        dep2.isEndorsingStrictVersions()
    }

    void "platform dependency can be made non-endorsing"() {

    [(IsNotInLiftedFunc $res),
     (IsEinsumSupportedByXlaDotV2 $equation)],
    [], (addBenefit 10)>;

}
defm : LiftCompositeOpsWithActivation<TF_ReluOp, "relu">;
defm : LiftCompositeOpsWithActivation<TF_Relu6Op, "relu6">;

def LiftGather : Pat<
  (TF_GatherV2Op:$res $params, $indices, $axis, $batch_dims),
  (LiftAsTFPartitionedCall<"composite_gather_fn">

	}

	// Through reader. Used to fail.
	r := NewDecoder(RawURLEncoding, bytes.NewReader([]byte(source)))
	dec2, err := io.ReadAll(io.LimitReader(r, 100))
	if err != nil || !bytes.Equal(dec2, want) {
		t.Errorf("reading NewDecoder(RawURLEncoding, %q) = %x, %v, want %x, nil", source, dec2, err, want)
	}

	// Should work with padding.
	r = NewDecoder(URLEncoding, bytes.NewReader([]byte(source+"==")))

    void "knows if is equal to"() {
        when:
        def dep1 = createDependency("group1", "name1", "version1")
        def dep2 = createDependency("group1", "name1", "version1")
        def attr1 = Attribute.of("attr1", String)
        def attr2 = Attribute.of("attr2", Integer)
        dep1.attributes {
            it.attribute(attr1, 'foo')
        }
        dep2.attributes {
            it.attribute(attr2, 123)
        }