How to use args method of rerun Package

Best Gauge code snippet using rerun.args

main_test.go

Source:main_test.go

...22}23func TestOptions_Validate_FromFlags(t *testing.T) {24	type testCase struct {25		name     string26		args     []string27		expected string28	}29	fn := func(t *testing.T, tc testCase) {30		flags, opts := setupFlags("gotestsum")31		err := flags.Parse(tc.args)32		assert.NilError(t, err)33		opts.args = flags.Args()34		err = opts.Validate()35		if tc.expected == "" {36			assert.NilError(t, err)37			return38		}39		assert.ErrorContains(t, err, tc.expected, "opts: %#v", opts)40	}41	var testCases = []testCase{42		{43			name: "no flags",44		},45		{46			name: "rerun flag, raw command",47			args: []string{"--rerun-fails", "--raw-command", "--", "./test-all"},48		},49		{50			name: "rerun flag, no go-test args",51			args: []string{"--rerun-fails", "--"},52		},53		{54			name:     "rerun flag, go-test args, no packages flag",55			args:     []string{"--rerun-fails", "--", "./..."},56			expected: "the list of packages to test must be specified by the --packages flag",57		},58		{59			name: "rerun flag, go-test args, with packages flag",60			args: []string{"--rerun-fails", "--packages", "./...", "--", "--foo"},61		},62		{63			name: "rerun flag, no go-test args, with packages flag",64			args: []string{"--rerun-fails", "--packages", "./..."},65		},66	}67	for _, tc := range testCases {68		t.Run(tc.name, func(t *testing.T) {69			fn(t, tc)70		})71	}72}73func TestGoTestCmdArgs(t *testing.T) {74	type testCase struct {75		opts      *options76		rerunOpts rerunOpts77		env       []string78		expected  []string79	}80	run := func(t *testing.T, name string, tc testCase) {81		t.Helper()82		runCase(t, name, func(t *testing.T) {83			defer env.PatchAll(t, env.ToMap(tc.env))()84			actual := goTestCmdArgs(tc.opts, tc.rerunOpts)85			assert.DeepEqual(t, actual, tc.expected)86		})87	}88	run(t, "raw command", testCase{89		opts: &options{90			rawCommand: true,91			args:       []string{"./script", "-test.timeout=20m"},92		},93		expected: []string{"./script", "-test.timeout=20m"},94	})95	run(t, "no args", testCase{96		opts:     &options{},97		expected: []string{"go", "test", "-json", "./..."},98	})99	run(t, "no args, with rerunPackageList arg", testCase{100		opts: &options{101			packages: []string{"./pkg"},102		},103		expected: []string{"go", "test", "-json", "./pkg"},104	})105	run(t, "TEST_DIRECTORY env var no args", testCase{106		opts:     &options{},107		env:      []string{"TEST_DIRECTORY=testdir"},108		expected: []string{"go", "test", "-json", "testdir"},109	})110	run(t, "TEST_DIRECTORY env var with args", testCase{111		opts: &options{112			args: []string{"-tags=integration"},113		},114		env:      []string{"TEST_DIRECTORY=testdir"},115		expected: []string{"go", "test", "-json", "-tags=integration", "testdir"},116	})117	run(t, "no -json arg", testCase{118		opts: &options{119			args: []string{"-timeout=2m", "./pkg"},120		},121		expected: []string{"go", "test", "-json", "-timeout=2m", "./pkg"},122	})123	run(t, "with -json arg", testCase{124		opts: &options{125			args: []string{"-json", "-timeout=2m", "./pkg"},126		},127		expected: []string{"go", "test", "-json", "-timeout=2m", "./pkg"},128	})129	run(t, "raw command, with rerunOpts", testCase{130		opts: &options{131			rawCommand: true,132			args:       []string{"./script", "-test.timeout=20m"},133		},134		rerunOpts: rerunOpts{135			runFlag: "-run=TestOne|TestTwo",136			pkg:     "./fails",137		},138		expected: []string{"./script", "-test.timeout=20m", "-run=TestOne|TestTwo", "./fails"},139	})140	run(t, "no args, with rerunOpts", testCase{141		opts: &options{},142		rerunOpts: rerunOpts{143			runFlag: "-run=TestOne|TestTwo",144			pkg:     "./fails",145		},146		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails"},147	})148	run(t, "TEST_DIRECTORY env var, no args, with rerunOpts", testCase{149		opts: &options{},150		rerunOpts: rerunOpts{151			runFlag: "-run=TestOne|TestTwo",152			pkg:     "./fails",153		},154		env: []string{"TEST_DIRECTORY=testdir"},155		// TEST_DIRECTORY should be overridden by rerun opts156		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails"},157	})158	run(t, "TEST_DIRECTORY env var, with args, with rerunOpts", testCase{159		opts: &options{160			args: []string{"-tags=integration"},161		},162		rerunOpts: rerunOpts{163			runFlag: "-run=TestOne|TestTwo",164			pkg:     "./fails",165		},166		env:      []string{"TEST_DIRECTORY=testdir"},167		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-tags=integration", "./fails"},168	})169	run(t, "no -json arg, with rerunOpts", testCase{170		opts: &options{171			args:     []string{"-timeout=2m"},172			packages: []string{"./pkg"},173		},174		rerunOpts: rerunOpts{175			runFlag: "-run=TestOne|TestTwo",176			pkg:     "./fails",177		},178		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-timeout=2m", "./fails"},179	})180	run(t, "with -json arg, with rerunOpts", testCase{181		opts: &options{182			args:     []string{"-json", "-timeout=2m"},183			packages: []string{"./pkg"},184		},185		rerunOpts: rerunOpts{186			runFlag: "-run=TestOne|TestTwo",187			pkg:     "./fails",188		},189		expected: []string{"go", "test", "-run=TestOne|TestTwo", "-json", "-timeout=2m", "./fails"},190	})191	run(t, "with args, with reunFailsPackageList args, with rerunOpts", testCase{192		opts: &options{193			args:     []string{"-timeout=2m"},194			packages: []string{"./pkg1", "./pkg2", "./pkg3"},195		},196		rerunOpts: rerunOpts{197			runFlag: "-run=TestOne|TestTwo",198			pkg:     "./fails",199		},200		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-timeout=2m", "./fails"},201	})202	run(t, "with args, with reunFailsPackageList", testCase{203		opts: &options{204			args:     []string{"-timeout=2m"},205			packages: []string{"./pkg1", "./pkg2", "./pkg3"},206		},207		expected: []string{"go", "test", "-json", "-timeout=2m", "./pkg1", "./pkg2", "./pkg3"},208	})209	run(t, "reunFailsPackageList args, with rerunOpts ", testCase{210		opts: &options{211			packages: []string{"./pkg1", "./pkg2", "./pkg3"},212		},213		rerunOpts: rerunOpts{214			runFlag: "-run=TestOne|TestTwo",215			pkg:     "./fails",216		},217		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails"},218	})219	run(t, "reunFailsPackageList args, with rerunOpts, with -args ", testCase{220		opts: &options{221			args:     []string{"before", "-args", "after"},222			packages: []string{"./pkg1"},223		},224		rerunOpts: rerunOpts{225			runFlag: "-run=TestOne|TestTwo",226			pkg:     "./fails",227		},228		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "before", "./fails", "-args", "after"},229	})230	run(t, "reunFailsPackageList args, with rerunOpts, with -args at end", testCase{231		opts: &options{232			args:     []string{"before", "-args"},233			packages: []string{"./pkg1"},234		},235		rerunOpts: rerunOpts{236			runFlag: "-run=TestOne|TestTwo",237			pkg:     "./fails",238		},239		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "before", "./fails", "-args"},240	})241	run(t, "reunFailsPackageList args, with -args at start", testCase{242		opts: &options{243			args:     []string{"-args", "after"},244			packages: []string{"./pkg1"},245		},246		expected: []string{"go", "test", "-json", "./pkg1", "-args", "after"},247	})248	run(t, "-run arg at start, with rerunOpts ", testCase{249		opts: &options{250			args:     []string{"-run=TestFoo", "-args"},251			packages: []string{"./pkg"},252		},253		rerunOpts: rerunOpts{254			runFlag: "-run=TestOne|TestTwo",255			pkg:     "./fails",256		},257		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails", "-args"},258	})259	run(t, "-run arg in middle, with rerunOpts ", testCase{260		opts: &options{261			args:     []string{"-count", "1", "--run", "TestFoo", "-args"},262			packages: []string{"./pkg"},263		},264		rerunOpts: rerunOpts{265			runFlag: "-run=TestOne|TestTwo",266			pkg:     "./fails",267		},268		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-count", "1", "./fails", "-args"},269	})270	run(t, "-run arg at end with missing value, with rerunOpts ", testCase{271		opts: &options{272			args:     []string{"-count", "1", "-run"},273			packages: []string{"./pkg"},274		},275		rerunOpts: rerunOpts{276			runFlag: "-run=TestOne|TestTwo",277			pkg:     "./fails",278		},279		expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-count", "1", "-run", "./fails"},280	})281}282func runCase(t *testing.T, name string, fn func(t *testing.T)) {283	t.Helper()284	t.Run(name, func(t *testing.T) {285		t.Helper()286		t.Log("case:", name)287		fn(t)288	})289}290func TestRun_RerunFails_WithTooManyInitialFailures(t *testing.T) {291	jsonFailed := `{"Package": "pkg", "Action": "run"}292{"Package": "pkg", "Test": "TestOne", "Action": "run"}293{"Package": "pkg", "Test": "TestOne", "Action": "fail"}294{"Package": "pkg", "Test": "TestTwo", "Action": "run"}295{"Package": "pkg", "Test": "TestTwo", "Action": "fail"}296{"Package": "pkg", "Action": "fail"}297`298	fn := func(args []string) *proc {299		return &proc{300			cmd:    fakeWaiter{result: newExitCode("failed", 1)},301			stdout: strings.NewReader(jsonFailed),302			stderr: bytes.NewReader(nil),303		}304	}305	reset := patchStartGoTestFn(fn)306	defer reset()307	out := new(bytes.Buffer)308	opts := &options{309		rawCommand:                   true,310		args:                         []string{"./test.test"},311		format:                       "testname",312		rerunFailsMaxAttempts:        3,313		rerunFailsMaxInitialFailures: 1,314		stdout:                       out,315		stderr:                       os.Stderr,316		hideSummary:                  newHideSummaryValue(),317	}318	err := run(opts)319	assert.ErrorContains(t, err, "number of test failures (2) exceeds maximum (1)", out.String())320}321func TestRun_RerunFails_BuildErrorPreventsRerun(t *testing.T) {322	jsonFailed := `{"Package": "pkg", "Action": "run"}323{"Package": "pkg", "Test": "TestOne", "Action": "run"}324{"Package": "pkg", "Test": "TestOne", "Action": "fail"}325{"Package": "pkg", "Test": "TestTwo", "Action": "run"}326{"Package": "pkg", "Test": "TestTwo", "Action": "fail"}327{"Package": "pkg", "Action": "fail"}328`329	fn := func(args []string) *proc {330		return &proc{331			cmd:    fakeWaiter{result: newExitCode("failed", 1)},332			stdout: strings.NewReader(jsonFailed),333			stderr: strings.NewReader("anything here is an error\n"),334		}335	}336	reset := patchStartGoTestFn(fn)337	defer reset()338	out := new(bytes.Buffer)339	opts := &options{340		rawCommand:                   true,341		args:                         []string{"./test.test"},342		format:                       "testname",343		rerunFailsMaxAttempts:        3,344		rerunFailsMaxInitialFailures: 1,345		stdout:                       out,346		stderr:                       os.Stderr,347		hideSummary:                  newHideSummaryValue(),348	}349	err := run(opts)350	assert.ErrorContains(t, err, "rerun aborted because previous run had errors", out.String())351}352// type checking of os/exec.ExitError is done in a test file so that users353// installing from source can continue to use versions prior to go1.12.354var _ exitCoder = &exec.ExitError{}355func TestRun_RerunFails_PanicPreventsRerun(t *testing.T) {356	jsonFailed := `{"Package": "pkg", "Action": "run"}357{"Package": "pkg", "Test": "TestOne", "Action": "run"}358{"Package": "pkg", "Test": "TestOne", "Action": "output","Output":"panic: something went wrong\n"}359{"Package": "pkg", "Action": "fail"}360`361	fn := func(args []string) *proc {362		return &proc{363			cmd:    fakeWaiter{result: newExitCode("failed", 1)},364			stdout: strings.NewReader(jsonFailed),365			stderr: bytes.NewReader(nil),366		}367	}368	reset := patchStartGoTestFn(fn)369	defer reset()370	out := new(bytes.Buffer)371	opts := &options{372		rawCommand:                   true,373		args:                         []string{"./test.test"},374		format:                       "testname",375		rerunFailsMaxAttempts:        3,376		rerunFailsMaxInitialFailures: 1,377		stdout:                       out,378		stderr:                       os.Stderr,379		hideSummary:                  newHideSummaryValue(),380	}381	err := run(opts)382	assert.ErrorContains(t, err, "rerun aborted because previous run had a suspected panic", out.String())383}384func TestRun_InputFromStdin(t *testing.T) {385	stdin := os.Stdin386	t.Cleanup(func() { os.Stdin = stdin })387	r, w, err := os.Pipe()388	assert.NilError(t, err)389	t.Cleanup(func() { _ = r.Close() })390	os.Stdin = r391	go func() {392		defer func() { _ = w.Close() }()393		e := json.NewEncoder(w)394		for _, event := range []testjson.TestEvent{395			{Action: "run", Package: "pkg"},396			{Action: "run", Package: "pkg", Test: "TestOne"},397			{Action: "fail", Package: "pkg", Test: "TestOne"},398			{Action: "fail", Package: "pkg"},399		} {400			assert.Check(t, e.Encode(event))401		}402	}()403	stdout := new(bytes.Buffer)404	err = run(&options{405		args:        []string{"cat"},406		format:      "testname",407		hideSummary: newHideSummaryValue(),408		rawCommand:  true,409		stdout: stdout,410		stderr: os.Stderr,411	})412	assert.NilError(t, err)413	assert.Assert(t, cmp.Contains(stdout.String(), "DONE 1"))414}...

main.go

Source:main.go

...13	"gotest.tools/gotestsum/log"14	"gotest.tools/gotestsum/testjson"15)16var version = "dev"17func Run(name string, args []string) error {18	flags, opts := setupFlags(name)19	switch err := flags.Parse(args); {20	case err == pflag.ErrHelp:21		return nil22	case err != nil:23		usage(os.Stderr, name, flags)24		return err25	}26	opts.args = flags.Args()27	setupLogging(opts)28	switch {29	case opts.version:30		fmt.Fprintf(os.Stdout, "gotestsum version %s\n", version)31		return nil32	case opts.watch:33		return runWatcher(opts)34	}35	return run(opts)36}37func setupFlags(name string) (*pflag.FlagSet, *options) {38	opts := &options{39		hideSummary:                  newHideSummaryValue(),40		junitTestCaseClassnameFormat: &junitFieldFormatValue{},41		junitTestSuiteNameFormat:     &junitFieldFormatValue{},42		postRunHookCmd:               &commandValue{},43		stdout:                       os.Stdout,44		stderr:                       os.Stderr,45	}46	flags := pflag.NewFlagSet(name, pflag.ContinueOnError)47	flags.SetInterspersed(false)48	flags.Usage = func() {49		usage(os.Stdout, name, flags)50	}51	flags.StringVarP(&opts.format, "format", "f",52		lookEnvWithDefault("GOTESTSUM_FORMAT", "short"),53		"print format of test input")54	flags.BoolVar(&opts.rawCommand, "raw-command", false,55		"don't prepend 'go test -json' to the 'go test' command")56	flags.BoolVar(&opts.ignoreNonJSONOutputLines, "ignore-non-json-output-lines", false,57		"write non-JSON 'go test' output lines to stderr instead of failing")58	flags.Lookup("ignore-non-json-output-lines").Hidden = true59	flags.StringVar(&opts.jsonFile, "jsonfile",60		lookEnvWithDefault("GOTESTSUM_JSONFILE", ""),61		"write all TestEvents to file")62	flags.BoolVar(&opts.noColor, "no-color", color.NoColor, "disable color output")63	flags.Var(opts.hideSummary, "no-summary",64		"do not print summary of: "+testjson.SummarizeAll.String())65	flags.Lookup("no-summary").Hidden = true66	flags.Var(opts.hideSummary, "hide-summary",67		"hide sections of the summary: "+testjson.SummarizeAll.String())68	flags.Var(opts.postRunHookCmd, "post-run-command",69		"command to run after the tests have completed")70	flags.BoolVar(&opts.watch, "watch", false,71		"watch go files, and run tests when a file is modified")72	flags.IntVar(&opts.maxFails, "max-fails", 0,73		"end the test run after this number of failures")74	flags.StringVar(&opts.junitFile, "junitfile",75		lookEnvWithDefault("GOTESTSUM_JUNITFILE", ""),76		"write a JUnit XML file")77	flags.Var(opts.junitTestSuiteNameFormat, "junitfile-testsuite-name",78		"format the testsuite name field as: "+junitFieldFormatValues)79	flags.Var(opts.junitTestCaseClassnameFormat, "junitfile-testcase-classname",80		"format the testcase classname field as: "+junitFieldFormatValues)81	flags.IntVar(&opts.rerunFailsMaxAttempts, "rerun-fails", 0,82		"rerun failed tests until they all pass, or attempts exceeds maximum. Defaults to max 2 reruns when enabled.")83	flags.Lookup("rerun-fails").NoOptDefVal = "2"84	flags.IntVar(&opts.rerunFailsMaxInitialFailures, "rerun-fails-max-failures", 10,85		"do not rerun any tests if the initial run has more than this number of failures")86	flags.Var((*stringSlice)(&opts.packages), "packages",87		"space separated list of package to test")88	flags.StringVar(&opts.rerunFailsReportFile, "rerun-fails-report", "",89		"write a report to the file, of the tests that were rerun")90	flags.BoolVar(&opts.rerunFailsOnlyRootCases, "rerun-fails-only-root-testcases", false,91		"rerun only root testcaes, instead of only subtests")92	flags.Lookup("rerun-fails-only-root-testcases").Hidden = true93	flags.BoolVar(&opts.debug, "debug", false, "enabled debug logging")94	flags.BoolVar(&opts.version, "version", false, "show version and exit")95	return flags, opts96}97func usage(out io.Writer, name string, flags *pflag.FlagSet) {98	fmt.Fprintf(out, `Usage:99    %[1]s [flags] [--] [go test flags]100    %[1]s [command]101Flags:102`, name)103	flags.SetOutput(out)104	flags.PrintDefaults()105	fmt.Fprint(out, `106Formats:107    dots                    print a character for each test108    dots-v2                 experimental dots format, one package per line109    pkgname                 print a line for each package110    pkgname-and-test-fails  print a line for each package and failed test output111    testname                print a line for each test and package112    standard-quiet          standard go test format113    standard-verbose        standard go test -v format114Commands:115    tool                    tools for working with test2json output116`)117}118func lookEnvWithDefault(key, defValue string) string {119	if value := os.Getenv(key); value != "" {120		return value121	}122	return defValue123}124type options struct {125	args                         []string126	format                       string127	debug                        bool128	rawCommand                   bool129	ignoreNonJSONOutputLines     bool130	jsonFile                     string131	junitFile                    string132	postRunHookCmd               *commandValue133	noColor                      bool134	hideSummary                  *hideSummaryValue135	junitTestSuiteNameFormat     *junitFieldFormatValue136	junitTestCaseClassnameFormat *junitFieldFormatValue137	rerunFailsMaxAttempts        int138	rerunFailsMaxInitialFailures int139	rerunFailsReportFile         string140	rerunFailsOnlyRootCases      bool141	packages                     []string142	watch                        bool143	maxFails                     int144	version                      bool145	// shims for testing146	stdout io.Writer147	stderr io.Writer148}149func (o options) Validate() error {150	if o.rerunFailsMaxAttempts > 0 && len(o.args) > 0 && !o.rawCommand && len(o.packages) == 0 {151		return fmt.Errorf(152			"when go test args are used with --rerun-fails-max-attempts " +153				"the list of packages to test must be specified by the --packages flag")154	}155	return nil156}157func setupLogging(opts *options) {158	if opts.debug {159		log.SetLevel(log.DebugLevel)160	}161	color.NoColor = opts.noColor162}163func run(opts *options) error {164	ctx, cancel := context.WithCancel(context.Background())165	defer cancel()166	if err := opts.Validate(); err != nil {167		return err168	}169	goTestProc, err := startGoTestFn(ctx, goTestCmdArgs(opts, rerunOpts{}))170	if err != nil {171		return err172	}173	handler, err := newEventHandler(opts)174	if err != nil {175		return err176	}177	defer handler.Close() // nolint: errcheck178	cfg := testjson.ScanConfig{179		Stdout:                   goTestProc.stdout,180		Stderr:                   goTestProc.stderr,181		Handler:                  handler,182		Stop:                     cancel,183		IgnoreNonJSONOutputLines: opts.ignoreNonJSONOutputLines,184	}185	exec, err := testjson.ScanTestOutput(cfg)186	if err != nil {187		return finishRun(opts, exec, err)188	}189	exitErr := goTestProc.cmd.Wait()190	if exitErr == nil || opts.rerunFailsMaxAttempts == 0 {191		return finishRun(opts, exec, exitErr)192	}193	if err := hasErrors(exitErr, exec); err != nil {194		return finishRun(opts, exec, err)195	}196	failed := len(rerunFailsFilter(opts)(exec.Failed()))197	if failed > opts.rerunFailsMaxInitialFailures {198		err := fmt.Errorf(199			"number of test failures (%d) exceeds maximum (%d) set by --rerun-fails-max-failures",200			failed, opts.rerunFailsMaxInitialFailures)201		return finishRun(opts, exec, err)202	}203	cfg = testjson.ScanConfig{Execution: exec, Handler: handler}204	exitErr = rerunFailed(ctx, opts, cfg)205	if err := writeRerunFailsReport(opts, exec); err != nil {206		return err207	}208	return finishRun(opts, exec, exitErr)209}210func finishRun(opts *options, exec *testjson.Execution, exitErr error) error {211	testjson.PrintSummary(opts.stdout, exec, opts.hideSummary.value)212	if err := writeJUnitFile(opts, exec); err != nil {213		return fmt.Errorf("failed to write junit file: %w", err)214	}215	if err := postRunHook(opts, exec); err != nil {216		return fmt.Errorf("post run command failed: %w", err)217	}218	return exitErr219}220func goTestCmdArgs(opts *options, rerunOpts rerunOpts) []string {221	if opts.rawCommand {222		var result []string223		result = append(result, opts.args...)224		result = append(result, rerunOpts.Args()...)225		return result226	}227	args := opts.args228	result := []string{"go", "test"}229	if len(args) == 0 {230		result = append(result, "-json")231		if rerunOpts.runFlag != "" {232			result = append(result, rerunOpts.runFlag)233		}234		return append(result, cmdArgPackageList(opts, rerunOpts, "./...")...)235	}236	if boolArgIndex("json", args) < 0 {237		result = append(result, "-json")238	}239	if rerunOpts.runFlag != "" {240		// Remove any existing run arg, it needs to be replaced with our new one241		// and duplicate args are not allowed by 'go test'.242		runIndex, runIndexEnd := argIndex("run", args)243		if runIndex >= 0 && runIndexEnd < len(args) {244			args = append(args[:runIndex], args[runIndexEnd+1:]...)245		}246		result = append(result, rerunOpts.runFlag)247	}248	pkgArgIndex := findPkgArgPosition(args)249	result = append(result, args[:pkgArgIndex]...)250	result = append(result, cmdArgPackageList(opts, rerunOpts)...)251	result = append(result, args[pkgArgIndex:]...)252	return result253}254func cmdArgPackageList(opts *options, rerunOpts rerunOpts, defPkgList ...string) []string {255	switch {256	case rerunOpts.pkg != "":257		return []string{rerunOpts.pkg}258	case len(opts.packages) > 0:259		return opts.packages260	case os.Getenv("TEST_DIRECTORY") != "":261		return []string{os.Getenv("TEST_DIRECTORY")}262	default:263		return defPkgList264	}265}266func boolArgIndex(flag string, args []string) int {267	for i, arg := range args {268		if arg == "-"+flag || arg == "--"+flag {269			return i270		}271	}272	return -1273}274func argIndex(flag string, args []string) (start, end int) {275	for i, arg := range args {276		if arg == "-"+flag || arg == "--"+flag {277			return i, i + 1278		}279		if strings.HasPrefix(arg, "-"+flag+"=") || strings.HasPrefix(arg, "--"+flag+"=") {280			return i, i281		}282	}283	return -1, -1284}285// The package list is before the -args flag, or at the end of the args list286// if the -args flag is not in args.287// The -args flag is a 'go test' flag that indicates that all subsequent288// args should be passed to the test binary. It requires that the list of289// packages comes before -args, so we re-use it as a placeholder in the case290// where some args must be passed to the test binary.291func findPkgArgPosition(args []string) int {292	if i := boolArgIndex("args", args); i >= 0 {293		return i294	}295	return len(args)296}297type proc struct {298	cmd    waiter299	stdout io.Reader300	stderr io.Reader301}302type waiter interface {303	Wait() error304}305func startGoTest(ctx context.Context, args []string) (proc, error) {306	if len(args) == 0 {307		return proc{}, errors.New("missing command to run")308	}309	cmd := exec.CommandContext(ctx, args[0], args[1:]...)310	p := proc{cmd: cmd}311	log.Debugf("exec: %s", cmd.Args)312	var err error313	p.stdout, err = cmd.StdoutPipe()314	if err != nil {315		return p, err316	}317	p.stderr, err = cmd.StderrPipe()318	if err != nil {319		return p, err320	}321	if err := cmd.Start(); err != nil {322		return p, errors.Wrapf(err, "failed to run %s", strings.Join(cmd.Args, " "))323	}...

args

Using AI Code Generation

1import (2func main() {3	for i := 1; i < len(os.Args); i++ {4	}5	fmt.Println(s)6}7import (8func main() {9	for _, arg := range os.Args[1:] {10	}11	fmt.Println(s)12}13import (14func main() {15	fmt.Println(strings.Join(os.Args[1:], " "))16}17import (18func main() {19	fmt.Println(strings.Join(os.Args[1:], " "))20}21import (22func main() {23	fmt.Println(strings.Join(os.Args[1:], " "))24}25import (26func main() {27	fmt.Println(strings.Join(os.Args[1:], " "))28}29import (30func main() {31	fmt.Println(strings.Join(os.Args[1:], " "))32}33import (34func main() {35	fmt.Println(strings.Join(os.Args[1:], " "))36}37import (38func main() {39	fmt.Println(strings.Join(os.Args[1:], " "))40}41import (

args

Using AI Code Generation

1import (2func main() {3	fmt.Println(os.Args[0])4	fmt.Println(os.Args[1])5	fmt.Println(os.Args[2])6}7import (8func main() {9	fmt.Println(os.Args[0])10	fmt.Println(os.Args[1])11	fmt.Println(os.Args[2])12}13import (14func main() {15	fmt.Println(os.Args[0])16	fmt.Println(os.Args[1])17	fmt.Println(os.Args[2])18}19import (20func main() {21	fmt.Println(os.Args[0])22	fmt.Println(os.Args[1])23	fmt.Println(os.Args[2])24}25import (26func main() {27	fmt.Println(os.Args[0])28	fmt.Println(os.Args[1])29	fmt.Println(os.Args[2])30}31import (32func main() {33	fmt.Println(os.Args[0])34	fmt.Println(os.Args[1])35	fmt.Println(os.Args[2])36}37import (38func main() {39	fmt.Println(os.Args[0])40	fmt.Println(os.Args[1])41	fmt.Println(os.Args[2])42}43import (44func main() {45	fmt.Println(os.Args[0])46	fmt.Println(os.Args[1])47	fmt.Println(os.Args[2])48}49import (50func main() {51	fmt.Println(os.Args[0])52	fmt.Println(os.Args[1])53	fmt.Println(os.Args[2])54}

args

Using AI Code Generation

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

args

Using AI Code Generation

1import (2func main() {3	fmt.Println(os.Args[0])4}5import (6func main() {7	fmt.Println(os.Args[1])8}9import (10func main() {11	fmt.Println(os.Args[2])12}13import (14func main() {15	fmt.Println(os.Args[3])16}17import (18func main() {19	fmt.Println(os.Args[4])20}21import (22func main() {23	fmt.Println(os.Args[5])24}25import (26func main() {27	fmt.Println(os.Args[6])28}29import (30func main() {31	fmt.Println(os.Args[7])32}33import (34func main() {35	fmt.Println(os.Args[8])36}37import (38func main() {39	fmt.Println(os.Args[9])40}41import (42func main() {43	fmt.Println(os.Args[10])44}45import (46func main() {47	fmt.Println(os.Args[11])48}

args

Using AI Code Generation

1import "fmt"2func main() {3rerun := Rerun{args: []string{"hello", "world"}}4fmt.Println(rerun.args)5}6import "fmt"7func main() {8rerun := Rerun{args: []string{"hello", "world"}}9fmt.Println(rerun.args)10}11import "fmt"12func main() {13rerun := Rerun{args: []string{"hello", "world"}}14fmt.Println(rerun.args)15}16import "fmt"17func main() {18rerun := Rerun{args: []string{"hello", "world"}}19fmt.Println(rerun.args)20}21import "fmt"22func main() {23rerun := Rerun{args: []string{"hello", "world"}}24fmt.Println(rerun.args)25}26import "fmt"27func main() {28rerun := Rerun{args: []string{"hello", "world"}}29fmt.Println(rerun.args)30}31import "fmt"32func main() {33rerun := Rerun{args: []string{"hello", "world"}}34fmt.Println(rerun.args)35}36import "fmt"37func main() {38rerun := Rerun{args: []string{"hello", "world"}}39fmt.Println(rerun.args)40}41import "fmt"42func main() {43rerun := Rerun{args: []string{"hello", "world"}}44fmt.Println(rerun.args)45}46import "fmt"47func main() {

args

Using AI Code Generation

1import (2func main() {3  cmd := exec.Command("go", "run", "1.go")4  err := cmd.Run()5  if err != nil {6    fmt.Println(err)7  }8}9import (10func main() {11  cmd := exec.Command("go", "run", "1.go")12  err := cmd.Run()13  if err != nil {14    fmt.Println(err)15  }16}17import (18func main() {19  cmd := exec.Command("go", "run", "1.go")20  err := cmd.Start()21  if err != nil {22    fmt.Println(err)23  }24}25import (26func main() {27  cmd := exec.Command("go", "run", "1.go")28  out, err := cmd.Output()29  if err != nil {30    fmt.Println(err)31  }32  fmt.Println(string(out))33}34import (35func main() {36  cmd := exec.Command("go", "run", "1.go")

args

Using AI Code Generation

1import "fmt"2func main() {3    fmt.Scanln(&a)4    fmt.Scanln(&b)5    fmt.Println("Sum of two numbers is", a+b)6}7import "fmt"8func main() {9    fmt.Scanf("%d %d", &a, &b)10    fmt.Println("Sum of two numbers is", a+b)11}12import "fmt"13func main() {14    fmt.Scan(&a, &b)15    fmt.Println("Sum of two numbers is", a+b)16}17import "fmt"18func main() {19    fmt.Scan(&a)20    fmt.Scan(&b)21    fmt.Println("Sum of two numbers is", a+b)22}23import "fmt"24func main() {25    fmt.Scanf("%d", &a)26    fmt.Scanf("%d", &b)27    fmt.Println("Sum of two numbers is", a+b)28}29import "fmt"30func main() {31    fmt.Scanf("%d32    fmt.Scanf("%d33    fmt.Println("Sum of two numbers is", a+b)34}35import "fmt"36func main() {37    fmt.Scanf("%d38    fmt.Scanf("%d39    fmt.Println("Sum of two numbers is", a+b)40}41import "fmt"42func main() {

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.