// AccessedFromPrivateClassPublicField.name, // would be in ClassAnalysis for SomeClass$Foo
                                              SomeClass.name + '$Foo',
                                              SomeClass.name + '$1'] as Set
    }

    def "knows basic class dependencies of a groovy class"() {

        when:
        componentUnderTest.applyModificationToClassAccessedFromPrivateMethod()
        run language.compileTaskName

        then:
        outputs.recompiledClasses 'AccessedFromPrivateMethod', 'SomeClass', 'SomeClass$Foo'
    }

    def "change to class accessed from private method body only recompile that class and the direct consumer"() {
        def componentUnderTest = new IncrementalLib()

  }

  @Test
  @TestMetadata("sameClass.kt")
  public void testSameClass() {
    runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/isSubclassOf/sameClass.kt");
  }

  @Test
  @TestMetadata("unrelatedClass.kt")
  public void testUnrelatedClass() {

  }

  @Test
  @TestMetadata("sameClass.kt")
  public void testSameClass() {
    runTest("analysis/analysis-api/testData/components/symbolDeclarationOverridesProvider/isSubclassOf/sameClass.kt");
  }

  @Test
  @TestMetadata("unrelatedClass.kt")
  public void testUnrelatedClass() {

 *     super.setUp();
 *     handler = new TestLogHandler();
 *     SomeClass.logger.addHandler(handler);
 *     addTearDown(new TearDown() {
 *       public void tearDown() throws Exception {
 *         SomeClass.logger.removeHandler(handler);
 *       }
 *     });
 *   }
 *
 *   public void test() {
 *     SomeClass.foo();
 *     LogRecord firstRecord = handler.getStoredLogRecords().get(0);

 *     super.setUp();
 *     handler = new TestLogHandler();
 *     SomeClass.logger.addHandler(handler);
 *     addTearDown(new TearDown() {
 *       public void tearDown() throws Exception {
 *         SomeClass.logger.removeHandler(handler);
 *       }
 *     });
 *   }
 *
 *   public void test() {
 *     SomeClass.foo();
 *     LogRecord firstRecord = handler.getStoredLogRecords().get(0);

import spock.lang.Issue
import spock.lang.Specification

class ClassInspectorTest extends Specification {
    def "extracts properties of a Groovy class"() {
        expect:
        def details = ClassInspector.inspect(SomeClass)

        details.propertyNames == ['class', 'metaClass', 'prop', 'readOnly', 'writeOnly'] as Set

        def prop = details.getProperty('prop')
        prop.getters.size() == 1
        prop.setters.size() == 1

    def handlesJavaSourceOnly() {
        given:
        buildFile << "apply plugin: 'groovy'"

        and:
        file("src/main/java/somepackage/SomeClass.java") << "public class SomeClass { }"
        file("settings.gradle") << "rootProject.name='javaOnly'"

        when:
        run "build"

        then:
        file("build/libs/javaOnly.jar").exists()
    }

                }
                jvmArgs('-Dkey=value')
                environment('KEY', 'VALUE')
            }
        """
        file('src/test/java/org/example/SomeClass.java') << """
            package org.example;
            public class SomeClass {}
        """

        when:
        fails('test', '--tests', 'Test*')

        then:
        failureCauseContains("No tests found for given includes")

    @Rule
    ZincScalaCompileFixture zincScalaCompileFixture = new ZincScalaCompileFixture(executer, testDirectoryProvider)

    def "handles java source only"() {
        file("src/main/java/somepackage/SomeClass.java") << "public class SomeClass { }"
        buildFile << """
            apply plugin: 'scala'
        """
        settingsFile << """
            rootProject.name = 'javaOnly'
            dependencyResolutionManagement {