class1.add(method1)
        class1.add(method2)
        def class2 = new TestClassResult(2, 'Class2', 5678)
        def results = [class1, class2]

        when:
        def read = serialize(results)

        then:
        read.size() == 2
        def readClass1 = read[0]
        readClass1.className == 'Class1'
        readClass1.startTime == 1234

    private customCode() {
        // class that would fail default rule set but doesn't fail custom rule set
        file("src/main/java/org/gradle/Class1.java") <<
            "package org.gradle; public class Class1 { public void doit() { boolean x = true; if (x) {} } }" // empty then-block
        // class that wouldn't fail default rule set but does fail custom rule set
        file("src/main/java/org/gradle/Class2.java") <<

        decodedSpec.internalServicesRequired
    }

    def filteringClassloaderSpec() {
        def classNames = [ 'allowed.Class1', 'allowed.Class2' ]
        def disallowedClassNames = [ 'disallowed.Class1', 'disallowed.Class2' ]
        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]

        TestDomainObject value2 = new TestDomainObject('a')
        repository.put('class1', value1)
        repository.put('class2', value2)
        Closure cl = Mock()

        when:
        repository.each(cl)

        then:
        1 * cl.call(['class1', value1] as Object[])
        1 * cl.call(['class2', value2] as Object[])
        0 * cl._
    }

    def canIterateOverClassesUsingAction() {

			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",

        then:
        decodedClassloaderStructure == classLoaderStructure
    }

    def filteringClassloaderSpec() {
        def classNames = [ 'allowed.Class1', 'allowed.Class2' ]
        def disallowedClassNames = [ 'disallowed.Class1', 'disallowed.Class2' ]
        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]

              ops << "withId 2"
            }

            def class1 = ${pluginBuilder.packageName}.TestPlugin
            def class2 = ${pluginBuilder2.packageName}.TestPlugin2

            plugins.withType(class1) {
              ops << "withType 1"
            }

            plugins.withType(class2) {
              ops << "withType 2"
            }

            apply plugin: '$PLUGIN_ID'

    private static testClass() {
        """
            package org.gradle.ruleusing;
            public class Class2 extends Class1 { }
        """
    }

    private static classReferencingIntermediate() {
        """
        package org.gradle.ruleusing;
        public class Class1 {
            private org.gradle.intermediate.IntermediateClass mClass = null;
        }
       """
    }

    }

    @Issue("GRADLE-3492")
    def "can exclude code"() {
        badCode()
        buildFile << """
            codenarcMain {
                exclude '**/class1*'
                exclude '**/Class2*'
            }
            codenarcTest {
                exclude '**/TestClass1*'
                exclude '**/testclass2*'
            }
        """.stripIndent()

        expect:

	// List them
	verifyListPVs(t, cache, pvs1, "class1")
	verifyListPVs(t, cache, pvs2, "class2")

	// Update a PV
	updatedPV := makePV("test-pv3", "class1").withVersion("2").PersistentVolume
	pvs1[updatedPV.Name] = updatedPV
	assumecache.UpdateTestObject(cache.AssumeCache, updatedPV)

	// List them
	verifyListPVs(t, cache, pvs1, "class1")
	verifyListPVs(t, cache, pvs2, "class2")

	// Delete a PV