}
	}
	for uploadIndex < len(uploads) {
		result.Uploads = append(result.Uploads, uploads[uploadIndex])
		result.NextUploadIDMarker = uploads[uploadIndex].UploadID
		uploadIndex++
		if len(result.Uploads) == maxUploads {
			break
		}
	}

	result.IsTruncated = uploadIndex < len(uploads)

	if !result.IsTruncated {
		result.NextKeyMarker = ""
		result.NextUploadIDMarker = ""
	}

	return result, nil

    /**
     * A suffix for the result file to distinguish it from the results of other session invalidation tests if the results are different.
     */
    protected abstract val resultFileSuffix: String?

    protected abstract fun getSession(ktModule: KtModule): SESSION

    protected abstract fun getSessionKtModule(session: SESSION): KtModule

    protected abstract fun isSessionValid(session: SESSION): Boolean

    /**

        }

        private static String fqid(Map<String, Object> id) {
            String result = id['name']
            def parent = id['group']
            while (parent != null) {
                result = "${parent['name']}:$result"
                parent = parent['parent']
            }
            result
        }

        String getFqid() {
            fqid
        }

        @Override

                doLast { }
            }
        """

        when:
        configurationCacheRun("ok")

        then:
        result.assertHasPostBuildOutput("Configuration cache entry stored.")

        when:
        configurationCacheRun("ok")

        then:
        result.assertHasPostBuildOutput("Configuration cache entry reused.")

        when:
        configurationCacheFails("broken")

        then:

        }
        val executionResult = workGraph.withNewWorkGraph { graph ->
            val result = cache.loadOrScheduleRequestedTasks(
                graph = graph,
                graphBuilder = scheduleTaskSelectorPostProcessing
            ) { workPreparer.scheduleRequestedTasks(graph, taskSelector) }
            if (!result.wasLoadedFromCache && !result.entryDiscarded && startParameter.loadAfterStore) {

    @Override
    public List<SomeToolingModel> execute(BuildController controller) {
        List<SomeToolingModel> result = new ArrayList<>();
        result.addAll(new FetchCustomModelForEachProject().execute(controller));
        result.addAll(new FetchCustomModelForEachProject().execute(controller));
        return result;
    }

        problems.assertResultHasProblems(result)
        outputDoesNotContain("apply =")
        outputContains("task = $value")

        when:
        configurationCacheRun("thing", "-DCI=$newValue")

        then: 'undeclared properties are considered build inputs'
        configurationCache.assertStateStored()
        problems.assertResultHasProblems(result)
        outputContains("apply = $newValue")

        }
        with(fixture.all(LoadProjectsBuildOperationType)) {
            size() == 2
            with(get(0)) {
                result.rootProject.name == 'thing'
                result.rootProject.path == ':'
                result.rootProject.children.size() == 3
                with(result.rootProject.children.first() as Map<String, Object>) {
                    name == 'a'
                    path == ':a'

                                                 &result)) {
    LOG(ERROR) << "Failed to export MLIR to flatbuffer.";
    return absl::InternalError("Failed to export MLIR to flatbuffer.");
  }
  builder->PushFlatBuffer(reinterpret_cast<const uint8_t*>(result.data()),
                          result.size());

  return absl::OkStatus();
}

}  // namespace lite

        StringBuilder result = new StringBuilder();
        for (String jvmArg : jvmArgs) {
            if (result.length() > 0) {
                result.append(" ");
            }
            if (jvmArg.contains(" ")) {
                assert !jvmArg.contains("\"") : "jvmArg '" + jvmArg + "' contains '\"'";
                result.append('"');
                result.append(jvmArg);