{"//abc", "/abc"},
	{"///abc", "/abc"},
	{"//abc//", "/abc"},
	{"abc//", "abc"},

	// Remove . elements
	{"abc/./def", "abc/def"},
	{"/./abc/def", "/abc/def"},
	{"abc/.", "abc"},

	// Remove .. elements
	{"abc/def/ghi/../jkl", "abc/def/jkl"},
	{"abc/def/../ghi/../jkl", "abc/jkl"},
	{"abc/def/..", "abc"},
	{"abc/def/../..", "."},
	{"/abc/def/../..", "/"},
	{"abc/def/../../..", ".."},

        def step1 = PatternStepFactory.getStep("*abc", true);
        step1 instanceof HasSuffixPatternStep
        step1.suffix == "abc"

        step1.matches("abc")
        step1.matches("thing.abc")
        !step1.matches("thing.java")

        and:
        def step2 = PatternStepFactory.getStep("**abc", true);
        step2 instanceof HasSuffixPatternStep
        step2.suffix == "abc"

        step2.matches("abc")

	Comma   rune
}{
	{Input: [][]string{{"abc"}}, Output: "abc\n"},
	{Input: [][]string{{"abc"}}, Output: "abc\r\n", UseCRLF: true},
	{Input: [][]string{{`"abc"`}}, Output: `"""abc"""` + "\n"},
	{Input: [][]string{{`a"b`}}, Output: `"a""b"` + "\n"},
	{Input: [][]string{{`"a"b"`}}, Output: `"""a""b"""` + "\n"},
	{Input: [][]string{{" abc"}}, Output: `" abc"` + "\n"},
	{Input: [][]string{{"abc,def"}}, Output: `"abc,def"` + "\n"},

	_ = s.ABC // ERROR "s.ABC undefined (type struct{x int; aBc int} has no field or method ABC, but does have field aBc)"
}

func _() {
	type S struct {
		x int
	}
	var s S
	_ = s.x
	_ = s /* ERROR "invalid operation: cannot call non-function s.x (variable of type int)" */ .x()
	_ = s.X // ERROR "s.X undefined (type S has no field or method X, but does have field x)"

			aggregate{fmt.Errorf("abc")},
			aggregate{fmt.Errorf("abc")},
		},
		{
			aggregate{fmt.Errorf("abc"), fmt.Errorf("def"), fmt.Errorf("ghi")},
			aggregate{fmt.Errorf("abc"), fmt.Errorf("def"), fmt.Errorf("ghi")},
		},
		{
			aggregate{aggregate{fmt.Errorf("abc")}},
			aggregate{fmt.Errorf("abc")},
		},
		{
			aggregate{aggregate{aggregate{fmt.Errorf("abc")}}},
			aggregate{fmt.Errorf("abc")},
		},
		{

import (
	"errors"
	"testing"
)

func TestNewEqual(t *testing.T) {
	// Different allocations should not be equal.
	if errors.New("abc") == errors.New("abc") {
		t.Errorf(`New("abc") == New("abc")`)
	}
	if errors.New("abc") == errors.New("xyz") {
		t.Errorf(`New("abc") == New("xyz")`)
	}

	// Same allocation should be equal to itself (not crash).
	err := errors.New("jkl")
	if err != err {
		t.Errorf(`err != err`)

    // Identical valid surrogate pairs.
    assertEquals(
        "abc\uD8AB\uDCAB", Strings.commonPrefix("abc\uD8AB\uDCABdef", "abc\uD8AB\uDCABxyz"));
    // Differing valid surrogate pairs.
    assertEquals("abc", Strings.commonPrefix("abc\uD8AB\uDCABdef", "abc\uD8AB\uDCACxyz"));
    // One invalid pair.

        assertEquals("", StringUtil.substringToLast("abc", "c"));
        assertEquals("c", StringUtil.substringToLast("abc", "b"));
        assertEquals("c", StringUtil.substringToLast("abcbc", "b"));
        assertEquals("abc", StringUtil.substringToLast("abc", ""));
        assertEquals("abc", StringUtil.substringToLast("abc", null));
        assertEquals("abc", StringUtil.substringToLast("abc", "dddd"));
    }

    /**

        where:
        types              | args           | transformed           | desc
        [TestEnum]         | ["abc"]        | [TestEnum.ABC]        | "one arg"
        [TestEnum, String] | ["abc", "abc"] | [TestEnum.ABC, "abc"] | "two args"
    }

    def "returns original args when no transformation is required - #desc"() {

        value = "${abc.xyz}";
        assertEquals(value, ResourceUtil.resolve(value));

        System.setProperty("abc.xyz", "789");

        value = "${abc.xyz}";
        assertEquals("789", ResourceUtil.resolve(value));

        value = "${abc}${abc.xyz}";
        assertEquals("123789", ResourceUtil.resolve(value));

        value = "xxx${abc.xyz}zzz";
        assertEquals("xxx789zzz", ResourceUtil.resolve(value));