private static AbstractTestResult adapt(TestResult result) {
        TestResult.ResultType resultType = result.getResultType();
        switch (resultType) {
            case SUCCESS:
                return new DefaultTestSuccessResult(result.getStartTime(), result.getEndTime());
            case SKIPPED:
                return new DefaultTestSkippedResult(result.getStartTime(), result.getEndTime());
            case FAILURE:

        then:
        DefaultTestExecutionResult result = new DefaultTestExecutionResult(testDirectory)
        result.assertTestClassesExecuted('NoCatTests', 'SomeTests', 'SomeOtherCatTests')
        result.testClass("SomeOtherCatTests").assertTestCount(2, 0, 0)
        result.testClass("SomeOtherCatTests").assertTestsExecuted('someOtherOk1', 'someOtherOk2')
        result.testClass("NoCatTests").assertTestCount(2, 0, 0)

        // initial try, use locally cached metadata

        List<MetadataResult> results = repositorySystem.resolveMetadata(request.getRepositorySession(), requests);
        requests.clear();

        PluginPrefixResult result = processResults(request, trace, results, requests);

        if (result != null) {
            return result;
        }

  std::unique_ptr<Graph> result;
  TF_ASSERT_OK(IncreaseDynamismForAutoJit(root, &result));

  Node* static_shaped_slice = testing::FindNodeByName(
      result.get(), "slice/static_shaped_slice/static_shaped_slice");
  EXPECT_NE(static_shaped_slice, nullptr);
  EXPECT_THAT(result->nodes(), Not(Contains(NodeWith(Op("ConcatV2")))));
}

        when:
        def result = dependencyHandler.module("someNotation", cl)

        then:
        result == clientModule

        and:
        1 * dependencyFactory.createModule("someNotation", cl) >> clientModule
    }

    void "creates gradle api dependency"() {
        Dependency dependency = Mock()

        when:
        def result = dependencyHandler.gradleApi()

        then:

                nullify(artifact.getClassifier()),
                handler);

        result.setFile(artifact.getFile());
        result.setResolved(artifact.getFile() != null);

        List<String> trail = new ArrayList<>(1);
        trail.add(result.getId());
        result.setDependencyTrail(trail);

        return result;
    }

    public static void toArtifacts(

        def impl1 = stream("org.gradle.Impl1")
        def impl2 = stream("org.gradle.Impl2")

        when:
        def result = serviceLocator.getAll(CharSequence)

        then:
        result.size() == 2
        result[0] instanceof String
        result[1] instanceof StringBuilder
        1 * classLoader.getResources("META-INF/services/java.lang.CharSequence") >> Collections.enumeration([impl1, impl2])

                }
            }

            task askInt {
                def result = handler.askUser { it.askIntQuestion("thing?", 2, 3) }
                doLast {
                    println "result = " + result.get()
                }
            }

            task selectOption {
                def result = handler.askUser { it.selectOption("select thing", ["a", "b", "c"], "b") }

        then:
        DefaultTestExecutionResult result = new DefaultTestExecutionResult(testDirectory)
        result.assertTestClassesExecuted('SomeLocaleTests')
        result.testClass("SomeLocaleTests").assertTestCount(3, 0, 0)
        result.testClass("SomeLocaleTests").assertTestsExecuted(
            result.testCase('ok1(Locale)[1]', 'French'),
            result.testCase('ok1(Locale)[2]', 'German'),

    }

    @Override
    protected <RESULT extends PathMapping> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));