}

func parseCpuList() {
	if len(*cpuListStr) == 0 {
		cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
	} else {
		for _, val := range strings.Split(*cpuListStr, ",") {
			cpu, err := strconv.Atoi(val)
			if err != nil || cpu <= 0 {
				fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu", val)
				os.Exit(1)
			}
			cpuList = append(cpuList, cpu)
		}
	}

		if err != nil {
			fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.bench: %s\n", err)
			os.Exit(1)
		}
		if !matched {
			continue
		}
		for _, procs := range cpuList {
			runtime.GOMAXPROCS(procs)
			b := &B{
				common: common{
					signal: make(chan any),
				},
				benchmark: Benchmark,
			}
			benchName := Benchmark.Name
			if procs != 1 {

		}
		cpu, err := strconv.Atoi(val)
		if err != nil || cpu <= 0 {
			fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu\n", val)
			os.Exit(1)
		}
		cpuList = append(cpuList, cpu)
	}
	if cpuList == nil {
		cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
	}
}

func shouldFailFast() bool {
	return *failFast && numFailed.Load() > 0

		cpuListStr	= flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
		parallel	= flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
	
		cpuList	[]int
	)

	// 
	var benchTime = flag.Duration("test.benchtime", 1*time.Second, "approximate run time for each benchmark")

	// 

	// If no flag was specified, don't run benchmarks.
	if len(*matchBenchmarks) == 0 {
		return true
	}
	// Collect matching benchmarks and determine longest name.
	maxprocs := 1
	for _, procs := range cpuList {
		if procs > maxprocs {
			maxprocs = procs
		}
	}
	ctx := &benchContext{
		match:  newMatcher(matchString, *matchBenchmarks, "-test.bench", *skip),
		extLen: len(benchmarkName("", maxprocs)),
	}

	}
	m := newMatcher(deps.MatchString, *match, "-test.run", *skip)
	var mFuzz *matcher
	if *matchFuzz != "" {
		mFuzz = newMatcher(deps.MatchString, *matchFuzz, "-test.fuzz", *skip)
	}

	for _, procs := range cpuList {
		runtime.GOMAXPROCS(procs)
		for i := uint(0); i < *count; i++ {
			if shouldFailFast() {
				break
			}

			tctx := newTestContext(*parallel, m)
			tctx.deadline = deadline

	Wiredmax           int64
	Nswapdev           int64
	Swpages            int64
	Swpginuse          int64
	Swpgonly           int64
	Nswget             int64
	Unused1            int64
	Cpuhit             int64
	Cpumiss            int64
	Faults             int64
	Traps              int64
	Intrs              int64
	Swtch              int64
	Softs              int64
	Syscalls           int64

	assert.Equal(t, len(actualRootInfos["/"].Stats), len(infos["/"].Stats))
	assert.Equal(t, actualRootInfos["/"].Stats[0].Cpu, infos["/"].Stats[0].Cpu)
	assert.Equal(t, actualRootInfos["/"].Stats[0].CpuInst, infos["/"].Stats[0].CpuInst)
	assert.Equal(t, actualRootInfos["/"].Stats[0].Memory, infos["/"].Stats[0].Memory)
}

func TestWinMachineInfo(t *testing.T) {
	c := getClient(t)

	machineInfo, err := c.WinMachineInfo()

	Wiredmax           int64
	Nswapdev           int64
	Swpages            int64
	Swpginuse          int64
	Swpgonly           int64
	Nswget             int64
	Unused1            int64
	Cpuhit             int64
	Cpumiss            int64
	Faults             int64
	Traps              int64
	Intrs              int64
	Swtch              int64
	Softs              int64
	Syscalls           int64

	Wiredmax           int64
	Nswapdev           int64
	Swpages            int64
	Swpginuse          int64
	Swpgonly           int64
	Nswget             int64
	Unused1            int64
	Cpuhit             int64
	Cpumiss            int64
	Faults             int64
	Traps              int64
	Intrs              int64
	Swtch              int64
	Softs              int64
	Syscalls           int64