classpath = files()
            }
            dependencies {
                implementation("org:foo:1.0") {
                    artifact {
                        name = "notfoo"
                    }
                }
            }

            publishing {
                repositories {
                    maven { url "${mavenRepo.uri}" }
                }

				nonresourceRequest("verb1").URL("/notfoo").New():         false,
				nonresourceRequest("verb1").URL("/notfoo/bar").New():     false,
				nonresourceRequest("verb1").URL("/notfoo/baz").New():     false,
				nonresourceRequest("verb1").URL("/notfoo/bar/one").New(): false,
				nonresourceRequest("verb1").URL("/notfoo/baz/one").New(): false,
			},
		},
		{

						{
							Properties: map[string]NestedValueValidation{
								"notfoo": {
									ValueValidation: ValueValidation{
										MinLength: ptr.To[int64](2),
									},
								},
							},
						},
					},
				},
			},
			error: `properties[notfoo]: Required value: because it is defined in allOf[0].properties[notfoo]`,
		},
		{
			name: "allowed items in valuevalidation, and in structure",

		// But subdomains should work:
		{"www-authenticate", "http://foo.com/", "http://foo.com/", true},
		{"www-authenticate", "http://foo.com/", "http://sub.foo.com/", true},
		{"www-authenticate", "http://foo.com/", "http://notfoo.com/", false},
		{"www-authenticate", "http://foo.com/", "https://foo.com/", true},
		{"www-authenticate", "http://foo.com:80/", "http://foo.com/", true},

----
dependencies {
    implementation("org:foo:1.0") {
        artifact {
            name = "notfoo"
        }
    }
}
----
======
[.multi-language-sample]
======
.build.gradle
[source,groovy]
----
dependencies {
    implementation("org:foo:1.0") {
        artifact {
            name = "notfoo"
        }
    }
}
----
======
=====

		// other checks however.
		name:        "LeafInRootsInvalid",
		leaf:        selfSigned,
		roots:       []string{selfSigned},
		currentTime: 1471624472,
		dnsName:     "notfoo.example",
		systemSkip:  true, // does not chain to a system root

		errorCallback: expectHostnameError("certificate is valid for"),
	},
	{
		// An X.509 v1 certificate should not be accepted as an

	g := Gcd(x, y)
	fmt.Println("The gcd of", x, "and", y, "is", g)

	// Manipulate the Foo global variable

	// Output its current value
	fmt.Println("Foo =", GetFoo())

	// Change its value
	SetFoo(3.1415926)

	// See if the change took effect
	fmt.Println("Foo =", GetFoo())
}
-- main.swig --
%module main

%inline %{
extern int    gcd(int x, int y);
extern double Foo;
%}
-- main_test.go --
package main

 * limitations under the License.
 */

package org.gradle.workers.fixtures;

import org.gradle.api.Named;

public class TestManagedTypes {
    public interface ManagedThing {
        String getFoo();
        void setFoo(String foo);
    }

    public interface ImmutableManagedThing extends Named {
    }

		diff2  string
		expect string
	}{
		{
			desc: "1-line-diff",
			diff1: `hola: yo
foo: bar
goo: tar
`,
			diff2: `hola: yo
foo: bar
notgoo: nottar
`,
			expect: ` foo: bar
-goo: tar
 hola: yo
+notgoo: nottar
 `,
		},
		{
			desc:   "no-diff",
			diff1:  `foo: bar`,
			diff2:  `foo: bar`,
			expect: ``,
		},
		{
			desc:   "invalid-yaml",

                @Inject abstract ProviderFactory getProviderFactory()

                @Internal abstract Property<String> getOther()

                @Internal Provider<String> getFoo() {
                    return other;
                }

                @TaskAction
                void useIt() {
                    assert foo.get() == "foobar"
                }
            }