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']]

import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.server.http.BlockingHttpServer
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.junit.Rule
import spock.lang.Issue

	timestamppb "google.golang.org/protobuf/types/known/timestamppb"

	"istio.io/istio/istioctl/pkg/util/configdump"
)

func TestNewAnalyzer(t *testing.T) {
	tests := []struct {
		name    string
		input   *configdump.Wrapper
		wantErr error
	}{
		{
			name: "Test1",
			input: &configdump.Wrapper{
				ConfigDump: &envoy_admin.ConfigDump{
					Configs: []*anypb.Any{
						{

        value = "ftp://123.123.123.123:21/test1/test.txt";
        ftpInfo = new FtpClient.FtpInfo(value);
        assertEquals("ftp://123.123.123.123/test1/test.txt", ftpInfo.toUrl());
        assertEquals("123.123.123.123:21", ftpInfo.getCacheKey());
        assertEquals("123.123.123.123", ftpInfo.getHost());
        assertEquals(21, ftpInfo.getPort());
        assertEquals("/test1", ftpInfo.getParent());

                "_id", "001", //
                "config_id", "W01", //
                "url", "http://test.com/001"//
        )));
        docList.add(new HashMap<>(Map.of(//
                "_id", "002", //
                "thumbnail", "http://test.com/002", //
                "url", "http://test.com/002"//
        )));
        indexingHelper.sendDocuments(client, docList);
        assertEquals(0, docList.size());

			skipFunc = opt.skip
		}
	}
	// Register each test package as a separate test.
	register1 := func(test *goTest) {
		if test.variant == "" {
			panic("empty variant")
		}
		name := testName(test.pkg, test.variant)
		t.addTest(name, heading, func(dt *distTest) error {
			if skipFunc != nil {
				msg, skip := skipFunc(dt)
				if skip {
					test.printSkip(t, msg)
					return nil
				}
			}

        testClassFile.assertHasTest('test1 < test2')
        testClassFile.assertHasFailure('test1 < test2', '<a failure>')
        testClassFile.assertHasStandardOutput('</html> & ')
        testClassFile.assertHasStandardError('</div> & ')
    }

    def encodesUnicodeCharactersInReport() {
        given:
        report = reportWithMaxThreads(1)
        def testTestResults = buildResults {

}

func TestEquals(t *testing.T) {
	tests := []struct {
		name   string
		first  Set[string]
		second Set[string]
		want   bool
	}{
		{
			"both nil",
			nil,
			nil,
			true,
		},
		{
			"unequal length",
			New("test"),
			New("test", "test1"),
			false,
		},
		{
			"equal sets",
			New("test", "test1"),
			New("test", "test1"),
			true,
		},
		{

                implementation(libs.test1) {
                    because("reason1")

                    exclude(group: "test-group", module: "test-module")
                    artifact {
                        name = "test-name"
                        classifier = "test-classifier"
                        extension = "test-ext"
                        type = "test-type"
                        url = "test-url"

        assertNull(System.getProperty("fess." + now));
        assertNull(System.getProperty("test." + now));
        appValue.set("=abc\nfess." + now + "=test1\ntest." + now + "=test2");
        helper.updateSystemProperties();
        assertEquals("test1", System.getProperty("fess." + now));
        assertEquals("test2", System.getProperty("test." + now));
    }