given:
        configureMetadata(local, "abc", null, -1)
        configureMetadataForEtagMatch(remote, "abc")

        when:
        compare(local, remote)

        then:
        unchanged
    }

    def "non matching etags, no mod date, but matching content length does not match"() {
        given:
        configureMetadata(local, "abc", null, 10)
        configureMetadataForEtagMatch(remote, "cde")

        "~"        | ""
        "-"        | ""
        ":a"       | "a"
        ":abc"     | "abc"
        ":a:b:c"   | "a_b_c"
        ":a:b:c:"  | "a_b_c"
        "a-b-c"    | "a_b_c"
        "-a-b-c-"  | "a_b_c"
        "::a::b::" | "a_b"
        "a b c"    | "a_b_c"
        "  a b c " | "a_b_c"
        "~abc"     | "abc"
        "~a~b~c~"  | "a_b_c"
    }

        value   | escaped
        ''      | ''
        'abc'   | 'abc'
        'a\n\t' | 'a\n\t'
        /a\b/   | /a\\b/
    }

    def "escapes value for inclusion in a string"() {
        expect:
        new TemplateValue(value).groovyString == escaped

        where:
        value         | escaped
        ''            | ''
        'abc'         | 'abc'
        'a\n\t\r\b\f' | /a\n\t\r\b\f/

type MatchTest struct {
	pattern, s string
	match      bool
	err        error
}

var matchTests = []MatchTest{
	{"abc", "abc", true, nil},
	{"*", "abc", true, nil},
	{"*c", "abc", true, nil},
	{"a*", "a", true, nil},
	{"a*", "abc", true, nil},
	{"a*", "ab/c", false, nil},
	{"a*/b", "abc/b", true, nil},
	{"a*/b", "a/c/b", false, nil},
	{"a*b*c*d*e*/f", "axbxcxdxe/f", true, nil},

        assertEquals(resultFile, file);
        FileUtil.writeBytes(file.getAbsolutePath(), "abc".getBytes());

        path = "foo1/hoge.html";
        file = fileTransformer.createFile(path);
        resultFile = new File(fileTransformer.baseDir, path);
        assertEquals(resultFile, file);
        FileUtil.writeBytes(file.getAbsolutePath(), "abc".getBytes());

        path = "foo1/foo2/hoge.html";

        def args = parser.parse("--some-option", "abc", "--some-flag")
        def bean = converter.convert(args, new Bean())

        then:
        bean.flag
        bean.prop == "abc"
    }

    def "can convert properties"() {
        def converter = set.propertiesConverter()

        when:
        def bean = converter.convert(["some.option": "abc", "some.flag": "true"], new Bean())

        then:

	}

	abc := NewCgroupName(ab, "c")

	expectedABC := CgroupName([]string{"a", "", "b", "c"})
	if !reflect.DeepEqual(abc, expectedABC) {
		t.Errorf("Expected %d%+v; got %d%+v", len(expectedABC), expectedABC, len(abc), abc)
	}

	_ = NewCgroupName(ab, "d")

	if !reflect.DeepEqual(abc, expectedABC) {

            "8.0",
            "9.0-abc"
        ]
        registry.getStringValue(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, "SOFTWARE\\AdoptOpenJDK\\JDK\\8.0\\hotspot\\MSI", "Path") >> "c:\\jdk8"
        registry.getStringValue(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, "SOFTWARE\\AdoptOpenJDK\\JDK\\9.0-abc\\hotspot\\MSI", "Path") >> "d:\\jdk9"

		wantNamespace string
	}{
		{
			name:          "foo-abc.istio-system",
			wantPodName:   "foo-abc",
			wantNamespace: "istio-system",
		},
		{
			name:          "foo-abc",
			wantPodName:   "foo-abc",
			wantNamespace: "test",
		},
		{
			name:          "Deployment/foo.istio-system",
			wantPodName:   "foo-abc",
			wantNamespace: "istio-system",
		},
		{

                super.connect(snk)
                write(TextUtil.toPlatformLineSeparators("abc\n123").bytes)
                close()
            }
        })

        when:
        run "echo"

        then:
        output.contains("[abc][123]")
    }

    def "task can read stdin when stdin has unbounded length"() {
        given:
        buildFile << '''
task echo {