}

        ExecutorService createExecutor(int parallelism) {
            //
            // We need an executor that will not block.
            // We can't use work stealing, as we are building a graph
            // and this could lead to cycles where a thread waits for
            // a task to finish, then execute another one which waits
            // for the initial task...

     * or even inconsistent. For example, databind 2.9.4 depends on annotations 2.9.0, but we still
     * want to upgrade annotations to the highest version of the platform seen in the graph, which
     * is 2.9.4.1, a **patch** release in this case. This patch release doesn't publish all versions
     */
    def "can align heterogeneous versions"() {
        repository {

/*!
  * Bootstrap v4.4.1 (https://getbootstrap.com/)
  * Copyright 2011-2019 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  */

			// supposed we have a top level directory with three
			// package subdirs, "a", "b", and "c", and
			// from the top level, a user runs "go test -coverpkg=./... ./...".
			// This will result in (roughly) the following action graph:
			//
			//	build("a")       build("b")         build("c")
			//	    |               |                   |
			//	link("a.test")   link("b.test")     link("c.test")
			//	    |               |                   |

// but in our usage we often need the opposite: for a given service, what are all the aliases?
// resolveServiceAliases walks this 'graph' of services and updates the Alias field in-place.
func resolveServiceAliases(allServices []*Service, configsUpdated sets.Set[ConfigKey]) {
	// rawAlias builds a map of Service -> AliasFor. So this will be ExternalName -> Service.

        e.message == "No model node at 'thing'"

        where:
        state << ModelNode.State.values()
    }

    def "getting self closed collection defines all links but does not realise them until graph closed"() {
        given:
        def events = []
        def mmType = ModelTypes.modelMap(Bean)

        registry
            .registerModelMap("things", Bean) { it.registerFactory(Bean) { new Bean(name: it) } }

  if (is_map_oc) {
    if (op_is_map_oc != *is_map_oc) {
      return op.emitOpError()
             << "Cannot mix map_outside_compilation with ordinary "
                "outside_compilation in the same graph.";
    }
  } else {
    is_map_oc = op_is_map_oc;
  }
  if (control_above && op_is_map_oc) {
    return op.emitOpError() << "map_outside_compilation inside control flow "

func (c *typeConv) Type(dtype dwarf.Type, pos token.Pos) *Type {
	return c.loadType(dtype, pos, "")
}

// loadType recursively loads the requested dtype and its dependency graph.
func (c *typeConv) loadType(dtype dwarf.Type, pos token.Pos, parent string) *Type {
	// Always recompute bad pointer typedefs, as the set of such
	// typedefs changes as we see more types.
	checkCache := true