failures.size() == 1
        failures.each {
            assert it.problem instanceof LockOutOfDateException
            assert it.problem.message.contains("Did not resolve 'org:foo:1.1' which has been forced / substituted to a different version: '1.0'")
        }
    }

    def 'invokes locking provider on writeLocks with visited modules'() {
        given:
        def identifier = newId(mid, '1.1')

                    edge('org:foo:2.0', 'org:foo:0.11').selectedByRule('because I can')
                }
            }
        }
    }

    def "a substitution does not leak substituted strict version constraint"() {
        given:
        repository {
            'org:foo:1.0'()
            'org:foo:2.0'()
            'org:new:1.0'()
            'org:bar:1.0' {

//  - We say that a Named type is "expanded" if it is an instantiated type and
//    type parameters in its underlying type and methods have been substituted
//    with the type arguments from the instantiation. A type may be partially
//    expanded if some but not all of these details have been substituted.
//    Similarly, we refer to these individual details (underlying type or
//    method) as being "expanded".

	r1, r2 rune
	want   rune
}{
	{0xd800, 0xdc00, 0x10000},
	{0xd800, 0xdc01, 0x10001},
	{0xd808, 0xdf45, 0x12345},
	{0xdbff, 0xdfff, 0x10ffff},
	{0xd800, 'a', 0xfffd}, // illegal, replacement rune substituted
}

func TestDecodeRune(t *testing.T) {
	for i, tt := range decodeRuneTests {
		got := DecodeRune(tt.r1, tt.r2)
		if got != tt.want {

func (t Tag) IsRoot() bool {
	if t.full != nil {
		return t.full.IsRoot()
	}
	return t.language == _und
}

// Parent returns the CLDR parent of t. In CLDR, missing fields in data for a
// specific language are substituted with fields from the parent language.
// The parent for a language may change for newer versions of CLDR.
func (t Tag) Parent() Tag {
	if t.full != nil {
		return Make(t.full.Parent())
	}

export MINIO_IDENTITY_LDAP_TLS_SKIP_VERIFY=on
```

### Variable substitution in configuration strings

In the configuration variables, `%s` is substituted with the _username_ from the STS request and `%d` is substituted with the _distinguished username (user DN)_ of the LDAP user. Please see the following table for which configuration variables support these substitution variables:

    }

    @Override
    public DefaultIdeaProject buildForRoot(Project project, boolean offlineDependencyResolution) {
        requireRootProject(project);

        // Ensure unique module names for dependencies substituted from included builds
        applyIdeaPluginToBuildTree(project);

        IdeaModelParameter parameter = createParameter(offlineDependencyResolution);
        return build(project, parameter);
    }

            }
        }
    }

    // TODO: This is not desired behavior. We should deprecate and forbid this.
    def "can consume non-consumable project configuration when substituted as a transitive dependency"() {

        file("included/settings.gradle") << """
            rootProject.name = "transitive"
        """
        file("included/build.gradle") << """
            group = "org"

                    }
                }
            }
        }
    }

    def "selects default configuration of ivy module when dependency from consuming maven module is substituted"() {
        def m1 = ivyRepo.module("org.test", "m1", "1.0")
            .configuration("compile")
            .publish()
        def m2 = ivyRepo.module("org.test", "m2", "1.0").publish()

	case reflect.Interface:
		return match(m, p.Elem(), v.Elem())
	}

	// Handle token integers, etc.
	return p.Interface() == v.Interface()
}

// subst returns a copy of pattern with values from m substituted in place
// of wildcards and pos used as the position of tokens from the pattern.
// if m == nil, subst returns a copy of pattern and doesn't change the line
// number information.