How to use handleConflictingParams method of cmd Package

...121		flags.BoolP("repeat", "r", false, "")122		flags.Set("repeat", "true")123		repeat = true124		expectedErrorMessage := "Invalid Command. Usage: gauge run --repeat"125		err := handleConflictingParams(&flags, args)126		if !reflect.DeepEqual(err.Error(), expectedErrorMessage) {127			fmt.Printf("Expected %v  Got %v\n", expectedErrorMessage, err)128			panic("assert failed")129		}130		return131	}132	var stdout bytes.Buffer133	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))134	cmd.Env = subEnv()135	cmd.Stdout = &stdout136	err := cmd.Run()137	if err != nil {138		t.Fatalf("process ran with err %v, want exit status 0. Stdout:\n%s", err, stdout.Bytes())139	}140}141func TestHandleConflictingParamsWithOtherFlags(t *testing.T) {142	args := []string{}143	var flags = pflag.FlagSet{}144	flags.BoolP("repeat", "r", false, "")145	flags.Set("repeat", "true")146	flags.StringP("tags", "", "", "")147	flags.Set("tags", "abcd")148	repeat = true149	expectedErrorMessage := "Invalid Command. Usage: gauge run --repeat"150	err := handleConflictingParams(&flags, args)151	if !reflect.DeepEqual(err.Error(), expectedErrorMessage) {152		t.Errorf("Expected %v  Got %v", expectedErrorMessage, err)153	}154}155func TestHandleConflictingParamsWithJustRepeatFlag(t *testing.T) {156	args := []string{}157	var flags = pflag.FlagSet{}158	flags.BoolP("repeat", "r", false, "")159	flags.Set("repeat", "true")160	repeat = true161	err := handleConflictingParams(&flags, args)162	if err != nil {163		t.Errorf("Expected %v  Got %v", nil, err.Error())164	}165}166func TestHandleRerunFlagsWithVerbose(t *testing.T) {167	if os.Getenv("TEST_EXITS") == "1" {168		cmd := &cobra.Command{}169		cmd.Flags().BoolP(verboseName, "v", verboseDefault, "Enable step level reporting on console, default being scenario level")170		cmd.Flags().BoolP(simpleConsoleName, "", simpleConsoleDefault, "Removes colouring and simplifies the console output")171		cmd.Flags().StringP(environmentName, "e", environmentDefault, "Specifies the environment to use")172		cmd.Flags().StringP(tagsName, "t", tagsDefault, "Executes the specs and scenarios tagged with given tags")173		cmd.Flags().StringP(rowsName, "r", rowsDefault, "Executes the specs and scenarios only for the selected rows. It can be specified by range as 2-4 or as list 2,4")174		cmd.Flags().BoolP(parallelName, "p", parallelDefault, "Execute specs in parallel")175		cmd.Flags().IntP(streamsName, "n", streamsDefault, "Specify number of parallel execution streams")176		cmd.Flags().IntP(groupName, "g", groupDefault, "Specify which group of specification to execute based on -n flag")177		cmd.Flags().StringP(strategyName, "", strategyDefault, "Set the parallelization strategy for execution. Possible options are: `eager`, `lazy`")178		cmd.Flags().BoolP(sortName, "s", sortDefault, "Run specs in Alphabetical Order")179		cmd.Flags().BoolP(installPluginsName, "i", installPluginsDefault, "Install All Missing Plugins")180		cmd.Flags().BoolP(failedName, "f", failedDefault, "Run only the scenarios failed in previous run. This is an exclusive flag, it cannot be used in conjunction with any other argument")181		cmd.Flags().BoolP(repeatName, "", repeatDefault, "Repeat last run. This is an exclusive flag, it cannot be used in conjunction with any other argument")182		cmd.Flags().BoolP(hideSuggestionName, "", hideSuggestionDefault, "Prints a step implementation stub for every unimplemented step")183		cmd.Flags().Set(repeatName, "true")184		cmd.Flags().Set(verboseName, "true")185		handleFlags(cmd, []string{"--repeat", "--verbose"})186		overridenFlagValue := cmd.Flag(verboseName).Value.String()187		expectedFlag := "true"188		if !reflect.DeepEqual(overridenFlagValue, expectedFlag) {189			fmt.Printf("Expected %v Got %v\n", expectedFlag, overridenFlagValue)190			os.Exit(1)191		}192		return193	}194	var stdout bytes.Buffer195	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))196	cmd.Env = subEnv()197	cmd.Stdout = &stdout198	err := cmd.Run()199	if err != nil {200		t.Fatalf("process ran with err %v, want exit status 0. Stdout:\n%s", err, stdout.Bytes())201	}202}203func TestHandleFailedCommandForNonGaugeProject(t *testing.T) {204	if os.Getenv("TEST_EXITS") == "1" {205		config.ProjectRoot = ""206		currDir, _ := os.Getwd()207		defer os.Chdir(currDir)208		testdir := filepath.Join(currDir, "dotGauge")209		dotgaugeDir := filepath.Join(testdir, ".gauge")210		os.Chdir(testdir)211		exit = func(err error, i string) {212			if _, e := os.Stat(dotgaugeDir); os.IsExist(e) {213				panic("Folder .gauge is created")214			}215			os.Exit(0)216		}217		os.Args = []string{"gauge", "run", "-f"}218		runCmd.Execute()219		return220	}221	cmd := exec.Command(os.Args[0], fmt.Sprintf("-test.run=%s", t.Name()))222	cmd.Env = subEnv()223	err := cmd.Run()224	if err != nil {225		t.Fatalf("process ran with err %v, want exit status 0", err)226	}227}228func TestHandleConflictingParamsWithLogLevelFlag(t *testing.T) {229	args := []string{}230	var flags = pflag.FlagSet{}231	flags.StringP("log-level", "l", "info", "")232	flags.Set("log-level", "debug")233	flags.BoolP("repeat", "r", false, "")234	flags.Set("repeat", "true")235	repeat = true236	err := handleConflictingParams(&flags, args)237	if err != nil {238		t.Errorf("Expected %v  Got %v", nil, err.Error())239	}240}241func TestNoExitCodeShouldForceReturnZero(t *testing.T) {242	if os.Getenv("TEST_EXITS") == "1" {243		installPlugins = false244		// simulate failure245		execution.ExecuteSpecs = func(s []string) int { return execution.ExecutionFailed }246		os.Args = []string{"gauge", "run", "--fail-safe", "specs"}247		failSafe = true248		runCmd.Execute()249		return250	}...

...76		Run: func(cmd *cobra.Command, args []string) {77			if err := config.SetProjectRoot(args); err != nil {78				exit(err, cmd.UsageString())79			}80			if er := handleConflictingParams(cmd.Flags(), args); er != nil {81				exit(er, "")82			}83			if repeat {84				repeatLastExecution(cmd)85			} else if failed {86				executeFailed(cmd)87			} else {88				execute(cmd, args)89			}90		},91		DisableAutoGenTag: true,92	}93	verbose                    bool94	simpleConsole              bool95	failed                     bool96	repeat                     bool97	parallel                   bool98	sort                       bool99	installPlugins             bool100	environment                string101	tags                       string102	tagsToFilterForParallelRun string103	rows                       string104	strategy                   string105	streams                    int106	maxRetriesCount            int107	retryOnlyTags              string108	group                      int109	failSafe                   bool110	skipCommandSave            bool111	scenarios                  []string112	scenarioNameDefault        []string113)114func init() {115	GaugeCmd.AddCommand(runCmd)116	f := runCmd.Flags()117	f.BoolVarP(&verbose, verboseName, "v", verboseDefault, "Enable step level reporting on console, default being scenario level")118	f.BoolVarP(&simpleConsole, simpleConsoleName, "", simpleConsoleDefault, "Removes colouring and simplifies the console output")119	f.StringVarP(&environment, environmentName, "e", environmentDefault, "Specifies the environment to use")120	f.StringVarP(&tags, tagsName, "t", tagsDefault, "Executes the specs and scenarios tagged with given tags")121	f.StringVarP(&rows, rowsName, "r", rowsDefault, "Executes the specs and scenarios only for the selected rows. It can be specified by range as 2-4 or as list 2,4")122	f.BoolVarP(&parallel, parallelName, "p", parallelDefault, "Execute specs in parallel")123	f.IntVarP(&streams, streamsName, "n", streamsDefault, "Specify number of parallel execution streams")124	f.IntVarP(&maxRetriesCount, maxRetriesCountName, "c", maxRetriesCountDefault, "Max count of iterations for failed scenario")125	f.StringVarP(&retryOnlyTags, retryOnlyTagsName, "", retryOnlyTagsDefault, "Retries the specs and scenarios tagged with given tags")126	f.StringVarP(&tagsToFilterForParallelRun, onlyName, "o", onlyDefault, "Specify number of parallel execution streams")127	f.MarkHidden(onlyName)128	f.IntVarP(&group, groupName, "g", groupDefault, "Specify which group of specification to execute based on -n flag")129	f.StringVarP(&strategy, strategyName, "", strategyDefault, "Set the parallelization strategy for execution. Possible options are: `eager`, `lazy`")130	f.BoolVarP(&sort, sortName, "s", sortDefault, "Run specs in Alphabetical Order")131	f.BoolVarP(&installPlugins, installPluginsName, "i", installPluginsDefault, "Install All Missing Plugins")132	f.BoolVarP(&failed, failedName, "f", failedDefault, "Run only the scenarios failed in previous run. This cannot be used in conjunction with any other argument")133	f.BoolVarP(&repeat, repeatName, "", repeatDefault, "Repeat last run. This cannot be used in conjunction with any other argument")134	f.BoolVarP(&hideSuggestion, hideSuggestionName, "", hideSuggestionDefault, "Prints a step implementation stub for every unimplemented step")135	f.BoolVarP(&failSafe, failSafeName, "", failSafeDefault, "Force return 0 exit code, even in case of failures.")136	f.BoolVarP(&skipCommandSave, skipCommandSaveName, "", skipCommandSaveDefault, "Skip saving last command in lastRunCmd.json")137	f.MarkHidden(skipCommandSaveName)138	f.StringArrayVar(&scenarios, scenarioName, scenarioNameDefault, "Set scenarios for running specs with scenario name")139}140func executeFailed(cmd *cobra.Command) {141	lastState, err := rerun.GetLastFailedState()142	if err != nil {143		exit(err, "")144	}145	if !skipCommandSave {146		rerun.WritePrevArgs(os.Args)147	}148	handleFlags(cmd, append([]string{"gauge"}, lastState...))149	cmd.Flags().Set(skipCommandSaveName, "true")150	logger.Debugf(true, "Executing => %s\n", strings.Join(os.Args, " "))151	cmd.Execute()152}153func handleFlags(cmd *cobra.Command, args []string) {154	cmd.Flags().Visit(func(flag *pflag.Flag) {155		if !util.ListContains(overrideRerunFlags, flag.Name) && flag.Changed {156			flag.Value.Set(flag.DefValue)157		}158	})159	for i := 0; i <= len(args)-1; i++ {160		f := lookupFlagFromArgs(cmd, args[i])161		if f == nil {162			continue163		}164		v := f.Value.String()165		_, err := strconv.ParseBool(v)166		if err != nil && f.Changed {167			if strings.Contains(args[i], "=") {168				args[i] = strings.SplitAfter(args[i], "=")[0] + f.Value.String()169			} else {170				args[i+1] = v171				i = i + 1172			}173		}174	}175	os.Args = args176}177func lookupFlagFromArgs(cmd *cobra.Command, arg string) *pflag.Flag {178	fName := strings.Split(strings.TrimLeft(arg, "-"), "=")[0]179	flags := cmd.Flags()180	f := flags.Lookup(fName)181	if f == nil && len(fName) == 1 {182		f = flags.ShorthandLookup(fName)183	}184	return f185}186func installMissingPlugins(flag bool) {187	if flag && os.Getenv("GAUGE_PLUGIN_INSTALL") != "false" {188		install.AllPlugins(machineReadable)189	}190}191func execute(cmd *cobra.Command, args []string) {192	loadEnvAndInitLogger(cmd)193	if parallel && tagsToFilterForParallelRun != "" && !env.AllowFilteredParallelExecution() {194		logger.Fatal(true, "Filtered parallel execution is a experimental feature. It can be enabled via allow_filtered_parallel_execution property.")195	}196	specs := getSpecsDir(args)197	rerun.SaveState(os.Args[1:], specs)198	if !skipCommandSave {199		rerun.WritePrevArgs(os.Args)200	}201	installMissingPlugins(installPlugins)202	exitCode := execution.ExecuteSpecs(specs)203	notifyTelemetryIfNeeded(cmd, args)204	if failSafe && exitCode != execution.ParseFailed {205		exitCode = 0206	}207	os.Exit(exitCode)208}209var repeatLastExecution = func(cmd *cobra.Command) {210	lastState := rerun.ReadPrevArgs()211	handleFlags(cmd, lastState)212	logger.Debugf(true, "Executing => %s\n", strings.Join(lastState, " "))213	cmd.Execute()214}215func handleConflictingParams(setFlags *pflag.FlagSet, args []string) error {216	flagDiffCount := 0217	setFlags.Visit(func(flag *pflag.Flag) {218		if !util.ListContains(overrideRerunFlags, flag.Name) && flag.DefValue != flag.Value.String() {219			flagDiffCount++220		}221	})222	if repeat && len(args)+flagDiffCount > 1 {223		return fmt.Errorf("Invalid Command. Usage: gauge run --repeat")224	}225	if failed && len(args)+flagDiffCount > 1 {226		return fmt.Errorf("Invalid Command. Usage: gauge run --failed")227	}228	if !parallel && tagsToFilterForParallelRun != "" {229		return fmt.Errorf("Invalid Command. flag --only can be used only with --parallel")...

1func main() {2    cmd = &cmd{}3    cmd.handleConflictingParams()4}5func main() {6    cmd = &cmd{}7    cmd.handleConflictingParams()8}9func main() {10    cmd = &cmd{}11    cmd.handleConflictingParams()12}13func main() {14    cmd = &cmd{}15    cmd.handleConflictingParams()16}17func main() {18    cmd = &cmd{}19    cmd.handleConflictingParams()20}21func main() {22    cmd = &cmd{}23    cmd.handleConflictingParams()24}25func main() {26    cmd = &cmd{}27    cmd.handleConflictingParams()28}29func main() {30    cmd = &cmd{}31    cmd.handleConflictingParams()32}33func main() {34    cmd = &cmd{}35    cmd.handleConflictingParams()36}37func main() {38    cmd = &cmd{}39    cmd.handleConflictingParams()40}41func main() {42    cmd = &cmd{}43    cmd.handleConflictingParams()44}45func main() {

1import (2type cmd struct {3}4func parseCmd() *cmd {5	cmd := &cmd{}6	flag.BoolVar(&cmd.helpFlag, "help", false, "print help message")7	flag.BoolVar(&cmd.helpFlag, "?", false, "print help message")8	flag.BoolVar(&cmd.versionFlag, "version", false, "print version and exit")9	flag.StringVar(&cmd.cpOption, "classpath", "", "classpath")10	flag.StringVar(&cmd.cpOption, "cp", "", "classpath")11	flag.StringVar(&cmd.XjreOption, "Xjre", "", "path to jre")12	flag.Parse()13	args := flag.Args()14	if len(args) > 0 {15	}16}17func printUsage() {18	fmt.Printf("Usage: %s [-options] class [args...]\n", os.Args[0])19}20func startJVM(cmd *cmd) {21	fmt.Printf("classpath:%s class:%s args:%v\n",22}23func main() {24	cmd := parseCmd()25	if cmd.versionFlag {26		fmt.Println("version 0.0.1")27	} else if cmd.helpFlag || cmd.class == "" {28		printUsage()29	} else {30		startJVM(cmd)31	}32}33import (34type cmd struct {35}36func parseCmd() *cmd {37	cmd := &cmd{}38	flag.BoolVar(&cmd.helpFlag, "help", false, "print help message")39	flag.BoolVar(&cmd.helpFlag, "?", false, "print help message")40	flag.BoolVar(&cmd.versionFlag, "version", false, "print version and exit")41	flag.StringVar(&cmd.cpOption, "classpath", "", "classpath")

1import (2func main() {3	cmd := exec.Command("go", "run", "2.go")4	cmd.SysProcAttr = &syscall.SysProcAttr{5	}6	err := cmd.Run()7	if err != nil {8		fmt.Println(err)9	}10}11import (12func main() {13	fmt.Println("Hello, playground")14	os.Exit(1)15}16import (17func main() {18	cmd := exec.Command("ls", "-la")19	output, err := cmd.Output()20	if err != nil {21		fmt.Println(err)22	}23	fmt.Println(string(output))24}

1import (2func main() {3	var cmd = &cobra.Command{4		Run: func(cmd *cobra.Command, args []string) {5			cmd.Help()6		},7	}8	cmd.Flags().String("name", "", "name of the person")9	cmd.Flags().String("nick", "", "nick name of the person")10	cmd.MarkFlagRequired("name")11	cmd.MarkFlagRequired("nick")12	cmd.Flags().String("age", "", "age of the person")13	cmd.Flags().String("address", "", "address of the person")14	cmd.Flags().String("city", "", "city of the person")15	cmd.Flags().String("state", "", "state of the person")16	cmd.Flags().String("country", "", "country of the person")17	cmd.Flags().String("zip", "", "zip of the person")18	cmd.Flags().String("phone", "", "phone of the person")19	cmd.Flags().String("email", "", "email of the person")20	cmd.Flags().String("company", "", "company of the person")21	cmd.Flags().String("designation", "", "designation of the person")22	cmd.Flags().String("website", "", "website of the person")23	cmd.Flags().String("twitter", "", "twitter of the person")24	cmd.Flags().String("facebook", "", "facebook of the person")25	cmd.Flags().String("linkedin", "", "linkedin of the person")26	cmd.Flags().String("github", "", "github of the person")27	cmd.Flags().String("bitbucket", "", "bitbucket of the person")28	cmd.Flags().String("gitlab", "", "gitlab of the person")29	cmd.Flags().String("googleplus", "", "googleplus of the person")30	cmd.Flags().String("youtube", "", "youtube of the person")31	cmd.Flags().String("instagram", "", "instagram of the person")32	cmd.Flags().String("pinterest", "", "pinterest of the person")33	cmd.Flags().String("tumblr", "", "tumblr of the person")34	cmd.Flags().String("skype", "", "skype of the person")35	cmd.Flags().String("telegram", "", "telegram of the person")36	cmd.Flags().String("slack", "", "slack of the person")37	cmd.Flags().String("wechat", "", "wechat of the person")38	cmd.Flags().String("weibo", "", "weibo of

1import (2func main() {3	app := cli.NewApp()4	app.Action = func(c *cli.Context) error {5		fmt.Println("Hello World")6	}7	app.Flags = []cli.Flag{8		cli.StringFlag{9		},10		cli.StringFlag{11		},12	}13	app.Run(os.Args)14}15import (16func main() {17	app := cli.NewApp()18	app.Action = func(c *cli.Context) error {19		fmt.Println("Hello World")20	}21	app.Flags = []cli.Flag{22		cli.StringFlag{23		},24		cli.StringFlag{25		},26	}27	app.Run(os.Args)28}29import (30func main() {31	app := cli.NewApp()32	app.Action = func(c *cli.Context) error {33		fmt.Println("Hello World")34	}35	app.Flags = []cli.Flag{36		cli.StringFlag{37		},38		cli.StringFlag{39		},40	}41	app.Run(os.Args)42}43import (44func main() {45	app := cli.NewApp()

1import (2type cmd struct {3}4func (c *cmd) handleConflictingParams() {5    if c.param != "" && c.flag {6        fmt.Println("Conflicting params")7        os.Exit(1)8    }9}10func (c *cmd) handleParams() {11    c.handleConflictingParams()12    if c.param != "" {13        fmt.Println(c.paramValue)14        os.Exit(0)15    }16    if c.flag {17        fmt.Println(c.flagValue)18        os.Exit(0)19    }20    fmt.Println(c.name)21    os.Exit(0)22}23func main() {24    if len(args) == 0 {25        fmt.Println("No args passed")26        os.Exit(1)27    }28    c := cmd{name: args[0]}29    if len(args) == 1 {30        c.handleParams()31    }32    if len(args) == 2 {33        if strings.Contains(args[1], "-") {34            c.handleParams()35        } else {36            c.handleParams()37        }38    }39    if len(args) == 3 {40        c.handleParams()41    }42}

1import (2func main() {3	cmd := &cobra.Command{4		Run: func(cmd *cobra.Command, args []string) {5			cmd.Help()6		},7	}8	cmd.Flags().Int("flag1", 0, "flag1")9	cmd.Flags().Int("flag2", 0, "flag2")10	cmd.Flags().Int("flag3", 0, "flag3")11	cmd.Flags().Int("flag4", 0, "flag4")12	cmd.Flags().MarkHidden("flag1")13	cmd.Flags().MarkHidden("flag2")14	cmd.Flags().MarkHidden("flag3")15	cmd.Flags().MarkHidden("flag4")16	cmd.Flags().MarkHidden("flag5")17	conflictingFlags := []string{"flag1", "flag2", "flag3", "flag4", "flag5"}18	err := cmd.handleConflictingFlags(conflictingFlags)19	if err != nil {20		fmt.Println(err)21	}22}23Error: flag(s) "flag1", "flag2" cannot be set simultaneously24Error: flag(s) "flag1", "flag3" cannot be set simultaneously25Error: flag(s) "flag1", "flag4" cannot be set simultaneously26Error: flag(s) "flag2", "flag3" cannot be set simultaneously27Error: flag(s) "flag2", "flag4" cannot be set simultaneously28Error: flag(s) "flag3", "flag4" cannot be set simultaneously