argumentsSpec.args(args);
        return this;
    }

    @Override
    public ExecSpec setArgs(List<String> arguments) {
        argumentsSpec.setArgs(arguments);
        return this;
    }

    @Override
    public ExecSpec setArgs(Iterable<?> arguments) {
        argumentsSpec.setArgs(arguments);
        return this;
    }

    @Override
    public List<String> getArgs() {

        return this;
    }

    @Override
    public DefaultExecHandleBuilder setArgs(List<String> arguments) {
        argumentsSpec.setArgs(arguments);
        return this;
    }

    @Override
    public DefaultExecHandleBuilder setArgs(Iterable<?> arguments) {
        argumentsSpec.setArgs(arguments);
        return this;
    }

    @Override
    public List<String> getArgs() {

        getDelegate().args(args);
        return this;
    }

    @Override
    default JavaExecSpec setArgs(@Nullable List<String> args) {
        getDelegate().setArgs(args);
        return this;
    }

    @Override
    default JavaExecSpec setArgs(@Nullable Iterable<?> args) {
        getDelegate().setArgs(args);
        return this;
    }

    @Override

            import org.gradle.api.tasks.JavaExec

            class CustomJavaExec extends CustomBaseJavaExec {

                @Override
                JavaExec setArgs(List<String> args) {
                    println "args set: \$args"
                    super.setArgs(args)
                }
            }
        """
        file("plugin/src/main/groovy/CustomBaseJavaExec.groovy") << """
            import org.gradle.api.tasks.JavaExec

        GUtil.addToCollection(arguments, true, args);
        return this;
    }

    public ProcessArgumentsSpec setArgs(List<String> arguments) {
        this.arguments.clear();
        args(arguments);
        return this;
    }

    public ProcessArgumentsSpec setArgs(Iterable<?> arguments) {
        this.arguments.clear();
        args(arguments);
        return this;
    }

				defer cs.Close()
			} else {
				log.Errorf("Unable to initialize ControlZ: %v", err)
			}

			run(sArgs)
			return nil
		},
	}

	loggingOptions.AttachCobraFlags(serverCmd)
	introspectionOptions.AttachCobraFlags(serverCmd)
	addServerFlags(serverCmd, sArgs)

	return serverCmd
}

// getWatchNamespaces returns the namespaces the operator should be watching for changes

    }

    /**
     * {@inheritDoc}
     */
    @Override
    public T setArgs(List<String> arguments) {
        execSpec.setArgs(arguments);
        return taskType.cast(this);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public T setArgs(@Nullable Iterable<?> arguments) {
        execSpec.setArgs(arguments);
        return taskType.cast(this);
    }

    /**

     *
     * @param args args for the command
     * @return this
     * @since 4.0
     */
    ExecSpec setArgs(List<String> args);

    /**
     * Sets the arguments for the command to be executed.
     *
     * @param args args for the command
     * @return this
     */
    ExecSpec setArgs(Iterable<?> args);

    /**
     * Returns the arguments for the command to be executed. Defaults to an empty list.

		t.Errorf(shellsError)
	}
	// test newCmdCompletion with a valid shell.
	// use a dummy parent command as newCmdCompletion needs it.
	parentCmd := &cobra.Command{}
	args := []string{"completion", shells[0]}
	parentCmd.SetArgs(args)
	cmd := newCmdCompletion(&out, "")
	parentCmd.AddCommand(cmd)
	if err := parentCmd.Execute(); err != nil {
		t.Errorf("Cannot execute newCmdCompletion: %v", err)
	}
}

func TestRunCompletion(t *testing.T) {

	rootCmd := &cobra.Command{
		Use:   "operator",
		Short: "The Istio operator.",
		Args:  cobra.ExactArgs(0),
		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
			return nil
		},
	}
	rootCmd.SetArgs(args)
	rootCmd.PersistentFlags().AddGoFlagSet(flag.CommandLine)

	rootCmd.AddCommand(serverCmd())
	rootCmd.AddCommand(version.CobraCommand())
	rootCmd.AddCommand(collateral.CobraCommand(rootCmd, collateral.Metadata{