then:
        result.assertConfigurationCacheStateStored()

        when:
        run([":tooling-api:clean", ":base-services:clean"])

        and:
        configurationCacheRun supportedTasks + ["--info"], 1

        then:
        result.assertConfigurationCacheStateLoaded()
        result.output.contains("Starting build in new daemon")

	result := allPrimitiveFieldPaths(t, expect, reflect.TypeOf(&KubeletConfiguration{}), nil)
	if !expect.Equal(result) {
		// expected fields missing from result
		missing := expect.Difference(result)
		// unexpected fields in result but not specified in expect
		unexpected := result.Difference(expect)
		if len(missing) > 0 {

        def firstRunOutput = removeVfsLogOutput(result.normalizedOutput)
            .replaceAll(/Calculating task graph as no cached configuration is available for tasks: ${task}.*\n/, '')
            .replaceAll(/Configuration cache entry stored.\n/, '')

        when:
        configurationCacheRun(task, *options)
        def secondRunOutput = removeVfsLogOutput(result.normalizedOutput)

sealed class IntermediateModel {
    abstract fun <T> result(): T?

    class NoModel(val message: String) : IntermediateModel() {
        override fun <T> result() = throw UnknownModelException(message)
    }

    object NullModel : IntermediateModel() {
        override fun <T> result(): T? = null
    }

    class Model(val value: Any) : IntermediateModel() {
        override fun <T> result(): T? = value.uncheckedCast()
    }

        if (token != other.token) return false

        return true
    }

    override fun hashCode(): Int {
        var result = fqName.hashCode()
        result = 31 * result + token.hashCode()
        return result
    }
}

class KtPackage(
    manager: PsiManager,
    private val fqName: FqName,
    private val scope: GlobalSearchScope

        }

        try {
            final CollectResult result =
                    session.getRepositorySystem().collectDependencies(systemSession, collectRequest);
            return new DefaultDependencyResolverResult(
                    null, result.getExceptions(), session.getNode(result.getRoot(), request.getVerbose()), 0);
        } catch (DependencyCollectionException e) {

      fb_builder.GetSize());
}

void Verify(const RuntimeMetadata* result, const RuntimeMetadata* expected) {
  EXPECT_EQ(result->subgraph_metadata()->size(),
            expected->subgraph_metadata()->size());
  for (int i = 0; i < result->subgraph_metadata()->size(); ++i) {
    auto result_subgraph_metadata =
        result->subgraph_metadata()->GetAs<SubgraphMetadata>(i);
    auto expected_subgraph_metadata =

        DefaultBuildableComponentResolveResult result = new DefaultBuildableComponentResolveResult();
        resolver.resolve(componentIdentifier, componentOverrideMetadata, result);

        if (result.getFailure() != null) {
            metadataResolveFailure = result.getFailure();
            return;
        }
        resolveState = result.getState();
        graphResolveState = result.getGraphState();
    }

		t.Errorf("No error should happen, got %v", err)
	}

	type Result struct {
		Name string
		Age  int
	}

	var results []Result
	for rows.Next() {
		var result Result
		if err := DB.ScanRows(rows, &result); err != nil {
			t.Errorf("should get no error, but got %v", err)
		}
		results = append(results, result)
	}

	sort.Slice(results, func(i, j int) bool {

    public List<String> execute(BuildController controller) {
        List<String> result = new ArrayList<>();
        GradleBuild buildModel = controller.getBuildModel();
        for (BasicGradleProject project : buildModel.getProjects()) {
            SomeToolingModel model = controller.findModel(project, SomeToolingModel.class);
            if (model != null) {
                result.add(model.getMessage());
            }
        }
        return result;