work.markrootNext = 0
	work.markrootJobs = uint32(fixedRootCount + work.nDataRoots + work.nBSSRoots + work.nSpanRoots + work.nStackRoots)

	// Calculate base indexes of each root type
	work.baseData = uint32(fixedRootCount)
	work.baseBSS = work.baseData + uint32(work.nDataRoots)
	work.baseSpans = work.baseBSS + uint32(work.nBSSRoots)
	work.baseStacks = work.baseSpans + uint32(work.nSpanRoots)

	//
	// nStackRoots == len(stackRoots), but we have nStackRoots for
	// consistency.
	nDataRoots, nBSSRoots, nSpanRoots, nStackRoots int

	// Base indexes of each root type. Set by gcMarkRootPrepare.
	baseData, baseBSS, baseSpans, baseStacks, baseEnd uint32

	// stackRoots is a snapshot of all of the Gs that existed
	// before the beginning of concurrent marking. The backing

    heritage: {{ .Release.Service }}
data:
  initialize: |-
    {{- include (print $.Template.BasePath "/_helper_create_bucket.txt") . | nindent 4 }}
  add-user: |-
    {{- include (print $.Template.BasePath "/_helper_create_user.txt") . | nindent 4 }}
  add-policy: |-
    {{- include (print $.Template.BasePath "/_helper_create_policy.txt") . | nindent 4 }}
  {{- range $idx, $policy := .Values.policies }}

        assert sourceFiles == ['build.gradle'] + sourceFiles(component.sourceFiles, basePath)
        assert headerFiles == sourceFiles(component.headerFiles, basePath)
    }

    void assertHasComponentSources(CppSourceElement component, String basePath) {
        assert sourceFiles == ['build.gradle'] + sourceFiles(component.sources.files, basePath)

    }

    File getBinPath(File basePath) {
        return new File(basePath, binPath);
    }

    File getLibPath(File basePath) {
        return new File(basePath, libPath);
    }

    File getCompilerPath(File basePath) {
        return new File(getBinPath(basePath), COMPILER_FILENAME);
    }

    File getCrossCompilePath(File basePath) {
        return null;
    }

    private VisualCppInstall buildVisualCppInstall(String name, File vsPath, File basePath, VersionNumber version, Compatibility compatibility) {
        switch (compatibility) {
            case LEGACY:
                return buildLegacyVisualCppInstall(name, vsPath, basePath, version);
            case VS2017_OR_LATER:
                return buildVisualCppInstall(name, vsPath, basePath, version);
            default:

        }

        this.basePath = getProperty(startParameter, SYSPROP);

        if (this.basePath == null || basePath.equals(Boolean.FALSE.toString())) {
            this.logOutputStream = null;
            return;
        }

        try {
            File logFile = logFile(basePath);
            GFileUtils.mkdirs(logFile.getParentFile());

    }

    def assertContainsVersioned(int version, String basePath) {
        assertContainsFile(toVersionedPath(version, basePath))
        this
    }

    def assertNotContainsVersioned(int version, String basePath) {
        assertNotContainsFile(toVersionedPath(version, basePath))
    }

    def assertVersionedContent(int version, String basePath, String content) {

    public void writeToFile(TestFile file) {
        if (file.exists()) {
            file.write("");
        }
        file.write(content);
    }

    public String withPath(String basePath) {
        return Joiner.on('/').join(basePath, path, name);
    }

        // get rid of the ivy [] token, as [ ] are not valid URI characters
        int pos = rawPattern.indexOf('[');
        String basePath = pos < 0 ? rawPattern : rawPattern.substring(0, pos);
        this.baseUri = fileResolver.resolveUri(basePath);
        this.pattern = pos < 0 ? "" : rawPattern.substring(pos);
        scheme = baseUri.getScheme().toLowerCase();