scavenge,
  sweep,
  sweepWaiters,
  testR,
  wakeableSleep
# Above SCHED are things that can call into the scheduler.
< SCHED
# Below SCHED is the scheduler implementation.
< allocmR,
  execR;
allocmR, execR, hchan < sched;
sched < allg, allp;

# Channels
NONE < notifyList;
hchan, notifyList < sudog;

hchan, pollDesc, wakeableSleep < timers;
timers, timerSend < timer < netpollInit;

# Semaphores
NONE < root;

	lockRankAllocmW:         "allocmW",
	lockRankExecW:           "execW",
	lockRankCpuprof:         "cpuprof",
	lockRankPollCache:       "pollCache",
	lockRankPollDesc:        "pollDesc",
	lockRankWakeableSleep:   "wakeableSleep",
	lockRankHchan:           "hchan",
	lockRankAllocmR:         "allocmR",
	lockRankExecR:           "execR",
	lockRankSched:           "sched",
	lockRankAllg:            "allg",

limitations under the License.
*/

package exec

import (
	"bytes"
	"errors"

	utilfeature "k8s.io/apiserver/pkg/util/feature"
	remote "k8s.io/cri-client/pkg"
	"k8s.io/kubernetes/pkg/features"
	"k8s.io/kubernetes/pkg/kubelet/util/ioutils"
	"k8s.io/kubernetes/pkg/probe"

	"k8s.io/klog/v2"
	"k8s.io/utils/exec"
)

const (
	maxReadLength = 10 * 1 << 10 // 10KB
)

 *     return standardOutput.toString()
 *   }
 * }
 * </pre>
 */
@DisableCachingByDefault(because = "Gradle would require more information to cache this task")
public abstract class Exec extends AbstractExecTask<Exec> {
    public Exec() {
        super(Exec.class);
    }

// can instead override the error using an errors.Is check:
//
//	path, err := exec.LookPath("prog")
//	if errors.Is(err, exec.ErrDot) {
//		err = nil
//	}
//	if err != nil {
//		log.Fatal(err)
//	}
//	use(path)
//
// and
//
//	cmd := exec.Command("prog")
//	if errors.Is(cmd.Err, exec.ErrDot) {
//		cmd.Err = nil
//	}
//	if err := cmd.Run(); err != nil {
//		log.Fatal(err)
//	}
//

// thread state (for example, Linux or Plan 9 name spaces), the new
// process will inherit the caller's thread state.
//
// StartProcess is a low-level interface. The [os/exec] package provides
// higher-level interfaces.
//
// If there is an error, it will be of type [*PathError].
func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error) {
	testlog.Open(name)

			span.Done()
		}
		if a.json != nil {
			a.json.TimeDone = time.Now()
		}

		// The actions run in parallel but all the updates to the
		// shared work state are serialized through b.exec.
		b.exec.Lock()
		defer b.exec.Unlock()

		if err != nil {
			if b.AllowErrors && a.Package != nil {
				if a.Package.Error == nil {
					a.Package.Error = &load.PackageError{Err: err}
					a.Package.Incomplete = true

Zxilly <******@****.***> 1710239775 +0000

            // Runtime.exec() overloads
            [fromString(), "Runtime.getRuntime().exec(command, new String[] {'FOOBAR=foobar'})", "", "foobar"],
            [fromGroovyString(), "Runtime.getRuntime().exec(command, new String[] {'FOOBAR=foobar'})", "", "foobar"],
            [fromStringArray(), "Runtime.getRuntime().exec(command, new String[] {'FOOBAR=foobar'})", "", "foobar"],

        val e = RuntimeExec()
        e.exec("some string")
        e.exec("some string", arrayOf("string"))
        e.exec("some string", arrayOf("string"), file("test"))
        e.exec(arrayOf("some", "string"))
        e.exec(arrayOf("some", "string"), arrayOf("string"))
        e.exec(arrayOf("some", "string"), arrayOf("string"), file("test"))

        val s = ProcessBuilderStart()