igr.Add(3)
	clk.Step(time.Second)
	results := igr.GetResults()
	rToo := igr.Reset()
	if e := (IntegratorResults{Duration: time.Second.Seconds(), Average: 3, Deviation: 0, Min: 0, Max: 3}); !e.Equal(&results) {
		t.Errorf("expected %#+v, got %#+v", e, results)
	}
	if !results.Equal(&rToo) {
		t.Errorf("expected %#+v, got %#+v", results, rToo)
	}
	igr.Set(2)
	results = igr.GetResults()

    private class KnownBuildSpecificationsPerformanceTestExecution implements PerformanceTestExecution {
        private final CrossBuildPerformanceResults results;

        public KnownBuildSpecificationsPerformanceTestExecution(CrossBuildPerformanceResults results) {
            this.results = results;
        }

        @Override
        public String getExecutionId() {

                textCell(results.getVersionUnderTest());
                textCell(results.getOperatingSystem());
                textCell(results.getHost());
                textCell(results.getJvm());
                textCell(results.getTestProject());
                textCell(results.getTasks());
                textCell(results.getCleanTasks());
                textCell(results.getArgs());

      input fallback tensors.

    results: the converted corert tensorhandles.
  }];

  let arguments = (ins
    Variadic<TFTensorType>:$args,
    StrAttr:$device
  );

  let results = (outs
    Variadic<CoreRT_TensorHandleType>:$results
  );

  let assemblyFormat = "operands attr-dict `:` `(` type($args) `)` `->` `(` type($results) `)`";
}

        given:
        resolveContext.hasDependencies() >> false

        when:
        def results = dependencyResolver.resolveGraph(resolveContext)

        then:
        results.visitedGraph.resolutionResult.rootSource.get().dependencies.empty

        def visitedArtifacts = results.visitedArtifacts
        def artifactSet = visitedArtifacts.select(Mock(ArtifactSelectionSpec))

    results: the tensor values for the corresponding indices.
  }];

  let arguments = (ins
    I64ArrayAttr:$indices
  );

  let results = (outs
    Variadic<TensorType>:$results
  );

  let assemblyFormat = "attr-dict `:` type($results)";
}

def CreateOp: FallbackSync_Op<"createop", []> {
  let summary = "The Fallback CreateOp";

  let description = [{

import org.gradle.performance.fixture.PerformanceTestDirectoryProvider
import org.gradle.performance.results.DataReporter
import org.gradle.performance.results.DefaultOutputDirSelector
import org.gradle.performance.results.GradleProfilerReporter
import org.gradle.performance.results.OutputDirSelector
import org.gradle.performance.results.PerformanceTestResult
import org.gradle.profiler.flamegraph.DifferentialStacksGenerator

package main

import "fmt"

var results string

type TwoInts struct {
	x, y int
}

func f(x int) int { results = results + fmt.Sprintf("_%d", x); return x }

func main() {
	_ = [19]int{1: f(1), 0: f(0), 2: f(2), 6, 7}
	_ = [2]int{1: f(4), 0: f(3)}
	_ = TwoInts{y: f(6), x: f(5)}
	_ = map[int]int{f(f(9) + 1): f(8), 0: f(7), f(22): -1}
	if results != "_1_0_2_4_3_6_5_9_10_8_7_22" {

                    )
                    rhs = BooleanLiteral [indexes: 45..50, line/column: 5/5..5/10, file: test] (false)
                )""".trimIndent()
        results.assert(expected)
    }

    @Test
    fun `parses imports`() {
        val results = parse(
            """
            import a.b.c
            import a.b.MyData
            import MyOtherData
            """.trimIndent()
        )

    $futures: A list of !mlrt.future. The underlying value must be tensorflow tensors.

    $results: A list of tensorflow tensors.
  }];

  let arguments = (ins
    Variadic<MlrtFutureType>:$futures
  );

  let results = (outs
    Variadic<TFTensorType>:$results
  );

  let assemblyFormat = "$futures attr-dict `:` type($results)";
}

def PromiseOp: TensorflowMlrt_Op<"promise", []> {