"id 'noop'",
                "id('noop').version('bar')",
                "id 'noop' version 'bar'",
                "id('noop').\nversion 'bar'",
                "id('java');id('noop')",
                "id('java')\nid('noop')",
                "id('noop').version('bar');id('java')",
                "id('noop').version('bar')\nid('java')",
                "id 'noop' apply false",

        plugin('bar', 'com.example.bar', 'The Bar Plugin', 'The greatest Bar plugin of all time.')
        publishToIvy()

        when:
        succeeds 'publish'

        then:
        def fooMarker = ivyRepo.module('com.example.foo', 'com.example.foo' + PLUGIN_MARKER_SUFFIX, '1.0')
        def barMarker = ivyRepo.module('com.example.bar', 'com.example.bar' + PLUGIN_MARKER_SUFFIX, '1.0')

    assertEquals("bar x 2", entry("bar", 2).toString());
  }

  public void testToStringNull() {
    assertEquals("null", entry(NE, 1).toString());
    assertEquals("null x 2", entry(NE, 2).toString());
  }

  public void testEquals() {
    assertEquals(control("foo", 1), entry("foo", 1));
    assertEquals(control("bar", 2), entry("bar", 2));

		x struct {
			x int "bar"
		} "bar"
	}
	s = s
	s = t // ERRORx `cannot use .* in assignment`
	s = u // ERRORx `cannot use .* in assignment`
	s = S(s)
	s = S(t)
	s = S(u)
	t = u // ERRORx `cannot use .* in assignment`
	t = T(u)
}

func _() {
	type E1 struct {
		x int "foo"
	}
	type E2 struct {
		x int "bar"
	}
	type S struct{ x E1 }
	type T struct {
		x E2 "foo"
	}

        parameters.getWorkingDirectory().get().asFile.absolutePath == tmpDir.file("foo/bar").absolutePath

        where:
        configureAction                                   | _
        configure { it.workingDir("foo/bar") }            | _
        configure { it.workingDir = "foo/bar" }           | _
        configure { it.workingDir = new File("foo/bar") } | _
    }

        list == ['bar', 'foo']

    }

    def "can addAll a collection which contains a same element types"() {
        when:
        mutate {
            add 'foo'
            addAll(['bar', 'baz'])
            addAll(1, ['one', 'two'])
        }


        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['foo', 'one', 'two', 'bar', 'baz'])
    }

				simpleEndpointSlice("bar-v4", "10.2.2.3", discovery.AddressTypeIPv4),
				simpleEndpointSlice("bar-v6", "2001:db8:2222:3333:4444:5555:6666:7777", discovery.AddressTypeIPv6),
			},
		},
		expectedSlices: &slicesByAction{
			toUpdate: []*discovery.EndpointSlice{
				simpleEndpointSlice("bar-v4", "10.1.2.3", discovery.AddressTypeIPv4),

              SmbResource c = new SmbFile(p, "foo/bar/") ) {
            SmbResourceLocator fl = c.getLocator();
            assertEquals("1.2.3.4", fl.getServer());
            assertEquals(SmbConstants.TYPE_FILESYSTEM, fl.getType());
            assertEquals("share", fl.getShare());
            assertEquals("\\foo\\bar\\", fl.getUNCPath());
            assertEquals("smb://1.2.3.4/share/foo/bar/", fl.getCanonicalURL());

-- input --
Cool things:

  - Foo
  - [Go]
  - Bar

[Go]: https://go.dev/
-- text --
Cool things:

  - Foo
  - Go
  - Bar

[Go]: https://go.dev/
-- markdown --
Cool things:

  - Foo
  - [Go](https://go.dev/)
  - Bar

-- html --
<p>Cool things:
<ul>
<li>Foo
<li><a href="https://go.dev/">Go</a>
<li>Bar

		},

		"slash": {
			Name:        "foo/bar",
			Prefix:      false,
			ExpectedMsg: "/",
		},
		"slash,prefix": {
			Name:        "foo/bar",
			Prefix:      true,
			ExpectedMsg: "/",
		},

		"percent": {
			Name:        "foo%bar",
			Prefix:      false,
			ExpectedMsg: "%",
		},
		"percent,prefix": {
			Name:        "foo%bar",
			Prefix:      true,
			ExpectedMsg: "%",
		},