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,

                getChildPath(name).registerConfigurationAction(closure);
                return null;
            } else if (args.length == 2 && args[0] instanceof Class && args[1] instanceof Closure) {
                Class<?> clazz = (Class<?>) args[0];
                Closure<?> closure = (Closure<?>) args[1];
                getChildPath(name).register(clazz, closure);
                return null;

		},
	}

	for _, rt := range tests {
		t.Run(rt.testName, func(t *testing.T) {
			args := SetArgValues(rt.args, rt.name, rt.value, rt.nArgs)
			if !reflect.DeepEqual(args, rt.expectedArgs) {
				t.Errorf("expected args: %#v, got: %#v", rt.expectedArgs, args)
			}
		})
	}

    def "final args only contains @path/to/options.txt"() {
        given:
        def argsWriter = getArgsWriter()
        List<String> args = ["firstArg", "secondArg"]

        when:
        argsWriter.execute(args)

        then:
        args.size() == 1
        hasOptionsFile(args)
    }

    boolean hasOptionsFile(args) {
        args.any({ it.startsWith("@") && it.endsWith("options.txt") })

//	db.Distinct("name").Find(&results)
//	// Select distinct name/age pairs from users
//	db.Distinct("name", "age").Find(&results)
func (db *DB) Distinct(args ...interface{}) (tx *DB) {
	tx = db.getInstance()
	tx.Statement.Distinct = true
	if len(args) > 0 {
		tx = tx.Select(args[0], args[1:]...)
	}
	return
}

// Select specify fields that you want when querying, creating, updating
//

    def "generates args file using system encoding"() {
        def argsFile = tmpDir.file("options.txt")
        def generator = ArgWriter.argsFileGenerator(argsFile, ArgWriter.unixStyleFactory())

        expect:
        generator.transform(["a", "\u0302", "a b c"]) == ["@${argsFile.absolutePath}"]
        argsFile.text == toPlatformLineSeparators('a\n\u0302\n"a b c"\n')
    }

    def "does not generate args file for empty args"() {

                // Cannot convert
                return args;
            }
            needsTransform = true;
        }
        if (!needsTransform) {
            return args;
        }
        Object[] transformed = new Object[args.length];
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            Class<?> type = types[i].getTheClass();

}

func Test_parseIstioVersion(t *testing.T) {
	type args struct {
		ver string
	}
	tests := []struct {
		name string
		args args
		want *model.IstioVersion
	}{
		{
			name: "major.minor.patch",
			args: args{ver: "1.2.3"},
			want: &model.IstioVersion{Major: 1, Minor: 2, Patch: 3},
		},
		{
			name: "major.minor",
			args: args{ver: "1.2"},

	cmd.PersistentFlags().StringVar(&args.common.tag, "tag", tag, TagFlagHelpStr)
	cmd.PersistentFlags().StringSliceVar(&args.common.imagePullSecrets, "imagePullSecrets", nil, ImagePullSecretsHelpStr)
	cmd.PersistentFlags().StringVar(&args.common.operatorNamespace, "operatorNamespace", operatorDefaultNamespace, OperatorNamespaceHelpstr)

	return types.String(result)
}

func findAll(args ...ref.Val) ref.Val {
	argn := len(args)
	if argn < 2 || argn > 3 {
		return types.NoSuchOverloadErr()
	}
	str, ok := args[0].Value().(string)
	if !ok {
		return types.MaybeNoSuchOverloadErr(args[0])
	}
	regex, ok := args[1].Value().(string)
	if !ok {
		return types.MaybeNoSuchOverloadErr(args[1])
	}
	n := int64(-1)
	if argn == 3 {