if (!path.endsWith(".class")) {
        throw IllegalArgumentException("Not a class file: $path")
    }
    inputStream().use {
        val reader = ClassReader(it)
        return setOf(reader.superName) + reader.interfaces
    }

            <p>
            We check the binary compatibility by comparing the current code’s binary interfaces
            against THE LATEST VERSION WHICH IS RELEASED FROM RELEASE BRANCH (from `released-version.json` on this branch)
            AND LOWER THAN CURRENT BASE VERSION (from `version.txt` on this branch).

                fun String.invoke(some: Int) {}
                operator fun Long.invoke(some: Int) {}

                fun Float.invoke(some: Int) {}
                infix fun Byte.invoke(some: Int) {}

                interface Source {
                    infix fun String.plus(some: List<Int>): String
                    operator fun Int.plus(some: List<Int>): Int
                }
            """,
            v2 = """

                            "acceptation": "org.gradle.api.AntBuilder now extends groovy.ant.AntBuilder",
                            "changes": [
                                "Abstract method has been added in implemented interface"
                            ]
                        },
                        {
                            "type": "org.gradle.api.file.SourceDirectorySet",

Another more targeted interface is `CompilationFailedIndicator`.
This interface is used to indicate that the exception is caused by a compilation failure. 

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package common

interface Jvm {
    val version: JvmVersion
    val vendor: JvmVendor
}

data class DefaultJvm(
    override val version: JvmVersion,
    override val vendor: JvmVendor
) : Jvm

object BuildToolBuildJvm : Jvm {

import java.io.File


/**
 * An extension to work with {@see TestFilesCleanupService}.
 * We have to collect all information we need in this extension and pass them
 * to the build service.
 */
interface TestFilesCleanupBuildServiceRootExtension {
    val projectStates: MapProperty<String, TestFilesCleanupProjectState>

    /**
     * Key is the path of a task, value is the possible report dirs it generates.
     */

    /**
     * To be compatible with configuration cache, this field must be Serializable.
     */
    abstract val collectedInformation: Serializable

    interface Params : BuildServiceParameters {
        val monitoredTaskPaths: SetProperty<String>
    }

    override fun onFinish(event: FinishEvent) {
        if (event !is TaskFinishEvent) {
            return
        }

import java.text.SimpleDateFormat
import java.util.Date
import java.util.TimeZone


abstract class BuildTimestampValueSource : ValueSource<String, BuildTimestampValueSource.Parameters>, Describable {

    interface Parameters : ValueSourceParameters {

        @get:Optional
        val buildTimestampFromBuildReceipt: Property<String>

        @get:Optional
        val buildTimestampFromGradleProperty: Property<String>

 */

package model

import common.Os
import java.util.Locale

interface PerformanceTestBuildSpec {
    val type: PerformanceTestType
    val os: Os
    val withoutDependencies: Boolean

    fun asConfigurationId(model: CIBuildModel, bucket: String): String
    fun channel(): String
}

interface PerformanceTestProjectSpec {
    val type: PerformanceTestType
    val failsStage: Boolean