this.test = test;
    }
    @Override
    Iterable<String> asArguments() {
        return test.javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)
            ? ["--add-opens=java.base/java.lang=ALL-UNNAMED"]
            : []
    }
}
tasks.withType(Test).configureEach {
    jvmArgumentProviders.add(new AddOpensArgProvider(it))

        jvmArgs(listOf("--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"))

        if (isUnitTest() || usesEmbeddedExecuter()) {
            jvmArgs(org.gradle.internal.jvm.JpmsConfiguration.GRADLE_DAEMON_JPMS_ARGS)
        } else {

            javaForkOptions.jvmArgs(
                "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
                "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
            );
        } else {
            // In JDK 8 and below, the compiler internal classes are in tools.jar.
            File toolsJar = jvm.getToolsJar();

	_ = x[0] + y[0]
}

// Test for issue 19687 (passing to unnamed parameters does not escape).
func f11(**int) {
}
func f12(_ **int) {
}
func f13() {
	var x *int
	f11(&x)
	f12(&x)
	runtime.KeepAlive(&x)
}

// Test for issue 24305 (passing to unnamed receivers does not escape).
type U int

func (*U) M()   {}
func (_ *U) N() {}

# If port is unnamed or port name doesn't follow <protocol>[-<suffix>], the analyzer will report warning.
# If the service is in system namespace, i.e., kube-system, istio-system, kube-public, the check will be skipped.
apiVersion: v1
kind: Service
metadata:
  name: my-service1
  namespace: kube-system  # Skipped because it's in a kube system namespace
spec:
  selector:
    app: my-service1
  ports:
    - protocol: TCP
      port: 8080

tasks.withType<Test>().configureEach {
    if (JavaVersion.current().isJava9Compatible) {
        //allow ProjectBuilder to inject legacy types into the system classloader
        jvmArgs("--add-opens", "java.base/java.lang=ALL-UNNAMED")
        jvmArgs("--illegal-access=deny")
    }
    useJUnitPlatform()

# If port is unnamed or port name doesn't follow <protocol>[-<suffix>], the analyzer will report warning.
apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: my-namespace
spec:
  selector:
    app: my-service
  ports:
  - name: tcp-foo
    protocol: TCP
    port: 8080
    targetPort: 8080
---
# internal waypoint, should not generate warning
apiVersion: v1
kind: Service
metadata:
  labels:

			case TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64, TUINT64, TINT, TUINT, TUINTPTR, TCOMPLEX64, TCOMPLEX128, TFLOAT32, TFLOAT64, TBOOL, TSTRING, TPTR, TUNSAFEPTR:
				return true
			}
			// fall through to unnamed type comparison for complex types.
			goto cont
		}
		// Special case: we keep byte/uint8 and rune/int32
		// separate for error messages. Treat them as equal.
		switch t1.kind {
		case TUINT8:

        given:
        def javaSourceFile = file("$JAVA_SRC_DIR_PATH/MyClass.java")
        def expectedOutput = "${javaSourceFile.absolutePath}:4: warning: [deprecation] Legacy in unnamed package has been deprecated"

        buildFile << """
            apply plugin: 'java'

            compileJava {
                options.compilerArgs = ['-Xlint:all']
            }
        """

// license that can be found in the LICENSE file.

package p

// The core type of M2 unifies with the type of m1
// during function argument type inference.
// M2's constraint is unnamed.
func f1[K1 comparable, E1 any](m1 map[K1]E1) {}

func f2[M2 map[string]int](m2 M2) {
	f1(m2)
}

// The core type of M3 unifies with the type of m1
// during function argument type inference.