}
    } else {
      // Unknown write.
      for (auto& [id, info] : per_resource_access_info_) {
        if (op_side_effect_collector_.IsOnlySelfDependent(id)) {
          // For self-dependent-only ID, clear unknown access tracking (the new
          // unknown write is not tracked by any other access). Note that we
          // cannot delete the access info because the new unknown write

                        + System.getProperty("maven.home", "<unknown Maven " + "home>")))
                .append(ls);
        version.append("Java version: ")
                .append(System.getProperty("java.version", "<unknown Java version>"))
                .append(", vendor: ")
                .append(System.getProperty("java.vendor", "<unknown vendor>"))
                .append(", runtime: ")

		t.Fatalf("unexpected error: %v", err)
	}

	// we want DecodeList to set type meta if possible, even on runtime.Unknown objects
	internal.Items[2].(*runtime.Unknown).TypeMeta = runtime.TypeMeta{Kind: "OtherTest", APIVersion: "unknown.group/unknown"}
	if e, a := internal.Items, list; !reflect.DeepEqual(e, a) {
		t.Errorf("mismatched decoded: %s", diff.ObjectGoPrintSideBySide(e, a))
	}
}

    }

    def "reports Ivy descriptor with artifact mapped to unknown configuration"() {
        given:
        buildFile << """
dependencies {
    compile 'group:projectA:1.2'
}
"""

        and:
        def module = ivyHttpRepo.module('group', 'projectA', '1.2').artifact(conf: 'default,unknown').publish()

        when:

    }

    def "plugin with an unknown identifier in a plugins management block - #settingScriptExtension"() {
        given:
        file("settings$settingScriptExtension") << use

        when:
        fails 'help'

        then:
        errorOutput.contains("Plugin [id: 'unknown', version: '1.0'] was not found in any of the following sources:")

        where:

		default:
			assert(false, "unknown")
		}
	}

	// boolean switch (has had bugs in past; worth writing down)
	switch {
	case true:
		assert(true, "switch 2 bool")
	default:
		assert(false, "switch 2 unknown")
	}

	switch true {
	case true:
		assert(true, "switch 3 bool")
	default:
		assert(false, "switch 3 unknown")
	}

	switch false {
	case false:

	t2
}

var (
	_ = t2{t1f1: 600} // ERROR "cannot use promoted field t1.t1f1 in struct literal of type t2|unknown field"
	_ = t3{t1f2: 800} // ERROR "cannot use promoted field t2.t1.t1f2 in struct literal of type t3|unknown field"
	_ = t3{t2f1: 900} // ERROR "cannot use promoted field t2.t2f1 in struct literal of type t3|unknown field"

	Success Result = "success"
	// Warning Result. Logically success, but with additional debugging information attached.
	Warning Result = "warning"
	// Failure Result
	Failure Result = "failure"
	// Unknown Result
	Unknown Result = "unknown"

    DEFAULT("default"), LATEST("latest"), PARTIAL("partial"), FULL("all"), UNKNOWN(null);

    public final String selector;

    CoverageContext(String selector) {
        this.selector = selector;
    }

    static CoverageContext from(String requested) {
        for (CoverageContext context : values()) {
            if (context != UNKNOWN && context.selector.equals(requested)) {
                return context;
            }

        and:
        metadata.installDir == dir2
        metadata.compatibility == LEGACY
        metadata.visualCppDir == new File(dir2, "VC")
        metadata.visualCppVersion == VersionNumber.UNKNOWN
        metadata.version == VersionNumber.UNKNOWN
    }

    def "can determine VS2017 metadata from installation directory when not found in command line results"() {
        def dir1 = tmpDir.createDir("dir1")