mavenRepo.module("org.utils", "dep2", '2.0').publish()
        createDirs("impl", "dep1", "dep2")
        settingsFile << 'include "impl", "dep1", "dep2"'

        buildFile << """
            $common

            project(":dep1") {
                group "org.utils"
                version = '1.6'
            }

            project(":dep2") {
                group "org.utils"

        succeeds 'publish'

        then:
        def mainPom = mavenRepo.module('org.gradle', 'root', '1.0').parsedPom
        def dependency = mainPom.scopes.compile.expectDependency('org.gradle:pom-excludes:0.1')
        dependency.exclusions.size() == 3
        def sorted = dependency.exclusions.sort { it.groupId }
        sorted[0].groupId == "*"
        sorted[0].artifactId == "dep2"
        sorted[1].groupId == "org.opensource1"

	n := syntax.NewName(pos, name)
	tv := syntax.TypeAndValue{Type: typ}
	tv.SetIsValue()
	n.SetTypeInfo(tv)
	r.info.Defs[n] = obj
	return obj, n
}

func (r *rewriter) generateParamName(results []*syntax.Field, i int) {
	obj, n := r.sig.RenameResult(results, i)
	r.info.Defs[n] = obj
}

// declVar declares a variable with a given name type and initializer value.

			defs := GetOpenAPIDefinitionsWithoutDisabledFeatures(getOpenAPIDefs)(func(path string) spec.Ref {
				return spec.Ref{}
			})
			def := defs["k8s.io/api/apps/v1.DeploymentCondition"]
			enumAppeared := false
			for _, prop := range def.Schema.Properties {
				if strings.Contains(prop.Description, "enum") {
					enumAppeared = true

}

func canonicalMethod(pass *analysis.Pass, id *ast.Ident) {
	// Expected input/output.
	expect, ok := canonicalMethods[id.Name]
	if !ok {
		return
	}

	// Actual input/output
	sign := pass.TypesInfo.Defs[id].Type().(*types.Signature)
	args := sign.Params()
	results := sign.Results()

	// Special case: WriteTo with more than one argument,
	// not trying at all to implement io.WriterTo,

        metadata.dependencies.size() == 3

        def dep1 = metadata.dependencies[0]
        dep1.selector == moduleId('group-two', 'artifact-one', '11')
        dep1.scope == MavenScope.Compile

        def dep2 = metadata.dependencies[1]
        dep2.selector == moduleId('group-two', 'artifact-three', '11')
        dep2.scope == MavenScope.Compile

        def inheritedDep = metadata.dependencies[2]

	"cmd/internal/obj/wasm"
)

// SymABIs records information provided by the assembler about symbol
// definition ABIs and reference ABIs.
type SymABIs struct {
	defs map[string]obj.ABI
	refs map[string]obj.ABISet
}

func NewSymABIs() *SymABIs {
	return &SymABIs{
		defs: make(map[string]obj.ABI),
		refs: make(map[string]obj.ABISet),
	}
}

// canonicalize returns the canonical name used for a linker symbol in

      if (env_->FileExists(file_path).ok()) {
        TF_CHECK_OK(api_def_map_->LoadFile(env_, file_path)) << file_path;
      } else {
        // API defs are currently used for only optional pieces.
      }
    }
  }

  // Doc strings (summary, description) typically come from the API def.
  api_def_map_->UpdateDocs();
}

void Controller::BuildModel() {
  // Build the internal data model for the requested ops

  bool found = false;
  for (Node* node : graph->nodes()) {
    if (CanCreateXlaKernel(node->def())) {
      EXPECT_FALSE(found);
      found = true;
      std::vector<int32> hostmem_attr;
      EXPECT_TRUE(TryGetNodeAttr(node->def(), "_input_hostmem", &hostmem_attr));
      EXPECT_EQ(hostmem_attr.size(), 1);
      EXPECT_EQ(hostmem_attr[0], 1);
    }
  }

        where:
        dep1           | v1      | dep2           | v2
        'org:core'     | '2.9.4' | 'org:databind' | '2.7.9'
        'org:databind' | '2.7.9' | 'org:core'     | '2.9.4'
    }

    def "fails if forcing a virtual platform version and forcing a leaf with different version"() {
        repository {