'/'                    | ''
        '/var/log/messages'    | 'var/log/messages'
        '//uncMount/some/path' | 'uncMount/some/path'
        '/a'                   | 'a'
        '/a/b/c'               | 'a/b/c'
        '/a/b/c/'              | 'a/b/c'
        ''                     | ''
    }

    def "'#relativePath' fromChild '#child' is '#result'"() {
        expect:

}
"""
        executer.withArgument('--info')
    }

    def "project dependency c->[a,b]"() {
        projectDependency from: 'c', to: ['a', 'b']
        when:
        run ':c:build'

        then:
        jarsBuilt 'a', 'b', 'c'
        depsCopied 'a', []
        depsCopied 'b', []
        depsCopied 'c', ['a', 'b']
    }

    def "project dependency c->b->a"() {

	"github.com/google/go-cmp/cmp"
	"k8s.io/apimachinery/pkg/util/dump"
)

func legacyDiff(a, b interface{}) string {
	return cmp.Diff(a, b)
}

// StringDiff diffs a and b and returns a human readable diff.
// DEPRECATED: use github.com/google/go-cmp/cmp.Diff
func StringDiff(a, b string) string {
	return legacyDiff(a, b)
}

// ObjectDiff prints the diff of two go objects and fails if the objects

        expect:
        select('a.b.c', 'a.b.c').includedTests == ['a.b/c']
    }

    def "ignores conceptual duplicate filters"() {
        expect:
        select('a.b.*', 'a.b.c', 'a.d.e').includedTests == ['a.b', 'a.d/e']
        select('a.b.c', 'a.d.e', 'a.b.*').includedTests == ['a.d/e', 'a.b']
        select('a.b', 'a.b.c', 'a.d.e').includedTests == ['a.b', 'a.d/e']

// license that can be found in the LICENSE file.

package p

func _() {
	a, b, b /* ERROR "b repeated on left side of :=" */ := 1, 2, 3
	_ = a
	_ = b
}

func _() {
	a, _, _ := 1, 2, 3 // multiple _'s ok
	_ = a
}

func _() {
	var b int
	a, b, b /* ERROR "b repeated on left side of :=" */ := 1, 2, 3
	_ = a
	_ = b
}

func _() {
	var a []int

	tests := []struct {
		data  []string
		limit int
		want  string
	}{
		{
			[]string{"a", "b", "c"},
			2,
			"a, and 2 others",
		},
		{
			[]string{"a", "b", "c"},
			4,
			"a, b, c",
		},
		{
			[]string{"a", "b", "c"},
			1,
			"a, b, c",
		},
		{
			[]string{"a", "b", "c"},
			0,
			"a, b, c",
		},
		{
			[]string{},
			3,
			"",
		},
	}
	for _, tt := range tests {

        ":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"
    }

	return casecons.Apply(xs)
}

type mapNil[a, b any] struct {
}

func (m mapNil[a, b]) Apply(_ Nil[a]) any {
	return Nil[b]{}
}

type mapCons[a, b any] struct {
	f Function[a, b]
}

func (m mapCons[a, b]) Apply(xs Cons[a]) any {
	return Cons[b]{m.f.Apply(xs.Head), Map[a, b](m.f, xs.Tail)}
}

func Map[a, b any](f Function[a, b], xs List[a]) List[b] {

        version.parts as List == parts

        where:
        versionStr      | parts
        '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-c+d_e'     | ['a', 'b', 'c', 'd', 'e']
        '\u03b1-\u03b2' | ['\u03b1', '\u03b2']
    }

    def "splits on adjacent digits and alpha"() {

		{
			name: "one group",
			in: `package p
import (
	"a"
	"b"
	"c"
	"d"
)
`,
			want: []string{"a"},
		},
		{
			name: "several groups",
			in: `package p
import (
	"a"

	"b"
	"c"

	"d"
)
`,
			want: []string{"a", "b", "d"},
		},
		{
			name: "extra space",
			in: `package p
import (
	"a"


	"b"
	"c"


	"d"
)
`,