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)
        then:

        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.' ]

              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'

        failure.assertThatCause(startsWith("CodeNarc rule violations were found. See the report at:"))
        failure.assertHasResolutions(SCAN)
        !report("main").text.contains("Class2")
        report("test").text.contains("testclass2")
    }

    def "can ignore failures"() {
        badCode()
        buildFile << """
            codenarc {
                ignoreFailures = true

        file("rule-using/src/test/java/org/gradle/ruleusing/Class2.java") << testClass()

        expect:
        fails ":rule-using:pmdTest"

        file("rule-using/build/reports/pmd/test.xml").
            assertContents(containsClass("org.gradle.ruleusing.Class2")).
            assertContents(containsText("auxclasspath configured"))
    }

	pvs2 := map[string]*v1.PersistentVolume{}
	for i := 0; i < 10; i++ {
		pv := makePV(fmt.Sprintf("test2-pv%v", i), "class2").withVersion("1").PersistentVolume
		pvs2[pv.Name] = pv
		assumecache.AddTestObject(cache.AssumeCache, pv)
	}

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

	// Update a PV
	updatedPV := makePV("test-pv3", "class1").withVersion("2").PersistentVolume

				Name: "my-storage-class1",
				Annotations: map[string]string{
					"a": "b",
				},
			},
		}
		sc2 = &storagev1.StorageClass{
			ObjectMeta: metav1.ObjectMeta{
				Name: "my-storage-class2",
				Annotations: map[string]string{
					"a": "b",
				},
			},
		}

		sc3 = &storagev1.StorageClass{
			ObjectMeta: metav1.ObjectMeta{
				Name: "my-storage-class3",
				Annotations: map[string]string{

        failure.assertHasDescription("Execution failed for task ':codenarcTest'.")
        failure.assertThatCause(startsWith("CodeNarc rule violations were found. See the report at:"))
        !report("main").text.contains("Class2")
        report("test").text.contains("testclass2")

        where:
        groovyVersion        | codenarcVersion
        latestGroovy3Version | CodeNarcPlugin.STABLE_VERSION

	</configurations>
	<publications>
		<artifact name="myartifact1" type="jar" e:attr3="value3" e:classifier="classy1"/>
		<artifact name="myartifact2" type="jar" conf="myconf1" m:classifier="classy2"/>
		<artifact name="myartifact3" type="jar" conf="myconf1, myconf2, myconf3"/>
		<artifact name="myartifact4" type="jar">
			<conf name="myconf1"/>
			<conf name="myconf3"/>
		</artifact>
	</publications>

Illustration of Jar instrumentation is shown below.

```mermaid
flowchart TB
    jar(Jar)
    modifiedJar(Jar*)
    class1("Class1")
    class2("Class2")
    class3("Class3")
    modifiedClass1("Class1*")
    modifiedClass2("Class2*")
    modifiedClass3("Class3*")
    instrumentingClassTransform{{"InstrumentingClassTransform\n(ClassVisitor)"}}
    interceptors(Generated interceptors)