Lomanic
/
gopsutil
mirror of https://github.com/shirou/gopsutil
1
0
Fork 0
Code Issues Releases Activity

[process] Skip tests on non-implemented platforms #446 and fix Kill/Children tests on windows

Browse Source
pull/758/head
Lomanic 6 years ago
parent f49203762b
commit f09ba75b25
1 changed files with 73 additions and 28 deletions
Show Stats Download Patch File Download Diff File

101
process/process_test.go
Unescape Escape View File

@ -20,6 +20,12 @@ import (
var mu sync.Mutex var mu sync.Mutex
func skipIfNotImplementedErr(t *testing.T, err error) {
if err == common.ErrNotImplementedError {
t.Skip("not implemented")
}
}
func testGetProcess() Process { func testGetProcess() Process {
checkPid := os.Getpid() // process.test checkPid := os.Getpid() // process.test
ret, _ := NewProcess(int32(checkPid)) ret, _ := NewProcess(int32(checkPid))
@ -28,6 +34,7 @@ func testGetProcess() Process {
func Test_Pids(t *testing.T) { func Test_Pids(t *testing.T) {
ret, err := Pids() ret, err := Pids()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -46,6 +53,7 @@ func Test_Pids_Fail(t *testing.T) {
invoke = common.FakeInvoke{Suffix: "fail"} invoke = common.FakeInvoke{Suffix: "fail"}
ret, err := Pids() ret, err := Pids()
skipIfNotImplementedErr(t, err)
invoke = common.Invoke{} invoke = common.Invoke{}
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
@ -58,6 +66,7 @@ func Test_Pid_exists(t *testing.T) {
checkPid := os.Getpid() checkPid := os.Getpid()
ret, err := PidExists(int32(checkPid)) ret, err := PidExists(int32(checkPid))
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -71,6 +80,7 @@ func Test_NewProcess(t *testing.T) {
checkPid := os.Getpid() checkPid := os.Getpid()
ret, err := NewProcess(int32(checkPid)) ret, err := NewProcess(int32(checkPid))
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -87,12 +97,14 @@ func Test_Process_memory_maps(t *testing.T) {
checkPid := os.Getpid() checkPid := os.Getpid()
ret, err := NewProcess(int32(checkPid)) ret, err := NewProcess(int32(checkPid))
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
// ungrouped memory maps // ungrouped memory maps
mmaps, err := ret.MemoryMaps(false) mmaps, err := ret.MemoryMaps(false)
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("memory map get error %v", err) t.Errorf("memory map get error %v", err)
} }
@ -105,6 +117,7 @@ func Test_Process_memory_maps(t *testing.T) {
// grouped memory maps // grouped memory maps
mmaps, err = ret.MemoryMaps(true) mmaps, err = ret.MemoryMaps(true)
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("memory map get error %v", err) t.Errorf("memory map get error %v", err)
} }
@ -119,8 +132,9 @@ func Test_Process_MemoryInfo(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.MemoryInfo() v, err := p.MemoryInfo()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting memory info error %v", err) t.Errorf("getting memory info error %v", err)
} }
empty := MemoryInfoStat{} empty := MemoryInfoStat{}
if v == nil || *v == empty { if v == nil || *v == empty {
@ -132,8 +146,9 @@ func Test_Process_CmdLine(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.Cmdline() v, err := p.Cmdline()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting cmdline error %v", err) t.Errorf("getting cmdline error %v", err)
} }
if !strings.Contains(v, "process.test") { if !strings.Contains(v, "process.test") {
t.Errorf("invalid cmd line %v", v) t.Errorf("invalid cmd line %v", v)
@ -144,8 +159,9 @@ func Test_Process_CmdLineSlice(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.CmdlineSlice() v, err := p.CmdlineSlice()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Fatalf("geting cmdline slice error %v", err) t.Fatalf("getting cmdline slice error %v", err)
} }
if !reflect.DeepEqual(v, os.Args) { if !reflect.DeepEqual(v, os.Args) {
t.Errorf("returned cmdline slice not as expected:\nexp: %v\ngot: %v", os.Args, v) t.Errorf("returned cmdline slice not as expected:\nexp: %v\ngot: %v", os.Args, v)
@ -156,8 +172,9 @@ func Test_Process_Ppid(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.Ppid() v, err := p.Ppid()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting ppid error %v", err) t.Errorf("getting ppid error %v", err)
} }
if v == 0 { if v == 0 {
t.Errorf("return value is 0 %v", v) t.Errorf("return value is 0 %v", v)
@ -168,8 +185,9 @@ func Test_Process_Status(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.Status() v, err := p.Status()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting status error %v", err) t.Errorf("getting status error %v", err)
} }
if v != "R" && v != "S" { if v != "R" && v != "S" {
t.Errorf("could not get state %v", v) t.Errorf("could not get state %v", v)
@ -180,8 +198,9 @@ func Test_Process_Terminal(t *testing.T) {
p := testGetProcess() p := testGetProcess()
_, err := p.Terminal() _, err := p.Terminal()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting terminal error %v", err) t.Errorf("getting terminal error %v", err)
} }
} }
@ -189,8 +208,9 @@ func Test_Process_IOCounters(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.IOCounters() v, err := p.IOCounters()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting iocounter error %v", err) t.Errorf("getting iocounter error %v", err)
return return
} }
empty := &IOCountersStat{} empty := &IOCountersStat{}
@ -203,8 +223,9 @@ func Test_Process_NumCtx(t *testing.T) {
p := testGetProcess() p := testGetProcess()
_, err := p.NumCtxSwitches() _, err := p.NumCtxSwitches()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting numctx error %v", err) t.Errorf("getting numctx error %v", err)
return return
} }
} }
@ -213,8 +234,9 @@ func Test_Process_Nice(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.Nice() n, err := p.Nice()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting nice error %v", err) t.Errorf("getting nice error %v", err)
} }
if n != 0 && n != 20 && n != 8 { if n != 0 && n != 20 && n != 8 {
t.Errorf("invalid nice: %d", n) t.Errorf("invalid nice: %d", n)
@ -224,8 +246,9 @@ func Test_Process_NumThread(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.NumThreads() n, err := p.NumThreads()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting NumThread error %v", err) t.Errorf("getting NumThread error %v", err)
} }
if n < 0 { if n < 0 {
t.Errorf("invalid NumThread: %d", n) t.Errorf("invalid NumThread: %d", n)
@ -236,16 +259,18 @@ func Test_Process_Threads(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.NumThreads() n, err := p.NumThreads()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting NumThread error %v", err) t.Errorf("getting NumThread error %v", err)
} }
if n < 0 { if n < 0 {
t.Errorf("invalid NumThread: %d", n) t.Errorf("invalid NumThread: %d", n)
} }
ts, err := p.Threads() ts, err := p.Threads()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting Threads error %v", err) t.Errorf("getting Threads error %v", err)
} }
if len(ts) != int(n) { if len(ts) != int(n) {
t.Errorf("unexpected number of threads: %v vs %v", len(ts), n) t.Errorf("unexpected number of threads: %v vs %v", len(ts), n)
@ -256,8 +281,9 @@ func Test_Process_Name(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.Name() n, err := p.Name()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting name error %v", err) t.Errorf("getting name error %v", err)
} }
if !strings.Contains(n, "process.test") { if !strings.Contains(n, "process.test") {
t.Errorf("invalid Exe %s", n) t.Errorf("invalid Exe %s", n)
@ -267,8 +293,9 @@ func Test_Process_Exe(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.Exe() n, err := p.Exe()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("geting Exe error %v", err) t.Errorf("getting Exe error %v", err)
} }
if !strings.Contains(n, "process.test") { if !strings.Contains(n, "process.test") {
t.Errorf("invalid Exe %s", n) t.Errorf("invalid Exe %s", n)
@ -278,6 +305,7 @@ func Test_Process_Exe(t *testing.T) {
func Test_Process_CpuPercent(t *testing.T) { func Test_Process_CpuPercent(t *testing.T) {
p := testGetProcess() p := testGetProcess()
percent, err := p.Percent(0) percent, err := p.Percent(0)
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -302,6 +330,7 @@ func Test_Process_CpuPercentLoop(t *testing.T) {
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
duration := time.Duration(100) * time.Microsecond duration := time.Duration(100) * time.Microsecond
percent, err := p.Percent(duration) percent, err := p.Percent(duration)
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -320,6 +349,7 @@ func Test_Process_CreateTime(t *testing.T) {
p := testGetProcess() p := testGetProcess()
c, err := p.CreateTime() c, err := p.CreateTime()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -340,6 +370,7 @@ func Test_Parent(t *testing.T) {
p := testGetProcess() p := testGetProcess()
c, err := p.Parent() c, err := p.Parent()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Fatalf("error %v", err) t.Fatalf("error %v", err)
} }
@ -356,7 +387,7 @@ func Test_Connections(t *testing.T) {
ch0 := make(chan string) ch0 := make(chan string)
ch1 := make(chan string) ch1 := make(chan string)
go func() { // TCP listening goroutine go func() { // TCP listening goroutine
addr, err := net.ResolveTCPAddr("tcp", "localhost:0") // dynamically get an open random port from OS addr, err := net.ResolveTCPAddr("tcp", "localhost:0") // dynamically get a random open port from OS
if err != nil { if err != nil {
t.Skip("unable to resolve localhost:", err) t.Skip("unable to resolve localhost:", err)
} }
@ -387,6 +418,7 @@ func Test_Connections(t *testing.T) {
t.Errorf("unable to parse tcpServerAddr port: %v", err) t.Errorf("unable to parse tcpServerAddr port: %v", err)
} }
c, err := p.Connections() c, err := p.Connections()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -405,18 +437,28 @@ func Test_Connections(t *testing.T) {
} }
func Test_Children(t *testing.T) { func Test_Children(t *testing.T) {
p, err := NewProcess(1) p := testGetProcess()
if err != nil {
t.Fatalf("new process error %v", err) var cmd *exec.Cmd
if runtime.GOOS == "windows" {
cmd = exec.Command("ping", "localhost", "-n", "4")
} else {
cmd = exec.Command("sleep", "3")
} }
assert.Nil(t, cmd.Start())
time.Sleep(100 * time.Millisecond)
c, err := p.Children() c, err := p.Children()
skipIfNotImplementedErr(t, err)
if err != nil { if err != nil {
t.Fatalf("error %v", err) t.Fatalf("error %v", err)
} }
if len(c) == 0 { if len(c) == 0 {
t.Fatalf("children is empty") t.Fatalf("children is empty")
} }
if c[0].Pid != int32(cmd.Process.Pid) {
t.Errorf("could not find child %d", cmd.Process.Pid)
}
} }
func Test_Username(t *testing.T) { func Test_Username(t *testing.T) {
@ -425,7 +467,8 @@ func Test_Username(t *testing.T) {
myUsername := currentUser.Username myUsername := currentUser.Username
process, _ := NewProcess(int32(myPid)) process, _ := NewProcess(int32(myPid))
pidUsername, _ := process.Username() pidUsername, err := process.Username()
skipIfNotImplementedErr(t, err)
assert.Equal(t, myUsername, pidUsername) assert.Equal(t, myUsername, pidUsername)
t.Log(pidUsername) t.Log(pidUsername)
@ -434,10 +477,12 @@ func Test_Username(t *testing.T) {
func Test_CPUTimes(t *testing.T) { func Test_CPUTimes(t *testing.T) {
pid := os.Getpid() pid := os.Getpid()
process, err := NewProcess(int32(pid)) process, err := NewProcess(int32(pid))
skipIfNotImplementedErr(t, err)
assert.Nil(t, err) assert.Nil(t, err)
spinSeconds := 0.2 spinSeconds := 0.2
cpuTimes0, err := process.Times() cpuTimes0, err := process.Times()
skipIfNotImplementedErr(t, err)
assert.Nil(t, err) assert.Nil(t, err)
// Spin for a duration of spinSeconds // Spin for a duration of spinSeconds
@ -464,9 +509,11 @@ func Test_CPUTimes(t *testing.T) {
func Test_OpenFiles(t *testing.T) { func Test_OpenFiles(t *testing.T) {
pid := os.Getpid() pid := os.Getpid()
p, err := NewProcess(int32(pid)) p, err := NewProcess(int32(pid))
skipIfNotImplementedErr(t, err)
assert.Nil(t, err) assert.Nil(t, err)
v, err := p.OpenFiles() v, err := p.OpenFiles()
skipIfNotImplementedErr(t, err)
assert.Nil(t, err) assert.Nil(t, err)
assert.NotEmpty(t, v) // test always open files. assert.NotEmpty(t, v) // test always open files.
@ -478,19 +525,17 @@ func Test_OpenFiles(t *testing.T) {
func Test_Kill(t *testing.T) { func Test_Kill(t *testing.T) {
var cmd *exec.Cmd var cmd *exec.Cmd
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
cmd = exec.Command("choice", "/C", "YN", "/D", "Y", "/t", "3") cmd = exec.Command("ping", "localhost", "-n", "4")
} else { } else {
cmd = exec.Command("sleep", "3") cmd = exec.Command("sleep", "3")
} }
var wg sync.WaitGroup assert.Nil(t, cmd.Start())
wg.Add(1)
go func() {
assert.NotNil(t, cmd.Run())
wg.Done()
}()
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
p, err := NewProcess(int32(cmd.Process.Pid)) p, err := NewProcess(int32(cmd.Process.Pid))
skipIfNotImplementedErr(t, err)
assert.Nil(t, err)
err = p.Kill()
skipIfNotImplementedErr(t, err)
assert.Nil(t, err) assert.Nil(t, err)
assert.Nil(t, p.Kill()) cmd.Wait()
wg.Wait()
} }

Write Preview
Loading…
Cancel
Save