}

Operation* GetAnyReturn(Region* region) {
  Operation* result;
  // We only go one level deep, since "returns" in nested functions
  // and return-as-yield CF don't belong to us.
  for (Block& block : region->getBlocks()) {
    for (Operation& op : block.getOperations()) {
      if (op.hasTrait<OpTrait::ReturnLike>()) result = &op;
    }
  }
  return result;
}

        firstOutput.assertExists()
        secondOutput.assertExists()
        // first can be loaded from the cache
        result.assertTaskSkipped(first)
        // second cannot be loaded from the cache due to a cache miss
        result.assertTaskNotSkipped(second)
    }

    def "overlapping output directory with first, second then second, first"() {
        def (String first, TestFile firstOutput,

    public Try<T> getValue() throws IllegalStateException {
        Try<T> result = this.result;
        if (result == null) {
            throw new IllegalStateException(String.format("Value for %s has not been calculated yet.", displayName));
        }
        return result;
    }

    @Override
    public boolean isFinalized() {
        return result != null;
    }

    /**

// Wrap op result uses in an unrealized cast to create a cast to buffer
// any type changes to result, and apply type converter to result:
//   result = op(V0)
//   V1     = op2(result)
//   ==>
//   result = op(V0)
//   V1     = unrealized_cast(result)
//   V2     = op2(V1)
void ConvertAndWrapUsesInUnrealizedCast(Value result, TypeConverter &converter,

        buildWorkResult
}


class BuildWorkResultProvider : AbstractMinimalProvider<BuildWorkResult>() {

    private
    var result: BuildWorkResult? = null

    fun set(result: BuildWorkResult) {
        require(this.result == null)
        this.result = result
    }

    override fun getType(): Class<BuildWorkResult> =
        BuildWorkResult::class.java

        val result = pluginsSchema.runChecks(
            """
            plugins { }
            plugins { }
            rootProject.name = "foo"
            plugins { }
            """.trimIndent()
        )

        assertEquals(2, result.size)
        assertEquals(listOf(2, 4), result.map { it.location.sourceData.lineRange.first })

                println("Deleting " + file)
                deletedSomething = true
            }
        }
        and:
        result = executer.withTasks("hello").run()
        then:
        deletedSomething
        result.assertHasErrorOutput("does not appear to contain a Gradle distribution.")
        result.assertTaskExecuted(":hello")
    }

		t.Run(fmt.Sprintf("compare version %s->%s", tc.a, tc.b), func(t *testing.T) {
			r := tc.a.Compare(tc.b)
			if r != tc.result {
				t.Errorf("expected %d, got %d", tc.result, r)
			}
		})
	}
}

func TestMinimumIstioVersion(t *testing.T) {
	tcs := []struct {
		name     string
		versions IstioVersions
		result   IstioVersion
	}{
		{
			"two versions",
			IstioVersions([]IstioVersion{
				"1.4", "1.5",
			}),

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                TaskWithComplexInputs() {
                    def result = name == "never"
                    outputs.upToDateWhen { !result }
                }

                @TaskAction
                def go() {
                    outputFile.get().asFile.text = "some-derived-value"
                }
            }

                throw UncheckedException.throwAsUncheckedException(t);
            } else {
                // Created a result which may contain failures. Combine this failure with any failures that happen to be packaged in the result