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

could not get coverage from test subdirectory. move back to top.

Browse Source 
But it becomes messy again.
pull/4/head
Shirou WAKAYAMA 11 years ago
parent 1464099024
commit 45710b5c9d
16 changed files with 490 additions and 505 deletions
Show Stats Download Patch File Download Diff File

13
test/cpu_test.go → cpu_test.go
Unescape Escape View File

@ -1,21 +1,20 @@
package test package gopsutil
import ( import (
"fmt" "fmt"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestCpu_times(t *testing.T) { func TestCpu_times(t *testing.T) {
v, err := gopsutil.CPUTimes(false) v, err := CPUTimes(false)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
if len(v) == 0 { if len(v) == 0 {
t.Errorf("could not get CPUs ", err) t.Errorf("could not get CPUs ", err)
} }
empty := gopsutil.CPUTimesStat{} empty := CPUTimesStat{}
for _, vv := range v { for _, vv := range v {
if vv == empty { if vv == empty {
t.Errorf("could not get CPU User: %v", vv) t.Errorf("could not get CPU User: %v", vv)
@ -24,7 +23,7 @@ func TestCpu_times(t *testing.T) {
} }
func TestCpu_counts(t *testing.T) { func TestCpu_counts(t *testing.T) {
v, err := gopsutil.CPUCounts(true) v, err := CPUCounts(true)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -34,7 +33,7 @@ func TestCpu_counts(t *testing.T) {
} }
func TestCPUTimeStat_String(t *testing.T) { func TestCPUTimeStat_String(t *testing.T) {
v := gopsutil.CPUTimesStat{ v := CPUTimesStat{
CPU: "cpu0", CPU: "cpu0",
User: 100.1, User: 100.1,
System: 200.1, System: 200.1,
@ -47,7 +46,7 @@ func TestCPUTimeStat_String(t *testing.T) {
} }
func TestCpuInfo(t *testing.T) { func TestCpuInfo(t *testing.T) {
v, err := gopsutil.CPUInfo() v, err := CPUInfo()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }

20
test/disk_test.go → disk_test.go
Unescape Escape View File

@ -1,11 +1,9 @@
package test package gopsutil
import ( import (
"fmt" "fmt"
"runtime" "runtime"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestDisk_usage(t *testing.T) { func TestDisk_usage(t *testing.T) {
@ -13,7 +11,7 @@ func TestDisk_usage(t *testing.T) {
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
path = "C:" path = "C:"
} }
v, err := gopsutil.DiskUsage(path) v, err := DiskUsage(path)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -23,11 +21,11 @@ func TestDisk_usage(t *testing.T) {
} }
func TestDisk_partitions(t *testing.T) { func TestDisk_partitions(t *testing.T) {
ret, err := gopsutil.DiskPartitions(false) ret, err := DiskPartitions(false)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := gopsutil.DiskPartitionStat{} empty := DiskPartitionStat{}
for _, disk := range ret { for _, disk := range ret {
if disk == empty { if disk == empty {
t.Errorf("Could not get device info %v", disk) t.Errorf("Could not get device info %v", disk)
@ -36,11 +34,11 @@ func TestDisk_partitions(t *testing.T) {
} }
func TestDisk_io_counters(t *testing.T) { func TestDisk_io_counters(t *testing.T) {
ret, err := gopsutil.DiskIOCounters() ret, err := DiskIOCounters()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := gopsutil.DiskIOCountersStat{} empty := DiskIOCountersStat{}
for _, io := range ret { for _, io := range ret {
if io == empty { if io == empty {
t.Errorf("io_counter error %v", io) t.Errorf("io_counter error %v", io)
@ -49,7 +47,7 @@ func TestDisk_io_counters(t *testing.T) {
} }
func TestDiskUsageStat_String(t *testing.T) { func TestDiskUsageStat_String(t *testing.T) {
v := gopsutil.DiskUsageStat{ v := DiskUsageStat{
Path: "/", Path: "/",
Total: 1000, Total: 1000,
Free: 2000, Free: 2000,
@ -63,7 +61,7 @@ func TestDiskUsageStat_String(t *testing.T) {
} }
func TestDiskPartitionStat_String(t *testing.T) { func TestDiskPartitionStat_String(t *testing.T) {
v := gopsutil.DiskPartitionStat{ v := DiskPartitionStat{
Device: "sd01", Device: "sd01",
Mountpoint: "/", Mountpoint: "/",
Fstype: "ext4", Fstype: "ext4",
@ -76,7 +74,7 @@ func TestDiskPartitionStat_String(t *testing.T) {
} }
func TestDiskIOCountersStat_String(t *testing.T) { func TestDiskIOCountersStat_String(t *testing.T) {
v := gopsutil.DiskIOCountersStat{ v := DiskIOCountersStat{
Name: "sd01", Name: "sd01",
ReadCount: 100, ReadCount: 100,
WriteCount: 200, WriteCount: 200,

18
test/host_test.go → host_test.go
Unescape Escape View File

@ -1,25 +1,23 @@
package test package gopsutil
import ( import (
"fmt" "fmt"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestHostInfo(t *testing.T) { func TestHostInfo(t *testing.T) {
v, err := gopsutil.HostInfo() v, err := HostInfo()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := &gopsutil.HostInfoStat{} empty := &HostInfoStat{}
if v == empty { if v == empty {
t.Errorf("Could not get hostinfo %v", v) t.Errorf("Could not get hostinfo %v", v)
} }
} }
func TestBoot_time(t *testing.T) { func TestBoot_time(t *testing.T) {
v, err := gopsutil.BootTime() v, err := BootTime()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -29,11 +27,11 @@ func TestBoot_time(t *testing.T) {
} }
func TestUsers(t *testing.T) { func TestUsers(t *testing.T) {
v, err := gopsutil.Users() v, err := Users()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := gopsutil.UserStat{} empty := UserStat{}
for _, u := range v { for _, u := range v {
if u == empty { if u == empty {
t.Errorf("Could not Users %v", v) t.Errorf("Could not Users %v", v)
@ -42,7 +40,7 @@ func TestUsers(t *testing.T) {
} }
func TestHostInfoStat_String(t *testing.T) { func TestHostInfoStat_String(t *testing.T) {
v := gopsutil.HostInfoStat{ v := HostInfoStat{
Hostname: "test", Hostname: "test",
Uptime: 3000, Uptime: 3000,
Procs: 100, Procs: 100,
@ -56,7 +54,7 @@ func TestHostInfoStat_String(t *testing.T) {
} }
func TestUserStat_String(t *testing.T) { func TestUserStat_String(t *testing.T) {
v := gopsutil.UserStat{ v := UserStat{
User: "user", User: "user",
Terminal: "term", Terminal: "term",
Host: "host", Host: "host",

10
test/load_test.go → load_test.go
Unescape Escape View File

@ -1,26 +1,24 @@
package test package gopsutil
import ( import (
"fmt" "fmt"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestLoad(t *testing.T) { func TestLoad(t *testing.T) {
v, err := gopsutil.LoadAvg() v, err := LoadAvg()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := &gopsutil.LoadAvgStat{} empty := &LoadAvgStat{}
if v == empty { if v == empty {
t.Errorf("error load: %v", v) t.Errorf("error load: %v", v)
} }
} }
func TestLoadAvgStat_String(t *testing.T) { func TestLoadAvgStat_String(t *testing.T) {
v := gopsutil.LoadAvgStat{ v := LoadAvgStat{
Load1: 10.1, Load1: 10.1,
Load5: 20.1, Load5: 20.1,
Load15: 30.1, Load15: 30.1,

16
test/mem_test.go → mem_test.go
Unescape Escape View File

@ -1,37 +1,35 @@
package test package gopsutil
import ( import (
"fmt" "fmt"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestVirtual_memory(t *testing.T) { func TestVirtual_memory(t *testing.T) {
v, err := gopsutil.VirtualMemory() v, err := VirtualMemory()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := &gopsutil.VirtualMemoryStat{} empty := &VirtualMemoryStat{}
if v == empty { if v == empty {
t.Errorf("error %v", v) t.Errorf("error %v", v)
} }
} }
func TestSwap_memory(t *testing.T) { func TestSwap_memory(t *testing.T) {
v, err := gopsutil.SwapMemory() v, err := SwapMemory()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := &gopsutil.SwapMemoryStat{} empty := &SwapMemoryStat{}
if v == empty { if v == empty {
t.Errorf("error %v", v) t.Errorf("error %v", v)
} }
} }
func TestVirtualMemoryStat_String(t *testing.T) { func TestVirtualMemoryStat_String(t *testing.T) {
v := gopsutil.VirtualMemoryStat{ v := VirtualMemoryStat{
Total: 10, Total: 10,
Available: 20, Available: 20,
Used: 30, Used: 30,
@ -45,7 +43,7 @@ func TestVirtualMemoryStat_String(t *testing.T) {
} }
func TestSwapMemoryStat_String(t *testing.T) { func TestSwapMemoryStat_String(t *testing.T) {
v := gopsutil.SwapMemoryStat{ v := SwapMemoryStat{
Total: 10, Total: 10,
Used: 30, Used: 30,
Free: 40, Free: 40,

12
test/net_test.go → net_test.go
Unescape Escape View File

@ -1,14 +1,12 @@
package test package gopsutil
import ( import (
"fmt" "fmt"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestAddrString(t *testing.T) { func TestAddrString(t *testing.T) {
v := gopsutil.Addr{IP: "192.168.0.1", Port: 8000} v := Addr{IP: "192.168.0.1", Port: 8000}
s := fmt.Sprintf("%v", v) s := fmt.Sprintf("%v", v)
if s != "{\"ip\":\"192.168.0.1\",\"port\":8000}" { if s != "{\"ip\":\"192.168.0.1\",\"port\":8000}" {
@ -17,7 +15,7 @@ func TestAddrString(t *testing.T) {
} }
func TestNetIOCountersStatString(t *testing.T) { func TestNetIOCountersStatString(t *testing.T) {
v := gopsutil.NetIOCountersStat{ v := NetIOCountersStat{
Name: "test", Name: "test",
BytesSent: 100, BytesSent: 100,
} }
@ -28,7 +26,7 @@ func TestNetIOCountersStatString(t *testing.T) {
} }
func TestNetConnectionStatString(t *testing.T) { func TestNetConnectionStatString(t *testing.T) {
v := gopsutil.NetConnectionStat{ v := NetConnectionStat{
Fd: 10, Fd: 10,
Family: 10, Family: 10,
Type: 10, Type: 10,
@ -41,7 +39,7 @@ func TestNetConnectionStatString(t *testing.T) {
} }
func TestNetIOCounters(t *testing.T) { func TestNetIOCounters(t *testing.T) {
v, err := gopsutil.NetIOCounters(true) v, err := NetIOCounters(true)
if err != nil { if err != nil {
t.Errorf("Could not get NetIOCounters: %v", err) t.Errorf("Could not get NetIOCounters: %v", err)
} }

6
test/process_posix_test.go → process_posix_test.go
Unescape Escape View File

@ -1,19 +1,17 @@
// +build linux freebsd // +build linux freebsd
package test package gopsutil
import ( import (
"os" "os"
"syscall" "syscall"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func Test_SendSignal(t *testing.T) { func Test_SendSignal(t *testing.T) {
checkPid := os.Getpid() checkPid := os.Getpid()
p, _ := gopsutil.NewProcess(int32(checkPid)) p, _ := NewProcess(int32(checkPid))
err := p.SendSignal(syscall.SIGCONT) err := p.SendSignal(syscall.SIGCONT)
if err != nil { if err != nil {
t.Errorf("send signal %v", err) t.Errorf("send signal %v", err)

22
test/process_test.go → process_test.go
Unescape Escape View File

@ -1,24 +1,22 @@
package test package gopsutil
import ( import (
"os" "os"
"runtime" "runtime"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func test_getProcess() gopsutil.Process { func test_getProcess() Process {
checkPid := os.Getpid() checkPid := os.Getpid()
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
checkPid = 7960 checkPid = 7960
} }
ret, _ := gopsutil.NewProcess(int32(checkPid)) ret, _ := NewProcess(int32(checkPid))
return *ret return *ret
} }
func Test_Pids(t *testing.T) { func Test_Pids(t *testing.T) {
ret, err := gopsutil.Pids() ret, err := Pids()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -33,7 +31,7 @@ func Test_Pid_exists(t *testing.T) {
checkPid = 0 checkPid = 0
} }
ret, err := gopsutil.PidExists(int32(checkPid)) ret, err := PidExists(int32(checkPid))
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -49,11 +47,11 @@ func Test_NewProcess(t *testing.T) {
checkPid = 0 checkPid = 0
} }
ret, err := gopsutil.NewProcess(int32(checkPid)) ret, err := NewProcess(int32(checkPid))
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := &gopsutil.Process{} empty := &Process{}
if runtime.GOOS != "windows" { // Windows pid is 0 if runtime.GOOS != "windows" { // Windows pid is 0
if empty == ret { if empty == ret {
t.Errorf("error %v", ret) t.Errorf("error %v", ret)
@ -67,13 +65,13 @@ func Test_Process_memory_maps(t *testing.T) {
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
checkPid = 0 checkPid = 0
} }
ret, err := gopsutil.NewProcess(int32(checkPid)) ret, err := NewProcess(int32(checkPid))
mmaps, err := ret.MemoryMaps(false) mmaps, err := ret.MemoryMaps(false)
if err != nil { if err != nil {
t.Errorf("memory map get error %v", err) t.Errorf("memory map get error %v", err)
} }
empty := gopsutil.MemoryMapsStat{} empty := MemoryMapsStat{}
for _, m := range *mmaps { for _, m := range *mmaps {
if m == empty { if m == empty {
t.Errorf("memory map get error %v", m) t.Errorf("memory map get error %v", m)
@ -103,7 +101,7 @@ func Test_Process_IOCounters(t *testing.T) {
t.Errorf("geting ppid error %v", err) t.Errorf("geting ppid error %v", err)
return return
} }
empty := &gopsutil.IOCountersStat{} empty := &IOCountersStat{}
if v == empty { if v == empty {
t.Errorf("error %v", v) t.Errorf("error %v", v)
} }
Write Preview
Loading…
Cancel
Save