if t.Failed() {
		return
	}

	// Could check &glass[0] == &glass2[0] but also want to make sure write does not fault
	// (data must not be in read-only memory).
	old := glass[0]
	glass[0]++
	if glass2[0] != glass[0] {
		t.Fatalf("glass and glass2 do not share storage")
	}
	glass[0] = old

	// Could check &bbig[0] == &bbig2[0] but also want to make sure write does not fault

					withCDIDevices("vendor1.com/class1=device1", "vendor2.com/class2=device2"),
				),
			},
			expected: &DeviceRunContainerOptions{
				Annotations: []kubecontainer.Annotation{
					{Name: "cdi.k8s.io/devicemanager_pod-container", Value: "vendor1.com/class1=device1,vendor2.com/class2=device2"},
				},
				CDIDevices: []kubecontainer.CDIDevice{
					{Name: "vendor1.com/class1=device1"},

			expect:  nil,
		},

		{
			name:    "one default storage class",
			classes: []*storagev1.StorageClass{sc1, sc2, sc3},
			expect:  sc3,
		},

		{
			name:    "two default storage class with different creation timestamp",
			classes: []*storagev1.StorageClass{sc3, sc4},
			expect:  sc4,
		},

		{
			name:    "two default storage class with same creation timestamp",

        !class2.exists()
    }

    def "zinc handles removal of stale output files after loading from cache"() {
        createJavaClass("Class1")
        def source2 = createJavaClass("Class2")
        def source3 = createJavaClass("Class3", "proto")
        def class1 = scalaClassFile('Class1.class')
        def class2 = scalaClassFile('Class2.class')
        def class3 = scalaClassFile('proto/Class3.class')

import spock.lang.Specification

class TestResultTest extends Specification {
    def canOrderResultsByClassNameAndTestName() {
        ClassTestResults class1 = Mock()
        _ * class1.name >> 'name'
        ClassTestResults class2 = Mock()
        _ * class2.name >> 'a'
        ClassTestResults class3 = Mock()
        _ * class3.name >> 'z'

        TestResult result = new TestResult('name', 0, class1)

        given:
        processor = new RunPreviousFailedFirstTestClassProcessor(['Class3'] as Set, delegate)

        when:
        processor.startProcessing(testResultProcessor)
        ['Class1', 'Class2', 'Class3'].each { processor.processTestClass(new DefaultTestClassRunInfo(it)) }
        processor.stop()

        then:
        1 * delegate.startProcessing(testResultProcessor)

I can eat glass and it doesn't hurt me....

        }
        def class2 = Stub(TestClassResult) {
            getClassName() >> 'class-2'
        }

        when:
        provider.visitClasses(action)

        then:
        1 * provider1.visitClasses(_) >> { Action a -> a.execute(class1) }
        1 * provider2.visitClasses(_) >> { Action a -> a.execute(class2) }
        // TODO(radimk): should not assume order
        1 * action.execute(_) >> { TestClassResult r ->

        file('src/main/java/org/gradle/Class1.java') << 'package org.gradle; class Class1 { }'
        file('src/main/groovy/org/gradle/Class2.java') << 'package org.gradle; class Class2 { }'
    }

    private void badCode() {
        file("src/main/java/org/gradle/class1.java") << "package org.gradle; class class1 { }"
        file("src/main/groovy/org/gradle/class2.java") << "package org.gradle; class class2 { }"
    }

        file('src/main/groovy/org/gradle/Class2.java') << 'package org.gradle; class Class2 { }'
        file('src/test/groovy/org/gradle/TestClass2.java') << 'package org.gradle; public class TestClass2 { @org.junit.Test public void test2() { } }'
    }

    private badCode() {
        file("src/main/java/org/gradle/class1.java") << "package org.gradle; class class1 { }"