succeeds("after")
        output.count("prop = " + file("build/dir.out")) == 3
    }

    @ToBeFixedForConfigurationCache(because = "https://github.com/gradle/gradle/issues/25513")
    def "cannot query strict task output file property until task starts execution"() {
        taskTypeWithOutputFileProperty()
        settingsFile << "rootProject.name = 'broken'"
        buildFile """
            task producer(type: FileProducer) {

    }

    private Set<ComponentIdentifier> computeDependencies(ResolvedComponentResult value, boolean strict) {
        ResolvedComponentResult targetComponent = findComponent(value, componentIdentifier);

        if (targetComponent == null) {
            // TODO: This is very suspicious. We should always fail here.
            // `strict` was added because file dependencies' components are never included in the graph.

	{StdEncoding, stdRef},
	{URLEncoding, urlRef},
	{RawStdEncoding, rawRef},
	{RawURLEncoding, rawURLRef},
	{funnyEncoding, funnyRef},
	{StdEncoding.Strict(), stdRef},
	{URLEncoding.Strict(), urlRef},
	{RawStdEncoding.Strict(), rawRef},
	{RawURLEncoding.Strict(), rawURLRef},
	{funnyEncoding.Strict(), funnyRef},
}

var bigtest = testpair{
	"Twas brillig, and the slithy toves",
	"VHdhcyBicmlsbGlnLCBhbmQgdGhlIHNsaXRoeSB0b3Zlcw==",
}

        failure.assertHasDescription("Execution failed for task ':thing'.")
        failure.assertHasCause("The value for this property is final and cannot be changed any further.")
    }

    def "can write but cannot read strict project property instance before project configuration completes"() {
        given:
        settingsFile << 'rootProject.name = "broken"'
        buildFile """
            interface ProjectModel {

			for _, ver := range merged {
				if ver.header.Type == invalidVersionType {
					t.Errorf("Invalid result returned: %v", ver.header)
				}
			}
		})
		t.Run(fmt.Sprintf("strict-signature-q%d", i), func(t *testing.T) {
			// Mutate signature, non strict
			vMod := make([][]xlMetaV2ShallowVersion, 0, len(vers))
			for i, ver := range vers {
				newVers := make([]xlMetaV2ShallowVersion, 0, len(ver))
				for _, v := range ver {

var ipTablesValuePtrType = reflect.TypeOf((*IPTablesValue)(nil))

// ParseRule parses rule. If strict is false, it will parse the recognized
// parameters and ignore unrecognized ones. If it is true, parsing will fail if there are
// unrecognized parameters.
func ParseRule(rule string, strict bool) (*Rule, error) {
	parsed := &Rule{Raw: rule}

	// Split rule into "words" (where a quoted string is a single word).

        when:
        fails('broken')

        then:
        failure.assertHasCause("The value for this file collection cannot be changed any further.")
    }

    def "can write but cannot read strict project file collection instance before project configuration completes"() {
        given:
        settingsFile << 'rootProject.name = "broken"'
        buildFile """
            interface ProjectModel {

	listQuorum := env.Get(EnvAPIListQuorum, kvs.GetWithDefault(apiListQuorum, DefaultKVS))
	switch listQuorum {
	case "strict", "optimal", "reduced", "disk", "auto":
	default:
		return cfg, fmt.Errorf("invalid value %v for list_quorum: will default to 'strict'", listQuorum)
	}
	cfg.ListQuorum = listQuorum

func TestDecodeNilToken(t *testing.T) {
	for _, strict := range []bool{true, false} {
		name := fmt.Sprintf("Strict=%v", strict)
		t.Run(name, func(t *testing.T) {
			start := StartElement{Name: Name{Local: "test"}}
			bad := StartElement{Name: Name{Local: "bad"}}
			d := NewTokenDecoder(&toksNil{
				// Malformed
				t: []Token{start, bad, start.End()},
			})
			d.Strict = strict
			err := d.Decode(&struct {

			url: &url.URL{
				RawQuery: "fieldValidation=Warn",
			},
			expectedFieldValidation: "Warn",
		},
		{
			name: "strict field validation",
			url: &url.URL{
				RawQuery: "fieldValidation=Strict",
			},
			expectedFieldValidation: "Strict",
		},
		{
			name: "invalid field validation",
			url: &url.URL{
				RawQuery: "fieldValidation=foo",
			},