}`

	var combinedErrs = []string{
		`unknown field "ca[1].unknown1"`,
		`unknown field "ca[2].unknown2"`,
		`unknown field "ba.unknown3"`,
		`unknown field "ba.unknown4"`,
		`unknown field "unknown5"`,
		`unknown field "ha.unknownH"`,
		`unknown field "ia.unknownI"`,

		`unknown field "ul1.b"`,
		`unknown field "ul1.bb"`,
		`unknown field "ul1.bbb"`,
		`unknown field "ul1.c"`,
		`unknown field "ul1.cc"`,

    %0 = "tf.ReadVariableOp"(%arg19)...

        failure.assertHasCause("Could not set unknown property 'modue' for object of type org.gradle.api.internal.artifacts.DefaultExcludeRule.")
    }

    void "makes no attempt to resolve an excluded dependency"() {
        given:
        mavenRepo.module('org.gradle.test', 'external', '1.0')
            .dependsOn('org.gradle.test', 'unknown1', '1.0')
            .dependsOn('org.gradle.test', 'unknown2', '1.0').publish()

        when:

// CHECK: [[UNKNOWN0:%.+]] = tf_executor.island([[READ0]], [[READ1]], [[READ2]], [[LOAD0]], [[READ3]], [[LOAD1]]) wraps "tf.UnknownOp"
// CHECK: [[UNKNOWN1:%.+]] = tf_executor.island([[UNKNOWN0]]) wraps "tf.UnknownOp"
// CHECK: [[LOAD2:%.+]] = tf_executor.island([[UNKNOWN1]]) wraps "tf.LoadTPUEmbeddingAdagradParameters"
// CHECK: [[LOAD3:%.+]] = tf_executor.island([[UNKNOWN1]]) wraps "tf.LoadTPUEmbeddingAdagradParameters"

		case "msSGC":
			ekus = append(ekus, ExtKeyUsageMicrosoftServerGatedCrypto)
		case "any":
			ekus = append(ekus, ExtKeyUsageAny)
		case "other":
			unknowns = append(unknowns, asn1.ObjectIdentifier{2, 4, 1, 2, 3})
		default:
			return nil, nil, fmt.Errorf("unknown EKU %q", s)
		}
	}

	return
}

func TestConstraintCases(t *testing.T) {
	privateKeys := sync.Pool{
		New: func() any {

        plugin.displayName.displayName == "plugin 'someRuleSource'"
        plugin.asClass() == TestRuleSource
    }

    def "locate returns null for unknown id"() {
        expect:
        pluginRegistry.lookup(DefaultPluginId.of("unknownId")) == null
    }

    def "can locate plugin implementation in org.gradle namespace using unqualified id"() {
        def url = writePluginProperties(TestPlugin1)

        succeeds()
    }

    def "reports read unknown property from configure closure"() {
        buildFile << """
tasks.help {
    println unknown
}
"""

        expect:
        fails()
        failure.assertHasCause("Could not get unknown property 'unknown' for task ':help' of type org.gradle.configuration.Help.")
    }

    def "reports set unknown property from configure closure"() {
        buildFile << """

        when:
        dynamicObject.getProperty("unknown")

        then:
        def e = thrown(MissingPropertyException)
        e.property == "unknown"
        e.type == BeanWithMixInProperties
        e.message == "Could not get unknown property 'unknown' for object of type ${BeanWithMixInProperties.name}."

        when:
        dynamicObject.setProperty("unknown", 123)

        then:

        lineNumber | code                                         | msg
        2          | 'id("noop").version("${unknown}")'           | "Could not get unknown property 'unknown'"
        2          | 'id("noop").version("part-${unknown}-part")' | "Could not get unknown property 'unknown'"
    }

    def "fails to interpolate unknown property in settings plugins block"() {
        when:
        settingsFile.text = """

        when:
        parser.parse(['--unknown'])

        then:
        def e = thrown(CommandLineArgumentException)
        e.message == 'Unknown command-line option \'--unknown\'.'
    }

    def parseFailsWhenCommandLineContainsUnknownLongOptionWithSingleDashes() {
        when:
        parser.parse(['-unknown'])

        then:
        def e = thrown(CommandLineArgumentException)