@Nested
                public abstract Bar getBar();

                @Configuring
                public void bar(Action<? super Bar> action) {
                    action.execute(getBar());
                }

                public abstract static class Bar {
                    public Bar() { }

                    @Restricted

		// New behavior.
		{vcsGit, "ssh://******@****.***/foo.git", false},
		{vcsGit, "foo://example.com/bar.git", true},
		{vcsHg, "foo://example.com/bar.hg", false},
		{vcsSvn, "foo://example.com/svn", false},
		{vcsBzr, "foo://example.com/bar.bzr", false},
	}

	defer os.Unsetenv("GIT_ALLOW_PROTOCOL")
	os.Setenv("GIT_ALLOW_PROTOCOL", "https:foo")
	for _, test := range tests {

            import java.io.Serializable;
            import org.gradle.another.Bar;

            public class Foo implements Serializable {
                Bar bar = new Bar();
            }
        """
    }

    void withWorkActionClassInExternalJar(File workActionJar) {
        file("buildSrc").deleteDir()

        def builder = artifactBuilder()

                }
            }
            abstract class Bar extends DefaultTask {
                @InputFile abstract RegularFileProperty getInDir()
                @TaskAction void bar() {}
            }
            def task = tasks.register("foo", Foo) {
                outDir.set(layout.buildDirectory.dir("bam"))
            }
            tasks.register("bar", Bar) {
                inDir.set($zipExpression)
            }

        fixture.workActionThatCreatesFiles.action += """
            fileOperations.copy {
                from "foo"
                into "bar"
            }
            fileOperations.sync {
                from "bar"
                into "baz"
            }
            fileOperations.delete {
                delete "foo"
            }
        """

        assertEquals(2, result.getChildCount());

        assertEquals("x", result.getChild("foo").getValue());
        assertEquals("y", result.getChild("bar").getValue());
        assertNotSame(result.getChild("bar"), recessiveConfig.getChild("bar"));
    }

    /**
     * <p>testDupeChildren.</p>
     */
    @Test
    void testDupeChildren() throws IOException, XMLStreamException {

        when:
        render dummyValidationProblem('Foo', 'Bar', 'with some description', 'some reason')

        then:
        outputEquals """
Type 'Foo' property 'Bar' with some description.

Reason: Some reason.
"""
    }

    def "displays plugin id when available"() {
        when:
        render dummyValidationProblem {
            inPlugin 'com.foo.bar'
            type 'Foo'
            property 'bar'

 *
 * <pre>{@code
 * Splitter.on(',').split("foo,bar,qux")
 * }</pre>
 *
 * ... produces an {@code Iterable} containing {@code "foo"}, {@code "bar"} and {@code "qux"}, in
 * that order.
 *
 * <p>By default, {@code Splitter}'s behavior is simplistic and unassuming. The following
 * expression:
 *
 * <pre>{@code
 * Splitter.on(',').split(" foo,,,  bar ,")
 * }</pre>
 *

      assertNull(errorMessage, incorrectError);
    }
  }

  public void verifyBarFail(Method method, TwoArg bar) {
    try {
      new NullPointerTester().testMethod(bar, method);
    } catch (AssertionError expected) {
      return; // good...we wanted a failure
    }
    String errorMessage =
        rootLocaleFormat("Should have flagged method %s for %s", method.getName(), bar);

          "",
          " ",
          "127.0.0.1",
          "::1",
          "13",
          "abc.12c",
          "foo-.com",
          "_bar.quux",
          "foo+bar.com",
          "foo!bar.com",
          ".foo.com",
          "..bar.com",
          "baz..com",
          "..quiffle.com",
          "fleeb.com..",
          ".",
          "..",
          "...",