{
		"testdata/go-relocation-test-gcc441-x86-64.obj",
		[]relocationTestEntry{
			{
				entry: &dwarf.Entry{
					Offset:   0xb,
					Tag:      dwarf.TagCompileUnit,
					Children: true,
					Field: []dwarf.Field{
						{Attr: dwarf.AttrProducer, Val: "GNU C 4.4.1", Class: dwarf.ClassString},
						{Attr: dwarf.AttrLanguage, Val: int64(1), Class: dwarf.ClassConstant},

                module('org.gradle.test:lib.subgroup:1.1') {
                    artifact(type: 'txt')
                }
            }
        }
    }

    def "supports aliases which also have children"() {
        settingsFile << """
            dependencyResolutionManagement {
                versionCatalogs {
                    libs {
                        library("top", "org:top:1.0")

			continue
		}
	}
}

func TestEscapeSet(t *testing.T) {
	type dataItem struct {
		Children []*dataItem
		X        string
	}

	data := dataItem{
		Children: []*dataItem{
			{X: "foo"},
			{X: "<bar>"},
			{
				Children: []*dataItem{
					{X: "baz"},
				},
			},
		},
	}

	tests := []struct {
		inputs map[string]string

            transformerName: "MakeGreen",
            subjectName: "producer.jar (project :producer)",
        ])

        def executeWorkOps1 = buildOperations.children(executePlannedStepOps[0], ExecuteWorkBuildOperationType)
        def executeWorkOps2 = buildOperations.children(executePlannedStepOps[1], ExecuteWorkBuildOperationType)

        // Order of scheduling/execution is not guaranteed between the consumer projects

        then:
        def ex = thrown IllegalStateException
        ex.message == "Tried to remove model 'foo' but it is depended on by: 'bar'"
    }

    def "can remove an element with children that has not been used as input by a rule"() {
        given:
        registry.register("parent") { it.unmanagedNode (Integer) { MutableModelNode node ->
            node.addLinkInstance("parent.foo", 12.toInteger())

    }


    @Override
    public CloseableIterator<SmbResource> children () throws CIFSException {
        return SmbEnumerationUtil.doEnum(this, "*", ATTR_DIRECTORY | ATTR_HIDDEN | ATTR_SYSTEM, null, null);
    }


    @Override
    public CloseableIterator<SmbResource> children ( String wildcard ) throws CIFSException {

        if (type == MutationType.STRATEGY) {
            return;
        }

        preventIllegalParentMutation(type);
        boolean emittedDeprecation = maybePreventMutation(type, type + " of parent");

        // Notify children of this mutation, but don't emit a deprecation if we already emitted one

        then:
        1 * fileResolver.resolve('a') >> file
        0 * fileResolver._

        then:
        files as List == [file]
    }

    def "can visit structure and children after finalized from paths"() {
        given:
        def file1 = new File('one')
        def file2 = new File('two')
        _ * fileResolver.resolve(file1) >> file1

		ds := loader.Sym(pdie.Sym.(dwSym))
		d.rtmap[ds] = gts
		d.tdmap[gts] = ds
	}

	return d.dtolsym(pdie.Sym)
}

// Copies src's children into dst. Copies attributes by value.
// DWAttr.data is copied as pointer only. If except is one of
// the top-level children, it will not be copied.
func (d *dwctxt) copychildrenexcept(ctxt *Link, dst *dwarf.DWDie, src *dwarf.DWDie, except *dwarf.DWDie) {

        mavenRepo.module('org', 'direct', '1.0')
        // endorsing dependency that will cause a reselection of the parent again causing a reselection of other children
        // ("looping back" if a another child is the same as the one that was endorsed)
            .dependsOn([endorseStrictVersions: true], lib1).dependsOn(lib05).dependsOn(lib1).withModuleMetadata().publish()