String[] args = {"apply"};
        CommonsCliUpgradeOptions options = CommonsCliUpgradeOptions.parse(args);

        assertFalse(options.plugins().isPresent(), "--plugins option should not be present by default");
    }

    @Test
    void testPluginsOptionWithOtherFlags() throws ParseException {
        String[] args = {"check", "--plugins", "--directory", "/some/path"};

	}
	if err = args.Validate(); err != nil {
		return args, err
	}
	return args, nil
}

// New - initializes Authorization Management Plugin.
func New(args Args) *AuthZPlugin {
	if args.URL == nil || args.URL.Scheme == "" && args.AuthToken == "" {
		return nil
	}
	return &AuthZPlugin{
		args:   args,
		client: &http.Client{Transport: args.Transport},
	}
}

	lockServers = make([]*lockServer, numberOfNodes)
)

func getLockArgs(r *http.Request) (args LockArgs, err error) {
	buf, err := io.ReadAll(r.Body)
	if err != nil {
		return args, err
	}
	_, err = args.UnmarshalMsg(buf)
	return args, err
}

type lockServerHandler struct {
	lsrv *lockServer
}

			})
		} else if strings.Count(v, "@") > 0 && len(args) > 0 {
			tx.Statement.AddClause(clause.Select{
				Distinct:   db.Statement.Distinct,
				Expression: clause.NamedExpr{SQL: v, Vars: args},
			})
		} else {
			tx.Statement.Selects = []string{v}

			for _, arg := range args {
				switch arg := arg.(type) {
				case string:
					tx.Statement.Selects = append(tx.Statement.Selects, arg)
				case []string:

        super(MessageFormatter.getMessage(messageCode, args), cause);
        this.argName = argName;
        this.messageCode = messageCode;
        this.args = args;
    }

    /**
     * Returns the name of the argument.
     *
     * @return Name of the argument
     */
    public String getArgName() {
        return argName;
    }

	// None of the args have ellipses use the old style.
	if ok {
		setArgs, err = GetAllSets(setDriveCount, args...)
		if err != nil {
			return err
		}
		ctxt.Layout = disksLayout{
			legacy: true,
			pools:  []poolDisksLayout{{layout: setArgs, cmdline: strings.Join(args, " ")}},
		}
		return err
	}

	for _, arg := range args {
		if !ellipses.HasEllipses(arg) && len(args) > 1 {

		RoleARN:     roleArn,
	}
	if err = args.Validate(); err != nil {
		return args, err
	}
	return args, nil
}

// New - initializes Authorization Management Plugin.
func New(shutdownCtx context.Context, args Args) *AuthNPlugin {
	if args.URL == nil || args.URL.Scheme == "" && args.AuthToken == "" {
		return nil
	}
	plugin := AuthNPlugin{
		args:        args,

	}
	for k, args := range cfg.Notify.NATS {
		notify.SetNotifyNATS(newCfg, k, args)
	}
	for k, args := range cfg.Notify.NSQ {
		notify.SetNotifyNSQ(newCfg, k, args)
	}
	for k, args := range cfg.Notify.PostgreSQL {
		notify.SetNotifyPostgres(newCfg, k, args)
	}
	for k, args := range cfg.Notify.Redis {
		notify.SetNotifyRedis(newCfg, k, args)
	}
	for k, args := range cfg.Notify.Webhook {

     * @param messageCode message code
     * @param args arguments for messages
     * @param cause cause of exception
     */
    public ClRuntimeException(final String messageCode, final Object[] args, final Throwable cause) {
        super(cause);
        this.messageCode = messageCode;
        this.args = args;
        simpleMessage = MessageFormatter.getSimpleMessage(messageCode, args);
        message = "[" + messageCode + "]" + simpleMessage;

    @Test
    void cleanArgs() {
        String[] args = {
            "\"",
        };
        CleanArgument.cleanArgs(args);
    }

    @Test
    void cleanArgsShouldRemoveWrongSurroundingQuotes() {
        String[] args = {"\"-Dfoo=bar", "\"-Dfoo2=bar two\""};
        String[] cleanArgs = CleanArgument.cleanArgs(args);
        assertEquals(args.length, cleanArgs.length);
        assertEquals("-Dfoo=bar", cleanArgs[0]);