diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_test.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_test.go
deleted file mode 100644
index bd20211759..0000000000
--- a/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_test.go
+++ /dev/null
@@ -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)
-		}
-	}
-}
diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_test.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_test.go
deleted file mode 100644
index 6082ffcc5f..0000000000
--- a/vendor/github.com/shirou/gopsutil/cpu/cpu_test.go
+++ /dev/null
@@ -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)
-}
diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_test.go b/vendor/github.com/shirou/gopsutil/host/host_linux_test.go
deleted file mode 100644
index 7808eee3d1..0000000000
--- a/vendor/github.com/shirou/gopsutil/host/host_linux_test.go
+++ /dev/null
@@ -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)
-	}
-}
diff --git a/vendor/github.com/shirou/gopsutil/host/host_test.go b/vendor/github.com/shirou/gopsutil/host/host_test.go
deleted file mode 100644
index 8456d2203f..0000000000
--- a/vendor/github.com/shirou/gopsutil/host/host_test.go
+++ /dev/null
@@ -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)
-	}
-}
diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common_test.go b/vendor/github.com/shirou/gopsutil/internal/common/common_test.go
deleted file mode 100644
index b7bda8b744..0000000000
--- a/vendor/github.com/shirou/gopsutil/internal/common/common_test.go
+++ /dev/null
@@ -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)
-	}
-}
diff --git a/vendor/github.com/shirou/gopsutil/mem/mem_darwin_test.go b/vendor/github.com/shirou/gopsutil/mem/mem_darwin_test.go
deleted file mode 100644
index dba421ffce..0000000000
--- a/vendor/github.com/shirou/gopsutil/mem/mem_darwin_test.go
+++ /dev/null
@@ -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)
-}
diff --git a/vendor/github.com/shirou/gopsutil/mem/mem_test.go b/vendor/github.com/shirou/gopsutil/mem/mem_test.go
deleted file mode 100644
index 346d02f84d..0000000000
--- a/vendor/github.com/shirou/gopsutil/mem/mem_test.go
+++ /dev/null
@@ -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)
-	}
-}
diff --git a/vendor/github.com/shirou/gopsutil/net/net_darwin_test.go b/vendor/github.com/shirou/gopsutil/net/net_darwin_test.go
deleted file mode 100644
index cae12d573c..0000000000
--- a/vendor/github.com/shirou/gopsutil/net/net_darwin_test.go
+++ /dev/null
@@ -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")
-}
diff --git a/vendor/github.com/shirou/gopsutil/net/net_linux_test.go b/vendor/github.com/shirou/gopsutil/net/net_linux_test.go
deleted file mode 100644
index a881b7ad14..0000000000
--- a/vendor/github.com/shirou/gopsutil/net/net_linux_test.go
+++ /dev/null
@@ -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))
-}
diff --git a/vendor/github.com/shirou/gopsutil/net/net_test.go b/vendor/github.com/shirou/gopsutil/net/net_test.go
deleted file mode 100644
index 491a738fd0..0000000000
--- a/vendor/github.com/shirou/gopsutil/net/net_test.go
+++ /dev/null
@@ -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)
-		}
-	}
-
-}
diff --git a/vendor/github.com/shirou/gopsutil/process/process_posix_test.go b/vendor/github.com/shirou/gopsutil/process/process_posix_test.go
deleted file mode 100644
index eb9129220d..0000000000
--- a/vendor/github.com/shirou/gopsutil/process/process_posix_test.go
+++ /dev/null
@@ -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)
-	}
-}
diff --git a/vendor/github.com/shirou/gopsutil/process/process_test.go b/vendor/github.com/shirou/gopsutil/process/process_test.go
deleted file mode 100644
index a5f41dace5..0000000000
--- a/vendor/github.com/shirou/gopsutil/process/process_test.go
+++ /dev/null
@@ -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)
-	}
-
-}