if err != nil {
		t.Fatalf("error making generator: %v", err)
	}
	rsaToken, err := rsaGenerator.GenerateToken(serviceaccount.LegacyClaims(*serviceAccount, *rsaSecret))
	if err != nil {
		t.Fatalf("error generating token: %v", err)
	}
	if len(rsaToken) == 0 {
		t.Fatalf("no token generated")
	}
	rsaSecret.Data = map[string][]byte{
		"token": []byte(rsaToken),
	}

        executer.expectDocumentedDe...

plugins {
    id("gradlebuild.build-logic.kotlin-dsl-gradle-plugin")
    id("gradlebuild.build-logic.groovy-dsl-gradle-plugin")
}

description = "Provides a plugin for generating and defining performance test projects"

dependencies {
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")

    implementation(project(":integration-testing"))
    implementation(project(":cleanup"))

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.performance.results

import groovy.transform.CompileStatic

/**
 * Used for generating performance-test-durations.json by Jackson.
 */
@CompileStatic
class PerformanceScenarioDurations {
    String scenario
    List<TestProjectDuration> durations

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Adds support for generating parsers from Antlr grammars."

errorprone {
    disabledChecks.addAll(
        "DefaultCharset", // 1 occurrences
        "Finally", // 1 occurrences
    )
}

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":core"))
    api(project(":core-api"))
    api(project(":files"))
    api(project(":model-core"))

public interface FilterableBytecodeInterceptorFactory {

    BytecodeInterceptorType getType();

    /**
     * A marker interface that indicates that a class is used for generating bytecode upgrades.
     */
    interface BytecodeUpgradeInterceptorFactory extends FilterableBytecodeInterceptorFactory {
        @Override
        default BytecodeInterceptorType getType() {

    public void generateReport(TestResultsProvider resultsProvider, File reportDir) {
        LOG.info("Generating HTML test report...");

        Timer clock = Time.startTimer();
        AllTestResults model = loadModelFromProvider(resultsProvider);
        generateFiles(model, resultsProvider, reportDir);
        LOG.info("Finished generating test html results ({}) into: {}", clock.getElapsed(), reportDir);
    }

// descriptions for all the error responses.
var stsErrCodes = stsErrorCodeMap{
	ErrSTSAccessDenied: {
		Code:           "AccessDenied",
		Description:    "Generating temporary credentials not allowed for this request.",
		HTTPStatusCode: http.StatusForbidden,
	},
	ErrSTSMissingParameter: {
		Code:           "MissingParameter",

            "To create the lock state, run a task that performs dependency resolution and add '--write-locks' to the command line.",
            new DocumentationRegistry().getDocumentationRecommendationFor("information on generating lock state", "dependency_locking", "generating_and_updating_dependency_locks"));
    }
    public MissingLockStateException(DisplayName displayName) {

    CMD_TARGETS="${CMD_TARGETS} ${KUBE_CONFORMANCE_IMAGE_TARGETS[*]}"
fi
# include extra WHAT if specified so you can build docker images + binaries
# in one call with a single pass of syncing to the container + generating code
if [[ -n "${KUBE_EXTRA_WHAT:-}" ]]; then
    CMD_TARGETS="${CMD_TARGETS} ${KUBE_EXTRA_WHAT}"
fi

kube::build::verify_prereqs
kube::build::build_image