mirror of
https://github.com/dolthub/dolt.git
synced 2026-02-11 10:33:08 -06:00
064c398dec
You can run these yourself using the -perf flag, e.g. > noms serve & > go test -v -perf http://localhost:8000 ./samples/go/csv/csv-import > noms ds http://localhost:8000 Though you'll need to go-get github.com/attic-labs/testdata. Note that all of this only records test results, it doesn't have any concept of failing perf (unless test assertsions themselves fail). It will be the job of some other Noms client (work in progress) to do that. I will be setting this up to run continuously momentarily.
401 lines
7.8 KiB
Go
401 lines
7.8 KiB
Go
package process
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"os/user"
|
|
"reflect"
|
|
"runtime"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/shirou/gopsutil/internal/common"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
var mu sync.Mutex
|
|
|
|
func testGetProcess() Process {
|
|
checkPid := os.Getpid() // process.test
|
|
ret, _ := NewProcess(int32(checkPid))
|
|
return *ret
|
|
}
|
|
|
|
func Test_Pids(t *testing.T) {
|
|
ret, err := Pids()
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
if len(ret) == 0 {
|
|
t.Errorf("could not get pids %v", ret)
|
|
}
|
|
}
|
|
|
|
func Test_Pids_Fail(t *testing.T) {
|
|
if runtime.GOOS != "darwin" {
|
|
t.Skip("darwin only")
|
|
}
|
|
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
|
|
invoke = common.FakeInvoke{Suffix: "fail"}
|
|
ret, err := Pids()
|
|
invoke = common.Invoke{}
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
if len(ret) != 9 {
|
|
t.Errorf("wrong getted pid nums: %v/%d", ret, len(ret))
|
|
}
|
|
}
|
|
func Test_Pid_exists(t *testing.T) {
|
|
checkPid := os.Getpid()
|
|
|
|
ret, err := PidExists(int32(checkPid))
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
|
|
if ret == false {
|
|
t.Errorf("could not get process exists: %v", ret)
|
|
}
|
|
}
|
|
|
|
func Test_NewProcess(t *testing.T) {
|
|
checkPid := os.Getpid()
|
|
|
|
ret, err := NewProcess(int32(checkPid))
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
empty := &Process{}
|
|
if runtime.GOOS != "windows" { // Windows pid is 0
|
|
if empty == ret {
|
|
t.Errorf("error %v", ret)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func Test_Process_memory_maps(t *testing.T) {
|
|
checkPid := os.Getpid()
|
|
|
|
ret, err := NewProcess(int32(checkPid))
|
|
|
|
mmaps, err := ret.MemoryMaps(false)
|
|
if err != nil {
|
|
t.Errorf("memory map get error %v", err)
|
|
}
|
|
empty := MemoryMapsStat{}
|
|
for _, m := range *mmaps {
|
|
if m == empty {
|
|
t.Errorf("memory map get error %v", m)
|
|
}
|
|
}
|
|
}
|
|
func Test_Process_MemoryInfo(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
v, err := p.MemoryInfo()
|
|
if err != nil {
|
|
t.Errorf("geting memory info error %v", err)
|
|
}
|
|
empty := MemoryInfoStat{}
|
|
if v == nil || *v == empty {
|
|
t.Errorf("could not get memory info %v", v)
|
|
}
|
|
}
|
|
|
|
func Test_Process_CmdLine(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
v, err := p.Cmdline()
|
|
if err != nil {
|
|
t.Errorf("geting cmdline error %v", err)
|
|
}
|
|
if !strings.Contains(v, "process.test") {
|
|
t.Errorf("invalid cmd line %v", v)
|
|
}
|
|
}
|
|
|
|
func Test_Process_CmdLineSlice(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
v, err := p.CmdlineSlice()
|
|
if err != nil {
|
|
t.Fatalf("geting cmdline slice error %v", err)
|
|
}
|
|
if !reflect.DeepEqual(v, os.Args) {
|
|
t.Errorf("returned cmdline slice not as expected:\nexp: %v\ngot: %v", os.Args, v)
|
|
}
|
|
}
|
|
|
|
func Test_Process_Ppid(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
v, err := p.Ppid()
|
|
if err != nil {
|
|
t.Errorf("geting ppid error %v", err)
|
|
}
|
|
if v == 0 {
|
|
t.Errorf("return value is 0 %v", v)
|
|
}
|
|
}
|
|
|
|
func Test_Process_Status(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
v, err := p.Status()
|
|
if err != nil {
|
|
t.Errorf("geting status error %v", err)
|
|
}
|
|
if v != "R" && v != "S" {
|
|
t.Errorf("could not get state %v", v)
|
|
}
|
|
}
|
|
|
|
func Test_Process_Terminal(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
_, err := p.Terminal()
|
|
if err != nil {
|
|
t.Errorf("geting terminal error %v", err)
|
|
}
|
|
|
|
/*
|
|
if v == "" {
|
|
t.Errorf("could not get terminal %v", v)
|
|
}
|
|
*/
|
|
}
|
|
|
|
func Test_Process_IOCounters(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
v, err := p.IOCounters()
|
|
if err != nil {
|
|
t.Errorf("geting iocounter error %v", err)
|
|
return
|
|
}
|
|
empty := &IOCountersStat{}
|
|
if v == empty {
|
|
t.Errorf("error %v", v)
|
|
}
|
|
}
|
|
|
|
func Test_Process_NumCtx(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
_, err := p.NumCtxSwitches()
|
|
if err != nil {
|
|
t.Errorf("geting numctx error %v", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func Test_Process_Nice(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
n, err := p.Nice()
|
|
if err != nil {
|
|
t.Errorf("geting nice error %v", err)
|
|
}
|
|
if n != 0 && n != 20 && n != 8 {
|
|
t.Errorf("invalid nice: %d", n)
|
|
}
|
|
}
|
|
func Test_Process_NumThread(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
n, err := p.NumThreads()
|
|
if err != nil {
|
|
t.Errorf("geting NumThread error %v", err)
|
|
}
|
|
if n < 0 {
|
|
t.Errorf("invalid NumThread: %d", n)
|
|
}
|
|
}
|
|
|
|
func Test_Process_Name(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
n, err := p.Name()
|
|
if err != nil {
|
|
t.Errorf("geting name error %v", err)
|
|
}
|
|
if !strings.Contains(n, "process.test") {
|
|
t.Errorf("invalid Exe %s", n)
|
|
}
|
|
}
|
|
func Test_Process_Exe(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
n, err := p.Exe()
|
|
if err != nil {
|
|
t.Errorf("geting Exe error %v", err)
|
|
}
|
|
if !strings.Contains(n, "process.test") {
|
|
t.Errorf("invalid Exe %s", n)
|
|
}
|
|
}
|
|
|
|
func Test_Process_CpuPercent(t *testing.T) {
|
|
p := testGetProcess()
|
|
percent, err := p.Percent(0)
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
duration := time.Duration(1000) * time.Microsecond
|
|
time.Sleep(duration)
|
|
percent, err = p.Percent(0)
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
|
|
numcpu := runtime.NumCPU()
|
|
// if percent < 0.0 || percent > 100.0*float64(numcpu) { // TODO
|
|
if percent < 0.0 {
|
|
t.Fatalf("CPUPercent value is invalid: %f, %d", percent, numcpu)
|
|
}
|
|
}
|
|
|
|
func Test_Process_CpuPercentLoop(t *testing.T) {
|
|
p := testGetProcess()
|
|
numcpu := runtime.NumCPU()
|
|
|
|
for i := 0; i < 2; i++ {
|
|
duration := time.Duration(100) * time.Microsecond
|
|
percent, err := p.Percent(duration)
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
// if percent < 0.0 || percent > 100.0*float64(numcpu) { // TODO
|
|
if percent < 0.0 {
|
|
t.Fatalf("CPUPercent value is invalid: %f, %d", percent, numcpu)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_Process_CreateTime(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
c, err := p.CreateTime()
|
|
if err != nil {
|
|
t.Errorf("error %v", err)
|
|
}
|
|
|
|
if c < 1420000000 {
|
|
t.Errorf("process created time is wrong.")
|
|
}
|
|
|
|
gotElapsed := time.Since(time.Unix(int64(c/1000), 0))
|
|
maxElapsed := time.Duration(5 * time.Second)
|
|
|
|
if gotElapsed >= maxElapsed {
|
|
t.Errorf("this process has not been running for %v", gotElapsed)
|
|
}
|
|
}
|
|
|
|
func Test_Parent(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
c, err := p.Parent()
|
|
if err != nil {
|
|
t.Fatalf("error %v", err)
|
|
}
|
|
if c == nil {
|
|
t.Fatalf("could not get parent")
|
|
}
|
|
if c.Pid == 0 {
|
|
t.Fatalf("wrong parent pid")
|
|
}
|
|
}
|
|
|
|
func Test_Connections(t *testing.T) {
|
|
p := testGetProcess()
|
|
|
|
c, err := p.Connections()
|
|
if err != nil {
|
|
t.Fatalf("error %v", err)
|
|
}
|
|
// TODO:
|
|
// Since go test open no conneciton, ret is empty.
|
|
// should invoke child process or other solutions.
|
|
if len(c) != 0 {
|
|
t.Fatalf("wrong connections")
|
|
}
|
|
}
|
|
|
|
func Test_Children(t *testing.T) {
|
|
p, err := NewProcess(1)
|
|
if err != nil {
|
|
t.Fatalf("new process error %v", err)
|
|
}
|
|
|
|
c, err := p.Children()
|
|
if err != nil {
|
|
t.Fatalf("error %v", err)
|
|
}
|
|
if len(c) == 0 {
|
|
t.Fatalf("children is empty")
|
|
}
|
|
}
|
|
|
|
func Test_Username(t *testing.T) {
|
|
myPid := os.Getpid()
|
|
currentUser, _ := user.Current()
|
|
myUsername := currentUser.Username
|
|
|
|
process, _ := NewProcess(int32(myPid))
|
|
pidUsername, _ := process.Username()
|
|
assert.Equal(t, myUsername, pidUsername)
|
|
}
|
|
|
|
func Test_CPUTimes(t *testing.T) {
|
|
pid := os.Getpid()
|
|
process, err := NewProcess(int32(pid))
|
|
assert.Nil(t, err)
|
|
|
|
spinSeconds := 0.2
|
|
cpuTimes0, err := process.Times()
|
|
assert.Nil(t, err)
|
|
|
|
// Spin for a duration of spinSeconds
|
|
t0 := time.Now()
|
|
tGoal := t0.Add(time.Duration(spinSeconds*1000) * time.Millisecond)
|
|
assert.Nil(t, err)
|
|
for time.Now().Before(tGoal) {
|
|
// This block intentionally left blank
|
|
}
|
|
|
|
cpuTimes1, err := process.Times()
|
|
assert.Nil(t, err)
|
|
|
|
if cpuTimes0 == nil || cpuTimes1 == nil {
|
|
t.FailNow()
|
|
}
|
|
measuredElapsed := cpuTimes1.Total() - cpuTimes0.Total()
|
|
message := fmt.Sprintf("Measured %fs != spun time of %fs\ncpuTimes0=%v\ncpuTimes1=%v",
|
|
measuredElapsed, spinSeconds, cpuTimes0, cpuTimes1)
|
|
assert.True(t, measuredElapsed > float64(spinSeconds)/5, message)
|
|
assert.True(t, measuredElapsed < float64(spinSeconds)*5, message)
|
|
}
|
|
|
|
func Test_OpenFiles(t *testing.T) {
|
|
pid := os.Getpid()
|
|
p, err := NewProcess(int32(pid))
|
|
assert.Nil(t, err)
|
|
|
|
v, err := p.OpenFiles()
|
|
assert.Nil(t, err)
|
|
assert.NotEmpty(t, v) // test always open files.
|
|
|
|
for _, vv := range v {
|
|
assert.NotEqual(t, "", vv.Path)
|
|
}
|
|
|
|
}
|