abcdefghijklmnopqrstuvwxyzab	string
	abcdefghijklmnopqrstuvwxyzabc	string
	abcde				string
	abcdefghijklmnopqrstuvwxyzabcde	string
	abcdefg				string
}

func main() {
	_ := Fmt{
		abcdefghijklmnopqrstuvwx:		"foo",
		abcdefghijklmnopqrstuvwxyza:		"foo",
		abcdefghijklmnopqrstuvwxyzab:		"foo",
		abcdefghijklmnopqrstuvwxyzabc:		"foo",
		abcde:					"foo",
		abcdefghijklmnopqrstuvwxyzabcde:	"foo",
		abcdefg:				"foo",

	abcdefghijklmnopqrstuvwxyzab string
	abcdefghijklmnopqrstuvwxyzabc string
	abcde string
	abcdefghijklmnopqrstuvwxyzabcde string
	abcdefg string
}

func main() {
	_ := Fmt{
		abcdefghijklmnopqrstuvwx: "foo",
		abcdefghijklmnopqrstuvwxyza: "foo",
		abcdefghijklmnopqrstuvwxyzab: "foo",
		abcdefghijklmnopqrstuvwxyzabc: "foo",
		abcde: "foo",
		abcdefghijklmnopqrstuvwxyzabcde: "foo",
		abcdefg: "foo",

BE	a*			NULL		(0,0)
E	([abc])*d		abbbcd		(0,6)(4,5)
E	([abc])*bcd		abcd		(0,4)(0,1)
E	a|b|c|d|e		e		(0,1)
E	(a|b|c|d|e)f		ef		(0,2)(0,1)
E	((a*|b))*		-		(0,0)(0,0)(0,0)
BE	abcd*efg		abcdefg		(0,7)
BE	ab*			xabyabbbz	(1,3)
BE	ab*			xayabbbz	(1,2)
E	(ab|cd)e		abcde		(2,5)(2,4)
BE	[abhgefdc]ij		hij		(0,3)
E	(a|b)c*d		abcd		(1,4)(1,2)
E	(ab|ab*)bc		abc		(0,3)(0,1)
E	a([bc]*)c*		abc		(0,3)(1,3)

a
ab
abc
abcd
abcde
abcdef
abcdefg
abcdefgh
abcdefghi
abcdefghij
Discard medicine more than two years old.
He who has a shady past knows that nice guys finish last.
I wouldn't marry him with a ten foot pole.
Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave
The days of the digital watch are numbered.  -Tom Stoppard
Nepal premier won't resign.
For every action there is an equal and opposite government program.

		iHasLeadingPercent bool
		resultExpected     string
		matchExpected      bool
	}{
		{"abcd", "bcd", false, "", false},
		{"abcd", "bcd", true, "", true},
		{"abcd", "abcd", false, "", true},
		{"abcd", "abcd", true, "", true},
		{"abcd", "ab", false, "cd", true},
		{"abcd", "ab", true, "cd", true},
		{"abcd", "bc", false, "", false},
		{"abcd", "bc", true, "d", true},
	}

	for i, tc := range matcherCases {

        assertEquals("abcd", normalizer.normalize("ａｂｃｄ", null));
        assertEquals("みかん", normalizer.normalize("みかん", null));
        assertEquals("みかん ﾘﾝｺﾞ", normalizer.normalize("みかん　リンゴ", null));
    }

    public void test_AnyLower() {
        ICUNormalizer normalizer = new ICUNormalizer("Any-Lower");
        assertEquals("abcd", normalizer.normalize("ABCD", null));
    }

}{
	{0x00000001, "", "adl\x01\x00\x00\x00\x01"},
	{0x00620062, "a", "adl\x01\x00\x00\x00\x01"},
	{0x012600c4, "ab", "adl\x01\x00b\x00b"},
	{0x024d0127, "abc", "adl\x01\x00b\x00b"},
	{0x03d8018b, "abcd", "adl\x01\x01&\x00\xc4"},
	{0x05c801f0, "abcde", "adl\x01\x01&\x00\xc4"},
	{0x081e0256, "abcdef", "adl\x01\x02M\x01'"},
	{0x0adb02bd, "abcdefg", "adl\x01\x02M\x01'"},
	{0x0e000325, "abcdefgh", "adl\x01\x03\xd8\x01\x8b"},

			canonicalizedETag: "",
		},
		{
			etag:              "\"\"\"abc\"",
			canonicalizedETag: "abc",
		},
		{
			etag:              "abcd",
			canonicalizedETag: "abcd",
		},
		{
			etag:              "abcd\"\"",
			canonicalizedETag: "abcd",
		},
	}
	for _, test := range testCases {
		etag := canonicalizeETag(test.etag)
		if test.canonicalizedETag != etag {

    }

    def containsWhitespace() {
        expect:
        TextUtil.containsWhitespace(str) == whitespace

        where:
        str       | whitespace
        "abcde"   | false
        "abc de"  | true
        " abcde"  | true
        "abcde "  | true
        "abc\tde" | true
        "abc\nde" | true
    }

    def indent() {
        expect:
        TextUtil.indent(text, indent) == result

        where:

func TestEvalSQLSubstring(t *testing.T) {
	evalCases := []struct {
		s           string
		startIdx    int
		length      int
		resExpected string
		errExpected error
	}{
		{"abcd", 1, 1, "a", nil},
		{"abcd", -1, 1, "a", nil},
		{"abcd", 999, 999, "", nil},
		{"", 999, 999, "", nil},
		{"测试abc", 1, 1, "测", nil},
		{"测试abc", 5, 5, "c", nil},
	}

	for i, tc := range evalCases {