runTest("analysis/analysis-api/testData/components/scopeProvider/combinedDeclaredMemberScope/innerClass.kt");
  }

  @Test
  @TestMetadata("javaClass.kt")
  public void testJavaClass() {
    runTest("analysis/analysis-api/testData/components/scopeProvider/combinedDeclaredMemberScope/javaClass.kt");
  }

  @Test
  @TestMetadata("javaDeclaredEnhancementScope.kt")
  public void testJavaDeclaredEnhancementScope() {

import com.thoughtworks.qdox.JavaProjectBuilder
import com.thoughtworks.qdox.library.OrderedClassLibraryBuilder
import com.thoughtworks.qdox.model.JavaAnnotatedElement
import com.thoughtworks.qdox.model.JavaClass
import org.gradle.internal.classloader.DefaultClassLoaderFactory
import org.gradle.internal.classpath.DefaultClassPath
import java.io.File
import java.io.StringReader
import java.net.URLClassLoader


/**

      return object : DeferredSocketAdapter.Factory {
        override fun matchesSocket(sslSocket: SSLSocket): Boolean = sslSocket.javaClass.name.startsWith("$packageName.")

        override fun create(sslSocket: SSLSocket): SocketAdapter {
          return build(sslSocket.javaClass)
        }
      }
    }
  }

            equalTo(
                textFromResource("PrintAccessors-expected-output.txt")
            )
        )
    }

    private
    fun textFromResource(named: String) =
        javaClass.getResource(named).readText()

    private
    fun String.withoutTrailingWhitespace() =
        lineSequence().map { it.trimEnd() }.joinToString("\n")

import org.junit.Rule

import java.io.File


@CleanupTestDirectory(fieldName = "tempFolder")
abstract class TestWithTempFiles {

    @JvmField
    @Rule
    val tempFolder = TestNameTestDirectoryProvider(javaClass)

    protected
    val root: File
        get() = tempFolder.testDirectory

    /**
     * See [org.junit.rules.TemporaryFolder.newFolder]
     */
    fun newFolder(): File =

                val myOwnPluginGroup =
                    getDeclaredMethod("getOwn", myPluginGroup.javaClass)
                        .invoke(null, myPluginGroup)!!

                val actualPluginSpec =
                    getDeclaredMethod("getPlugin", myOwnPluginGroup.javaClass)
                        .invoke(null, myOwnPluginGroup) as PluginDependencySpec

                assertThat(

        assertEquals(Protocol.HTTP_2, response.protocol)
      }

      assertThat(response.connection.socket().javaClass.name).isEqualTo(
        "sun.security.ssl.SSLSocketImpl",
      )
    }
  }

  @Test
  fun testSupportedProtocols() {
    val factory = SSLSocketFactory.getDefault()
    assertThat(factory.javaClass.name).isEqualTo("sun.security.ssl.SSLSocketFactoryImpl")
    val s = factory.createSocket() as SSLSocket

  override fun contentLength(): Long {
    return delegate.contentLength()
  }

  override fun source(): BufferedSource {
    return delegate.source()
  }

  override fun toString(): String {
    return javaClass.simpleName + "(" + delegate.toString() + ")"
  }

  init {
    requireNotNull(delegate) { "delegate == null" }
    this.delegate = delegate
  }

 */
class PlatformRuleTest {
  @RegisterExtension @JvmField
  val platform = PlatformRule()

  @Test
  fun testMode() {
    println(PlatformRule.getPlatformSystemProperty())
    println(Platform.get().javaClass.simpleName)
  }

  @Test
  fun testGreenCase() {
  }

  @Test
  fun testGreenCaseFailingOnLater() {
    platform.expectFailureFromJdkVersion(PlatformVersion.majorVersion + 1)
  }

  @Test

  public void testInt() {
    runTest("analysis/analysis-api/testData/components/scopeProvider/memberScope/Int.kt");
  }

  @Test
  @TestMetadata("javaClass.kt")
  public void testJavaClass() {
    runTest("analysis/analysis-api/testData/components/scopeProvider/memberScope/javaClass.kt");
  }

  @Test
  @TestMetadata("javaField.kt")
  public void testJavaField() {