goto childerror
		}
		pid, _, err1 = RawSyscall(SYS_READ, uintptr(mapPipe[0]), uintptr(unsafe.Pointer(&err2)), unsafe.Sizeof(err2))
		if err1 != 0 {
			goto childerror
		}
		if pid != unsafe.Sizeof(err2) {
			err1 = EINVAL
			goto childerror
		}
		if err2 != 0 {
			err1 = err2
			goto childerror
		}
	}

	// Session ID
	if sys.Setsid {

	t.Logf("raw stdout: %q", stdout.String())
	t.Logf("raw stderr: %q", stderr.String())

	f1, err1 := parseFakeTime(stdout.Bytes())
	if err1 != nil {
		t.Fatal(err1)
	}
	f2, err2 := parseFakeTime(stderr.Bytes())
	if err2 != nil {
		t.Fatal(err2)
	}

	const time0 = 1257894000000000000
	got := [][]fakeTimeFrame{f1, f2}
	var want = [][]fakeTimeFrame{{
		{time0 + 1, "line 2\n"},
		{time0 + 1, "line 3\n"},

	if !testableNetwork("unix") {
		t.Skipf("skipping: unix sockets not supported")
	}

	ls := newLocalServer(t, "unix")
	defer ls.teardown()

	errc := make(chan error, 1)
	done := make(chan bool)
	handler := func(ls *localServer, ln Listener) {
		server, err := ln.Accept()
		errc <- err
		if err != nil {
			return
		}
		defer server.Close()
		<-done
	}
	if err := ls.buildup(handler); err != nil {
		t.Fatal(err)
	}

		var err1, err2 error
		var rs *HTTPRangeSpec
		var o, l int64
		rs, err1 = parseRequestRangeSpec(irs)
		if err1 == nil {
			o, l, err2 = rs.GetOffsetLength(resourceSize)
		}
		if isErrInvalidRange(err1) || (err1 == nil && isErrInvalidRange(err2)) {
			continue
		}
		t.Errorf("Case %d: Expected errInvalidRange but: %v %v %d %d %v", i, rs, err1, o, l, err2)
	}
}

		return ""
	}
	return perr.Path
}

func TestReadDirPath(t *testing.T) {
	fsys := os.DirFS(t.TempDir())
	_, err1 := ReadDir(fsys, "non-existent")
	_, err2 := ReadDir(struct{ FS }{fsys}, "non-existent")
	if s1, s2 := errorPath(err1), errorPath(err2); s1 != s2 {
		t.Fatalf("s1: %s != s2: %s", s1, s2)
	}

	g := NewWithT(t)
	r := &resource.Instance{Origin: &legacykube.Origin{FieldsMap: fieldMap}}
	test1, err1 := ErrorLine(r, "{.metadata.name}")
	test2, err2 := ErrorLine(r, "{.metadata.fake}")
	g.Expect(test1).To(Equal(1))
	g.Expect(err1).To(Equal(true))
	g.Expect(test2).To(Equal(0))
	g.Expect(err2).To(Equal(false))
}

func TestConstants(t *testing.T) {
	g := NewWithT(t)

	constantsPath := []string{

	default:
	}
loop /* =@loop */:
	for {
		if true {
			break loop /* @loop */
		}
	}
	select {
	case err /* =@err1 */ := <-_:
		return err /* @err1 */
	case err /* =@err2 */ := <-_:
		return err /* @err2 */
	}

	_ = func(p1 /* =@p1 */ int, p2 /* =@p2 */ p1) {
		closed /* =@closed */ := p1 // @p1
		shadowed /* =@shadowed1 */ := p2 // @p2
		_ = func(shadowed /* =@shadowed2 */ p2 /* @p2 */) {

		_, err := ctl.WriteString(msg)
		return err
	}
	written := make(chan struct{})
	errc := make(chan error)
	go func() {
		select {
		case <-ctx.Done():
			ctl.WriteString("hangup")
			errc <- mapErr(ctx.Err())
		case <-written:
			errc <- nil
		}
	}()
	_, err := ctl.WriteString(msg)
	close(written)
	if e := <-errc; err == nil && e != nil { // we hung up
		return e
	}
	return err

				Status: v1.NodeStatus{Addresses: tc.addresses},
			}
			nodeIPs, err := GetNodeHostIPs(node)
			nodeIP, err2 := GetNodeHostIP(node)

			if (err == nil && err2 != nil) || (err != nil && err2 == nil) {
				t.Errorf("GetNodeHostIPs() returned error=%q but GetNodeHostIP() returned error=%q", err, err2)
			}
			if err != nil {
				if tc.expectIPs != nil {
					t.Errorf("expected %v, got error (%v)", tc.expectIPs, err)

	for _, test := range testCases {
		_, err1 := parseResourceList(test.kubeReserved)
		_, err2 := parseResourceList(test.systemReserved)
		if test.errorExpected {
			if err1 == nil && err2 == nil {
				t.Errorf("%s: error expected", test.name)
			}
		} else {
			if err1 != nil || err2 != nil {
				t.Errorf("%s: unexpected error: %v, %v", test.name, err1, err2)
			}
		}
	}
}

func TestMergeKubeletConfigurations(t *testing.T) {