/* b */ 0,
}

var _ = T{ /* a */ {}}

var _ = T{ /* a */ /* b */ {}}

var _ = T{	/* a */	/* b */
	/* c */ {},
}

var _ = T{	/* a */	/* b */
	/* c */
	/* d */ {},
}

var _ = T{
	/* a */
	/* b */ {},
}

var _ = []T{
	func() {
		var _ = [][]int{
			/*       a, b, c, d, e */
			/* a */ {0, 0, 0, 0, 0},
			/* b */ {0, 5, 4, 4, 4},
			/* c */ {0, 4, 5, 4, 4},

	return a - b>>3
}

//go:noinline
func rsbshiftRL_ssa(a, b uint32) uint32 {
	return a>>3 - b
}

//go:noinline
func andshiftRL_ssa(a, b uint32) uint32 {
	return a & (b >> 3)
}

//go:noinline
func orshiftRL_ssa(a, b uint32) uint32 {
	return a | b>>3
}

//go:noinline
func xorshiftRL_ssa(a, b uint32) uint32 {
	return a ^ b>>3
}

//go:noinline

		{name: "two", value: "a b", want: []string{"a", "b"}},
		{name: "two_multi_space", value: "a  b", want: []string{"a", "b"}},
		{name: "two_tab", value: "a\tb", want: []string{"a", "b"}},
		{name: "two_newline", value: "a\nb", want: []string{"a", "b"}},
		{name: "quote_single", value: `'a b'`, want: []string{"a b"}},
		{name: "quote_double", value: `"a b"`, want: []string{"a b"}},

    @Rule
    public final BlockingHttpServer blockingServer = new BlockingHttpServer()

    def setup() {
        blockingServer.start()

        createDirs("a", "b", "c")
        settingsFile << """
            include 'a', 'b', 'c'
        """
        buildFile << """
            allprojects {
                task ping {
                    def projectName = project.name
                    doLast {

			path:      `a.b.[name:n1].value`,
			value:     `v2`,
			wantFound: true,
			want: `
a:
  b:
  - name: "n1"
    value: v2
  - list:
    - v1
    - v2
    - v3_regex
    name: n2
`,
		},
		{
			desc:      "ModifyListEntry",
			path:      `a.b.[name:n2].list.[:v2]`,
			value:     `v3`,
			wantFound: true,
			want: `
a:
  b:
  - name: n1
    value: v1
  - list:

		{"/{a}/a/", "/a/{z}/", "/ax/a/"},
		{"/a/{z}/{x...}", "/{z}/b/{y...}", "/a/z/"},
		{"/{z}/b/{y...}", "/a/{z}/{x...}", "/z/b/"},
		{"/a/b/", "/a/b/c", "/a/b/"},
		{"/a/b/{x...}", "/a/b/c", "/a/b/"},
		{"/a/b/{x...}", "/a/b/c/d", "/a/b/"},
		{"/a/b/{x...}", "/a/b/c/d/", "/a/b/"},
		{"/a/{z}/{m...}", "/{z}/a/", "/a/z/"},
		{"/{z}/a/", "/a/{z}/{m...}", "/z/a/"},
		{"/{z}/{$}", "/a/", "/z/"},
		{"/a/", "/{z}/{$}", "/a/x"},

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