mirror of https://github.com/status-im/consul.git
Remove _test.go files from shirou/gopsutil
This commit is contained in:
Sean Chittenden
parent
ee8705f549
commit
95a8ee35d6
|
|
@ -1,40 +0,0 @@
|
|||
package cpu
|
||||
|
||||
import (
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"testing"
|
||||
|
||||
"github.com/shirou/gopsutil/internal/common"
|
||||
)
|
||||
|
||||
func TestParseDmesgBoot(t *testing.T) {
|
||||
if runtime.GOOS != "freebsd" {
|
||||
t.SkipNow()
|
||||
}
|
||||
|
||||
var cpuTests = []struct {
|
||||
file string
|
||||
cpuNum int
|
||||
cores int32
|
||||
}{
|
||||
{"1cpu_2core.txt", 1, 2},
|
||||
{"1cpu_4core.txt", 1, 4},
|
||||
{"2cpu_4core.txt", 2, 4},
|
||||
}
|
||||
for _, tt := range cpuTests {
|
||||
v, num, err := parseDmesgBoot(filepath.Join("expected/freebsd/", tt.file))
|
||||
if err != nil {
|
||||
t.Errorf("parseDmesgBoot failed(%s), %v", tt.file, err)
|
||||
}
|
||||
if num != tt.cpuNum {
|
||||
t.Errorf("parseDmesgBoot wrong length(%s), %v", tt.file, err)
|
||||
}
|
||||
if v.Cores != tt.cores {
|
||||
t.Errorf("parseDmesgBoot wrong core(%s), %v", tt.file, err)
|
||||
}
|
||||
if !common.StringsContains(v.Flags, "fpu") {
|
||||
t.Errorf("parseDmesgBoot fail to parse features(%s), %v", tt.file, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,145 +0,0 @@
|
|||
package cpu
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestCpu_times(t *testing.T) {
|
||||
v, err := Times(false)
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Error("could not get CPUs ", err)
|
||||
}
|
||||
empty := TimesStat{}
|
||||
for _, vv := range v {
|
||||
if vv == empty {
|
||||
t.Errorf("could not get CPU User: %v", vv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCpu_counts(t *testing.T) {
|
||||
v, err := Counts(true)
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
if v == 0 {
|
||||
t.Errorf("could not get CPU counts: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCPUTimeStat_String(t *testing.T) {
|
||||
v := TimesStat{
|
||||
CPU: "cpu0",
|
||||
User: 100.1,
|
||||
System: 200.1,
|
||||
Idle: 300.1,
|
||||
}
|
||||
e := `{"cpu":"cpu0","user":100.1,"system":200.1,"idle":300.1,"nice":0.0,"iowait":0.0,"irq":0.0,"softirq":0.0,"steal":0.0,"guest":0.0,"guestNice":0.0,"stolen":0.0}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("CPUTimesStat string is invalid: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCpuInfo(t *testing.T) {
|
||||
v, err := Info()
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Errorf("could not get CPU Info")
|
||||
}
|
||||
for _, vv := range v {
|
||||
if vv.ModelName == "" {
|
||||
t.Errorf("could not get CPU Info: %v", vv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testCPUPercent(t *testing.T, percpu bool) {
|
||||
numcpu := runtime.NumCPU()
|
||||
testCount := 3
|
||||
|
||||
if runtime.GOOS != "windows" {
|
||||
testCount = 100
|
||||
v, err := Percent(time.Millisecond, percpu)
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
// Skip CircleCI which CPU num is different
|
||||
if os.Getenv("CIRCLECI") != "true" {
|
||||
if (percpu && len(v) != numcpu) || (!percpu && len(v) != 1) {
|
||||
t.Fatalf("wrong number of entries from CPUPercent: %v", v)
|
||||
}
|
||||
}
|
||||
}
|
||||
for i := 0; i < testCount; i++ {
|
||||
duration := time.Duration(10) * time.Microsecond
|
||||
v, err := Percent(duration, percpu)
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
for _, percent := range v {
|
||||
// Check for slightly greater then 100% to account for any rounding issues.
|
||||
if percent < 0.0 || percent > 100.0001*float64(numcpu) {
|
||||
t.Fatalf("CPUPercent value is invalid: %f", percent)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testCPUPercentLastUsed(t *testing.T, percpu bool) {
|
||||
|
||||
numcpu := runtime.NumCPU()
|
||||
testCount := 10
|
||||
|
||||
if runtime.GOOS != "windows" {
|
||||
testCount = 2
|
||||
v, err := Percent(time.Millisecond, percpu)
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
// Skip CircleCI which CPU num is different
|
||||
if os.Getenv("CIRCLECI") != "true" {
|
||||
if (percpu && len(v) != numcpu) || (!percpu && len(v) != 1) {
|
||||
t.Fatalf("wrong number of entries from CPUPercent: %v", v)
|
||||
}
|
||||
}
|
||||
}
|
||||
for i := 0; i < testCount; i++ {
|
||||
v, err := Percent(0, percpu)
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
time.Sleep(1 * time.Millisecond)
|
||||
for _, percent := range v {
|
||||
// Check for slightly greater then 100% to account for any rounding issues.
|
||||
if percent < 0.0 || percent > 100.0001*float64(numcpu) {
|
||||
t.Fatalf("CPUPercent value is invalid: %f", percent)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestCPUPercent(t *testing.T) {
|
||||
testCPUPercent(t, false)
|
||||
}
|
||||
|
||||
func TestCPUPercentPerCpu(t *testing.T) {
|
||||
testCPUPercent(t, true)
|
||||
}
|
||||
|
||||
func TestCPUPercentIntervalZero(t *testing.T) {
|
||||
testCPUPercentLastUsed(t, false)
|
||||
}
|
||||
|
||||
func TestCPUPercentIntervalZeroPerCPU(t *testing.T) {
|
||||
testCPUPercentLastUsed(t, true)
|
||||
}
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
// +build linux
|
||||
|
||||
package host
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestGetRedhatishVersion(t *testing.T) {
|
||||
var ret string
|
||||
c := []string{"Rawhide"}
|
||||
ret = getRedhatishVersion(c)
|
||||
if ret != "rawhide" {
|
||||
t.Errorf("Could not get version rawhide: %v", ret)
|
||||
}
|
||||
|
||||
c = []string{"Fedora release 15 (Lovelock)"}
|
||||
ret = getRedhatishVersion(c)
|
||||
if ret != "15" {
|
||||
t.Errorf("Could not get version fedora: %v", ret)
|
||||
}
|
||||
|
||||
c = []string{"Enterprise Linux Server release 5.5 (Carthage)"}
|
||||
ret = getRedhatishVersion(c)
|
||||
if ret != "5.5" {
|
||||
t.Errorf("Could not get version redhat enterprise: %v", ret)
|
||||
}
|
||||
|
||||
c = []string{""}
|
||||
ret = getRedhatishVersion(c)
|
||||
if ret != "" {
|
||||
t.Errorf("Could not get version with no value: %v", ret)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRedhatishPlatform(t *testing.T) {
|
||||
var ret string
|
||||
c := []string{"red hat"}
|
||||
ret = getRedhatishPlatform(c)
|
||||
if ret != "redhat" {
|
||||
t.Errorf("Could not get platform redhat: %v", ret)
|
||||
}
|
||||
|
||||
c = []string{"Fedora release 15 (Lovelock)"}
|
||||
ret = getRedhatishPlatform(c)
|
||||
if ret != "fedora" {
|
||||
t.Errorf("Could not get platform fedora: %v", ret)
|
||||
}
|
||||
|
||||
c = []string{"Enterprise Linux Server release 5.5 (Carthage)"}
|
||||
ret = getRedhatishPlatform(c)
|
||||
if ret != "enterprise" {
|
||||
t.Errorf("Could not get platform redhat enterprise: %v", ret)
|
||||
}
|
||||
|
||||
c = []string{""}
|
||||
ret = getRedhatishPlatform(c)
|
||||
if ret != "" {
|
||||
t.Errorf("Could not get platform with no value: %v", ret)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
package host
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestHostInfo(t *testing.T) {
|
||||
v, err := Info()
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
empty := &InfoStat{}
|
||||
if v == empty {
|
||||
t.Errorf("Could not get hostinfo %v", v)
|
||||
}
|
||||
if v.Procs == 0 {
|
||||
t.Errorf("Could not determine the number of host processes")
|
||||
}
|
||||
}
|
||||
|
||||
func TestUptime(t *testing.T) {
|
||||
v, err := Uptime()
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
if v == 0 {
|
||||
t.Errorf("Could not get up time %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBoot_time(t *testing.T) {
|
||||
v, err := BootTime()
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
if v == 0 {
|
||||
t.Errorf("Could not get boot time %v", v)
|
||||
}
|
||||
if v < 946652400 {
|
||||
t.Errorf("Invalid Boottime, older than 2000-01-01")
|
||||
}
|
||||
|
||||
v2, err := BootTime()
|
||||
if v != v2 {
|
||||
t.Errorf("cached boot time is different")
|
||||
}
|
||||
}
|
||||
|
||||
func TestUsers(t *testing.T) {
|
||||
v, err := Users()
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
empty := UserStat{}
|
||||
if len(v) == 0 {
|
||||
t.Errorf("Users is empty")
|
||||
}
|
||||
for _, u := range v {
|
||||
if u == empty {
|
||||
t.Errorf("Could not Users %v", v)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostInfoStat_String(t *testing.T) {
|
||||
v := InfoStat{
|
||||
Hostname: "test",
|
||||
Uptime: 3000,
|
||||
Procs: 100,
|
||||
OS: "linux",
|
||||
Platform: "ubuntu",
|
||||
BootTime: 1447040000,
|
||||
HostID: "edfd25ff-3c9c-b1a4-e660-bd826495ad35",
|
||||
}
|
||||
e := `{"hostname":"test","uptime":3000,"bootTime":1447040000,"procs":100,"os":"linux","platform":"ubuntu","platformFamily":"","platformVersion":"","kernelVersion":"","virtualizationSystem":"","virtualizationRole":"","hostid":"edfd25ff-3c9c-b1a4-e660-bd826495ad35"}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("HostInfoStat string is invalid: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUserStat_String(t *testing.T) {
|
||||
v := UserStat{
|
||||
User: "user",
|
||||
Terminal: "term",
|
||||
Host: "host",
|
||||
Started: 100,
|
||||
}
|
||||
e := `{"user":"user","terminal":"term","host":"host","started":100}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("UserStat string is invalid: %v", v)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
package common
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestReadlines(t *testing.T) {
|
||||
ret, err := ReadLines("common_test.go")
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if !strings.Contains(ret[0], "package common") {
|
||||
t.Error("could not read correctly")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadLinesOffsetN(t *testing.T) {
|
||||
ret, err := ReadLinesOffsetN("common_test.go", 2, 1)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
fmt.Println(ret[0])
|
||||
if !strings.Contains(ret[0], `import (`) {
|
||||
t.Error("could not read correctly")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntToString(t *testing.T) {
|
||||
src := []int8{65, 66, 67}
|
||||
dst := IntToString(src)
|
||||
if dst != "ABC" {
|
||||
t.Error("could not convert")
|
||||
}
|
||||
}
|
||||
func TestByteToString(t *testing.T) {
|
||||
src := []byte{65, 66, 67}
|
||||
dst := ByteToString(src)
|
||||
if dst != "ABC" {
|
||||
t.Error("could not convert")
|
||||
}
|
||||
|
||||
src = []byte{0, 65, 66, 67}
|
||||
dst = ByteToString(src)
|
||||
if dst != "ABC" {
|
||||
t.Error("could not convert")
|
||||
}
|
||||
}
|
||||
|
||||
func TestmustParseInt32(t *testing.T) {
|
||||
ret := mustParseInt32("11111")
|
||||
if ret != int32(11111) {
|
||||
t.Error("could not parse")
|
||||
}
|
||||
}
|
||||
func TestmustParseUint64(t *testing.T) {
|
||||
ret := mustParseUint64("11111")
|
||||
if ret != uint64(11111) {
|
||||
t.Error("could not parse")
|
||||
}
|
||||
}
|
||||
func TestmustParseFloat64(t *testing.T) {
|
||||
ret := mustParseFloat64("11111.11")
|
||||
if ret != float64(11111.11) {
|
||||
t.Error("could not parse")
|
||||
}
|
||||
ret = mustParseFloat64("11111")
|
||||
if ret != float64(11111) {
|
||||
t.Error("could not parse")
|
||||
}
|
||||
}
|
||||
func TestStringsContains(t *testing.T) {
|
||||
target, err := ReadLines("common_test.go")
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if !StringsContains(target, "func TestStringsContains(t *testing.T) {") {
|
||||
t.Error("cloud not test correctly")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPathExists(t *testing.T) {
|
||||
if !PathExists("common_test.go") {
|
||||
t.Error("exists but return not exists")
|
||||
}
|
||||
if PathExists("should_not_exists.go") {
|
||||
t.Error("not exists but return exists")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHostEtc(t *testing.T) {
|
||||
p := HostEtc("mtab")
|
||||
if p != "/etc/mtab" {
|
||||
t.Errorf("invalid HostEtc, %s", p)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
// +build darwin
|
||||
|
||||
package mem
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestVirtualMemoryDarwin(t *testing.T) {
|
||||
v, err := VirtualMemory()
|
||||
assert.Nil(t, err)
|
||||
|
||||
outBytes, err := invoke.Command("/usr/sbin/sysctl", "hw.memsize")
|
||||
assert.Nil(t, err)
|
||||
outString := string(outBytes)
|
||||
outString = strings.TrimSpace(outString)
|
||||
outParts := strings.Split(outString, " ")
|
||||
actualTotal, err := strconv.ParseInt(outParts[1], 10, 64)
|
||||
assert.Nil(t, err)
|
||||
assert.Equal(t, uint64(actualTotal), v.Total)
|
||||
|
||||
assert.True(t, v.Available > 0)
|
||||
assert.Equal(t, v.Available, v.Free+v.Inactive, "%v", v)
|
||||
|
||||
assert.True(t, v.Used > 0)
|
||||
assert.True(t, v.Used < v.Total)
|
||||
|
||||
assert.True(t, v.UsedPercent > 0)
|
||||
assert.True(t, v.UsedPercent < 100)
|
||||
|
||||
assert.True(t, v.Free > 0)
|
||||
assert.True(t, v.Free < v.Available)
|
||||
|
||||
assert.True(t, v.Active > 0)
|
||||
assert.True(t, v.Active < v.Total)
|
||||
|
||||
assert.True(t, v.Inactive > 0)
|
||||
assert.True(t, v.Inactive < v.Total)
|
||||
|
||||
assert.True(t, v.Wired > 0)
|
||||
assert.True(t, v.Wired < v.Total)
|
||||
}
|
||||
|
|
@ -1,72 +0,0 @@
|
|||
package mem
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestVirtual_memory(t *testing.T) {
|
||||
v, err := VirtualMemory()
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
empty := &VirtualMemoryStat{}
|
||||
if v == empty {
|
||||
t.Errorf("error %v", v)
|
||||
}
|
||||
|
||||
assert.True(t, v.Total > 0)
|
||||
assert.True(t, v.Available > 0)
|
||||
assert.True(t, v.Used > 0)
|
||||
|
||||
assert.Equal(t, v.Total, v.Available+v.Used,
|
||||
"Total should be computable from available + used: %v", v)
|
||||
|
||||
assert.True(t, v.Free > 0)
|
||||
assert.True(t, v.Available > v.Free,
|
||||
"Free should be a subset of Available: %v", v)
|
||||
|
||||
assert.InDelta(t, v.UsedPercent,
|
||||
100*float64(v.Used)/float64(v.Total), 0.1,
|
||||
"UsedPercent should be how many percent of Total is Used: %v", v)
|
||||
}
|
||||
|
||||
func TestSwap_memory(t *testing.T) {
|
||||
v, err := SwapMemory()
|
||||
if err != nil {
|
||||
t.Errorf("error %v", err)
|
||||
}
|
||||
empty := &SwapMemoryStat{}
|
||||
if v == empty {
|
||||
t.Errorf("error %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVirtualMemoryStat_String(t *testing.T) {
|
||||
v := VirtualMemoryStat{
|
||||
Total: 10,
|
||||
Available: 20,
|
||||
Used: 30,
|
||||
UsedPercent: 30.1,
|
||||
Free: 40,
|
||||
}
|
||||
e := `{"total":10,"available":20,"used":30,"usedPercent":30.1,"free":40,"active":0,"inactive":0,"wired":0,"buffers":0,"cached":0,"writeback":0,"dirty":0,"writebacktmp":0,"shared":0,"slab":0,"pagetables":0,"swapcached":0}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("VirtualMemoryStat string is invalid: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSwapMemoryStat_String(t *testing.T) {
|
||||
v := SwapMemoryStat{
|
||||
Total: 10,
|
||||
Used: 30,
|
||||
Free: 40,
|
||||
UsedPercent: 30.1,
|
||||
}
|
||||
e := `{"total":10,"used":30,"free":40,"usedPercent":30.1,"sin":0,"sout":0}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("SwapMemoryStat string is invalid: %v", v)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,140 +0,0 @@
|
|||
package net
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
assert "github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
const (
|
||||
netstatTruncated = `Name Mtu Network Address Ipkts Ierrs Ibytes Opkts Oerrs Obytes Coll Drop
|
||||
lo0 16384 <Link#1> 31241 0 3769823 31241 0 3769823 0 0
|
||||
lo0 16384 ::1/128 ::1 31241 - 3769823 31241 - 3769823 - -
|
||||
lo0 16384 127 127.0.0.1 31241 - 3769823 31241 - 3769823 - -
|
||||
lo0 16384 fe80::1%lo0 fe80:1::1 31241 - 3769823 31241 - 3769823 - -
|
||||
gif0* 1280 <Link#2> 0 0 0 0 0 0 0 0
|
||||
stf0* 1280 <Link#3> 0 0 0 0 0 0 0 0
|
||||
utun8 1500 <Link#88> 286 0 27175 0 0 0 0 0
|
||||
utun8 1500 <Link#90> 286 0 29554 0 0 0 0 0
|
||||
utun8 1500 <Link#92> 286 0 29244 0 0 0 0 0
|
||||
utun8 1500 <Link#93> 286 0 28267 0 0 0 0 0
|
||||
utun8 1500 <Link#95> 286 0 28593 0 0 0 0 0`
|
||||
netstatNotTruncated = `Name Mtu Network Address Ipkts Ierrs Ibytes Opkts Oerrs Obytes Coll Drop
|
||||
lo0 16384 <Link#1> 27190978 0 12824763793 27190978 0 12824763793 0 0
|
||||
lo0 16384 ::1/128 ::1 27190978 - 12824763793 27190978 - 12824763793 - -
|
||||
lo0 16384 127 127.0.0.1 27190978 - 12824763793 27190978 - 12824763793 - -
|
||||
lo0 16384 fe80::1%lo0 fe80:1::1 27190978 - 12824763793 27190978 - 12824763793 - -
|
||||
gif0* 1280 <Link#2> 0 0 0 0 0 0 0 0
|
||||
stf0* 1280 <Link#3> 0 0 0 0 0 0 0 0
|
||||
en0 1500 <Link#4> a8:66:7f:dd:ee:ff 5708989 0 7295722068 3494252 0 379533492 0 230
|
||||
en0 1500 fe80::aa66: fe80:4::aa66:7fff 5708989 - 7295722068 3494252 - 379533492 - -`
|
||||
)
|
||||
|
||||
func TestparseNetstatLineHeader(t *testing.T) {
|
||||
stat, linkIkd, err := parseNetstatLine(`Name Mtu Network Address Ipkts Ierrs Ibytes Opkts Oerrs Obytes Coll Drop`)
|
||||
assert.Nil(t, linkIkd)
|
||||
assert.Nil(t, stat)
|
||||
assert.Error(t, err)
|
||||
assert.Equal(t, errNetstatHeader, err)
|
||||
}
|
||||
|
||||
func assertLoopbackStat(t *testing.T, err error, stat *IOCountersStat) {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, 869107, stat.PacketsRecv)
|
||||
assert.Equal(t, 0, stat.Errin)
|
||||
assert.Equal(t, 169411755, stat.BytesRecv)
|
||||
assert.Equal(t,869108, stat.PacketsSent)
|
||||
assert.Equal(t, 1, stat.Errout)
|
||||
assert.Equal(t, 169411756, stat.BytesSent)
|
||||
}
|
||||
|
||||
func TestparseNetstatLineLink(t *testing.T) {
|
||||
stat, linkId, err := parseNetstatLine(
|
||||
`lo0 16384 <Link#1> 869107 0 169411755 869108 1 169411756 0 0`,
|
||||
)
|
||||
assertLoopbackStat(t, err, stat)
|
||||
assert.NotNil(t, linkId)
|
||||
assert.Equal(t, uint(1), *linkId)
|
||||
}
|
||||
|
||||
func TestparseNetstatLineIPv6(t *testing.T) {
|
||||
stat, linkId, err := parseNetstatLine(
|
||||
`lo0 16384 ::1/128 ::1 869107 - 169411755 869108 1 169411756 - -`,
|
||||
)
|
||||
assertLoopbackStat(t, err, stat)
|
||||
assert.Nil(t, linkId)
|
||||
}
|
||||
|
||||
func TestparseNetstatLineIPv4(t *testing.T) {
|
||||
stat, linkId, err := parseNetstatLine(
|
||||
`lo0 16384 127 127.0.0.1 869107 - 169411755 869108 1 169411756 - -`,
|
||||
)
|
||||
assertLoopbackStat(t, err, stat)
|
||||
assert.Nil(t, linkId)
|
||||
}
|
||||
|
||||
func TestParseNetstatOutput(t *testing.T) {
|
||||
nsInterfaces, err := parseNetstatOutput(netstatNotTruncated)
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, nsInterfaces, 8)
|
||||
for index := range nsInterfaces {
|
||||
assert.NotNil(t, nsInterfaces[index].stat, "Index %d", index)
|
||||
}
|
||||
|
||||
assert.NotNil(t, nsInterfaces[0].linkId)
|
||||
assert.Equal(t, uint(1), *nsInterfaces[0].linkId)
|
||||
|
||||
assert.Nil(t, nsInterfaces[1].linkId)
|
||||
assert.Nil(t, nsInterfaces[2].linkId)
|
||||
assert.Nil(t, nsInterfaces[3].linkId)
|
||||
|
||||
assert.NotNil(t, nsInterfaces[4].linkId)
|
||||
assert.Equal(t, uint(2), *nsInterfaces[4].linkId)
|
||||
|
||||
assert.NotNil(t, nsInterfaces[5].linkId)
|
||||
assert.Equal(t, uint(3), *nsInterfaces[5].linkId)
|
||||
|
||||
assert.NotNil(t, nsInterfaces[6].linkId)
|
||||
assert.Equal(t, uint(4), *nsInterfaces[6].linkId)
|
||||
|
||||
assert.Nil(t, nsInterfaces[7].linkId)
|
||||
|
||||
mapUsage := newMapInterfaceNameUsage(nsInterfaces)
|
||||
assert.False(t, mapUsage.isTruncated())
|
||||
assert.Len(t, mapUsage.notTruncated(), 4)
|
||||
}
|
||||
|
||||
func TestParseNetstatTruncated(t *testing.T) {
|
||||
nsInterfaces, err := parseNetstatOutput(netstatTruncated)
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, nsInterfaces, 11)
|
||||
for index := range nsInterfaces {
|
||||
assert.NotNil(t, nsInterfaces[index].stat, "Index %d", index)
|
||||
}
|
||||
|
||||
const truncatedIface = "utun8"
|
||||
|
||||
assert.NotNil(t, nsInterfaces[6].linkId)
|
||||
assert.Equal(t, uint(88), *nsInterfaces[6].linkId)
|
||||
assert.Equal(t, truncatedIface, nsInterfaces[6].stat.Name)
|
||||
|
||||
assert.NotNil(t, nsInterfaces[7].linkId)
|
||||
assert.Equal(t,uint(90), *nsInterfaces[7].linkId)
|
||||
assert.Equal(t, truncatedIface, nsInterfaces[7].stat.Name)
|
||||
|
||||
assert.NotNil(t, nsInterfaces[8].linkId)
|
||||
assert.Equal(t, uint(92), *nsInterfaces[8].linkId )
|
||||
assert.Equal(t, truncatedIface, nsInterfaces[8].stat.Name)
|
||||
|
||||
assert.NotNil(t, nsInterfaces[9].linkId)
|
||||
assert.Equal(t, uint(93), *nsInterfaces[9].linkId )
|
||||
assert.Equal(t, truncatedIface, nsInterfaces[9].stat.Name)
|
||||
|
||||
assert.NotNil(t, nsInterfaces[10].linkId)
|
||||
assert.Equal(t, uint(95), *nsInterfaces[10].linkId )
|
||||
assert.Equal(t, truncatedIface, nsInterfaces[10].stat.Name)
|
||||
|
||||
mapUsage := newMapInterfaceNameUsage(nsInterfaces)
|
||||
assert.True(t, mapUsage.isTruncated())
|
||||
assert.Equal(t, 3, len(mapUsage.notTruncated()), "en0, gif0 and stf0")
|
||||
}
|
||||
|
|
@ -1,96 +0,0 @@
|
|||
package net
|
||||
|
||||
import (
|
||||
"os"
|
||||
"syscall"
|
||||
"testing"
|
||||
|
||||
"github.com/shirou/gopsutil/internal/common"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestGetProcInodesAll(t *testing.T) {
|
||||
if os.Getenv("CIRCLECI") == "true" {
|
||||
t.Skip("Skip CI")
|
||||
}
|
||||
|
||||
root := common.HostProc("")
|
||||
v, err := getProcInodesAll(root, 0)
|
||||
assert.Nil(t, err)
|
||||
assert.NotEmpty(t, v)
|
||||
}
|
||||
|
||||
func TestConnectionsMax(t *testing.T) {
|
||||
if os.Getenv("CIRCLECI") == "true" {
|
||||
t.Skip("Skip CI")
|
||||
}
|
||||
|
||||
max := 10
|
||||
v, err := ConnectionsMax("tcp", max)
|
||||
assert.Nil(t, err)
|
||||
assert.NotEmpty(t, v)
|
||||
|
||||
cxByPid := map[int32]int{}
|
||||
for _, cx := range v {
|
||||
if cx.Pid > 0 {
|
||||
cxByPid[cx.Pid]++
|
||||
}
|
||||
}
|
||||
for _, c := range cxByPid {
|
||||
assert.True(t, c <= max)
|
||||
}
|
||||
}
|
||||
|
||||
type AddrTest struct {
|
||||
IP string
|
||||
Port int
|
||||
Error bool
|
||||
}
|
||||
|
||||
func TestDecodeAddress(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
addr := map[string]AddrTest{
|
||||
"0500000A:0016": AddrTest{
|
||||
IP: "10.0.0.5",
|
||||
Port: 22,
|
||||
},
|
||||
"0100007F:D1C2": AddrTest{
|
||||
IP: "127.0.0.1",
|
||||
Port: 53698,
|
||||
},
|
||||
"11111:0035": AddrTest{
|
||||
Error: true,
|
||||
},
|
||||
"0100007F:BLAH": AddrTest{
|
||||
Error: true,
|
||||
},
|
||||
"0085002452100113070057A13F025401:0035": AddrTest{
|
||||
IP: "2400:8500:1301:1052:a157:7:154:23f",
|
||||
Port: 53,
|
||||
},
|
||||
"00855210011307F025401:0035": AddrTest{
|
||||
Error: true,
|
||||
},
|
||||
}
|
||||
|
||||
for src, dst := range addr {
|
||||
family := syscall.AF_INET
|
||||
if len(src) > 13 {
|
||||
family = syscall.AF_INET6
|
||||
}
|
||||
addr, err := decodeAddress(uint32(family), src)
|
||||
if dst.Error {
|
||||
assert.NotNil(err, src)
|
||||
} else {
|
||||
assert.Nil(err, src)
|
||||
assert.Equal(dst.IP, addr.IP, src)
|
||||
assert.Equal(dst.Port, int(addr.Port), src)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestReverse(t *testing.T) {
|
||||
src := []byte{0x01, 0x02, 0x03}
|
||||
assert.Equal(t, []byte{0x03, 0x02, 0x01}, Reverse(src))
|
||||
}
|
||||
|
|
@ -1,229 +0,0 @@
|
|||
package net
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"runtime"
|
||||
"testing"
|
||||
|
||||
"github.com/shirou/gopsutil/internal/common"
|
||||
)
|
||||
|
||||
func TestAddrString(t *testing.T) {
|
||||
v := Addr{IP: "192.168.0.1", Port: 8000}
|
||||
|
||||
s := fmt.Sprintf("%v", v)
|
||||
if s != "{\"ip\":\"192.168.0.1\",\"port\":8000}" {
|
||||
t.Errorf("Addr string is invalid: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetIOCountersStatString(t *testing.T) {
|
||||
v := IOCountersStat{
|
||||
Name: "test",
|
||||
BytesSent: 100,
|
||||
}
|
||||
e := `{"name":"test","bytesSent":100,"bytesRecv":0,"packetsSent":0,"packetsRecv":0,"errin":0,"errout":0,"dropin":0,"dropout":0,"fifoin":0,"fifoout":0}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("NetIOCountersStat string is invalid: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetProtoCountersStatString(t *testing.T) {
|
||||
v := ProtoCountersStat{
|
||||
Protocol: "tcp",
|
||||
Stats: map[string]int64{
|
||||
"MaxConn": -1,
|
||||
"ActiveOpens": 4000,
|
||||
"PassiveOpens": 3000,
|
||||
},
|
||||
}
|
||||
e := `{"protocol":"tcp","stats":{"ActiveOpens":4000,"MaxConn":-1,"PassiveOpens":3000}}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("NetProtoCountersStat string is invalid: %v", v)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestNetConnectionStatString(t *testing.T) {
|
||||
v := ConnectionStat{
|
||||
Fd: 10,
|
||||
Family: 10,
|
||||
Type: 10,
|
||||
Uids: []int32{10, 10},
|
||||
}
|
||||
e := `{"fd":10,"family":10,"type":10,"localaddr":{"ip":"","port":0},"remoteaddr":{"ip":"","port":0},"status":"","uids":[10,10],"pid":0}`
|
||||
if e != fmt.Sprintf("%v", v) {
|
||||
t.Errorf("NetConnectionStat string is invalid: %v", v)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestNetIOCountersAll(t *testing.T) {
|
||||
v, err := IOCounters(false)
|
||||
per, err := IOCounters(true)
|
||||
if err != nil {
|
||||
t.Errorf("Could not get NetIOCounters: %v", err)
|
||||
}
|
||||
if len(v) != 1 {
|
||||
t.Errorf("Could not get NetIOCounters: %v", v)
|
||||
}
|
||||
if v[0].Name != "all" {
|
||||
t.Errorf("Invalid NetIOCounters: %v", v)
|
||||
}
|
||||
var pr uint64
|
||||
for _, p := range per {
|
||||
pr += p.PacketsRecv
|
||||
}
|
||||
if v[0].PacketsRecv != pr {
|
||||
t.Errorf("invalid sum value: %v, %v", v[0].PacketsRecv, pr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetIOCountersPerNic(t *testing.T) {
|
||||
v, err := IOCounters(true)
|
||||
if err != nil {
|
||||
t.Errorf("Could not get NetIOCounters: %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Errorf("Could not get NetIOCounters: %v", v)
|
||||
}
|
||||
for _, vv := range v {
|
||||
if vv.Name == "" {
|
||||
t.Errorf("Invalid NetIOCounters: %v", vv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetNetIOCountersAll(t *testing.T) {
|
||||
n := []IOCountersStat{
|
||||
IOCountersStat{
|
||||
Name: "a",
|
||||
BytesRecv: 10,
|
||||
PacketsRecv: 10,
|
||||
},
|
||||
IOCountersStat{
|
||||
Name: "b",
|
||||
BytesRecv: 10,
|
||||
PacketsRecv: 10,
|
||||
Errin: 10,
|
||||
},
|
||||
}
|
||||
ret, err := getIOCountersAll(n)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if len(ret) != 1 {
|
||||
t.Errorf("invalid return count")
|
||||
}
|
||||
if ret[0].Name != "all" {
|
||||
t.Errorf("invalid return name")
|
||||
}
|
||||
if ret[0].BytesRecv != 20 {
|
||||
t.Errorf("invalid count bytesrecv")
|
||||
}
|
||||
if ret[0].Errin != 10 {
|
||||
t.Errorf("invalid count errin")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetInterfaces(t *testing.T) {
|
||||
v, err := Interfaces()
|
||||
if err != nil {
|
||||
t.Errorf("Could not get NetInterfaceStat: %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Errorf("Could not get NetInterfaceStat: %v", err)
|
||||
}
|
||||
for _, vv := range v {
|
||||
if vv.Name == "" {
|
||||
t.Errorf("Invalid NetInterface: %v", vv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetProtoCountersStatsAll(t *testing.T) {
|
||||
v, err := ProtoCounters(nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Could not get NetProtoCounters: %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Fatalf("Could not get NetProtoCounters: %v", err)
|
||||
}
|
||||
for _, vv := range v {
|
||||
if vv.Protocol == "" {
|
||||
t.Errorf("Invalid NetProtoCountersStat: %v", vv)
|
||||
}
|
||||
if len(vv.Stats) == 0 {
|
||||
t.Errorf("Invalid NetProtoCountersStat: %v", vv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetProtoCountersStats(t *testing.T) {
|
||||
v, err := ProtoCounters([]string{"tcp", "ip"})
|
||||
if err != nil {
|
||||
t.Fatalf("Could not get NetProtoCounters: %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Fatalf("Could not get NetProtoCounters: %v", err)
|
||||
}
|
||||
if len(v) != 2 {
|
||||
t.Fatalf("Go incorrect number of NetProtoCounters: %v", err)
|
||||
}
|
||||
for _, vv := range v {
|
||||
if vv.Protocol != "tcp" && vv.Protocol != "ip" {
|
||||
t.Errorf("Invalid NetProtoCountersStat: %v", vv)
|
||||
}
|
||||
if len(vv.Stats) == 0 {
|
||||
t.Errorf("Invalid NetProtoCountersStat: %v", vv)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetConnections(t *testing.T) {
|
||||
if ci := os.Getenv("CI"); ci != "" { // skip if test on drone.io
|
||||
return
|
||||
}
|
||||
|
||||
v, err := Connections("inet")
|
||||
if err != nil {
|
||||
t.Errorf("could not get NetConnections: %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Errorf("could not get NetConnections: %v", v)
|
||||
}
|
||||
for _, vv := range v {
|
||||
if vv.Family == 0 {
|
||||
t.Errorf("invalid NetConnections: %v", vv)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestNetFilterCounters(t *testing.T) {
|
||||
if ci := os.Getenv("CI"); ci != "" { // skip if test on drone.io
|
||||
return
|
||||
}
|
||||
|
||||
if runtime.GOOS == "linux" {
|
||||
// some test environment has not the path.
|
||||
if !common.PathExists("/proc/sys/net/netfilter/nf_conntrackCount") {
|
||||
t.SkipNow()
|
||||
}
|
||||
}
|
||||
|
||||
v, err := FilterCounters()
|
||||
if err != nil {
|
||||
t.Errorf("could not get NetConnections: %v", err)
|
||||
}
|
||||
if len(v) == 0 {
|
||||
t.Errorf("could not get NetConnections: %v", v)
|
||||
}
|
||||
for _, vv := range v {
|
||||
if vv.ConnTrackMax == 0 {
|
||||
t.Errorf("nf_conntrackMax needs to be greater than zero: %v", vv)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
// +build linux freebsd
|
||||
|
||||
package process
|
||||
|
||||
import (
|
||||
"os"
|
||||
"syscall"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func Test_SendSignal(t *testing.T) {
|
||||
checkPid := os.Getpid()
|
||||
|
||||
p, _ := NewProcess(int32(checkPid))
|
||||
err := p.SendSignal(syscall.SIGCONT)
|
||||
if err != nil {
|
||||
t.Errorf("send signal %v", err)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,400 +0,0 @@
|
|||
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)
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue