$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", []> {

        ComponentIdResolveResult result = selector.resolve(allRejects);

        if (result.getFailure() != null) {
            results.register(selector, result);
            return;
        }

        results.replaceExistingResolutionsWithBetterResult(result, selector.isFromLock());
        results.register(selector, result);
    }

    /**

    }

    TestExecutionResult assertTestClassesExecuted(String... testClasses) {
        results.each { result ->
            result.assertTestClassesExecuted(testClasses)
        }
        return this
    }

    TestExecutionResult assertTestClassesNotExecuted(String... testClasses) {
        results.each { result ->
            result.assertTestClassesNotExecuted(testClasses)
        }
        return this
    }

        then:
        results.size() == 1
        def result = results.values().toList().first()
        result.className == 'Test Worker 1'
        result.startTime == 50
        result.testsCount == 1
        result.failuresCount == 1
        result.duration == 400
        result.results.size() == 1
        result.results[0].failures.size() == 1
    }

    @Issue("GRADLE-2730")

  QuantizationResults results{};
  ASSERT_TRUE(TextFormat::ParseFromString(*file_data, &results));

  // Check that `results` reflects the information of the quantized units
  // properly.
  ASSERT_THAT(results.results(), SizeIs(1));
  EXPECT_THAT(results.results(0).quantizable_unit().name(),
              StrEq("composite_dot_general_fn"));
  EXPECT_TRUE(results.results(0).method().has_static_range_ptq());
}

`tf_device` dialect operation.
  }];

  let arguments = (ins
    Variadic<AnyType>:$results
  );

  let builders = [
    OpBuilder<(ins),
    [{
      build($_builder, $_state, {});
    }]>
   ];

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

def TfDevice_LaunchFuncOp : TfDevice_Op<"launch_func", []> {
  let summary = [{

        }
        when:
        report.generateReport(testTestResults, reportDir)

        then:
        def index = results(indexFile)
        index.assertHasLinkTo('packages/default-package', 'default-package')
        index.assertHasLinkTo('classes/Test', 'Test')

        def packageFile = results(reportDir.file('packages/default-package.html'))
        packageFile.assertHasLinkTo('../classes/Test', 'Test')
    }

        for (ProjectBuildingResult result : results) {
            if (result.getPomFile().getParentFile().getName().equals("child")) {
                return result.getProject();
            }
        }
        return null;
    }

    private void assertResultShowNoError(List<ProjectBuildingResult> results) {
        for (ProjectBuildingResult result : results) {

			require.Equal(t, len(evalResults), len(tc.results))
			for i, result := range tc.results {
				if result.EvalResult != evalResults[i].EvalResult {
					t.Errorf("Expected result '%v' but got '%v'", result.EvalResult, evalResults[i].EvalResult)
				}
				if result.Error != nil && !strings.Contains(evalResults[i].Error.Error(), result.Error.Error()) {
					t.Errorf("Expected result '%v' but got '%v'", result.Error, evalResults[i].Error)
				}
			}

        then:
        contains "There were test failures:"
        contains "There were failing tests. See the results at: "

        and:
        file("build/test-results/helloTest/CUnitAutomated-Results.xml").assertExists()
        file("build/test-results/helloTest/CUnitAutomated-Listing.xml").assertExists()
    }

    @ToBeFixedForConfigurationCache