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

make test directory and moved in it.

Browse Source
pull/4/head
Shirou WAKAYAMA 11 years ago
parent f5a85e6b55
commit dc78f4bcbe
16 changed files with 505 additions and 491 deletions
Show Stats Download Patch File Download Diff File

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

@ -1,19 +1,21 @@
package gopsutil package test
import ( import (
"fmt" "fmt"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestCpu_times(t *testing.T) { func TestCpu_times(t *testing.T) {
v, err := CPUTimes(false) v, err := gopsutil.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 := CPUTimesStat{} empty := gopsutil.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)
@ -22,7 +24,7 @@ func TestCpu_times(t *testing.T) {
} }
func TestCpu_counts(t *testing.T) { func TestCpu_counts(t *testing.T) {
v, err := CPUCounts(true) v, err := gopsutil.CPUCounts(true)
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -32,7 +34,7 @@ func TestCpu_counts(t *testing.T) {
} }
func TestCPUTimeStat_String(t *testing.T) { func TestCPUTimeStat_String(t *testing.T) {
v := CPUTimesStat{ v := gopsutil.CPUTimesStat{
CPU: "cpu0", CPU: "cpu0",
User: 100.1, User: 100.1,
System: 200.1, System: 200.1,
@ -45,7 +47,7 @@ func TestCPUTimeStat_String(t *testing.T) {
} }
func TestCpuInfo(t *testing.T) { func TestCpuInfo(t *testing.T) {
v, err := CPUInfo() v, err := gopsutil.CPUInfo()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }

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

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

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

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

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

@ -1,26 +1,26 @@
// +build linux 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 := LoadAvg() v, err := gopsutil.LoadAvg()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := &LoadAvgStat{} empty := &gopsutil.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 := LoadAvgStat{ v := gopsutil.LoadAvgStat{
Load1: 10.1, Load1: 10.1,
Load5: 20.1, Load5: 20.1,
Load15: 30.1, Load15: 30.1,

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

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

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

@ -1,12 +1,14 @@
package gopsutil package test
import ( import (
"fmt" "fmt"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func TestAddrString(t *testing.T) { func TestAddrString(t *testing.T) {
v := Addr{IP: "192.168.0.1", Port: 8000} v := gopsutil.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}" {
@ -15,7 +17,7 @@ func TestAddrString(t *testing.T) {
} }
func TestNetIOCountersStatString(t *testing.T) { func TestNetIOCountersStatString(t *testing.T) {
v := NetIOCountersStat{ v := gopsutil.NetIOCountersStat{
Name: "test", Name: "test",
BytesSent: 100, BytesSent: 100,
} }
@ -26,7 +28,7 @@ func TestNetIOCountersStatString(t *testing.T) {
} }
func TestNetConnectionStatString(t *testing.T) { func TestNetConnectionStatString(t *testing.T) {
v := NetConnectionStat{ v := gopsutil.NetConnectionStat{
Fd: 10, Fd: 10,
Family: 10, Family: 10,
Type: 10, Type: 10,
@ -39,7 +41,7 @@ func TestNetConnectionStatString(t *testing.T) {
} }
func TestNetIOCounters(t *testing.T) { func TestNetIOCounters(t *testing.T) {
v, err := NetIOCounters(true) v, err := gopsutil.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
process_posix_test.go → test/process_posix_test.go
Unescape Escape View File

@ -1,17 +1,19 @@
// +build linux freebsd // +build linux freebsd
package gopsutil package test
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, _ := NewProcess(int32(checkPid)) p, _ := gopsutil.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
process_test.go → test/process_test.go
Unescape Escape View File

@ -1,22 +1,24 @@
package gopsutil package test
import ( import (
"os" "os"
"runtime" "runtime"
"testing" "testing"
"github.com/shirou/gopsutil"
) )
func test_getProcess() Process { func test_getProcess() gopsutil.Process {
checkPid := os.Getpid() checkPid := os.Getpid()
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
checkPid = 7960 checkPid = 7960
} }
ret, _ := NewProcess(int32(checkPid)) ret, _ := gopsutil.NewProcess(int32(checkPid))
return *ret return *ret
} }
func Test_Pids(t *testing.T) { func Test_Pids(t *testing.T) {
ret, err := Pids() ret, err := gopsutil.Pids()
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -31,7 +33,7 @@ func Test_Pid_exists(t *testing.T) {
checkPid = 0 checkPid = 0
} }
ret, err := PidExists(int32(checkPid)) ret, err := gopsutil.PidExists(int32(checkPid))
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -47,11 +49,11 @@ func Test_NewProcess(t *testing.T) {
checkPid = 0 checkPid = 0
} }
ret, err := NewProcess(int32(checkPid)) ret, err := gopsutil.NewProcess(int32(checkPid))
if err != nil { if err != nil {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
empty := &Process{} empty := &gopsutil.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)
@ -65,13 +67,13 @@ func Test_Process_memory_maps(t *testing.T) {
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
checkPid = 0 checkPid = 0
} }
ret, err := NewProcess(int32(checkPid)) ret, err := gopsutil.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 := MemoryMapsStat{} empty := gopsutil.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)
@ -101,7 +103,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 := &IOCountersStat{} empty := &gopsutil.IOCountersStat{}
if v == empty { if v == empty {
t.Errorf("error %v", v) t.Errorf("error %v", v)
} }
Write Preview
Loading…
Cancel
Save