// license that can be found in the LICENSE file.

// Tests syscall P stealing.
//
// Specifically, it tests a scenerio wherein, without a
// P sequence number of GoSyscallBegin, the syscall that
// a ProcSteal applies to is ambiguous. This only happens in
// practice when the events aren't already properly ordered
// by timestamp, since the ProcSteal won't be seen until after
// the correct GoSyscallBegin appears on the frontier.

    return new NoOpScheduledExecutorService();
  }

  /**
   * Creates a scheduled executor service that runs each task in the thread that invokes {@code
   * execute/submit/schedule}, as in {@link CallerRunsPolicy}. This applies both to individually
   * submitted tasks and to collections of tasks submitted via {@code invokeAll}, {@code invokeAny},
   * {@code schedule}, {@code scheduleAtFixedRate}, and {@code scheduleWithFixedDelay}. In the case

 * [TestModuleKind][org.jetbrains.kotlin.analysis.test.framework.test.configurators.TestModuleKind] supplied by generated tests applies to
 * the expansion-site module instead of the use-site module in these tests, as we want to check the `KaType` when it's built with an

    @Deprecated("Use `callableId` instead.", ReplaceWith("callableId"))
    public val callableIdIfNonLocal: CallableId? get() = callableId

    /**
     * Applies a [substitutor] to the given signature and return a new signature with substituted types.
     *
     * @see KaSubstitutor.substitute
     */
    public abstract fun substitute(substitutor: KaSubstitutor): KaCallableSignature<S>

fun AnalysisStatementFilter.or(other: AnalysisStatementFilter): AnalysisStatementFilter = AnalysisStatementFiltersImplementations.DefaultOrFilter(this, other)


fun AnalysisStatementFilter.implies(other: AnalysisStatementFilter) = this.not().or(other)


fun AnalysisStatementFilter.not(): AnalysisStatementFilter = AnalysisStatementFiltersImplementations.DefaultNotFilter(this)


internal

However, the latest Java version may only be supported for compilation or testing, not for running Gradle.
Support is achieved using <<toolchains#toolchains,toolchains>> and applies to all tasks supporting toolchains.

See the table below for the Java version supported by a specific Gradle release:

.Java Compatibility
|===
|Java version | Support for toolchains | Support for running Gradle

// library will feed zero value, which is the default value in the v3a schema.
// The actual builtin operator code value will exist in the
// `deprecated_builtin_code` field. At the same time, it implies that
// `deprecated_builtin_code` >= `builtin_code` and the maximum value of the two
// fields will be same with `deprecated_builtin_code'.
//
// - Supporting builtin operator codes beyonds 127
//

    }
}

public typealias KtContractCallsInPlaceContractEffectDeclaration = KaContractCallsInPlaceContractEffectDeclaration

/**
 * Represents [kotlin.contracts.SimpleEffect.implies].
 */
public class KaContractConditionalContractEffectDeclaration(
    private val backingEffect: KaContractEffectDeclaration,
    private val backingCondition: KaContractBooleanExpression
) : KaContractEffectDeclaration {

structured k8s.io/apiserver/pkg/server/options/encryptionconfig/.*

# The following packages have been migrated to contextual logging.
# Packages matched here do not have to be listed above because
# "contextual" implies "structured".
contextual k8s.io/api/.*
contextual k8s.io/apimachinery/pkg/util/runtime/.*
contextual k8s.io/client-go/metadata/.*
contextual k8s.io/client-go/tools/events/.*
contextual k8s.io/client-go/tools/record/.*

        then:
        result.assertTasksExecuted(":a:thing", ":b:thing", ":a:a:thing", ":b:b:thing")
    }

    @ToBeFixedForIsolatedProjects(because = "subprojects")
    def "stops traversing sub-projects when task implies sub-projects"() {
        createDirs("a", "b", "a/a", "b/b")
        settingsFile << "include 'a', 'b', 'a:a', 'b:b'"

        buildFile << """
            subprojects {
                task thing