annotations to track which parts of each function are executed (this
is referred to "instrumentation"). Cover can operate in "legacy mode"
on a single Go source file at a time, or when invoked by the Go tool
it will process all the source files in a single package at a time
(package-scope instrumentation is enabled via "-pkgcfg" option).

When generated instrumented code, the cover tool computes approximate

import org.jetbrains.kotlin.types.Variance
import kotlin.collections.single

abstract class AbstractCreateInheritanceTypeSubstitutorTest : AbstractAnalysisApiBasedTest() {
    override fun doTest(testServices: TestServices) {
        val baseClass = testServices.expressionMarkerProvider
            .getElementsOfTypeAtCarets<KtClassOrObject>(testServices, "base")
            .single().first
        val superClass = testServices.expressionMarkerProvider

    @Test
    fun `empty plugins block`() {
        assertStaticInterpretationOf("")
    }

    @Test
    fun `single plugin - id()`() {
        assertStaticInterpretationOf(
            """id("plugin-id")""",
            PluginRequestSpec("plugin-id")
        )
    }

    @Test
    fun `single plugin - id() version`() {
        assertStaticInterpretationOf(
            """id("plugin-id") version "1.0"""",

        assertTrue { aType.properties.single { it.name == "y" }.isHiddenInDsl }

        val result = schema.resolve(
            """
            x = 1
            y = 2
            """.trimIndent()
        )

        assertEquals(2, result.errors.size)
        assertEquals("y = 2", result.errors.single { it.errorReason is ErrorReason.UnresolvedAssignmentLhs }.element.sourceData.text())

        fixture.assertDeploymentIsRunning(key)

        when:
        def lastBuildTime = single(buildTimes)
        waitBeforeModification fixture.triggerFile
        fixture.triggerFile << "\n#a change"
        buildTriggeredAndSucceeded()

        then:
        fixture.assertDeploymentIsRunning(key)
        lastBuildTime >= single(buildTimes)
    }

    List<Integer> getBuildTimes() {

  func.return %a : tensor<i1>
}

// Tests that single TensorFlow op with no device attribute is not wrapped in `tf_device.launch`.
// CHECK-LABEL: func @no_device_attribute
func.func @no_device_attribute() {
  // CHECK-NOT: "tf_device.launch"
  // CHECK: "tf.opA"
  "tf.opA"() : () -> tensor<i1>
  func.return
}

// Tests that single TensorFlow op with empty device attribute is not wrapped in `tf_device.launch`.

transporting arguments and results of remote procedure calls (RPCs) such as
those provided by package "net/rpc".

The implementation compiles a custom codec for each data type in the stream
and is most efficient when a single Encoder is used to transmit a stream of
values, amortizing the cost of compilation.
-- text --
                    Package gob manages streams of gobs - binary values

// The parameters for a single unit of work
interface ReverseParameters : WorkParameters {
    val fileToReverse : RegularFileProperty
    val destinationDir : DirectoryProperty
}

// The implementation of a single unit of work
abstract class ReverseFile @Inject constructor(val fileSystemOperations: FileSystemOperations) : WorkAction<ReverseParameters> {
    override fun execute() {
        val fileToReverse = parameters.fileToReverse.asFile.get()

#### Docker Compose

You could be deploying to a **single server** (not a cluster) with **Docker Compose**, so you wouldn't have an easy way to manage replication of containers (with Docker Compose) while preserving the shared network and **load balancing**.

     * and another transform that converts 'red' to 'green'.
     * By default the 'blue' variant will contain a single file, and the transform will produce a single 'green' file from this.
     */
    void setupBuildWithChainedColorTransform(boolean lenient = false) {
        setupBuildWithColorAttributes()
        buildFile << """
            allprojects {