where:
        path1    | path2    | test1   | test2   | expectedEntries
        '/pathA' | '/pathA' | 'false' | 'false' | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'false' | 'true'  | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'true'  | 'false' | [[path: '/pathA', test: 'false']]

                                    operationDisplayName "[2] bar"
                                    testDisplayName "[2] bar"
                                }
                            }
                            testMethodSuite("test2(String)") {
                                operationDisplayName "2nd test"
                                testDisplayName "2nd test"

// The contents of fsys must not change concurrently with TestFS.
//
// If TestFS finds any misbehaviors, it returns either the first error or a
// list of errors. Use [errors.Is] or [errors.As] to inspect.
//
// Typical usage inside a test is:
//
//	if err := fstest.TestFS(myFS, "file/that/should/be/present"); err != nil {
//		t.Fatal(err)
//	}
func TestFS(fsys fs.FS, expected ...string) error {

		fmt.Sprintf(DestinationHost, "test", 0, 0),
		fmt.Sprintf(MirrorHost, 0),
		fmt.Sprintf(VSGateway, 0),
		fmt.Sprintf(URISchemeMethodAuthorityRegexMatch, 0, 0, "test"),
		fmt.Sprintf(HeaderAndQueryParamsRegexMatch, 0, 0, "test", "test"),
		fmt.Sprintf(AllowOriginsRegexMatch, 0, 0),
		fmt.Sprintf(WorkloadSelector, "test"),
		fmt.Sprintf(PortInPorts, 0),
		fmt.Sprintf(FromRegistry, "test", 0),
		fmt.Sprintf(ImageInContainer, 0),

        then:
        outputContains("files: [test-lib.jar, a.jar, a-lib.jar, test-1.0.jar, b.jar, b-lib.jar, test2-1.0.jar]")
        outputContains("ids: [test-lib.jar, a.jar (project :a), a-lib.jar, test-1.0.jar (org:test:1.0), b.jar (project :b), b-lib.jar, test2-1.0.jar (org:test2:1.0)]")

                foo = "test2"

                bar {
                    baz = "fizz"
                }
            }
        """

        when:
        run(":printTestSoftwareTypeExtensionConfiguration", ":printAnotherSoftwareTypeExtensionConfiguration")

        then:
        assertThatDeclaredValuesAreSetProperly()
        outputContains("""foo = test2\nbaz = fizz""")

        and:

        with:
          path: ~/go/pkg/mod
          key: ${{ runner.os }}-go-${{ matrix.go }}-${{ hashFiles('tests/go.mod') }}

      - name: Tests

# Generate integration test targets for kubernetes environment.
test.integration.%.kube: | $(JUNIT_REPORT) check-go-tag
	$(call run-test,./tests/integration/$(subst .,/,$*)/...)

# Generate integration fuzz test targets for kubernetes environment.
test.integration-fuzz.%.kube: | $(JUNIT_REPORT) check-go-tag

        Map<String, Object> value = new LinkedHashMap<>();
        DocMap docMap = new DocMap(value);
        assertTrue(docMap.isEmpty());
        value.clear();

        List<String> keys = Arrays.asList("test_2", "test_0", "lang", "test_1");
        value.put(keys.get(0), true);
        value.put(keys.get(1), 1000);
        value.put(keys.get(2), "ja");
        value.put(keys.get(3), "str");
        docMap = new DocMap(value);

			ok = false
		}
	}
	return ok
}

func isTestingType(typ types.Type, testingType string) bool {
	// No Unalias here: I doubt "go test" recognizes
	// "type A = *testing.T; func Test(A) {}" as a test.
	ptr, ok := typ.(*types.Pointer)
	if !ok {
		return false
	}
	return analysisutil.IsNamedType(ptr.Elem(), "testing", testingType)
}