scopes.Framework.Infof("Skipping suite %q: %s", ctx.Settings().TestID, s.skipMessage)

	// Mark this suite as skipped in the context.
	ctx.skipped = true

	// Run the tests so that the golang test framework exits normally. The tests will not run because
	// they see that this suite has been skipped.
	_ = s.mRun(ctx)

	// Return success.
	return 0
}

func (s *suiteImpl) run() (errLevel int) {

	}
	f.common.Helper()
	f.common.Fail()
}

// Skipped reports whether the test was skipped.
func (f *F) Skipped() bool {
	// (*F).Skipped may be called by tRunner, which we should allow. However, we
	// shouldn't allow direct (*F).Skipped calls from inside the (*F).Fuzz function.
	if f.inFuzzFn {
		panic("testing: f.Skipped was called inside the fuzz target, use t.Skipped instead")
	}
	f.common.Helper()

        then:
        executedAndNotSkipped(":copyTask")
        !copyOfExcludedFile.exists()

        when:
        excludedFile.text = "changed"
        run "copyTask"
        then:
        skipped(":copyTask")
    }

    def "default excludes are reset if nothing is defined in settings"() {
        settingsFile << addDefaultExclude(EXCLUDED_FILE_NAME)

        when:
        run "copyTask"

import java.util.List;

/**
 * Describes a test result.
 */
public interface TestResult {
    /**
     * The final status of a test.
     */
    public enum ResultType {
        SUCCESS, FAILURE, SKIPPED
    }

    /**
     * Returns the type of result.  Generally one wants it to be SUCCESS!
     *
     * @return The result type.
     */
    ResultType getResultType();

    /**

        """

        buildFile.makeOlder()

        when:
        run 'myTask'
        then:
        executedAndNotSkipped(':myTask')

        when:
        run 'myTask'
        then:
        skipped(':myTask')

        when:
        buildFile.text = """
            tasks.create<TaskWithNestedAction>("myTask") {
                action = Action { writeText("changed") }
            }
        """

    def "task up to date when no reporting configuration change"() {
        expect:
        succeeds(task)
        executedAndNotSkipped(task)

        and:
        succeeds(task)
        skipped(task)
    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    @ToBeFixedForConfigurationCache
    def "task not up to date when enabled set changes"() {
        expect:
        succeeds(task)

                                testTask.configure {
                                    testLogging {
                                        quiet {
                                            events "skipped", "failed"
                                            minGranularity 2
                                            maxGranularity -1
                                            displayGranularity 3

        when:
        run "compile"
        then:
        skipped ":compile"

        when:
        file("lib1.jar").renameTo(file("lib1-renamed.jar"))
        buildFile.text = buildScriptWithClasspath("lib1-renamed.jar", "lib2.jar")

        run "compile"
        then:
        skipped ":compile"
    }

    def buildScriptWithClasspath(String... dependencies) {
        """

        when:
        executer.execute(task, state, executionContext)

        then:
        1 * spec.findUnsatisfiedSpec(task) >> Mock(SelfDescribingSpec)
        1 * state.setOutcome(TaskExecutionOutcome.SKIPPED)
        noMoreInteractions()
    }

    def handlesOldStyleOnlyIfSpec() {
        given:
        def project = task.project
        def otherTask = Mock(TaskInternal)
        Spec<Task> oldStyleSpec = Mock(Spec)

							TxBytes: toP(20),
						},
					},
				},
			},
			wantErr: false,
			skipped: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// TODO: Remove skip once https://github.com/kubernetes/kubernetes/issues/116692 is fixed.
			if tt.skipped {
				t.Skip("Test temporarily skipped.")
			}
			p := &criStatsProvider{
				windowsNetworkStatsProvider: fakeNetworkStatsProvider{