private final boolean isDryRun;

    public JUnitSpec(
        TestFilterSpec filter,
        Set<String> includeCategories,
        Set<String> excludeCategories,
        boolean isDryRun
    ) {
        this.filter = filter;
        this.includeCategories = includeCategories;
        this.excludeCategories = excludeCategories;
        this.isDryRun = isDryRun;
    }

    private final Set<String> excludeTags;
    private final boolean isDryRun;

    public JUnitPlatformSpec(
        TestFilterSpec filter,
        Set<String> includeEngines,
        Set<String> excludeEngines,
        Set<String> includeTags,
        Set<String> excludeTags,
        boolean isDryRun
    ) {
        this.filter = filter;
        this.includeEngines = includeEngines;

    ) {
        this.usingJUnitPlatform = usingJUnitPlatform;
        this.forkEvery = forkEvery;
        this.isDryRun = isDryRun;
        this.filters = filters;
        this.forkOptions = forkOptions;
        this.candidateClassFiles = candidateClassFiles;
        this.inputFileProperties = inputFileProperties;
        this.outputFileProperties = outputFileProperties;
    }

    @Override
    public boolean isUsingJUnitPlatform() {

        this.listeners = listeners;
        this.configFailurePolicy = configFailurePolicy;
        this.preserveOrder = preserveOrder;
        this.groupByInstances = groupByInstances;
        this.isDryRun = isDryRun;
    }

    public TestFilterSpec getFilter() {
        return filter;
    }

    public Set<String> getListeners() {
        return listeners;
    }

    public Set<String> getExcludeGroups() {

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

package dryrun

// IsDryRun returns true if the DryRun flag is an actual dry-run.
func IsDryRun(flag []string) bool {
	return len(flag) > 0

	serve(w, r, wh.validate)
}

func (wh *Webhook) validate(request *kube.AdmissionRequest) *kube.AdmissionResponse {
	isDryRun := request.DryRun != nil && *request.DryRun
	addDryRunMessageIfNeeded := func(errStr string) error {
		err := fmt.Errorf("%s", errStr)
		if isDryRun {
			err = fmt.Errorf("%s (dry run)", err)
		}
		return err
	}
	switch request.Operation {
	case kube.Create, kube.Update:

	if cfg.Etcd.External != nil {
		return errors.New("etcd static pod manifest cannot be generated for cluster using external etcd")
	}

	if err := prepareAndWriteEtcdStaticPod(manifestDir, patchesDir, cfg, endpoint, nodeName, []etcdutil.Member{}, isDryRun); err != nil {
		return err
	}

        def task2 = Mock(TaskInternal.class)
        def category = DryRunBuildExecutionAction.class.name
        def contents = Mock(QueryableExecutionPlan)

        given:
        startParameter.isDryRun() >> true
        executionPlan.contents >> contents
        contents.tasks >> toList(task1, task2)

        when:
        action.execute(gradle, executionPlan)

        then:

				return
			}

			var attr admission.Attributes
			if tt.IsCRD {
				attr = webhooktesting.NewAttributeUnstructured(ns, tt.AdditionalLabels, tt.IsDryRun)
			} else {
				attr = webhooktesting.NewAttribute(ns, tt.AdditionalLabels, tt.IsDryRun)
			}

			b.ResetTimer()
			b.RunParallel(func(pb *testing.PB) {
				for pb.Next() {
					wh.Admit(context.TODO(), attr, objectInterfaces)
				}
			})

		},
	}

	return []DurationTest{
		{
			Name:                "duration test",
			IsDryRun:            false,
			InitContext:         true,
			Webhooks:            webhooks,
			ExpectedDurationSum: 500,
			ExpectedDurationMax: 400,
		},
		{
			Name:                "duration dry run",
			IsDryRun:            true,
			InitContext:         true,
			Webhooks:            webhooks,