statement.setString(1, results.getTestClass());
            statement.setString(2, results.getTestId());
            statement.setString(3, results.getTestProject());
            statement.setTimestamp(4, new Timestamp(results.getStartTime()));
            statement.setTimestamp(5, new Timestamp(results.getEndTime()));
            statement.setString(6, results.getVersionUnderTest());

            statement.setObject(8, toArray(results.getArgs()));
            statement.setObject(9, toArray(results.getGradleOpts()));
            statement.setBoolean(10, results.getDaemon());
            statement.setString(11, results.getOperatingSystem());
            statement.setString(12, results.getJvm());
            statement.setString(13, results.getVcsBranch());

      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) `)`";
}

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

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

    }

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

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

  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());
}

        }
        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) {