import org.gradle.util.internal.GUtil
import org.junit.Rule
import spock.lang.Specification

class DefaultPluginRegistryTest extends Specification {
    @Rule
    final TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())
    def classLoader = Mock(ClassLoader)
    def classLoaderScope = Stub(ClassLoaderScope) {
        getLocalClassLoader() >> classLoader
    }

            }
        """
        file("src/test/java/BarTest.java") << """
            ${testFrameworkImports}
            public class BarTest {
                @Test
                public void testBar() { }
            }
        """
        file("src/test/java/AllFooTests.java") << """
            ${testFrameworkImports}
            import org.junit.runners.Suite;

import static org.gradle.util.internal.TextUtil.normaliseFileSeparators

class RelativeFileNameTransformerTest extends Specification {
    static rootDir = new File("root")

    @Rule
    TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())

    def "returns canonical path where file outside of root"() {
        expect:
        transform(relative, file) == normaliseFileSeparators(file.canonicalPath)

	key2 := []byte("0123456789abcdef0123456789abcdef")

	testErr := fmt.Errorf("test error")
	block1, err := aes.NewCipher(key1)
	if err != nil {
		t.Fatal(err)
	}
	block2, err := aes.NewCipher(key2)
	if err != nil {
		t.Fatal(err)
	}

	ctx := context.Background()
	dataCtx := value.DefaultContext("authenticated_data")

	p := value.NewPrefixTransformers(testErr,

func inc(b []byte) {
	for i := len(b) - 1; i >= 0; i++ {
		b[i]++
		if b[i] != 0 {
			break
		}
	}
}

func xor(a, b []byte) {
	for i := range a {
		a[i] ^= b[i]
	}
}

func TestCTR(t *testing.T) {
	for size := 64; size <= 1024; size *= 2 {
		iv := make([]byte, size)
		ctr := cipher.NewCTR(noopBlock(size), iv)
		src := make([]byte, 1024)
		for i := range src {
			src[i] = 0xff
		}

package b

import (
	"os"
	"testing"
)

func TestDir(t *testing.T) {
	if _, err := os.Stat("../testdata/1"); err != nil {
		t.Fatalf("testdata: %v", err)
	}
}
-- a/foo/bar/c/main.go --
package c
import _ "a/foo/bar/b"
-- a/foo/bar/c/main_test.go --
package c

import (
	"os"
	"testing"
)

func TestDir(t *testing.T) {
	if _, err := os.Stat("../../../testdata/1"); err != nil {

                testImplementation 'junit:junit:4.13'
            }

            eclipse.classpath.file.whenMerged {
                def testDir = entries.find { entry -> entry.path == 'src/test/java' }
                def guavaDep = entries.find { entry -> entry.path.contains 'guava-18.0.jar' }
                testDir.entryAttributes['gradle_used_by_scope'] = 'test,integTest'
                guavaDep.entryAttributes['gradle_used_by_scope'] = 'main,test,integTest'

	NamedStr  namedString       `json:"namedStr,omitempty"`
	NamedBool namedBool         `json:"namedBool,omitempty"`
	Foobar    bar               `json:"foobar,omitempty"`
	Testmap   map[string]string `json:"testmap,omitempty"`
}

func (obj *foo) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }

type baz struct {
	Ptr  *int  `json:"ptr"`
	Bptr *bool `json:"bptr,omitempty"`
}

        // Don't store userHome in the default location (in the project dir), because this will cause the non-empty project dir detection to fail
        init = TestUtil.create(testDir.testDirectory.file("project"), testDir.testDirectory.file("userHome")).task(InitBuild)
        projectLayoutRegistry = Mock()
        defaultGenerator = Mock()
        buildConverter = Mock()
        init.projectLayoutRegistry = projectLayoutRegistry

import static org.junit.Assert.assertSame;
import static org.hamcrest.MatcherAssert.assertThat;

public class DefaultProjectDescriptorRegistryTest {
    private static final File TEST_DIR = new File("testDir");

    private static final FileResolver FILE_RESOLVER = TestFiles.resolver(TEST_DIR.getAbsoluteFile());
    private final DefaultProjectDescriptorRegistry registry = new DefaultProjectDescriptorRegistry();

    @Test