diff --git a/cmd/viewcore/vendor/README b/cmd/viewcore/vendor/README
index 0c0ddc8..d430a13 100644
--- a/cmd/viewcore/vendor/README
+++ b/cmd/viewcore/vendor/README
@@ -8,6 +8,7 @@
 
   $ cd `go env GOPATH`/src/golang.org/x/debug/cmd/viewcore
   $ govendor fetch github.com/spf13/cobra
+  $ govendor fetch github.com/chzyer/readline
 
 Check the updated vendor.json file carefully and
 create a review request.
diff --git a/cmd/viewcore/vendor/github.com/chzyer/logex/LICENSE b/cmd/viewcore/vendor/github.com/chzyer/logex/LICENSE
deleted file mode 100644
index c9afab3..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/logex/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Chzyer
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
diff --git a/cmd/viewcore/vendor/github.com/chzyer/logex/Makefile b/cmd/viewcore/vendor/github.com/chzyer/logex/Makefile
deleted file mode 100644
index 8dc10bf..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/logex/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-test:
-	go test -v ./...
-
-install:
-	go install ./...
diff --git a/cmd/viewcore/vendor/github.com/chzyer/logex/README.md b/cmd/viewcore/vendor/github.com/chzyer/logex/README.md
deleted file mode 100644
index 668d0eb..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/logex/README.md
+++ /dev/null
@@ -1,133 +0,0 @@
-Logex
-=======
-[![Build Status](https://travis-ci.org/chzyer/logex.svg?branch=master)](https://travis-ci.org/chzyer/logex)
-[![GoDoc](https://godoc.org/gopkg.in/logex.v1?status.svg)](https://godoc.org/gopkg.in/logex.v1)
-[![Join the chat at https://gitter.im/go-logex/logex](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/go-logex/logex?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-An golang log lib, supports tracing and level, wrap by standard log lib
-
-How To Get
-=======
-shell
-```
-go get gopkg.in/logex.v1
-```
-
-source code
-```{go}
-import "gopkg.in/logex.v1" // package name is logex
-
-func main() {
-  logex.Info("Hello!")
-}
-```
-
-Level
-=======
-
-```{go}
-import "gopkg.in/logex.v1"
-
-func main() {
-  logex.Println("")
-  logex.Debug("debug staff.") // Only show if has an "DEBUG" named env variable(whatever value).
-  logex.Info("info")
-  logex.Warn("")
-  logex.Fatal("") // also trigger exec "os.Exit(1)"
-  logex.Error(err) // print error
-  logex.Struct(obj) // print objs follow such layout "%T(%+v)"
-  logex.Pretty(obj) // print objs as JSON-style, more readable and hide non-publish properties, just JSON
-}
-```
-
-Extendability
-======
-
-source code
-```{go}
-type MyStruct struct {
-  BiteMe bool
-}
-```
-
-may change to
-
-```{go}
-type MyStruct struct {
-  BiteMe bool
-  logex.Logger // just this
-}
-
-func main() {
-  ms := new(MyStruct)
-  ms.Info("woo!")
-}
-```
-
-Runtime Tracing
-======
-All log will attach theirs stack info. Stack Info will shown by an layout, `{packageName}.{FuncName}:{FileName}:{FileLine}`
-
-```{go}
-package main
-
-import "gopkg.in/logex.v1"
-
-func test() {
-	logex.Pretty("hello")
-}
-
-func main() {
-	test()
-}
-```
-
-response
-```
-2014/10/10 15:17:14 [main.test:testlog.go:6][PRETTY] "hello"
-```
-
-Error Tracing
-======
-You can trace an error if you want.
-
-```{go}
-package main
-
-import (
-	"gopkg.in/logex.v1"
-	"os"
-)
-
-func openfile() (*os.File, error) {
-	f, err := os.Open("xxx")
-	if err != nil {
-		err = logex.Trace(err)
-	}
-	return f, err
-}
-
-func test() error {
-	f, err := openfile()
-	if err != nil {
-		return logex.Trace(err)
-	}
-	f.Close()
-	return nil
-}
-
-func main() {
-	err := test()
-	if err != nil {
-		logex.Error(err)
-		return
-	}
-	logex.Info("test success")
-}
-```
-
-
-response
-```
-2014/10/10 15:22:29 [main.main:testlog.go:28][ERROR] [main.openfile:11;main.test:19] open xxx: no such file or directory
-```
diff --git a/cmd/viewcore/vendor/github.com/chzyer/logex/err.go b/cmd/viewcore/vendor/github.com/chzyer/logex/err.go
deleted file mode 100644
index 8bd69c7..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/logex/err.go
+++ /dev/null
@@ -1,182 +0,0 @@
-package logex
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
-)
-
-func Define(info string) *traceError {
-	return &traceError{
-		error: errors.New(info),
-	}
-}
-
-func NewError(info ...interface{}) *traceError {
-	return TraceEx(1, errors.New(sprint(info)))
-}
-
-func NewErrorf(format string, info ...interface{}) *traceError {
-	return TraceEx(1, errors.New(sprintf(format, info)))
-}
-
-func EqualAny(e error, es []error) bool {
-	for i := 0; i < len(es); i++ {
-		if Equal(e, es[i]) {
-			return true
-		}
-	}
-	return false
-}
-
-func Equal(e1, e2 error) bool {
-	if e, ok := e1.(*traceError); ok {
-		e1 = e.error
-	}
-	if e, ok := e2.(*traceError); ok {
-		e2 = e.error
-	}
-	return e1 == e2
-}
-
-type traceError struct {
-	error
-	format []interface{}
-	stack  []string
-	code   *int
-}
-
-func (t *traceError) SetCode(code int) *traceError {
-	if t.stack == nil {
-		t = TraceEx(1, t)
-	}
-	t.code = &code
-	return t
-}
-
-func (t *traceError) GetCode() int {
-	if t.code == nil {
-		return 500
-	}
-	return *t.code
-}
-
-func (t *traceError) Error() string {
-	if t == nil {
-		return "<nil>"
-	}
-	if t.format == nil {
-		if t.error == nil {
-			panic(t.stack)
-		}
-		return t.error.Error()
-	}
-	return fmt.Sprintf(t.error.Error(), t.format...)
-}
-
-func (t *traceError) Trace(info ...interface{}) *traceError {
-	return TraceEx(1, t, info...)
-}
-
-func (t *traceError) Follow(err error) *traceError {
-	if t == nil {
-		return nil
-	}
-	if te, ok := err.(*traceError); ok {
-		if len(te.stack) > 0 {
-			te.stack[len(te.stack)-1] += ":" + err.Error()
-		}
-		t.stack = append(te.stack, t.stack...)
-	}
-	return t
-}
-
-func (t *traceError) Format(obj ...interface{}) *traceError {
-	if t.stack == nil {
-		t = TraceEx(1, t)
-	}
-	t.format = obj
-	return t
-}
-
-func (t *traceError) StackError() string {
-	if t == nil {
-		return t.Error()
-	}
-	if len(t.stack) == 0 {
-		return t.Error()
-	}
-	return fmt.Sprintf("[%s] %s", strings.Join(t.stack, ";"), t.Error())
-}
-
-func Tracefmt(layout string, objs ...interface{}) error {
-	var teInfo *traceError
-	for idx, obj := range objs {
-		if te, ok := obj.(*traceError); ok {
-			teInfo = te
-			objs[idx] = te.Error()
-		}
-	}
-	return &traceError{
-		error:  fmt.Errorf(layout, objs...),
-		format: teInfo.format,
-		stack:  teInfo.stack,
-		code:   teInfo.code,
-	}
-}
-
-func Tracef(err error, obj ...interface{}) *traceError {
-	e := TraceEx(1, err).Format(obj...)
-	return e
-}
-
-// set runtime info to error
-func TraceError(err error, info ...interface{}) *traceError {
-	return TraceEx(1, err, info...)
-}
-
-func Trace(err error, info ...interface{}) error {
-	if err == nil {
-		return nil
-	}
-	return TraceEx(1, err, info...)
-}
-
-func joinInterface(info []interface{}, ch string) string {
-	ret := bytes.NewBuffer(make([]byte, 0, 512))
-	for idx, o := range info {
-		if idx > 0 {
-			ret.WriteString(ch)
-		}
-		ret.WriteString(fmt.Sprint(o))
-	}
-	return ret.String()
-}
-
-func TraceEx(depth int, err error, info ...interface{}) *traceError {
-	if err == nil {
-		return nil
-	}
-	pc, _, line, _ := runtime.Caller(1 + depth)
-	name := runtime.FuncForPC(pc).Name()
-	name = path.Base(name)
-	stack := name + ":" + strconv.Itoa(line)
-	if len(info) > 0 {
-		stack += "(" + joinInterface(info, ",") + ")"
-	}
-	if te, ok := err.(*traceError); ok {
-		if te.stack == nil { // define
-			return &traceError{
-				error: te.error,
-				stack: []string{stack},
-			}
-		}
-		te.stack = append(te.stack, stack)
-		return te
-	}
-	return &traceError{err, nil, []string{stack}, nil}
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/logex/err_test.go b/cmd/viewcore/vendor/github.com/chzyer/logex/err_test.go
deleted file mode 100644
index 376a08a..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/logex/err_test.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package logex
-
-import (
-	"os"
-	"strings"
-	"testing"
-)
-
-func b() error {
-	_, err := os.Open("dflkjasldfkas")
-	return Trace(err)
-}
-
-func a() error {
-	return Trace(b())
-}
-
-func TestError(t *testing.T) {
-	te := TraceError(a())
-	errInfo := te.StackError()
-	prefixes := []string{"logex%2ev1", "logex"}
-	for _, p := range prefixes {
-		if strings.Contains(errInfo, p+".b:11") &&
-			strings.Contains(errInfo, p+".a:15") &&
-			strings.Contains(errInfo, p+".TestError:19") {
-			return
-		}
-	}
-
-	t.Error("fail", te.StackError())
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/logex/logex.go b/cmd/viewcore/vendor/github.com/chzyer/logex/logex.go
deleted file mode 100644
index 9ab5079..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/logex/logex.go
+++ /dev/null
@@ -1,287 +0,0 @@
-package logex
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	goLog "log"
-	"os"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
-)
-
-var DebugLevel = 1
-
-type Logger struct {
-	depth  int
-	reqid  string
-	Logger *goLog.Logger
-}
-
-func NewLogger(l int) *Logger {
-	return &Logger{l, "", goLogStd}
-}
-
-func NewLoggerEx(w io.Writer) *Logger {
-	return &Logger{0, "", NewGoLog(w)}
-}
-
-func NewGoLog(w io.Writer) *goLog.Logger {
-	return goLog.New(w, "", goLog.LstdFlags)
-}
-
-var goLogStd = goLog.New(os.Stderr, "", goLog.LstdFlags)
-var std = NewLogger(1)
-var ShowCode = true
-var (
-	Println    = std.Println
-	Infof      = std.Infof
-	Info       = std.Info
-	Debug      = std.Debug
-	Debugf     = std.Debugf
-	Error      = std.Error
-	Errorf     = std.Errorf
-	Warn       = std.Warn
-	PrintStack = std.PrintStack
-	Stack      = std.Stack
-	Panic      = std.Panic
-	Fatal      = std.Fatal
-	Struct     = std.Struct
-	Pretty     = std.Pretty
-	Todo       = std.Todo
-)
-
-func SetStd(l *Logger) {
-	std = l
-	Println = std.Println
-	Infof = std.Infof
-	Info = std.Info
-	Debug = std.Debug
-	Error = std.Error
-	Warn = std.Warn
-	PrintStack = std.PrintStack
-	Stack = std.Stack
-	Panic = std.Panic
-	Fatal = std.Fatal
-	Struct = std.Struct
-	Pretty = std.Pretty
-	Todo = std.Todo
-}
-
-var (
-	INFO   = "[INFO] "
-	ERROR  = "[ERROR] "
-	PANIC  = "[PANIC] "
-	DEBUG  = "[DEBUG] "
-	WARN   = "[WARN] "
-	FATAL  = "[FATAL] "
-	STRUCT = "[STRUCT] "
-	PRETTY = "[PRETTY] "
-	TODO   = "[TODO] "
-)
-
-func color(col, s string) string {
-	if col == "" {
-		return s
-	}
-	return "\x1b[0;" + col + "m" + s + "\x1b[0m"
-}
-
-func init() {
-	if os.Getenv("DEBUG") != "" {
-		DebugLevel = 0
-		ERROR = color("32", ERROR)
-	}
-}
-
-func DownLevel(i int) Logger {
-	return std.DownLevel(i - 1)
-}
-
-// decide to show which level's stack
-func (l Logger) DownLevel(i int) Logger {
-	return Logger{l.depth + i, l.reqid, l.Logger}
-}
-
-// output objects to json format
-func (l Logger) Pretty(os ...interface{}) {
-	content := ""
-	for i := range os {
-		if ret, err := json.MarshalIndent(os[i], "", "\t"); err == nil {
-			content += string(ret) + "\n"
-		}
-	}
-	l.Output(2, PRETTY+content)
-}
-
-// just print
-func (l Logger) Print(o ...interface{}) {
-	l.Output(2, sprint(o))
-}
-
-// just print by format
-func (l Logger) Printf(layout string, o ...interface{}) {
-	l.Output(2, sprintf(layout, o))
-}
-
-// just println
-func (l Logger) Println(o ...interface{}) {
-	l.Output(2, " "+sprint(o))
-}
-
-func (l Logger) Info(o ...interface{}) {
-	if DebugLevel > 1 {
-		return
-	}
-
-	l.Output(2, INFO+sprint(o))
-}
-func (l Logger) Infof(f string, o ...interface{}) {
-	if DebugLevel > 1 {
-		return
-	}
-
-	l.Output(2, INFO+sprintf(f, o))
-}
-
-func (l Logger) Debug(o ...interface{}) {
-	if DebugLevel > 0 {
-		return
-	}
-	l.Output(2, DEBUG+sprint(o))
-}
-
-func (l Logger) Debugf(f string, o ...interface{}) {
-	if DebugLevel > 0 {
-		return
-	}
-	l.Output(2, DEBUG+sprintf(f, o))
-}
-
-func (l Logger) Todo(o ...interface{}) {
-	l.Output(2, TODO+sprint(o))
-}
-
-func (l Logger) Error(o ...interface{}) {
-	l.Output(2, ERROR+sprint(o))
-}
-
-func (l Logger) Errorf(f string, o ...interface{}) {
-	l.Output(2, ERROR+sprintf(f, o))
-}
-
-func (l Logger) Warn(o ...interface{}) {
-	l.Output(2, WARN+sprint(o))
-}
-func (l Logger) Warnf(f string, o ...interface{}) {
-	l.Output(2, WARN+sprintf(f, o))
-}
-
-func (l Logger) Panic(o ...interface{}) {
-	l.Output(2, PANIC+sprint(o))
-	panic(o)
-}
-func (l Logger) Panicf(f string, o ...interface{}) {
-	info := sprintf(f, o)
-	l.Output(2, PANIC+info)
-	panic(info)
-}
-
-func (l Logger) Fatal(o ...interface{}) {
-	l.Output(2, FATAL+sprint(o))
-	os.Exit(1)
-}
-
-func (l Logger) Fatalf(f string, o ...interface{}) {
-	l.Output(2, FATAL+sprintf(f, o))
-	os.Exit(1)
-}
-
-func (l Logger) Struct(o ...interface{}) {
-	items := make([]interface{}, 0, len(o)*2)
-	for _, item := range o {
-		items = append(items, item, item)
-	}
-	layout := strings.Repeat(", %T(%+v)", len(o))
-	if len(layout) > 0 {
-		layout = layout[2:]
-	}
-	l.Output(2, STRUCT+sprintf(layout, items))
-}
-
-func (l Logger) PrintStack() {
-	Info(string(l.Stack()))
-}
-
-func (l Logger) Stack() []byte {
-	a := make([]byte, 1024*1024)
-	n := runtime.Stack(a, true)
-	return a[:n]
-}
-
-func (l Logger) Output(calldepth int, s string) error {
-	calldepth += l.depth + 1
-	if l.Logger == nil {
-		l.Logger = goLogStd
-	}
-	return l.Logger.Output(calldepth, l.makePrefix(calldepth)+s)
-}
-
-func (l Logger) makePrefix(calldepth int) string {
-	if !ShowCode {
-		return ""
-	}
-	pc, f, line, _ := runtime.Caller(calldepth)
-	name := runtime.FuncForPC(pc).Name()
-	name = path.Base(name) // only use package.funcname
-	f = path.Base(f)       // only use filename
-
-	tags := make([]string, 0, 3)
-
-	pos := name + ":" + f + ":" + strconv.Itoa(line)
-	tags = append(tags, pos)
-	if l.reqid != "" {
-		tags = append(tags, l.reqid)
-	}
-	return "[" + strings.Join(tags, "][") + "]"
-}
-
-func Sprint(o ...interface{}) string {
-	return sprint(o)
-}
-
-func Sprintf(f string, o ...interface{}) string {
-	return sprintf(f, o)
-}
-
-func sprint(o []interface{}) string {
-	decodeTraceError(o)
-	return joinInterface(o, " ")
-}
-func sprintf(f string, o []interface{}) string {
-	decodeTraceError(o)
-	return fmt.Sprintf(f, o...)
-}
-
-func DecodeError(e error) string {
-	if e == nil {
-		return ""
-	}
-	if e1, ok := e.(*traceError); ok {
-		return e1.StackError()
-	}
-	return e.Error()
-}
-
-func decodeTraceError(o []interface{}) {
-	if !ShowCode {
-		return
-	}
-	for idx, obj := range o {
-		if te, ok := obj.(*traceError); ok {
-			o[idx] = te.StackError()
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/logex/logex_test.go b/cmd/viewcore/vendor/github.com/chzyer/logex/logex_test.go
deleted file mode 100644
index e6027f2..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/logex/logex_test.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package logex
-
-import (
-	"bytes"
-	"io"
-	"strings"
-	"testing"
-)
-
-func (s *S) hello() {
-	s.Warn("warn in hello")
-}
-
-func log(buf io.Writer, s string) {
-	Logger{Logger: NewGoLog(buf)}.Output(2, s)
-}
-
-func test(buf io.Writer) {
-	log(buf, "aa")
-	Info("b")
-	NewLoggerEx(buf).Info("c")
-	Error("ec")
-	s.hello()
-	Struct(&s, 1, "", false)
-}
-
-// -------------------------------------------------------------------
-
-type S struct {
-	Logger
-}
-
-var s = S{}
-
-func TestLogex(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	logger := NewLoggerEx(buf)
-	logger.depth = 1
-	goLogStd = logger.Logger
-	SetStd(logger)
-
-	test(buf)
-	ret := buf.String()
-
-	println("--------\n", ret)
-
-	except := []string{
-		".test:logex_test.go:19]aa",
-		".test:logex_test.go:20][INFO] b",
-		".test:logex_test.go:21][INFO] c",
-		".test:logex_test.go:22][ERROR] ec",
-		".(*S).hello:logex_test.go:11][WARN] warn in hello",
-	}
-
-	for _, e := range except {
-		idx := strings.Index(ret, e)
-		if idx < 0 {
-			t.Fatal("except", e, "not found")
-		}
-		ret = ret[idx+len(e):]
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/readline/complete_segment_test.go b/cmd/viewcore/vendor/github.com/chzyer/readline/complete_segment_test.go
deleted file mode 100644
index 73a828a..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/readline/complete_segment_test.go
+++ /dev/null
@@ -1,167 +0,0 @@
-package readline
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/chzyer/test"
-)
-
-func rs(s [][]rune) []string {
-	ret := make([]string, len(s))
-	for idx, ss := range s {
-		ret[idx] = string(ss)
-	}
-	return ret
-}
-
-func sr(s ...string) [][]rune {
-	ret := make([][]rune, len(s))
-	for idx, ss := range s {
-		ret[idx] = []rune(ss)
-	}
-	return ret
-}
-
-func TestRetSegment(t *testing.T) {
-	defer test.New(t)
-	// a
-	// |- a1
-	// |--- a11
-	// |--- a12
-	// |- a2
-	// |--- a21
-	// b
-	// add
-	// adddomain
-	ret := []struct {
-		Segments [][]rune
-		Cands    [][]rune
-		idx      int
-		Ret      [][]rune
-		pos      int
-	}{
-		{sr(""), sr("a", "b", "add", "adddomain"), 0, sr("a", "b", "add", "adddomain"), 0},
-		{sr("a"), sr("a", "add", "adddomain"), 1, sr("", "dd", "dddomain"), 1},
-		{sr("a", ""), sr("a1", "a2"), 0, sr("a1", "a2"), 0},
-		{sr("a", "a"), sr("a1", "a2"), 1, sr("1", "2"), 1},
-		{sr("a", "a1"), sr("a1"), 2, sr(""), 2},
-		{sr("add"), sr("add", "adddomain"), 2, sr("", "domain"), 2},
-	}
-	for idx, r := range ret {
-		ret, pos := RetSegment(r.Segments, r.Cands, r.idx)
-		test.Equal(ret, r.Ret, fmt.Errorf("%v", idx))
-		test.Equal(pos, r.pos, fmt.Errorf("%v", idx))
-	}
-}
-
-func TestSplitSegment(t *testing.T) {
-	defer test.New(t)
-	// a
-	// |- a1
-	// |--- a11
-	// |--- a12
-	// |- a2
-	// |--- a21
-	// b
-	ret := []struct {
-		Line     string
-		Pos      int
-		Segments [][]rune
-		Idx      int
-	}{
-		{"", 0, sr(""), 0},
-		{"a", 1, sr("a"), 1},
-		{"a ", 2, sr("a", ""), 0},
-		{"a a", 3, sr("a", "a"), 1},
-		{"a a1", 4, sr("a", "a1"), 2},
-		{"a a1 ", 5, sr("a", "a1", ""), 0},
-	}
-
-	for i, r := range ret {
-		ret, idx := SplitSegment([]rune(r.Line), r.Pos)
-		test.Equal(rs(ret), rs(r.Segments), fmt.Errorf("%v", i))
-		test.Equal(idx, r.Idx, fmt.Errorf("%v", i))
-	}
-}
-
-type Tree struct {
-	Name     string
-	Children []Tree
-}
-
-func TestSegmentCompleter(t *testing.T) {
-	defer test.New(t)
-
-	tree := Tree{"", []Tree{
-		{"a", []Tree{
-			{"a1", []Tree{
-				{"a11", nil},
-				{"a12", nil},
-			}},
-			{"a2", []Tree{
-				{"a21", nil},
-			}},
-		}},
-		{"b", nil},
-		{"route", []Tree{
-			{"add", nil},
-			{"adddomain", nil},
-		}},
-	}}
-	s := SegmentFunc(func(ret [][]rune, n int) [][]rune {
-		tree := tree
-	main:
-		for level := 0; level < len(ret)-1; {
-			name := string(ret[level])
-			for _, t := range tree.Children {
-				if t.Name == name {
-					tree = t
-					level++
-					continue main
-				}
-			}
-		}
-
-		ret = make([][]rune, len(tree.Children))
-		for idx, r := range tree.Children {
-			ret[idx] = []rune(r.Name)
-		}
-		return ret
-	})
-
-	// a
-	// |- a1
-	// |--- a11
-	// |--- a12
-	// |- a2
-	// |--- a21
-	// b
-	ret := []struct {
-		Line  string
-		Pos   int
-		Ret   [][]rune
-		Share int
-	}{
-		{"", 0, sr("a", "b", "route"), 0},
-		{"a", 1, sr(""), 1},
-		{"a ", 2, sr("a1", "a2"), 0},
-		{"a a", 3, sr("1", "2"), 1},
-		{"a a1", 4, sr(""), 2},
-		{"a a1 ", 5, sr("a11", "a12"), 0},
-		{"a a1 a", 6, sr("11", "12"), 1},
-		{"a a1 a1", 7, sr("1", "2"), 2},
-		{"a a1 a11", 8, sr(""), 3},
-		{"route add", 9, sr("", "domain"), 3},
-	}
-	for _, r := range ret {
-		for idx, rr := range r.Ret {
-			r.Ret[idx] = append(rr, ' ')
-		}
-	}
-	for i, r := range ret {
-		newLine, length := s.Do([]rune(r.Line), r.Pos)
-		test.Equal(rs(newLine), rs(r.Ret), fmt.Errorf("%v", i))
-		test.Equal(length, r.Share, fmt.Errorf("%v", i))
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/readline/readline_test.go b/cmd/viewcore/vendor/github.com/chzyer/readline/readline_test.go
deleted file mode 100644
index 34a5a3b..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/readline/readline_test.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package readline
-
-import (
-	"testing"
-	"time"
-)
-
-func TestRace(t *testing.T) {
-	rl, err := NewEx(&Config{})
-	if err != nil {
-		t.Fatal(err)
-		return
-	}
-
-	go func() {
-		for range time.Tick(time.Millisecond) {
-			rl.SetPrompt("hello")
-		}
-	}()
-
-	go func() {
-		time.Sleep(100 * time.Millisecond)
-		rl.Close()
-	}()
-
-	rl.Readline()
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/readline/runes_test.go b/cmd/viewcore/vendor/github.com/chzyer/readline/runes_test.go
deleted file mode 100644
index 9c56d79..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/readline/runes_test.go
+++ /dev/null
@@ -1,68 +0,0 @@
-package readline
-
-import (
-	"reflect"
-	"testing"
-)
-
-type twidth struct {
-	r      []rune
-	length int
-}
-
-func TestRuneWidth(t *testing.T) {
-	rs := []twidth{
-		{[]rune("☭"), 1},
-		{[]rune("a"), 1},
-		{[]rune("你"), 2},
-		{runes.ColorFilter([]rune("☭\033[13;1m你")), 3},
-	}
-	for _, r := range rs {
-		if w := runes.WidthAll(r.r); w != r.length {
-			t.Fatal("result not expect", r.r, r.length, w)
-		}
-	}
-}
-
-type tagg struct {
-	r      [][]rune
-	e      [][]rune
-	length int
-}
-
-func TestAggRunes(t *testing.T) {
-	rs := []tagg{
-		{
-			[][]rune{[]rune("ab"), []rune("a"), []rune("abc")},
-			[][]rune{[]rune("b"), []rune(""), []rune("bc")},
-			1,
-		},
-		{
-			[][]rune{[]rune("addb"), []rune("ajkajsdf"), []rune("aasdfkc")},
-			[][]rune{[]rune("ddb"), []rune("jkajsdf"), []rune("asdfkc")},
-			1,
-		},
-		{
-			[][]rune{[]rune("ddb"), []rune("ajksdf"), []rune("aasdfkc")},
-			[][]rune{[]rune("ddb"), []rune("ajksdf"), []rune("aasdfkc")},
-			0,
-		},
-		{
-			[][]rune{[]rune("ddb"), []rune("ddajksdf"), []rune("ddaasdfkc")},
-			[][]rune{[]rune("b"), []rune("ajksdf"), []rune("aasdfkc")},
-			2,
-		},
-	}
-	for _, r := range rs {
-		same, off := runes.Aggregate(r.r)
-		if off != r.length {
-			t.Fatal("result not expect", off)
-		}
-		if len(same) != off {
-			t.Fatal("result not expect", same)
-		}
-		if !reflect.DeepEqual(r.r, r.e) {
-			t.Fatal("result not expect")
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/readline/utils_test.go b/cmd/viewcore/vendor/github.com/chzyer/readline/utils_test.go
deleted file mode 100644
index 96037df..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/readline/utils_test.go
+++ /dev/null
@@ -1 +0,0 @@
-package readline
diff --git a/cmd/viewcore/vendor/github.com/chzyer/test/LICENSE b/cmd/viewcore/vendor/github.com/chzyer/test/LICENSE
deleted file mode 100644
index 96c44aa..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/test/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 chzyer
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/cmd/viewcore/vendor/github.com/chzyer/test/README.md b/cmd/viewcore/vendor/github.com/chzyer/test/README.md
deleted file mode 100644
index 00bcb6e..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/test/README.md
+++ /dev/null
@@ -1 +0,0 @@
-# test
\ No newline at end of file
diff --git a/cmd/viewcore/vendor/github.com/chzyer/test/disk.go b/cmd/viewcore/vendor/github.com/chzyer/test/disk.go
deleted file mode 100644
index 417d2f5..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/test/disk.go
+++ /dev/null
@@ -1,106 +0,0 @@
-package test
-
-import (
-	"encoding/hex"
-	"io"
-)
-
-type MemDisk struct {
-	data       [][]byte
-	size       int64
-	woff, roff int
-}
-
-func NewMemDisk() *MemDisk {
-	return &MemDisk{}
-}
-
-func (w *MemDisk) Write(b []byte) (int, error) {
-	n, err := w.WriteAt(b, int64(w.woff))
-	w.woff += n
-	return n, err
-}
-
-func (w *MemDisk) getData(off int64) []byte {
-	idx := int(off >> 20)
-	if idx >= cap(w.data) {
-		newdata := make([][]byte, idx+1)
-		copy(newdata, w.data)
-		w.data = newdata
-	}
-	if len(w.data[idx]) == 0 {
-		w.data[idx] = make([]byte, 1<<20)
-	}
-
-	return w.data[idx][off&((1<<20)-1):]
-}
-
-func (w *MemDisk) WriteAt(b []byte, off int64) (int, error) {
-	n := len(b)
-	for len(b) > 0 {
-		buf := w.getData(off)
-		m := copy(buf, b)
-		if off+int64(m) > w.size {
-			w.size = off + int64(m)
-		}
-		b = b[m:]
-		off += int64(m)
-	}
-	return n, nil
-}
-
-func (w *MemDisk) ReadAt(b []byte, off int64) (int, error) {
-	byteRead := 0
-	for byteRead < len(b) {
-		if off >= w.size {
-			return 0, io.EOF
-		}
-		buf := w.getData(off)
-		if int64(len(buf))+off > w.size {
-			buf = buf[:w.size-off]
-		}
-		if len(buf) == 0 {
-			return byteRead, io.EOF
-		}
-		n := copy(b[byteRead:], buf)
-		off += int64(n)
-		byteRead += n
-	}
-	return byteRead, nil
-}
-
-func (w *MemDisk) Dump() string {
-	return hex.Dump(w.getData(0))
-}
-
-func (w *MemDisk) SeekRead(offset int64, whence int) (ret int64) {
-	switch whence {
-	case 0:
-		w.roff += int(offset)
-	case 1:
-		w.roff = int(offset)
-	default:
-	}
-	return int64(w.roff)
-}
-
-func (w *MemDisk) SeekWrite(offset int64, whence int) (ret int64) {
-	switch whence {
-	case 0:
-		w.woff += int(offset)
-	case 1:
-		w.woff = int(offset)
-	default:
-	}
-	return int64(w.woff)
-}
-
-func (w *MemDisk) Read(b []byte) (int, error) {
-	n, err := w.ReadAt(b, int64(w.roff))
-	w.roff += n
-	return n, err
-}
-
-func (w *MemDisk) Close() error {
-	return nil
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/test/disk_test.go b/cmd/viewcore/vendor/github.com/chzyer/test/disk_test.go
deleted file mode 100644
index 3b6988c..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/test/disk_test.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package test
-
-import (
-	"io"
-	"testing"
-)
-
-func TestMemDisk(t *testing.T) {
-	defer New(t)
-	md := NewMemDisk()
-	WriteAt(md, []byte("hello"), 4)
-	h := make([]byte, 5)
-	n, err := md.ReadAt(h, 3)
-	Equals(n, 5, err, nil, h, []byte("\x00hell"))
-
-	{
-		n, err := md.ReadAt(h, 10)
-		Equals(n, 0, err, io.EOF)
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/chzyer/test/test.go b/cmd/viewcore/vendor/github.com/chzyer/test/test.go
deleted file mode 100644
index aef573a..0000000
--- a/cmd/viewcore/vendor/github.com/chzyer/test/test.go
+++ /dev/null
@@ -1,420 +0,0 @@
-package test
-
-import (
-	"bytes"
-	"crypto/rand"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"strconv"
-	"strings"
-
-	"github.com/chzyer/logex"
-)
-
-var (
-	mainRoot           = ""
-	RootPath           = os.TempDir()
-	ErrNotExcept       = logex.Define("result not expect")
-	ErrNotEqual        = logex.Define("result not equals")
-	ErrRequireNotEqual = logex.Define("result require not equals")
-	StrNotSuchFile     = "no such file or directory"
-)
-
-func init() {
-	println("tmpdir:", RootPath)
-}
-
-type testException struct {
-	depth int
-	info  string
-}
-
-func getMainRoot() string {
-	if mainRoot != "" {
-		return mainRoot
-	}
-
-	cwd, err := os.Getwd()
-	if err != nil {
-		return ""
-	}
-
-	for len(cwd) > 1 {
-		_, err := os.Stat(filepath.Join(cwd, ".git"))
-		if err == nil {
-			mainRoot = cwd + string([]rune{filepath.Separator})
-			break
-		}
-		cwd = filepath.Dir(cwd)
-	}
-	return mainRoot
-}
-
-func Skip() {
-	panic(nil)
-}
-
-type Failer interface {
-	FailNow()
-}
-
-func New(t Failer) {
-	err := recover()
-	if err == nil {
-		return
-	}
-	te, ok := err.(*testException)
-	if !ok {
-		panic(err)
-	}
-
-	_, file, line, _ := runtime.Caller(5 + te.depth)
-	if strings.HasPrefix(file, getMainRoot()) {
-		file = file[len(getMainRoot()):]
-	}
-	println(fmt.Sprintf("%s:%d: %s", file, line, te.info))
-	t.FailNow()
-}
-
-func getErr(def error, e []error) error {
-	if len(e) == 0 {
-		return def
-	}
-	return e[0]
-}
-
-func ReadAt(r io.ReaderAt, b []byte, at int64) {
-	n, err := r.ReadAt(b, at)
-	if err != nil {
-		Panic(0, fmt.Errorf("ReadAt error: %v", err))
-	}
-	if n != len(b) {
-		Panic(0, fmt.Errorf("ReadAt short read: %v, want: %v", n, len(b)))
-	}
-}
-
-func ReadAndCheck(r io.Reader, b []byte) {
-	buf := make([]byte, len(b))
-	Read(r, buf)
-	equalBytes(1, buf, b)
-}
-
-func Read(r io.Reader, b []byte) {
-	n, err := r.Read(b)
-	if err != nil && !logex.Equal(err, io.EOF) {
-		Panic(0, fmt.Errorf("Read error: %v", err))
-	}
-	if n != len(b) {
-		Panic(0, fmt.Errorf("Read: %v, want: %v", n, len(b)))
-	}
-}
-
-func ReadStringAt(r io.ReaderAt, off int64, s string) {
-	buf := make([]byte, len(s))
-	n, err := r.ReadAt(buf, off)
-	buf = buf[:n]
-	if err != nil {
-		Panic(0, fmt.Errorf("ReadStringAt: %v", err))
-	}
-	if string(buf) != s {
-		Panic(0, fmt.Errorf(
-			"ReadStringAt not match: %v, got: %v",
-			strconv.Quote(s),
-			strconv.Quote(string(buf)),
-		))
-	}
-}
-
-func ReadString(r io.Reader, s string) {
-	buf := make([]byte, len(s))
-	n, err := r.Read(buf)
-	if err != nil && !logex.Equal(err, io.EOF) {
-		Panic(0, fmt.Errorf("ReadString: %v, got: %v", strconv.Quote(s), err))
-	}
-	if n != len(buf) {
-		Panic(0, fmt.Errorf("ReadString: %v, got: %v", strconv.Quote(s), n))
-	}
-	if string(buf) != s {
-		Panic(0, fmt.Errorf(
-			"ReadString not match: %v, got: %v",
-			strconv.Quote(s),
-			strconv.Quote(string(buf)),
-		))
-	}
-}
-
-func WriteAt(w io.WriterAt, b []byte, at int64) {
-	n, err := w.WriteAt(b, at)
-	if err != nil {
-		Panic(0, err)
-	}
-	if n != len(b) {
-		Panic(0, "short write")
-	}
-}
-
-func Write(w io.Writer, b []byte) {
-	n, err := w.Write(b)
-	if err != nil {
-		Panic(0, err)
-	}
-	if n != len(b) {
-		Panic(0, "short write")
-	}
-}
-
-func WriteString(w io.Writer, s string) {
-	n, err := w.Write([]byte(s))
-	if err != nil {
-		Panic(0, err)
-	}
-	if n != len(s) {
-		Panic(0, "short write")
-	}
-}
-
-func Equals(o ...interface{}) {
-	if len(o)%2 != 0 {
-		Panic(0, "invalid Equals arguments")
-	}
-	for i := 0; i < len(o); i += 2 {
-		equal(1, o[i], o[i+1], nil)
-	}
-}
-
-func NotEqual(a, b interface{}, e ...error) {
-	notEqual(1, a, b, e)
-}
-
-func toInt(a interface{}) (int64, bool) {
-	switch n := a.(type) {
-	case int:
-		return int64(n), true
-	case int8:
-		return int64(n), true
-	case int16:
-		return int64(n), true
-	case int32:
-		return int64(n), true
-	case int64:
-		return int64(n), true
-	case uintptr:
-		return int64(n), true
-	default:
-		return -1, false
-	}
-}
-
-func MarkLine() {
-	r := strings.Repeat("-", 20)
-	println(r)
-}
-
-var globalMarkInfo string
-
-func Mark(obj ...interface{}) {
-	globalMarkInfo = fmt.Sprint(obj...)
-}
-
-func EqualBytes(got, want []byte) {
-	equalBytes(0, got, want)
-}
-
-func equalBytes(n int, got, want []byte) {
-	a := got
-	b := want
-	size := 16
-	if len(a) != len(b) {
-		Panic(n, fmt.Sprintf("equal bytes, %v != %v", len(a), len(b)))
-	}
-	if bytes.Equal(a, b) {
-		return
-	}
-
-	for off := 0; off < len(a); off += size {
-		end := off + size
-		if end > len(a) {
-			end = len(a)
-		}
-		if !bytes.Equal(a[off:end], b[off:end]) {
-			Panic(n, fmt.Sprintf(
-				"equal [%v]byte in [%v, %v]:\n\tgot: %v\n\twant: %v",
-				len(a),
-				off, off+size,
-				a[off:end], b[off:end],
-			))
-		}
-	}
-}
-
-func Equal(a, b interface{}, e ...error) {
-	if ai, ok := toInt(a); ok {
-		if bi, ok := toInt(b); ok {
-			equal(1, ai, bi, e)
-			return
-		}
-	}
-	equal(1, a, b, e)
-}
-
-func CheckError(e error, s string) {
-	if e == nil {
-		Panic(0, ErrNotExcept)
-	}
-	if !strings.Contains(e.Error(), s) {
-		Panic(0, fmt.Errorf(
-			"want: %s, got %s",
-			strconv.Quote(s),
-			strconv.Quote(e.Error()),
-		))
-	}
-}
-
-func formatMax(o interface{}, max int) string {
-	aStr := fmt.Sprint(o)
-	if len(aStr) > max {
-		aStr = aStr[:max] + " ..."
-	}
-	return aStr
-}
-
-func notEqual(d int, a, b interface{}, e []error) {
-	_, oka := a.(error)
-	_, okb := b.(error)
-	if oka && okb {
-		if logex.Equal(a.(error), b.(error)) {
-			Panic(d, fmt.Sprintf("%v: %v",
-				getErr(ErrRequireNotEqual, e),
-				a,
-			))
-		}
-		return
-	}
-	if reflect.DeepEqual(a, b) {
-		Panic(d, fmt.Sprintf("%v: (%v, %v)",
-			getErr(ErrRequireNotEqual, e),
-			formatMax(a, 100),
-			formatMax(b, 100),
-		))
-	}
-}
-
-func equal(d int, a, b interface{}, e []error) {
-	_, oka := a.(error)
-	_, okb := b.(error)
-	if oka && okb {
-		if !logex.Equal(a.(error), b.(error)) {
-			Panic(d, fmt.Sprintf("%v: (%v, %v)",
-				getErr(ErrNotEqual, e),
-				formatMax(a, 100), formatMax(b, 100),
-			))
-		}
-		return
-	}
-	if !reflect.DeepEqual(a, b) {
-		Panic(d, fmt.Sprintf("%v: (%+v, %+v)", getErr(ErrNotEqual, e), a, b))
-	}
-}
-
-func Should(b bool, e ...error) {
-	if !b {
-		Panic(0, getErr(ErrNotExcept, e))
-	}
-}
-
-func NotNil(obj interface{}) {
-	if obj == nil {
-		Panic(0, "should not nil")
-	}
-}
-
-func False(obj bool) {
-	if obj {
-		Panic(0, "should false")
-	}
-}
-
-func True(obj bool) {
-	if !obj {
-		Panic(0, "should true")
-	}
-}
-
-func Nil(obj interface{}) {
-	if obj != nil {
-		// double check, incase different type with nil value
-		if !reflect.ValueOf(obj).IsNil() {
-			str := fmt.Sprint(obj)
-			if err, ok := obj.(error); ok {
-				str = logex.DecodeError(err)
-			}
-			Panic(0, fmt.Sprintf("should nil: %v", str))
-		}
-	}
-}
-
-func Panic(depth int, obj interface{}) {
-	t := &testException{
-		depth: depth,
-	}
-	if err, ok := obj.(error); ok {
-		t.info = logex.DecodeError(err)
-	} else {
-		t.info = fmt.Sprint(obj)
-	}
-	if globalMarkInfo != "" {
-		t.info = "[info:" + globalMarkInfo + "] " + t.info
-	}
-	panic(t)
-}
-
-func CleanTmp() {
-	os.RemoveAll(root(2))
-}
-
-func TmpFile() (*os.File, error) {
-	dir := root(2)
-	if err := os.MkdirAll(dir, 0744); err != nil {
-		return nil, err
-	}
-	return ioutil.TempFile(dir, "")
-}
-
-func Root() string {
-	p := root(2)
-	os.RemoveAll(root(2))
-	return p
-}
-
-func root(n int) string {
-	pc, _, _, _ := runtime.Caller(n)
-	name := runtime.FuncForPC(pc).Name()
-	if idx := strings.LastIndex(name, "."); idx > 0 {
-		name = name[:idx] + "/" + name[idx+1:]
-	}
-
-	root := os.Getenv("TEST_ROOT")
-	if root == "" {
-		root = RootPath
-	}
-	return filepath.Join(root, name)
-}
-
-func RandBytes(n int) []byte {
-	buf := make([]byte, n)
-	rand.Read(buf)
-	return buf
-}
-
-func SeqBytes(n int) []byte {
-	buf := make([]byte, n)
-	for idx := range buf {
-		buf[idx] = byte(idx)
-	}
-	return buf
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/cobra/args_test.go b/cmd/viewcore/vendor/github.com/spf13/cobra/args_test.go
deleted file mode 100644
index d797b6f..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/cobra/args_test.go
+++ /dev/null
@@ -1,241 +0,0 @@
-package cobra
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestNoArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: NoArgs, Run: emptyRun}
-
-	output, err := executeCommand(c)
-	if output != "" {
-		t.Errorf("Unexpected string: %v", output)
-	}
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-}
-
-func TestNoArgsWithArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: NoArgs, Run: emptyRun}
-
-	_, err := executeCommand(c, "illegal")
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := `unknown command "illegal" for "c"`
-	if got != expected {
-		t.Errorf("Expected: %q, got: %q", expected, got)
-	}
-}
-
-func TestOnlyValidArgs(t *testing.T) {
-	c := &Command{
-		Use:       "c",
-		Args:      OnlyValidArgs,
-		ValidArgs: []string{"one", "two"},
-		Run:       emptyRun,
-	}
-
-	output, err := executeCommand(c, "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-}
-
-func TestOnlyValidArgsWithInvalidArgs(t *testing.T) {
-	c := &Command{
-		Use:       "c",
-		Args:      OnlyValidArgs,
-		ValidArgs: []string{"one", "two"},
-		Run:       emptyRun,
-	}
-
-	_, err := executeCommand(c, "three")
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := `invalid argument "three" for "c"`
-	if got != expected {
-		t.Errorf("Expected: %q, got: %q", expected, got)
-	}
-}
-
-func TestArbitraryArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: ArbitraryArgs, Run: emptyRun}
-	output, err := executeCommand(c, "a", "b")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-}
-
-func TestMinimumNArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: MinimumNArgs(2), Run: emptyRun}
-	output, err := executeCommand(c, "a", "b", "c")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-}
-
-func TestMinimumNArgsWithLessArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: MinimumNArgs(2), Run: emptyRun}
-	_, err := executeCommand(c, "a")
-
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := "requires at least 2 arg(s), only received 1"
-	if got != expected {
-		t.Fatalf("Expected %q, got %q", expected, got)
-	}
-}
-
-func TestMaximumNArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: MaximumNArgs(3), Run: emptyRun}
-	output, err := executeCommand(c, "a", "b")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-}
-
-func TestMaximumNArgsWithMoreArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: MaximumNArgs(2), Run: emptyRun}
-	_, err := executeCommand(c, "a", "b", "c")
-
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := "accepts at most 2 arg(s), received 3"
-	if got != expected {
-		t.Fatalf("Expected %q, got %q", expected, got)
-	}
-}
-
-func TestExactArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: ExactArgs(3), Run: emptyRun}
-	output, err := executeCommand(c, "a", "b", "c")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-}
-
-func TestExactArgsWithInvalidCount(t *testing.T) {
-	c := &Command{Use: "c", Args: ExactArgs(2), Run: emptyRun}
-	_, err := executeCommand(c, "a", "b", "c")
-
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := "accepts 2 arg(s), received 3"
-	if got != expected {
-		t.Fatalf("Expected %q, got %q", expected, got)
-	}
-}
-
-func TestRangeArgs(t *testing.T) {
-	c := &Command{Use: "c", Args: RangeArgs(2, 4), Run: emptyRun}
-	output, err := executeCommand(c, "a", "b", "c")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-}
-
-func TestRangeArgsWithInvalidCount(t *testing.T) {
-	c := &Command{Use: "c", Args: RangeArgs(2, 4), Run: emptyRun}
-	_, err := executeCommand(c, "a")
-
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := "accepts between 2 and 4 arg(s), received 1"
-	if got != expected {
-		t.Fatalf("Expected %q, got %q", expected, got)
-	}
-}
-
-func TestRootTakesNoArgs(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	_, err := executeCommand(rootCmd, "illegal", "args")
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := `unknown command "illegal" for "root"`
-	if !strings.Contains(got, expected) {
-		t.Errorf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestRootTakesArgs(t *testing.T) {
-	rootCmd := &Command{Use: "root", Args: ArbitraryArgs, Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	_, err := executeCommand(rootCmd, "legal", "args")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-}
-
-func TestChildTakesNoArgs(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Args: NoArgs, Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	_, err := executeCommand(rootCmd, "child", "illegal", "args")
-	if err == nil {
-		t.Fatal("Expected an error")
-	}
-
-	got := err.Error()
-	expected := `unknown command "illegal" for "root child"`
-	if !strings.Contains(got, expected) {
-		t.Errorf("expected %q, got %q", expected, got)
-	}
-}
-
-func TestChildTakesArgs(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Args: ArbitraryArgs, Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	_, err := executeCommand(rootCmd, "child", "legal", "args")
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/cobra/bash_completions.md b/cmd/viewcore/vendor/github.com/spf13/cobra/bash_completions.md
index e79d476..49d0680 100644
--- a/cmd/viewcore/vendor/github.com/spf13/cobra/bash_completions.md
+++ b/cmd/viewcore/vendor/github.com/spf13/cobra/bash_completions.md
@@ -1,5 +1,40 @@
 # Generating Bash Completions For Your Own cobra.Command
 
+If you are using the generator you can create a completion command by running
+
+```bash
+cobra add completion
+```
+
+Update the help text show how to install the bash_completion Linux show here [Kubectl docs show mac options](https://kubernetes.io/docs/tasks/tools/install-kubectl/#enabling-shell-autocompletion)
+
+Writing the shell script to stdout allows the most flexible use.
+
+```go
+// completionCmd represents the completion command
+var completionCmd = &cobra.Command{
+	Use:   "completion",
+	Short: "Generates bash completion scripts",
+	Long: `To load completion run
+
+. <(bitbucket completion)
+
+To configure your bash shell to load completions for each session add to your bashrc
+
+# ~/.bashrc or ~/.profile
+. <(bitbucket completion)
+`,
+	Run: func(cmd *cobra.Command, args []string) {
+		rootCmd.GenBashCompletion(os.Stdout);
+	},
+}
+```
+
+**Note:** The cobra generator may include messages printed to stdout for example if the config file is loaded, this will break the auto complete script
+
+
+## Example from kubectl
+
 Generating bash completions from a cobra command is incredibly easy. An actual program which does so for the kubernetes kubectl binary is as follows:
 
 ```go
diff --git a/cmd/viewcore/vendor/github.com/spf13/cobra/bash_completions_test.go b/cmd/viewcore/vendor/github.com/spf13/cobra/bash_completions_test.go
deleted file mode 100644
index 859f1ac..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/cobra/bash_completions_test.go
+++ /dev/null
@@ -1,217 +0,0 @@
-package cobra
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"os/exec"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-func checkOmit(t *testing.T, found, unexpected string) {
-	if strings.Contains(found, unexpected) {
-		t.Errorf("Got: %q\nBut should not have!\n", unexpected)
-	}
-}
-
-func check(t *testing.T, found, expected string) {
-	if !strings.Contains(found, expected) {
-		t.Errorf("Expecting to contain: \n %q\nGot:\n %q\n", expected, found)
-	}
-}
-
-func checkRegex(t *testing.T, found, pattern string) {
-	matched, err := regexp.MatchString(pattern, found)
-	if err != nil {
-		t.Errorf("Error thrown performing MatchString: \n %s\n", err)
-	}
-	if !matched {
-		t.Errorf("Expecting to match: \n %q\nGot:\n %q\n", pattern, found)
-	}
-}
-
-func runShellCheck(s string) error {
-	excluded := []string{
-		"SC2034", // PREFIX appears unused. Verify it or export it.
-	}
-	cmd := exec.Command("shellcheck", "-s", "bash", "-", "-e", strings.Join(excluded, ","))
-	cmd.Stderr = os.Stderr
-	cmd.Stdout = os.Stdout
-
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return err
-	}
-	go func() {
-		stdin.Write([]byte(s))
-		stdin.Close()
-	}()
-
-	return cmd.Run()
-}
-
-// World worst custom function, just keep telling you to enter hello!
-const bashCompletionFunc = `__custom_func() {
-	COMPREPLY=( "hello" )
-}
-`
-
-func TestBashCompletions(t *testing.T) {
-	rootCmd := &Command{
-		Use:                    "root",
-		ArgAliases:             []string{"pods", "nodes", "services", "replicationcontrollers", "po", "no", "svc", "rc"},
-		ValidArgs:              []string{"pod", "node", "service", "replicationcontroller"},
-		BashCompletionFunction: bashCompletionFunc,
-		Run:                    emptyRun,
-	}
-	rootCmd.Flags().IntP("introot", "i", -1, "help message for flag introot")
-	rootCmd.MarkFlagRequired("introot")
-
-	// Filename.
-	rootCmd.Flags().String("filename", "", "Enter a filename")
-	rootCmd.MarkFlagFilename("filename", "json", "yaml", "yml")
-
-	// Persistent filename.
-	rootCmd.PersistentFlags().String("persistent-filename", "", "Enter a filename")
-	rootCmd.MarkPersistentFlagFilename("persistent-filename")
-	rootCmd.MarkPersistentFlagRequired("persistent-filename")
-
-	// Filename extensions.
-	rootCmd.Flags().String("filename-ext", "", "Enter a filename (extension limited)")
-	rootCmd.MarkFlagFilename("filename-ext")
-	rootCmd.Flags().String("custom", "", "Enter a filename (extension limited)")
-	rootCmd.MarkFlagCustom("custom", "__complete_custom")
-
-	// Subdirectories in a given directory.
-	rootCmd.Flags().String("theme", "", "theme to use (located in /themes/THEMENAME/)")
-	rootCmd.Flags().SetAnnotation("theme", BashCompSubdirsInDir, []string{"themes"})
-
-	echoCmd := &Command{
-		Use:     "echo [string to echo]",
-		Aliases: []string{"say"},
-		Short:   "Echo anything to the screen",
-		Long:    "an utterly useless command for testing.",
-		Example: "Just run cobra-test echo",
-		Run:     emptyRun,
-	}
-
-	echoCmd.Flags().String("filename", "", "Enter a filename")
-	echoCmd.MarkFlagFilename("filename", "json", "yaml", "yml")
-	echoCmd.Flags().String("config", "", "config to use (located in /config/PROFILE/)")
-	echoCmd.Flags().SetAnnotation("config", BashCompSubdirsInDir, []string{"config"})
-
-	printCmd := &Command{
-		Use:   "print [string to print]",
-		Args:  MinimumNArgs(1),
-		Short: "Print anything to the screen",
-		Long:  "an absolutely utterly useless command for testing.",
-		Run:   emptyRun,
-	}
-
-	deprecatedCmd := &Command{
-		Use:        "deprecated [can't do anything here]",
-		Args:       NoArgs,
-		Short:      "A command which is deprecated",
-		Long:       "an absolutely utterly useless command for testing deprecation!.",
-		Deprecated: "Please use echo instead",
-		Run:        emptyRun,
-	}
-
-	colonCmd := &Command{
-		Use: "cmd:colon",
-		Run: emptyRun,
-	}
-
-	timesCmd := &Command{
-		Use:        "times [# times] [string to echo]",
-		SuggestFor: []string{"counts"},
-		Args:       OnlyValidArgs,
-		ValidArgs:  []string{"one", "two", "three", "four"},
-		Short:      "Echo anything to the screen more times",
-		Long:       "a slightly useless command for testing.",
-		Run:        emptyRun,
-	}
-
-	echoCmd.AddCommand(timesCmd)
-	rootCmd.AddCommand(echoCmd, printCmd, deprecatedCmd, colonCmd)
-
-	buf := new(bytes.Buffer)
-	rootCmd.GenBashCompletion(buf)
-	output := buf.String()
-
-	check(t, output, "_root")
-	check(t, output, "_root_echo")
-	check(t, output, "_root_echo_times")
-	check(t, output, "_root_print")
-	check(t, output, "_root_cmd__colon")
-
-	// check for required flags
-	check(t, output, `must_have_one_flag+=("--introot=")`)
-	check(t, output, `must_have_one_flag+=("--persistent-filename=")`)
-	// check for custom completion function
-	check(t, output, `COMPREPLY=( "hello" )`)
-	// check for required nouns
-	check(t, output, `must_have_one_noun+=("pod")`)
-	// check for noun aliases
-	check(t, output, `noun_aliases+=("pods")`)
-	check(t, output, `noun_aliases+=("rc")`)
-	checkOmit(t, output, `must_have_one_noun+=("pods")`)
-	// check for filename extension flags
-	check(t, output, `flags_completion+=("_filedir")`)
-	// check for filename extension flags
-	check(t, output, `must_have_one_noun+=("three")`)
-	// check for filename extension flags
-	check(t, output, fmt.Sprintf(`flags_completion+=("__%s_handle_filename_extension_flag json|yaml|yml")`, rootCmd.Name()))
-	// check for filename extension flags in a subcommand
-	checkRegex(t, output, fmt.Sprintf(`_root_echo\(\)\n{[^}]*flags_completion\+=\("__%s_handle_filename_extension_flag json\|yaml\|yml"\)`, rootCmd.Name()))
-	// check for custom flags
-	check(t, output, `flags_completion+=("__complete_custom")`)
-	// check for subdirs_in_dir flags
-	check(t, output, fmt.Sprintf(`flags_completion+=("__%s_handle_subdirs_in_dir_flag themes")`, rootCmd.Name()))
-	// check for subdirs_in_dir flags in a subcommand
-	checkRegex(t, output, fmt.Sprintf(`_root_echo\(\)\n{[^}]*flags_completion\+=\("__%s_handle_subdirs_in_dir_flag config"\)`, rootCmd.Name()))
-
-	checkOmit(t, output, deprecatedCmd.Name())
-
-	// If available, run shellcheck against the script.
-	if err := exec.Command("which", "shellcheck").Run(); err != nil {
-		return
-	}
-	if err := runShellCheck(output); err != nil {
-		t.Fatalf("shellcheck failed: %v", err)
-	}
-}
-
-func TestBashCompletionHiddenFlag(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-
-	const flagName = "hiddenFlag"
-	c.Flags().Bool(flagName, false, "")
-	c.Flags().MarkHidden(flagName)
-
-	buf := new(bytes.Buffer)
-	c.GenBashCompletion(buf)
-	output := buf.String()
-
-	if strings.Contains(output, flagName) {
-		t.Errorf("Expected completion to not include %q flag: Got %v", flagName, output)
-	}
-}
-
-func TestBashCompletionDeprecatedFlag(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-
-	const flagName = "deprecated-flag"
-	c.Flags().Bool(flagName, false, "")
-	c.Flags().MarkDeprecated(flagName, "use --not-deprecated instead")
-
-	buf := new(bytes.Buffer)
-	c.GenBashCompletion(buf)
-	output := buf.String()
-
-	if strings.Contains(output, flagName) {
-		t.Errorf("expected completion to not include %q flag: Got %v", flagName, output)
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/cobra/cobra_test.go b/cmd/viewcore/vendor/github.com/spf13/cobra/cobra_test.go
deleted file mode 100644
index 0d1755b..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/cobra/cobra_test.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package cobra
-
-import (
-	"testing"
-	"text/template"
-)
-
-func TestAddTemplateFunctions(t *testing.T) {
-	AddTemplateFunc("t", func() bool { return true })
-	AddTemplateFuncs(template.FuncMap{
-		"f": func() bool { return false },
-		"h": func() string { return "Hello," },
-		"w": func() string { return "world." }})
-
-	c := &Command{}
-	c.SetUsageTemplate(`{{if t}}{{h}}{{end}}{{if f}}{{h}}{{end}} {{w}}`)
-
-	const expected = "Hello, world."
-	if got := c.UsageString(); got != expected {
-		t.Errorf("Expected UsageString: %v\nGot: %v", expected, got)
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/cobra/command_test.go b/cmd/viewcore/vendor/github.com/spf13/cobra/command_test.go
deleted file mode 100644
index ccee031..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/cobra/command_test.go
+++ /dev/null
@@ -1,1733 +0,0 @@
-package cobra
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/spf13/pflag"
-)
-
-func emptyRun(*Command, []string) {}
-
-func executeCommand(root *Command, args ...string) (output string, err error) {
-	_, output, err = executeCommandC(root, args...)
-	return output, err
-}
-
-func executeCommandC(root *Command, args ...string) (c *Command, output string, err error) {
-	buf := new(bytes.Buffer)
-	root.SetOutput(buf)
-	root.SetArgs(args)
-
-	c, err = root.ExecuteC()
-
-	return c, buf.String(), err
-}
-
-func resetCommandLineFlagSet() {
-	pflag.CommandLine = pflag.NewFlagSet(os.Args[0], pflag.ExitOnError)
-}
-
-func checkStringContains(t *testing.T, got, expected string) {
-	if !strings.Contains(got, expected) {
-		t.Errorf("Expected to contain: \n %v\nGot:\n %v\n", expected, got)
-	}
-}
-
-func checkStringOmits(t *testing.T, got, expected string) {
-	if strings.Contains(got, expected) {
-		t.Errorf("Expected to not contain: \n %v\nGot: %v", expected, got)
-	}
-}
-
-func TestSingleCommand(t *testing.T) {
-	var rootCmdArgs []string
-	rootCmd := &Command{
-		Use:  "root",
-		Args: ExactArgs(2),
-		Run:  func(_ *Command, args []string) { rootCmdArgs = args },
-	}
-	aCmd := &Command{Use: "a", Args: NoArgs, Run: emptyRun}
-	bCmd := &Command{Use: "b", Args: NoArgs, Run: emptyRun}
-	rootCmd.AddCommand(aCmd, bCmd)
-
-	output, err := executeCommand(rootCmd, "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(rootCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("rootCmdArgs expected: %q, got: %q", expected, got)
-	}
-}
-
-func TestChildCommand(t *testing.T) {
-	var child1CmdArgs []string
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-	child1Cmd := &Command{
-		Use:  "child1",
-		Args: ExactArgs(2),
-		Run:  func(_ *Command, args []string) { child1CmdArgs = args },
-	}
-	child2Cmd := &Command{Use: "child2", Args: NoArgs, Run: emptyRun}
-	rootCmd.AddCommand(child1Cmd, child2Cmd)
-
-	output, err := executeCommand(rootCmd, "child1", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(child1CmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("child1CmdArgs expected: %q, got: %q", expected, got)
-	}
-}
-
-func TestCallCommandWithoutSubcommands(t *testing.T) {
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-	_, err := executeCommand(rootCmd)
-	if err != nil {
-		t.Errorf("Calling command without subcommands should not have error: %v", err)
-	}
-}
-
-func TestRootExecuteUnknownCommand(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	rootCmd.AddCommand(&Command{Use: "child", Run: emptyRun})
-
-	output, _ := executeCommand(rootCmd, "unknown")
-
-	expected := "Error: unknown command \"unknown\" for \"root\"\nRun 'root --help' for usage.\n"
-
-	if output != expected {
-		t.Errorf("Expected:\n %q\nGot:\n %q\n", expected, output)
-	}
-}
-
-func TestSubcommandExecuteC(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	c, output, err := executeCommandC(rootCmd, "child")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if c.Name() != "child" {
-		t.Errorf(`invalid command returned from ExecuteC: expected "child"', got %q`, c.Name())
-	}
-}
-
-func TestRootUnknownCommandSilenced(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	rootCmd.SilenceErrors = true
-	rootCmd.SilenceUsage = true
-	rootCmd.AddCommand(&Command{Use: "child", Run: emptyRun})
-
-	output, _ := executeCommand(rootCmd, "unknown")
-	if output != "" {
-		t.Errorf("Expected blank output, because of silenced usage.\nGot:\n %q\n", output)
-	}
-}
-
-func TestCommandAlias(t *testing.T) {
-	var timesCmdArgs []string
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-	echoCmd := &Command{
-		Use:     "echo",
-		Aliases: []string{"say", "tell"},
-		Args:    NoArgs,
-		Run:     emptyRun,
-	}
-	timesCmd := &Command{
-		Use:  "times",
-		Args: ExactArgs(2),
-		Run:  func(_ *Command, args []string) { timesCmdArgs = args },
-	}
-	echoCmd.AddCommand(timesCmd)
-	rootCmd.AddCommand(echoCmd)
-
-	output, err := executeCommand(rootCmd, "tell", "times", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(timesCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("timesCmdArgs expected: %v, got: %v", expected, got)
-	}
-}
-
-func TestEnablePrefixMatching(t *testing.T) {
-	EnablePrefixMatching = true
-
-	var aCmdArgs []string
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-	aCmd := &Command{
-		Use:  "aCmd",
-		Args: ExactArgs(2),
-		Run:  func(_ *Command, args []string) { aCmdArgs = args },
-	}
-	bCmd := &Command{Use: "bCmd", Args: NoArgs, Run: emptyRun}
-	rootCmd.AddCommand(aCmd, bCmd)
-
-	output, err := executeCommand(rootCmd, "a", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(aCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("aCmdArgs expected: %q, got: %q", expected, got)
-	}
-
-	EnablePrefixMatching = false
-}
-
-func TestAliasPrefixMatching(t *testing.T) {
-	EnablePrefixMatching = true
-
-	var timesCmdArgs []string
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-	echoCmd := &Command{
-		Use:     "echo",
-		Aliases: []string{"say", "tell"},
-		Args:    NoArgs,
-		Run:     emptyRun,
-	}
-	timesCmd := &Command{
-		Use:  "times",
-		Args: ExactArgs(2),
-		Run:  func(_ *Command, args []string) { timesCmdArgs = args },
-	}
-	echoCmd.AddCommand(timesCmd)
-	rootCmd.AddCommand(echoCmd)
-
-	output, err := executeCommand(rootCmd, "sa", "times", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(timesCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("timesCmdArgs expected: %v, got: %v", expected, got)
-	}
-
-	EnablePrefixMatching = false
-}
-
-// TestChildSameName checks the correct behaviour of cobra in cases,
-// when an application with name "foo" and with subcommand "foo"
-// is executed with args "foo foo".
-func TestChildSameName(t *testing.T) {
-	var fooCmdArgs []string
-	rootCmd := &Command{Use: "foo", Args: NoArgs, Run: emptyRun}
-	fooCmd := &Command{
-		Use:  "foo",
-		Args: ExactArgs(2),
-		Run:  func(_ *Command, args []string) { fooCmdArgs = args },
-	}
-	barCmd := &Command{Use: "bar", Args: NoArgs, Run: emptyRun}
-	rootCmd.AddCommand(fooCmd, barCmd)
-
-	output, err := executeCommand(rootCmd, "foo", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(fooCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("fooCmdArgs expected: %v, got: %v", expected, got)
-	}
-}
-
-// TestGrandChildSameName checks the correct behaviour of cobra in cases,
-// when user has a root command and a grand child
-// with the same name.
-func TestGrandChildSameName(t *testing.T) {
-	var fooCmdArgs []string
-	rootCmd := &Command{Use: "foo", Args: NoArgs, Run: emptyRun}
-	barCmd := &Command{Use: "bar", Args: NoArgs, Run: emptyRun}
-	fooCmd := &Command{
-		Use:  "foo",
-		Args: ExactArgs(2),
-		Run:  func(_ *Command, args []string) { fooCmdArgs = args },
-	}
-	barCmd.AddCommand(fooCmd)
-	rootCmd.AddCommand(barCmd)
-
-	output, err := executeCommand(rootCmd, "bar", "foo", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(fooCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("fooCmdArgs expected: %v, got: %v", expected, got)
-	}
-}
-
-func TestFlagLong(t *testing.T) {
-	var cArgs []string
-	c := &Command{
-		Use:  "c",
-		Args: ArbitraryArgs,
-		Run:  func(_ *Command, args []string) { cArgs = args },
-	}
-
-	var intFlagValue int
-	var stringFlagValue string
-	c.Flags().IntVar(&intFlagValue, "intf", -1, "")
-	c.Flags().StringVar(&stringFlagValue, "sf", "", "")
-
-	output, err := executeCommand(c, "--intf=7", "--sf=abc", "one", "--", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", err)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if c.ArgsLenAtDash() != 1 {
-		t.Errorf("Expected ArgsLenAtDash: %v but got %v", 1, c.ArgsLenAtDash())
-	}
-	if intFlagValue != 7 {
-		t.Errorf("Expected intFlagValue: %v, got %v", 7, intFlagValue)
-	}
-	if stringFlagValue != "abc" {
-		t.Errorf("Expected stringFlagValue: %q, got %q", "abc", stringFlagValue)
-	}
-
-	got := strings.Join(cArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("Expected arguments: %q, got %q", expected, got)
-	}
-}
-
-func TestFlagShort(t *testing.T) {
-	var cArgs []string
-	c := &Command{
-		Use:  "c",
-		Args: ArbitraryArgs,
-		Run:  func(_ *Command, args []string) { cArgs = args },
-	}
-
-	var intFlagValue int
-	var stringFlagValue string
-	c.Flags().IntVarP(&intFlagValue, "intf", "i", -1, "")
-	c.Flags().StringVarP(&stringFlagValue, "sf", "s", "", "")
-
-	output, err := executeCommand(c, "-i", "7", "-sabc", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", err)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if intFlagValue != 7 {
-		t.Errorf("Expected flag value: %v, got %v", 7, intFlagValue)
-	}
-	if stringFlagValue != "abc" {
-		t.Errorf("Expected stringFlagValue: %q, got %q", "abc", stringFlagValue)
-	}
-
-	got := strings.Join(cArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("Expected arguments: %q, got %q", expected, got)
-	}
-}
-
-func TestChildFlag(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	var intFlagValue int
-	childCmd.Flags().IntVarP(&intFlagValue, "intf", "i", -1, "")
-
-	output, err := executeCommand(rootCmd, "child", "-i7")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", err)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if intFlagValue != 7 {
-		t.Errorf("Expected flag value: %v, got %v", 7, intFlagValue)
-	}
-}
-
-func TestChildFlagWithParentLocalFlag(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	var intFlagValue int
-	rootCmd.Flags().StringP("sf", "s", "", "")
-	childCmd.Flags().IntVarP(&intFlagValue, "intf", "i", -1, "")
-
-	_, err := executeCommand(rootCmd, "child", "-i7", "-sabc")
-	if err == nil {
-		t.Errorf("Invalid flag should generate error")
-	}
-
-	checkStringContains(t, err.Error(), "unknown shorthand")
-
-	if intFlagValue != 7 {
-		t.Errorf("Expected flag value: %v, got %v", 7, intFlagValue)
-	}
-}
-
-func TestFlagInvalidInput(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	rootCmd.Flags().IntP("intf", "i", -1, "")
-
-	_, err := executeCommand(rootCmd, "-iabc")
-	if err == nil {
-		t.Errorf("Invalid flag value should generate error")
-	}
-
-	checkStringContains(t, err.Error(), "invalid syntax")
-}
-
-func TestFlagBeforeCommand(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	var flagValue int
-	childCmd.Flags().IntVarP(&flagValue, "intf", "i", -1, "")
-
-	// With short flag.
-	_, err := executeCommand(rootCmd, "-i7", "child")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if flagValue != 7 {
-		t.Errorf("Expected flag value: %v, got %v", 7, flagValue)
-	}
-
-	// With long flag.
-	_, err = executeCommand(rootCmd, "--intf=8", "child")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if flagValue != 8 {
-		t.Errorf("Expected flag value: %v, got %v", 9, flagValue)
-	}
-}
-
-func TestStripFlags(t *testing.T) {
-	tests := []struct {
-		input  []string
-		output []string
-	}{
-		{
-			[]string{"foo", "bar"},
-			[]string{"foo", "bar"},
-		},
-		{
-			[]string{"foo", "--str", "-s"},
-			[]string{"foo"},
-		},
-		{
-			[]string{"-s", "foo", "--str", "bar"},
-			[]string{},
-		},
-		{
-			[]string{"-i10", "echo"},
-			[]string{"echo"},
-		},
-		{
-			[]string{"-i=10", "echo"},
-			[]string{"echo"},
-		},
-		{
-			[]string{"--int=100", "echo"},
-			[]string{"echo"},
-		},
-		{
-			[]string{"-ib", "echo", "-sfoo", "baz"},
-			[]string{"echo", "baz"},
-		},
-		{
-			[]string{"-i=baz", "bar", "-i", "foo", "blah"},
-			[]string{"bar", "blah"},
-		},
-		{
-			[]string{"--int=baz", "-sbar", "-i", "foo", "blah"},
-			[]string{"blah"},
-		},
-		{
-			[]string{"--bool", "bar", "-i", "foo", "blah"},
-			[]string{"bar", "blah"},
-		},
-		{
-			[]string{"-b", "bar", "-i", "foo", "blah"},
-			[]string{"bar", "blah"},
-		},
-		{
-			[]string{"--persist", "bar"},
-			[]string{"bar"},
-		},
-		{
-			[]string{"-p", "bar"},
-			[]string{"bar"},
-		},
-	}
-
-	c := &Command{Use: "c", Run: emptyRun}
-	c.PersistentFlags().BoolP("persist", "p", false, "")
-	c.Flags().IntP("int", "i", -1, "")
-	c.Flags().StringP("str", "s", "", "")
-	c.Flags().BoolP("bool", "b", false, "")
-
-	for i, test := range tests {
-		got := stripFlags(test.input, c)
-		if !reflect.DeepEqual(test.output, got) {
-			t.Errorf("(%v) Expected: %v, got: %v", i, test.output, got)
-		}
-	}
-}
-
-func TestDisableFlagParsing(t *testing.T) {
-	var cArgs []string
-	c := &Command{
-		Use:                "c",
-		DisableFlagParsing: true,
-		Run: func(_ *Command, args []string) {
-			cArgs = args
-		},
-	}
-
-	args := []string{"cmd", "-v", "-race", "-file", "foo.go"}
-	output, err := executeCommand(c, args...)
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if !reflect.DeepEqual(args, cArgs) {
-		t.Errorf("Expected: %v, got: %v", args, cArgs)
-	}
-}
-
-func TestPersistentFlagsOnSameCommand(t *testing.T) {
-	var rootCmdArgs []string
-	rootCmd := &Command{
-		Use:  "root",
-		Args: ArbitraryArgs,
-		Run:  func(_ *Command, args []string) { rootCmdArgs = args },
-	}
-
-	var flagValue int
-	rootCmd.PersistentFlags().IntVarP(&flagValue, "intf", "i", -1, "")
-
-	output, err := executeCommand(rootCmd, "-i7", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(rootCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("rootCmdArgs expected: %q, got %q", expected, got)
-	}
-	if flagValue != 7 {
-		t.Errorf("flagValue expected: %v, got %v", 7, flagValue)
-	}
-}
-
-// TestEmptyInputs checks,
-// if flags correctly parsed with blank strings in args.
-func TestEmptyInputs(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-
-	var flagValue int
-	c.Flags().IntVarP(&flagValue, "intf", "i", -1, "")
-
-	output, err := executeCommand(c, "", "-i7", "")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if flagValue != 7 {
-		t.Errorf("flagValue expected: %v, got %v", 7, flagValue)
-	}
-}
-
-func TestOverwrittenFlag(t *testing.T) {
-	// TODO: This test fails, but should work.
-	t.Skip()
-
-	parent := &Command{Use: "parent", Run: emptyRun}
-	child := &Command{Use: "child", Run: emptyRun}
-
-	parent.PersistentFlags().Bool("boolf", false, "")
-	parent.PersistentFlags().Int("intf", -1, "")
-	child.Flags().String("strf", "", "")
-	child.Flags().Int("intf", -1, "")
-
-	parent.AddCommand(child)
-
-	childInherited := child.InheritedFlags()
-	childLocal := child.LocalFlags()
-
-	if childLocal.Lookup("strf") == nil {
-		t.Error(`LocalFlags expected to contain "strf", got "nil"`)
-	}
-	if childInherited.Lookup("boolf") == nil {
-		t.Error(`InheritedFlags expected to contain "boolf", got "nil"`)
-	}
-
-	if childInherited.Lookup("intf") != nil {
-		t.Errorf(`InheritedFlags should not contain overwritten flag "intf"`)
-	}
-	if childLocal.Lookup("intf") == nil {
-		t.Error(`LocalFlags expected to contain "intf", got "nil"`)
-	}
-}
-
-func TestPersistentFlagsOnChild(t *testing.T) {
-	var childCmdArgs []string
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{
-		Use:  "child",
-		Args: ArbitraryArgs,
-		Run:  func(_ *Command, args []string) { childCmdArgs = args },
-	}
-	rootCmd.AddCommand(childCmd)
-
-	var parentFlagValue int
-	var childFlagValue int
-	rootCmd.PersistentFlags().IntVarP(&parentFlagValue, "parentf", "p", -1, "")
-	childCmd.Flags().IntVarP(&childFlagValue, "childf", "c", -1, "")
-
-	output, err := executeCommand(rootCmd, "child", "-c7", "-p8", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	got := strings.Join(childCmdArgs, " ")
-	expected := "one two"
-	if got != expected {
-		t.Errorf("childCmdArgs expected: %q, got %q", expected, got)
-	}
-	if parentFlagValue != 8 {
-		t.Errorf("parentFlagValue expected: %v, got %v", 8, parentFlagValue)
-	}
-	if childFlagValue != 7 {
-		t.Errorf("childFlagValue expected: %v, got %v", 7, childFlagValue)
-	}
-}
-
-func TestRequiredFlags(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-	c.Flags().String("foo1", "", "")
-	c.MarkFlagRequired("foo1")
-	c.Flags().String("foo2", "", "")
-	c.MarkFlagRequired("foo2")
-	c.Flags().String("bar", "", "")
-
-	expected := fmt.Sprintf("required flag(s) %q, %q not set", "foo1", "foo2")
-
-	_, err := executeCommand(c)
-	got := err.Error()
-
-	if got != expected {
-		t.Errorf("Expected error: %q, got: %q", expected, got)
-	}
-}
-
-func TestPersistentRequiredFlags(t *testing.T) {
-	parent := &Command{Use: "parent", Run: emptyRun}
-	parent.PersistentFlags().String("foo1", "", "")
-	parent.MarkPersistentFlagRequired("foo1")
-	parent.PersistentFlags().String("foo2", "", "")
-	parent.MarkPersistentFlagRequired("foo2")
-	parent.Flags().String("foo3", "", "")
-
-	child := &Command{Use: "child", Run: emptyRun}
-	child.Flags().String("bar1", "", "")
-	child.MarkFlagRequired("bar1")
-	child.Flags().String("bar2", "", "")
-	child.MarkFlagRequired("bar2")
-	child.Flags().String("bar3", "", "")
-
-	parent.AddCommand(child)
-
-	expected := fmt.Sprintf("required flag(s) %q, %q, %q, %q not set", "bar1", "bar2", "foo1", "foo2")
-
-	_, err := executeCommand(parent, "child")
-	if err.Error() != expected {
-		t.Errorf("Expected %q, got %q", expected, err.Error())
-	}
-}
-
-func TestInitHelpFlagMergesFlags(t *testing.T) {
-	usage := "custom flag"
-	rootCmd := &Command{Use: "root"}
-	rootCmd.PersistentFlags().Bool("help", false, "custom flag")
-	childCmd := &Command{Use: "child"}
-	rootCmd.AddCommand(childCmd)
-
-	childCmd.InitDefaultHelpFlag()
-	got := childCmd.Flags().Lookup("help").Usage
-	if got != usage {
-		t.Errorf("Expected the help flag from the root command with usage: %v\nGot the default with usage: %v", usage, got)
-	}
-}
-
-func TestHelpCommandExecuted(t *testing.T) {
-	rootCmd := &Command{Use: "root", Long: "Long description", Run: emptyRun}
-	rootCmd.AddCommand(&Command{Use: "child", Run: emptyRun})
-
-	output, err := executeCommand(rootCmd, "help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, rootCmd.Long)
-}
-
-func TestHelpCommandExecutedOnChild(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Long: "Long description", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	output, err := executeCommand(rootCmd, "help", "child")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, childCmd.Long)
-}
-
-func TestSetHelpCommand(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-	c.AddCommand(&Command{Use: "empty", Run: emptyRun})
-
-	expected := "WORKS"
-	c.SetHelpCommand(&Command{
-		Use:   "help [command]",
-		Short: "Help about any command",
-		Long: `Help provides help for any command in the application.
-	Simply type ` + c.Name() + ` help [path to command] for full details.`,
-		Run: func(c *Command, _ []string) { c.Print(expected) },
-	})
-
-	got, err := executeCommand(c, "help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if got != expected {
-		t.Errorf("Expected to contain %q, got %q", expected, got)
-	}
-}
-
-func TestHelpFlagExecuted(t *testing.T) {
-	rootCmd := &Command{Use: "root", Long: "Long description", Run: emptyRun}
-
-	output, err := executeCommand(rootCmd, "--help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, rootCmd.Long)
-}
-
-func TestHelpFlagExecutedOnChild(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Long: "Long description", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	output, err := executeCommand(rootCmd, "child", "--help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, childCmd.Long)
-}
-
-// TestHelpFlagInHelp checks,
-// if '--help' flag is shown in help for child (executing `parent help child`),
-// that has no other flags.
-// Related to https://github.com/spf13/cobra/issues/302.
-func TestHelpFlagInHelp(t *testing.T) {
-	parentCmd := &Command{Use: "parent", Run: func(*Command, []string) {}}
-
-	childCmd := &Command{Use: "child", Run: func(*Command, []string) {}}
-	parentCmd.AddCommand(childCmd)
-
-	output, err := executeCommand(parentCmd, "help", "child")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, "[flags]")
-}
-
-func TestFlagsInUsage(t *testing.T) {
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: func(*Command, []string) {}}
-	output, err := executeCommand(rootCmd, "--help")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, "[flags]")
-}
-
-func TestHelpExecutedOnNonRunnableChild(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Long: "Long description"}
-	rootCmd.AddCommand(childCmd)
-
-	output, err := executeCommand(rootCmd, "child")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, childCmd.Long)
-}
-
-func TestVersionFlagExecuted(t *testing.T) {
-	rootCmd := &Command{Use: "root", Version: "1.0.0", Run: emptyRun}
-
-	output, err := executeCommand(rootCmd, "--version", "arg1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, "root version 1.0.0")
-}
-
-func TestVersionTemplate(t *testing.T) {
-	rootCmd := &Command{Use: "root", Version: "1.0.0", Run: emptyRun}
-	rootCmd.SetVersionTemplate(`customized version: {{.Version}}`)
-
-	output, err := executeCommand(rootCmd, "--version", "arg1")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, "customized version: 1.0.0")
-}
-
-func TestVersionFlagExecutedOnSubcommand(t *testing.T) {
-	rootCmd := &Command{Use: "root", Version: "1.0.0"}
-	rootCmd.AddCommand(&Command{Use: "sub", Run: emptyRun})
-
-	output, err := executeCommand(rootCmd, "--version", "sub")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, "root version 1.0.0")
-}
-
-func TestVersionFlagOnlyAddedToRoot(t *testing.T) {
-	rootCmd := &Command{Use: "root", Version: "1.0.0", Run: emptyRun}
-	rootCmd.AddCommand(&Command{Use: "sub", Run: emptyRun})
-
-	_, err := executeCommand(rootCmd, "sub", "--version")
-	if err == nil {
-		t.Errorf("Expected error")
-	}
-
-	checkStringContains(t, err.Error(), "unknown flag: --version")
-}
-
-func TestVersionFlagOnlyExistsIfVersionNonEmpty(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-
-	_, err := executeCommand(rootCmd, "--version")
-	if err == nil {
-		t.Errorf("Expected error")
-	}
-	checkStringContains(t, err.Error(), "unknown flag: --version")
-}
-
-func TestUsageIsNotPrintedTwice(t *testing.T) {
-	var cmd = &Command{Use: "root"}
-	var sub = &Command{Use: "sub"}
-	cmd.AddCommand(sub)
-
-	output, _ := executeCommand(cmd, "")
-	if strings.Count(output, "Usage:") != 1 {
-		t.Error("Usage output is not printed exactly once")
-	}
-}
-
-func TestVisitParents(t *testing.T) {
-	c := &Command{Use: "app"}
-	sub := &Command{Use: "sub"}
-	dsub := &Command{Use: "dsub"}
-	sub.AddCommand(dsub)
-	c.AddCommand(sub)
-
-	total := 0
-	add := func(x *Command) {
-		total++
-	}
-	sub.VisitParents(add)
-	if total != 1 {
-		t.Errorf("Should have visited 1 parent but visited %d", total)
-	}
-
-	total = 0
-	dsub.VisitParents(add)
-	if total != 2 {
-		t.Errorf("Should have visited 2 parents but visited %d", total)
-	}
-
-	total = 0
-	c.VisitParents(add)
-	if total != 0 {
-		t.Errorf("Should have visited no parents but visited %d", total)
-	}
-}
-
-func TestSuggestions(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	timesCmd := &Command{
-		Use:        "times",
-		SuggestFor: []string{"counts"},
-		Run:        emptyRun,
-	}
-	rootCmd.AddCommand(timesCmd)
-
-	templateWithSuggestions := "Error: unknown command \"%s\" for \"root\"\n\nDid you mean this?\n\t%s\n\nRun 'root --help' for usage.\n"
-	templateWithoutSuggestions := "Error: unknown command \"%s\" for \"root\"\nRun 'root --help' for usage.\n"
-
-	tests := map[string]string{
-		"time":     "times",
-		"tiems":    "times",
-		"tims":     "times",
-		"timeS":    "times",
-		"rimes":    "times",
-		"ti":       "times",
-		"t":        "times",
-		"timely":   "times",
-		"ri":       "",
-		"timezone": "",
-		"foo":      "",
-		"counts":   "times",
-	}
-
-	for typo, suggestion := range tests {
-		for _, suggestionsDisabled := range []bool{true, false} {
-			rootCmd.DisableSuggestions = suggestionsDisabled
-
-			var expected string
-			output, _ := executeCommand(rootCmd, typo)
-
-			if suggestion == "" || suggestionsDisabled {
-				expected = fmt.Sprintf(templateWithoutSuggestions, typo)
-			} else {
-				expected = fmt.Sprintf(templateWithSuggestions, typo, suggestion)
-			}
-
-			if output != expected {
-				t.Errorf("Unexpected response.\nExpected:\n %q\nGot:\n %q\n", expected, output)
-			}
-		}
-	}
-}
-
-func TestRemoveCommand(t *testing.T) {
-	rootCmd := &Command{Use: "root", Args: NoArgs, Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-	rootCmd.RemoveCommand(childCmd)
-
-	_, err := executeCommand(rootCmd, "child")
-	if err == nil {
-		t.Error("Expected error on calling removed command. Got nil.")
-	}
-}
-
-func TestReplaceCommandWithRemove(t *testing.T) {
-	childUsed := 0
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	child1Cmd := &Command{
-		Use: "child",
-		Run: func(*Command, []string) { childUsed = 1 },
-	}
-	child2Cmd := &Command{
-		Use: "child",
-		Run: func(*Command, []string) { childUsed = 2 },
-	}
-	rootCmd.AddCommand(child1Cmd)
-	rootCmd.RemoveCommand(child1Cmd)
-	rootCmd.AddCommand(child2Cmd)
-
-	output, err := executeCommand(rootCmd, "child")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if childUsed == 1 {
-		t.Error("Removed command shouldn't be called")
-	}
-	if childUsed != 2 {
-		t.Error("Replacing command should have been called but didn't")
-	}
-}
-
-func TestDeprecatedCommand(t *testing.T) {
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	deprecatedCmd := &Command{
-		Use:        "deprecated",
-		Deprecated: "This command is deprecated",
-		Run:        emptyRun,
-	}
-	rootCmd.AddCommand(deprecatedCmd)
-
-	output, err := executeCommand(rootCmd, "deprecated")
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	checkStringContains(t, output, deprecatedCmd.Deprecated)
-}
-
-func TestHooks(t *testing.T) {
-	var (
-		persPreArgs  string
-		preArgs      string
-		runArgs      string
-		postArgs     string
-		persPostArgs string
-	)
-
-	c := &Command{
-		Use: "c",
-		PersistentPreRun: func(_ *Command, args []string) {
-			persPreArgs = strings.Join(args, " ")
-		},
-		PreRun: func(_ *Command, args []string) {
-			preArgs = strings.Join(args, " ")
-		},
-		Run: func(_ *Command, args []string) {
-			runArgs = strings.Join(args, " ")
-		},
-		PostRun: func(_ *Command, args []string) {
-			postArgs = strings.Join(args, " ")
-		},
-		PersistentPostRun: func(_ *Command, args []string) {
-			persPostArgs = strings.Join(args, " ")
-		},
-	}
-
-	output, err := executeCommand(c, "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if persPreArgs != "one two" {
-		t.Errorf("Expected persPreArgs %q, got %q", "one two", persPreArgs)
-	}
-	if preArgs != "one two" {
-		t.Errorf("Expected preArgs %q, got %q", "one two", preArgs)
-	}
-	if runArgs != "one two" {
-		t.Errorf("Expected runArgs %q, got %q", "one two", runArgs)
-	}
-	if postArgs != "one two" {
-		t.Errorf("Expected postArgs %q, got %q", "one two", postArgs)
-	}
-	if persPostArgs != "one two" {
-		t.Errorf("Expected persPostArgs %q, got %q", "one two", persPostArgs)
-	}
-}
-
-func TestPersistentHooks(t *testing.T) {
-	var (
-		parentPersPreArgs  string
-		parentPreArgs      string
-		parentRunArgs      string
-		parentPostArgs     string
-		parentPersPostArgs string
-	)
-
-	var (
-		childPersPreArgs  string
-		childPreArgs      string
-		childRunArgs      string
-		childPostArgs     string
-		childPersPostArgs string
-	)
-
-	parentCmd := &Command{
-		Use: "parent",
-		PersistentPreRun: func(_ *Command, args []string) {
-			parentPersPreArgs = strings.Join(args, " ")
-		},
-		PreRun: func(_ *Command, args []string) {
-			parentPreArgs = strings.Join(args, " ")
-		},
-		Run: func(_ *Command, args []string) {
-			parentRunArgs = strings.Join(args, " ")
-		},
-		PostRun: func(_ *Command, args []string) {
-			parentPostArgs = strings.Join(args, " ")
-		},
-		PersistentPostRun: func(_ *Command, args []string) {
-			parentPersPostArgs = strings.Join(args, " ")
-		},
-	}
-
-	childCmd := &Command{
-		Use: "child",
-		PersistentPreRun: func(_ *Command, args []string) {
-			childPersPreArgs = strings.Join(args, " ")
-		},
-		PreRun: func(_ *Command, args []string) {
-			childPreArgs = strings.Join(args, " ")
-		},
-		Run: func(_ *Command, args []string) {
-			childRunArgs = strings.Join(args, " ")
-		},
-		PostRun: func(_ *Command, args []string) {
-			childPostArgs = strings.Join(args, " ")
-		},
-		PersistentPostRun: func(_ *Command, args []string) {
-			childPersPostArgs = strings.Join(args, " ")
-		},
-	}
-	parentCmd.AddCommand(childCmd)
-
-	output, err := executeCommand(parentCmd, "child", "one", "two")
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	// TODO: This test fails, but should not.
-	// Related to https://github.com/spf13/cobra/issues/252.
-	//
-	// if parentPersPreArgs != "one two" {
-	// 	t.Errorf("Expected parentPersPreArgs %q, got %q", "one two", parentPersPreArgs)
-	// }
-	if parentPreArgs != "" {
-		t.Errorf("Expected blank parentPreArgs, got %q", parentPreArgs)
-	}
-	if parentRunArgs != "" {
-		t.Errorf("Expected blank parentRunArgs, got %q", parentRunArgs)
-	}
-	if parentPostArgs != "" {
-		t.Errorf("Expected blank parentPostArgs, got %q", parentPostArgs)
-	}
-	// TODO: This test fails, but should not.
-	// Related to https://github.com/spf13/cobra/issues/252.
-	//
-	// if parentPersPostArgs != "one two" {
-	// 	t.Errorf("Expected parentPersPostArgs %q, got %q", "one two", parentPersPostArgs)
-	// }
-
-	if childPersPreArgs != "one two" {
-		t.Errorf("Expected childPersPreArgs %q, got %q", "one two", childPersPreArgs)
-	}
-	if childPreArgs != "one two" {
-		t.Errorf("Expected childPreArgs %q, got %q", "one two", childPreArgs)
-	}
-	if childRunArgs != "one two" {
-		t.Errorf("Expected childRunArgs %q, got %q", "one two", childRunArgs)
-	}
-	if childPostArgs != "one two" {
-		t.Errorf("Expected childPostArgs %q, got %q", "one two", childPostArgs)
-	}
-	if childPersPostArgs != "one two" {
-		t.Errorf("Expected childPersPostArgs %q, got %q", "one two", childPersPostArgs)
-	}
-}
-
-// Related to https://github.com/spf13/cobra/issues/521.
-func TestGlobalNormFuncPropagation(t *testing.T) {
-	normFunc := func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		return pflag.NormalizedName(name)
-	}
-
-	rootCmd := &Command{Use: "root", Run: emptyRun}
-	childCmd := &Command{Use: "child", Run: emptyRun}
-	rootCmd.AddCommand(childCmd)
-
-	rootCmd.SetGlobalNormalizationFunc(normFunc)
-	if reflect.ValueOf(normFunc).Pointer() != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()).Pointer() {
-		t.Error("rootCmd seems to have a wrong normalization function")
-	}
-
-	if reflect.ValueOf(normFunc).Pointer() != reflect.ValueOf(childCmd.GlobalNormalizationFunc()).Pointer() {
-		t.Error("childCmd should have had the normalization function of rootCmd")
-	}
-}
-
-// Related to https://github.com/spf13/cobra/issues/521.
-func TestNormPassedOnLocal(t *testing.T) {
-	toUpper := func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		return pflag.NormalizedName(strings.ToUpper(name))
-	}
-
-	c := &Command{}
-	c.Flags().Bool("flagname", true, "this is a dummy flag")
-	c.SetGlobalNormalizationFunc(toUpper)
-	if c.LocalFlags().Lookup("flagname") != c.LocalFlags().Lookup("FLAGNAME") {
-		t.Error("Normalization function should be passed on to Local flag set")
-	}
-}
-
-// Related to https://github.com/spf13/cobra/issues/521.
-func TestNormPassedOnInherited(t *testing.T) {
-	toUpper := func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		return pflag.NormalizedName(strings.ToUpper(name))
-	}
-
-	c := &Command{}
-	c.SetGlobalNormalizationFunc(toUpper)
-
-	child1 := &Command{}
-	c.AddCommand(child1)
-
-	c.PersistentFlags().Bool("flagname", true, "")
-
-	child2 := &Command{}
-	c.AddCommand(child2)
-
-	inherited := child1.InheritedFlags()
-	if inherited.Lookup("flagname") == nil || inherited.Lookup("flagname") != inherited.Lookup("FLAGNAME") {
-		t.Error("Normalization function should be passed on to inherited flag set in command added before flag")
-	}
-
-	inherited = child2.InheritedFlags()
-	if inherited.Lookup("flagname") == nil || inherited.Lookup("flagname") != inherited.Lookup("FLAGNAME") {
-		t.Error("Normalization function should be passed on to inherited flag set in command added after flag")
-	}
-}
-
-// Related to https://github.com/spf13/cobra/issues/521.
-func TestConsistentNormalizedName(t *testing.T) {
-	toUpper := func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		return pflag.NormalizedName(strings.ToUpper(name))
-	}
-	n := func(f *pflag.FlagSet, name string) pflag.NormalizedName {
-		return pflag.NormalizedName(name)
-	}
-
-	c := &Command{}
-	c.Flags().Bool("flagname", true, "")
-	c.SetGlobalNormalizationFunc(toUpper)
-	c.SetGlobalNormalizationFunc(n)
-
-	if c.LocalFlags().Lookup("flagname") == c.LocalFlags().Lookup("FLAGNAME") {
-		t.Error("Normalizing flag names should not result in duplicate flags")
-	}
-}
-
-func TestFlagOnPflagCommandLine(t *testing.T) {
-	flagName := "flagOnCommandLine"
-	pflag.String(flagName, "", "about my flag")
-
-	c := &Command{Use: "c", Run: emptyRun}
-	c.AddCommand(&Command{Use: "child", Run: emptyRun})
-
-	output, _ := executeCommand(c, "--help")
-	checkStringContains(t, output, flagName)
-
-	resetCommandLineFlagSet()
-}
-
-// TestHiddenCommandExecutes checks,
-// if hidden commands run as intended.
-func TestHiddenCommandExecutes(t *testing.T) {
-	executed := false
-	c := &Command{
-		Use:    "c",
-		Hidden: true,
-		Run:    func(*Command, []string) { executed = true },
-	}
-
-	output, err := executeCommand(c)
-	if output != "" {
-		t.Errorf("Unexpected output: %v", output)
-	}
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-
-	if !executed {
-		t.Error("Hidden command should have been executed")
-	}
-}
-
-// test to ensure hidden commands do not show up in usage/help text
-func TestHiddenCommandIsHidden(t *testing.T) {
-	c := &Command{Use: "c", Hidden: true, Run: emptyRun}
-	if c.IsAvailableCommand() {
-		t.Errorf("Hidden command should be unavailable")
-	}
-}
-
-func TestCommandsAreSorted(t *testing.T) {
-	EnableCommandSorting = true
-
-	originalNames := []string{"middle", "zlast", "afirst"}
-	expectedNames := []string{"afirst", "middle", "zlast"}
-
-	var rootCmd = &Command{Use: "root"}
-
-	for _, name := range originalNames {
-		rootCmd.AddCommand(&Command{Use: name})
-	}
-
-	for i, c := range rootCmd.Commands() {
-		got := c.Name()
-		if expectedNames[i] != got {
-			t.Errorf("Expected: %s, got: %s", expectedNames[i], got)
-		}
-	}
-
-	EnableCommandSorting = true
-}
-
-func TestEnableCommandSortingIsDisabled(t *testing.T) {
-	EnableCommandSorting = false
-
-	originalNames := []string{"middle", "zlast", "afirst"}
-
-	var rootCmd = &Command{Use: "root"}
-
-	for _, name := range originalNames {
-		rootCmd.AddCommand(&Command{Use: name})
-	}
-
-	for i, c := range rootCmd.Commands() {
-		got := c.Name()
-		if originalNames[i] != got {
-			t.Errorf("expected: %s, got: %s", originalNames[i], got)
-		}
-	}
-
-	EnableCommandSorting = true
-}
-
-func TestSetOutput(t *testing.T) {
-	c := &Command{}
-	c.SetOutput(nil)
-	if out := c.OutOrStdout(); out != os.Stdout {
-		t.Errorf("Expected setting output to nil to revert back to stdout")
-	}
-}
-
-func TestFlagErrorFunc(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-
-	expectedFmt := "This is expected: %v"
-	c.SetFlagErrorFunc(func(_ *Command, err error) error {
-		return fmt.Errorf(expectedFmt, err)
-	})
-
-	_, err := executeCommand(c, "--unknown-flag")
-
-	got := err.Error()
-	expected := fmt.Sprintf(expectedFmt, "unknown flag: --unknown-flag")
-	if got != expected {
-		t.Errorf("Expected %v, got %v", expected, got)
-	}
-}
-
-// TestSortedFlags checks,
-// if cmd.LocalFlags() is unsorted when cmd.Flags().SortFlags set to false.
-// Related to https://github.com/spf13/cobra/issues/404.
-func TestSortedFlags(t *testing.T) {
-	c := &Command{}
-	c.Flags().SortFlags = false
-	names := []string{"C", "B", "A", "D"}
-	for _, name := range names {
-		c.Flags().Bool(name, false, "")
-	}
-
-	i := 0
-	c.LocalFlags().VisitAll(func(f *pflag.Flag) {
-		if i == len(names) {
-			return
-		}
-		if stringInSlice(f.Name, names) {
-			if names[i] != f.Name {
-				t.Errorf("Incorrect order. Expected %v, got %v", names[i], f.Name)
-			}
-			i++
-		}
-	})
-}
-
-// TestMergeCommandLineToFlags checks,
-// if pflag.CommandLine is correctly merged to c.Flags() after first call
-// of c.mergePersistentFlags.
-// Related to https://github.com/spf13/cobra/issues/443.
-func TestMergeCommandLineToFlags(t *testing.T) {
-	pflag.Bool("boolflag", false, "")
-	c := &Command{Use: "c", Run: emptyRun}
-	c.mergePersistentFlags()
-	if c.Flags().Lookup("boolflag") == nil {
-		t.Fatal("Expecting to have flag from CommandLine in c.Flags()")
-	}
-
-	resetCommandLineFlagSet()
-}
-
-// TestUseDeprecatedFlags checks,
-// if cobra.Execute() prints a message, if a deprecated flag is used.
-// Related to https://github.com/spf13/cobra/issues/463.
-func TestUseDeprecatedFlags(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-	c.Flags().BoolP("deprecated", "d", false, "deprecated flag")
-	c.Flags().MarkDeprecated("deprecated", "This flag is deprecated")
-
-	output, err := executeCommand(c, "c", "-d")
-	if err != nil {
-		t.Error("Unexpected error:", err)
-	}
-	checkStringContains(t, output, "This flag is deprecated")
-}
-
-func TestTraverseWithParentFlags(t *testing.T) {
-	rootCmd := &Command{Use: "root", TraverseChildren: true}
-	rootCmd.Flags().String("str", "", "")
-	rootCmd.Flags().BoolP("bool", "b", false, "")
-
-	childCmd := &Command{Use: "child"}
-	childCmd.Flags().Int("int", -1, "")
-
-	rootCmd.AddCommand(childCmd)
-
-	c, args, err := rootCmd.Traverse([]string{"-b", "--str", "ok", "child", "--int"})
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if len(args) != 1 && args[0] != "--add" {
-		t.Errorf("Wrong args: %v", args)
-	}
-	if c.Name() != childCmd.Name() {
-		t.Errorf("Expected command: %q, got: %q", childCmd.Name(), c.Name())
-	}
-}
-
-func TestTraverseNoParentFlags(t *testing.T) {
-	rootCmd := &Command{Use: "root", TraverseChildren: true}
-	rootCmd.Flags().String("foo", "", "foo things")
-
-	childCmd := &Command{Use: "child"}
-	childCmd.Flags().String("str", "", "")
-	rootCmd.AddCommand(childCmd)
-
-	c, args, err := rootCmd.Traverse([]string{"child"})
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if len(args) != 0 {
-		t.Errorf("Wrong args %v", args)
-	}
-	if c.Name() != childCmd.Name() {
-		t.Errorf("Expected command: %q, got: %q", childCmd.Name(), c.Name())
-	}
-}
-
-func TestTraverseWithBadParentFlags(t *testing.T) {
-	rootCmd := &Command{Use: "root", TraverseChildren: true}
-
-	childCmd := &Command{Use: "child"}
-	childCmd.Flags().String("str", "", "")
-	rootCmd.AddCommand(childCmd)
-
-	expected := "unknown flag: --str"
-
-	c, _, err := rootCmd.Traverse([]string{"--str", "ok", "child"})
-	if err == nil || !strings.Contains(err.Error(), expected) {
-		t.Errorf("Expected error, %q, got %q", expected, err)
-	}
-	if c != nil {
-		t.Errorf("Expected nil command")
-	}
-}
-
-func TestTraverseWithBadChildFlag(t *testing.T) {
-	rootCmd := &Command{Use: "root", TraverseChildren: true}
-	rootCmd.Flags().String("str", "", "")
-
-	childCmd := &Command{Use: "child"}
-	rootCmd.AddCommand(childCmd)
-
-	// Expect no error because the last commands args shouldn't be parsed in
-	// Traverse.
-	c, args, err := rootCmd.Traverse([]string{"child", "--str"})
-	if err != nil {
-		t.Errorf("Unexpected error: %v", err)
-	}
-	if len(args) != 1 && args[0] != "--str" {
-		t.Errorf("Wrong args: %v", args)
-	}
-	if c.Name() != childCmd.Name() {
-		t.Errorf("Expected command %q, got: %q", childCmd.Name(), c.Name())
-	}
-}
-
-func TestTraverseWithTwoSubcommands(t *testing.T) {
-	rootCmd := &Command{Use: "root", TraverseChildren: true}
-
-	subCmd := &Command{Use: "sub", TraverseChildren: true}
-	rootCmd.AddCommand(subCmd)
-
-	subsubCmd := &Command{
-		Use: "subsub",
-	}
-	subCmd.AddCommand(subsubCmd)
-
-	c, _, err := rootCmd.Traverse([]string{"sub", "subsub"})
-	if err != nil {
-		t.Fatalf("Unexpected error: %v", err)
-	}
-	if c.Name() != subsubCmd.Name() {
-		t.Fatalf("Expected command: %q, got %q", subsubCmd.Name(), c.Name())
-	}
-}
-
-// TestUpdateName checks if c.Name() updates on changed c.Use.
-// Related to https://github.com/spf13/cobra/pull/422#discussion_r143918343.
-func TestUpdateName(t *testing.T) {
-	c := &Command{Use: "name xyz"}
-	originalName := c.Name()
-
-	c.Use = "changedName abc"
-	if originalName == c.Name() || c.Name() != "changedName" {
-		t.Error("c.Name() should be updated on changed c.Use")
-	}
-}
-
-type calledAsTestcase struct {
-	args []string
-	call string
-	want string
-	epm  bool
-	tc   bool
-}
-
-func (tc *calledAsTestcase) test(t *testing.T) {
-	defer func(ov bool) { EnablePrefixMatching = ov }(EnablePrefixMatching)
-	EnablePrefixMatching = tc.epm
-
-	var called *Command
-	run := func(c *Command, _ []string) { t.Logf("called: %q", c.Name()); called = c }
-
-	parent := &Command{Use: "parent", Run: run}
-	child1 := &Command{Use: "child1", Run: run, Aliases: []string{"this"}}
-	child2 := &Command{Use: "child2", Run: run, Aliases: []string{"that"}}
-
-	parent.AddCommand(child1)
-	parent.AddCommand(child2)
-	parent.SetArgs(tc.args)
-
-	output := new(bytes.Buffer)
-	parent.SetOutput(output)
-
-	parent.Execute()
-
-	if called == nil {
-		if tc.call != "" {
-			t.Errorf("missing expected call to command: %s", tc.call)
-		}
-		return
-	}
-
-	if called.Name() != tc.call {
-		t.Errorf("called command == %q; Wanted %q", called.Name(), tc.call)
-	} else if got := called.CalledAs(); got != tc.want {
-		t.Errorf("%s.CalledAs() == %q; Wanted: %q", tc.call, got, tc.want)
-	}
-}
-
-func TestCalledAs(t *testing.T) {
-	tests := map[string]calledAsTestcase{
-		"find/no-args":            {nil, "parent", "parent", false, false},
-		"find/real-name":          {[]string{"child1"}, "child1", "child1", false, false},
-		"find/full-alias":         {[]string{"that"}, "child2", "that", false, false},
-		"find/part-no-prefix":     {[]string{"thi"}, "", "", false, false},
-		"find/part-alias":         {[]string{"thi"}, "child1", "this", true, false},
-		"find/conflict":           {[]string{"th"}, "", "", true, false},
-		"traverse/no-args":        {nil, "parent", "parent", false, true},
-		"traverse/real-name":      {[]string{"child1"}, "child1", "child1", false, true},
-		"traverse/full-alias":     {[]string{"that"}, "child2", "that", false, true},
-		"traverse/part-no-prefix": {[]string{"thi"}, "", "", false, true},
-		"traverse/part-alias":     {[]string{"thi"}, "child1", "this", true, true},
-		"traverse/conflict":       {[]string{"th"}, "", "", true, true},
-	}
-
-	for name, tc := range tests {
-		t.Run(name, tc.test)
-	}
-}
-
-func TestFParseErrWhitelistBackwardCompatibility(t *testing.T) {
-	c := &Command{Use: "c", Run: emptyRun}
-	c.Flags().BoolP("boola", "a", false, "a boolean flag")
-
-	output, err := executeCommand(c, "c", "-a", "--unknown", "flag")
-	if err == nil {
-		t.Error("expected unknown flag error")
-	}
-	checkStringContains(t, output, "unknown flag: --unknown")
-}
-
-func TestFParseErrWhitelistSameCommand(t *testing.T) {
-	c := &Command{
-		Use: "c",
-		Run: emptyRun,
-		FParseErrWhitelist: FParseErrWhitelist{
-			UnknownFlags: true,
-		},
-	}
-	c.Flags().BoolP("boola", "a", false, "a boolean flag")
-
-	_, err := executeCommand(c, "c", "-a", "--unknown", "flag")
-	if err != nil {
-		t.Error("unexpected error: ", err)
-	}
-}
-
-func TestFParseErrWhitelistParentCommand(t *testing.T) {
-	root := &Command{
-		Use: "root",
-		Run: emptyRun,
-		FParseErrWhitelist: FParseErrWhitelist{
-			UnknownFlags: true,
-		},
-	}
-
-	c := &Command{
-		Use: "child",
-		Run: emptyRun,
-	}
-	c.Flags().BoolP("boola", "a", false, "a boolean flag")
-
-	root.AddCommand(c)
-
-	output, err := executeCommand(root, "child", "-a", "--unknown", "flag")
-	if err == nil {
-		t.Error("expected unknown flag error")
-	}
-	checkStringContains(t, output, "unknown flag: --unknown")
-}
-
-func TestFParseErrWhitelistChildCommand(t *testing.T) {
-	root := &Command{
-		Use: "root",
-		Run: emptyRun,
-	}
-
-	c := &Command{
-		Use: "child",
-		Run: emptyRun,
-		FParseErrWhitelist: FParseErrWhitelist{
-			UnknownFlags: true,
-		},
-	}
-	c.Flags().BoolP("boola", "a", false, "a boolean flag")
-
-	root.AddCommand(c)
-
-	_, err := executeCommand(root, "child", "-a", "--unknown", "flag")
-	if err != nil {
-		t.Error("unexpected error: ", err.Error())
-	}
-}
-
-func TestFParseErrWhitelistSiblingCommand(t *testing.T) {
-	root := &Command{
-		Use: "root",
-		Run: emptyRun,
-	}
-
-	c := &Command{
-		Use: "child",
-		Run: emptyRun,
-		FParseErrWhitelist: FParseErrWhitelist{
-			UnknownFlags: true,
-		},
-	}
-	c.Flags().BoolP("boola", "a", false, "a boolean flag")
-
-	s := &Command{
-		Use: "sibling",
-		Run: emptyRun,
-	}
-	s.Flags().BoolP("boolb", "b", false, "a boolean flag")
-
-	root.AddCommand(c)
-	root.AddCommand(s)
-
-	output, err := executeCommand(root, "sibling", "-b", "--unknown", "flag")
-	if err == nil {
-		t.Error("expected unknown flag error")
-	}
-	checkStringContains(t, output, "unknown flag: --unknown")
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/cobra/zsh_completions_test.go b/cmd/viewcore/vendor/github.com/spf13/cobra/zsh_completions_test.go
deleted file mode 100644
index 34e6949..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/cobra/zsh_completions_test.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package cobra
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-)
-
-func TestZshCompletion(t *testing.T) {
-	tcs := []struct {
-		name                string
-		root                *Command
-		expectedExpressions []string
-	}{
-		{
-			name:                "trivial",
-			root:                &Command{Use: "trivialapp"},
-			expectedExpressions: []string{"#compdef trivial"},
-		},
-		{
-			name: "linear",
-			root: func() *Command {
-				r := &Command{Use: "linear"}
-
-				sub1 := &Command{Use: "sub1"}
-				r.AddCommand(sub1)
-
-				sub2 := &Command{Use: "sub2"}
-				sub1.AddCommand(sub2)
-
-				sub3 := &Command{Use: "sub3"}
-				sub2.AddCommand(sub3)
-				return r
-			}(),
-			expectedExpressions: []string{"sub1", "sub2", "sub3"},
-		},
-		{
-			name: "flat",
-			root: func() *Command {
-				r := &Command{Use: "flat"}
-				r.AddCommand(&Command{Use: "c1"})
-				r.AddCommand(&Command{Use: "c2"})
-				return r
-			}(),
-			expectedExpressions: []string{"(c1 c2)"},
-		},
-		{
-			name: "tree",
-			root: func() *Command {
-				r := &Command{Use: "tree"}
-
-				sub1 := &Command{Use: "sub1"}
-				r.AddCommand(sub1)
-
-				sub11 := &Command{Use: "sub11"}
-				sub12 := &Command{Use: "sub12"}
-
-				sub1.AddCommand(sub11)
-				sub1.AddCommand(sub12)
-
-				sub2 := &Command{Use: "sub2"}
-				r.AddCommand(sub2)
-
-				sub21 := &Command{Use: "sub21"}
-				sub22 := &Command{Use: "sub22"}
-
-				sub2.AddCommand(sub21)
-				sub2.AddCommand(sub22)
-
-				return r
-			}(),
-			expectedExpressions: []string{"(sub11 sub12)", "(sub21 sub22)"},
-		},
-	}
-
-	for _, tc := range tcs {
-		t.Run(tc.name, func(t *testing.T) {
-			buf := new(bytes.Buffer)
-			tc.root.GenZshCompletion(buf)
-			output := buf.String()
-
-			for _, expectedExpression := range tc.expectedExpressions {
-				if !strings.Contains(output, expectedExpression) {
-					t.Errorf("Expected completion to contain %q somewhere; got %q", expectedExpression, output)
-				}
-			}
-		})
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/bool_slice_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/bool_slice_test.go
deleted file mode 100644
index b617dd2..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/bool_slice_test.go
+++ /dev/null
@@ -1,215 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func setUpBSFlagSet(bsp *[]bool) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.BoolSliceVar(bsp, "bs", []bool{}, "Command separated list!")
-	return f
-}
-
-func setUpBSFlagSetWithDefault(bsp *[]bool) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.BoolSliceVar(bsp, "bs", []bool{false, true}, "Command separated list!")
-	return f
-}
-
-func TestEmptyBS(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSet(&bs)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatal("got an error from GetBoolSlice():", err)
-	}
-	if len(getBS) != 0 {
-		t.Fatalf("got bs %v with len=%d but expected length=0", getBS, len(getBS))
-	}
-}
-
-func TestBS(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSet(&bs)
-
-	vals := []string{"1", "F", "TRUE", "0"}
-	arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected is[%d] to be %s but got: %t", i, vals[i], v)
-		}
-	}
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatalf("got error: %v", err)
-	}
-	for i, v := range getBS {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %s but got: %t from GetBoolSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestBSDefault(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSetWithDefault(&bs)
-
-	vals := []string{"false", "T"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
-		}
-	}
-
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatal("got an error from GetBoolSlice():", err)
-	}
-	for i, v := range getBS {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatal("got an error from GetBoolSlice():", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
-		}
-	}
-}
-
-func TestBSWithDefault(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSetWithDefault(&bs)
-
-	vals := []string{"FALSE", "1"}
-	arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t but got: %t", i, b, v)
-		}
-	}
-
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatal("got an error from GetBoolSlice():", err)
-	}
-	for i, v := range getBS {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
-		}
-	}
-}
-
-func TestBSCalledTwice(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSet(&bs)
-
-	in := []string{"T,F", "T"}
-	expected := []bool{true, false, true}
-	argfmt := "--bs=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		if expected[i] != v {
-			t.Fatalf("expected bs[%d] to be %t but got %t", i, expected[i], v)
-		}
-	}
-}
-
-func TestBSBadQuoting(t *testing.T) {
-
-	tests := []struct {
-		Want    []bool
-		FlagArg []string
-	}{
-		{
-			Want:    []bool{true, false, true},
-			FlagArg: []string{"1", "0", "true"},
-		},
-		{
-			Want:    []bool{true, false},
-			FlagArg: []string{"True", "F"},
-		},
-		{
-			Want:    []bool{true, false},
-			FlagArg: []string{"T", "0"},
-		},
-		{
-			Want:    []bool{true, false},
-			FlagArg: []string{"1", "0"},
-		},
-		{
-			Want:    []bool{true, false, false},
-			FlagArg: []string{"true,false", "false"},
-		},
-		{
-			Want:    []bool{true, false, false, true, false, true, false},
-			FlagArg: []string{`"true,false,false,1,0,     T"`, " false "},
-		},
-		{
-			Want:    []bool{false, false, true, false, true, false, true},
-			FlagArg: []string{`"0, False,  T,false  , true,F"`, "true"},
-		},
-	}
-
-	for i, test := range tests {
-
-		var bs []bool
-		f := setUpBSFlagSet(&bs)
-
-		if err := f.Parse([]string{fmt.Sprintf("--bs=%s", strings.Join(test.FlagArg, ","))}); err != nil {
-			t.Fatalf("flag parsing failed with error: %s\nparsing:\t%#v\nwant:\t\t%#v",
-				err, test.FlagArg, test.Want[i])
-		}
-
-		for j, b := range bs {
-			if b != test.Want[j] {
-				t.Fatalf("bad value parsed for test %d on bool %d:\nwant:\t%t\ngot:\t%t", i, j, test.Want[j], b)
-			}
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/bool_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/bool_test.go
deleted file mode 100644
index a4319e7..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/bool_test.go
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"bytes"
-	"strconv"
-	"testing"
-)
-
-// This value can be a boolean ("true", "false") or "maybe"
-type triStateValue int
-
-const (
-	triStateFalse triStateValue = 0
-	triStateTrue  triStateValue = 1
-	triStateMaybe triStateValue = 2
-)
-
-const strTriStateMaybe = "maybe"
-
-func (v *triStateValue) IsBoolFlag() bool {
-	return true
-}
-
-func (v *triStateValue) Get() interface{} {
-	return triStateValue(*v)
-}
-
-func (v *triStateValue) Set(s string) error {
-	if s == strTriStateMaybe {
-		*v = triStateMaybe
-		return nil
-	}
-	boolVal, err := strconv.ParseBool(s)
-	if boolVal {
-		*v = triStateTrue
-	} else {
-		*v = triStateFalse
-	}
-	return err
-}
-
-func (v *triStateValue) String() string {
-	if *v == triStateMaybe {
-		return strTriStateMaybe
-	}
-	return strconv.FormatBool(*v == triStateTrue)
-}
-
-// The type of the flag as required by the pflag.Value interface
-func (v *triStateValue) Type() string {
-	return "version"
-}
-
-func setUpFlagSet(tristate *triStateValue) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	*tristate = triStateFalse
-	flag := f.VarPF(tristate, "tristate", "t", "tristate value (true, maybe or false)")
-	flag.NoOptDefVal = "true"
-	return f
-}
-
-func TestExplicitTrue(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate=true"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-}
-
-func TestImplicitTrue(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-}
-
-func TestShortFlag(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"-t"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-}
-
-func TestShortFlagExtraArgument(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	// The"maybe"turns into an arg, since short boolean options will only do true/false
-	err := f.Parse([]string{"-t", "maybe"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-	args := f.Args()
-	if len(args) != 1 || args[0] != "maybe" {
-		t.Fatal("expected an extra 'maybe' argument to stick around")
-	}
-}
-
-func TestExplicitMaybe(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate=maybe"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateMaybe {
-		t.Fatal("expected", triStateMaybe, "(triStateMaybe) but got", tristate, "instead")
-	}
-}
-
-func TestExplicitFalse(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate=false"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateFalse {
-		t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead")
-	}
-}
-
-func TestImplicitFalse(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateFalse {
-		t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead")
-	}
-}
-
-func TestInvalidValue(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	var buf bytes.Buffer
-	f.SetOutput(&buf)
-	err := f.Parse([]string{"--tristate=invalid"})
-	if err == nil {
-		t.Fatal("expected an error but did not get any, tristate has value", tristate)
-	}
-}
-
-func TestBoolP(t *testing.T) {
-	b := BoolP("bool", "b", false, "bool value in CommandLine")
-	c := BoolP("c", "c", false, "other bool value")
-	args := []string{"--bool"}
-	if err := CommandLine.Parse(args); err != nil {
-		t.Error("expected no error, got ", err)
-	}
-	if *b != true {
-		t.Errorf("expected b=true got b=%v", *b)
-	}
-	if *c != false {
-		t.Errorf("expect c=false got c=%v", *c)
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/bytes_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/bytes_test.go
deleted file mode 100644
index cc4a769..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/bytes_test.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"os"
-	"testing"
-)
-
-func setUpBytesHex(bytesHex *[]byte) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.BytesHexVar(bytesHex, "bytes", []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, "Some bytes in HEX")
-	f.BytesHexVarP(bytesHex, "bytes2", "B", []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, "Some bytes in HEX")
-	return f
-}
-
-func TestBytesHex(t *testing.T) {
-	testCases := []struct {
-		input    string
-		success  bool
-		expected string
-	}{
-		/// Positive cases
-		{"", true, ""}, // Is empty string OK ?
-		{"01", true, "01"},
-		{"0101", true, "0101"},
-		{"1234567890abcdef", true, "1234567890ABCDEF"},
-		{"1234567890ABCDEF", true, "1234567890ABCDEF"},
-
-		// Negative cases
-		{"0", false, ""},   // Short string
-		{"000", false, ""}, /// Odd-length string
-		{"qq", false, ""},  /// non-hex character
-	}
-
-	devnull, _ := os.Open(os.DevNull)
-	os.Stderr = devnull
-
-	for i := range testCases {
-		var bytesHex []byte
-		f := setUpBytesHex(&bytesHex)
-
-		tc := &testCases[i]
-
-		// --bytes
-		args := []string{
-			fmt.Sprintf("--bytes=%s", tc.input),
-			fmt.Sprintf("-B  %s", tc.input),
-			fmt.Sprintf("--bytes2=%s", tc.input),
-		}
-
-		for _, arg := range args {
-			err := f.Parse([]string{arg})
-
-			if err != nil && tc.success == true {
-				t.Errorf("expected success, got %q", err)
-				continue
-			} else if err == nil && tc.success == false {
-				// bytesHex, err := f.GetBytesHex("bytes")
-				t.Errorf("expected failure while processing %q", tc.input)
-				continue
-			} else if tc.success {
-				bytesHex, err := f.GetBytesHex("bytes")
-				if err != nil {
-					t.Errorf("Got error trying to fetch the IP flag: %v", err)
-				}
-				if fmt.Sprintf("%X", bytesHex) != tc.expected {
-					t.Errorf("expected %q, got '%X'", tc.expected, bytesHex)
-				}
-			}
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/count_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/count_test.go
deleted file mode 100644
index 3785d37..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/count_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package pflag
-
-import (
-	"os"
-	"testing"
-)
-
-func setUpCount(c *int) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.CountVarP(c, "verbose", "v", "a counter")
-	return f
-}
-
-func TestCount(t *testing.T) {
-	testCases := []struct {
-		input    []string
-		success  bool
-		expected int
-	}{
-		{[]string{}, true, 0},
-		{[]string{"-v"}, true, 1},
-		{[]string{"-vvv"}, true, 3},
-		{[]string{"-v", "-v", "-v"}, true, 3},
-		{[]string{"-v", "--verbose", "-v"}, true, 3},
-		{[]string{"-v=3", "-v"}, true, 4},
-		{[]string{"--verbose=0"}, true, 0},
-		{[]string{"-v=0"}, true, 0},
-		{[]string{"-v=a"}, false, 0},
-	}
-
-	devnull, _ := os.Open(os.DevNull)
-	os.Stderr = devnull
-	for i := range testCases {
-		var count int
-		f := setUpCount(&count)
-
-		tc := &testCases[i]
-
-		err := f.Parse(tc.input)
-		if err != nil && tc.success == true {
-			t.Errorf("expected success, got %q", err)
-			continue
-		} else if err == nil && tc.success == false {
-			t.Errorf("expected failure, got success")
-			continue
-		} else if tc.success {
-			c, err := f.GetCount("verbose")
-			if err != nil {
-				t.Errorf("Got error trying to fetch the counter flag")
-			}
-			if c != tc.expected {
-				t.Errorf("expected %d, got %d", tc.expected, c)
-			}
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/duration_slice_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/duration_slice_test.go
deleted file mode 100644
index 489b012..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/duration_slice_test.go
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code ds governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-	"time"
-)
-
-func setUpDSFlagSet(dsp *[]time.Duration) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.DurationSliceVar(dsp, "ds", []time.Duration{}, "Command separated list!")
-	return f
-}
-
-func setUpDSFlagSetWithDefault(dsp *[]time.Duration) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.DurationSliceVar(dsp, "ds", []time.Duration{0, 1}, "Command separated list!")
-	return f
-}
-
-func TestEmptyDS(t *testing.T) {
-	var ds []time.Duration
-	f := setUpDSFlagSet(&ds)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getDS, err := f.GetDurationSlice("ds")
-	if err != nil {
-		t.Fatal("got an error from GetDurationSlice():", err)
-	}
-	if len(getDS) != 0 {
-		t.Fatalf("got ds %v with len=%d but expected length=0", getDS, len(getDS))
-	}
-}
-
-func TestDS(t *testing.T) {
-	var ds []time.Duration
-	f := setUpDSFlagSet(&ds)
-
-	vals := []string{"1ns", "2ms", "3m", "4h"}
-	arg := fmt.Sprintf("--ds=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ds {
-		d, err := time.ParseDuration(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected ds[%d] to be %s but got: %d", i, vals[i], v)
-		}
-	}
-	getDS, err := f.GetDurationSlice("ds")
-	if err != nil {
-		t.Fatalf("got error: %v", err)
-	}
-	for i, v := range getDS {
-		d, err := time.ParseDuration(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected ds[%d] to be %s but got: %d from GetDurationSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestDSDefault(t *testing.T) {
-	var ds []time.Duration
-	f := setUpDSFlagSetWithDefault(&ds)
-
-	vals := []string{"0s", "1ns"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ds {
-		d, err := time.ParseDuration(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected ds[%d] to be %d but got: %d", i, d, v)
-		}
-	}
-
-	getDS, err := f.GetDurationSlice("ds")
-	if err != nil {
-		t.Fatal("got an error from GetDurationSlice():", err)
-	}
-	for i, v := range getDS {
-		d, err := time.ParseDuration(vals[i])
-		if err != nil {
-			t.Fatal("got an error from GetDurationSlice():", err)
-		}
-		if d != v {
-			t.Fatalf("expected ds[%d] to be %d from GetDurationSlice but got: %d", i, d, v)
-		}
-	}
-}
-
-func TestDSWithDefault(t *testing.T) {
-	var ds []time.Duration
-	f := setUpDSFlagSetWithDefault(&ds)
-
-	vals := []string{"1ns", "2ns"}
-	arg := fmt.Sprintf("--ds=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ds {
-		d, err := time.ParseDuration(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected ds[%d] to be %d but got: %d", i, d, v)
-		}
-	}
-
-	getDS, err := f.GetDurationSlice("ds")
-	if err != nil {
-		t.Fatal("got an error from GetDurationSlice():", err)
-	}
-	for i, v := range getDS {
-		d, err := time.ParseDuration(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected ds[%d] to be %d from GetDurationSlice but got: %d", i, d, v)
-		}
-	}
-}
-
-func TestDSCalledTwice(t *testing.T) {
-	var ds []time.Duration
-	f := setUpDSFlagSet(&ds)
-
-	in := []string{"1ns,2ns", "3ns"}
-	expected := []time.Duration{1, 2, 3}
-	argfmt := "--ds=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ds {
-		if expected[i] != v {
-			t.Fatalf("expected ds[%d] to be %d but got: %d", i, expected[i], v)
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/example_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/example_test.go
deleted file mode 100644
index abd7806..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/example_test.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag_test
-
-import (
-	"fmt"
-
-	"github.com/spf13/pflag"
-)
-
-func ExampleShorthandLookup() {
-	name := "verbose"
-	short := name[:1]
-
-	pflag.BoolP(name, short, false, "verbose output")
-
-	// len(short) must be == 1
-	flag := pflag.ShorthandLookup(short)
-
-	fmt.Println(flag.Name)
-}
-
-func ExampleFlagSet_ShorthandLookup() {
-	name := "verbose"
-	short := name[:1]
-
-	fs := pflag.NewFlagSet("Example", pflag.ContinueOnError)
-	fs.BoolP(name, short, false, "verbose output")
-
-	// len(short) must be == 1
-	flag := fs.ShorthandLookup(short)
-
-	fmt.Println(flag.Name)
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/export_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/export_test.go
deleted file mode 100644
index 9318fee..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/export_test.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2010 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"io/ioutil"
-	"os"
-)
-
-// Additional routines compiled into the package only during testing.
-
-// ResetForTesting clears all flag state and sets the usage function as directed.
-// After calling ResetForTesting, parse errors in flag handling will not
-// exit the program.
-func ResetForTesting(usage func()) {
-	CommandLine = &FlagSet{
-		name:          os.Args[0],
-		errorHandling: ContinueOnError,
-		output:        ioutil.Discard,
-	}
-	Usage = usage
-}
-
-// GetCommandLine returns the default FlagSet.
-func GetCommandLine() *FlagSet {
-	return CommandLine
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/flag.go b/cmd/viewcore/vendor/github.com/spf13/pflag/flag.go
index 5eadc84..5cc710c 100644
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/flag.go
+++ b/cmd/viewcore/vendor/github.com/spf13/pflag/flag.go
@@ -990,11 +990,12 @@
 }
 
 func (f *FlagSet) parseSingleShortArg(shorthands string, args []string, fn parseFunc) (outShorts string, outArgs []string, err error) {
+	outArgs = args
+
 	if strings.HasPrefix(shorthands, "test.") {
 		return
 	}
 
-	outArgs = args
 	outShorts = shorthands[1:]
 	c := shorthands[0]
 
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/flag_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/flag_test.go
deleted file mode 100644
index f600f0a..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/flag_test.go
+++ /dev/null
@@ -1,1259 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"os"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-)
-
-var (
-	testBool                     = Bool("test_bool", false, "bool value")
-	testInt                      = Int("test_int", 0, "int value")
-	testInt64                    = Int64("test_int64", 0, "int64 value")
-	testUint                     = Uint("test_uint", 0, "uint value")
-	testUint64                   = Uint64("test_uint64", 0, "uint64 value")
-	testString                   = String("test_string", "0", "string value")
-	testFloat                    = Float64("test_float64", 0, "float64 value")
-	testDuration                 = Duration("test_duration", 0, "time.Duration value")
-	testOptionalInt              = Int("test_optional_int", 0, "optional int value")
-	normalizeFlagNameInvocations = 0
-)
-
-func boolString(s string) string {
-	if s == "0" {
-		return "false"
-	}
-	return "true"
-}
-
-func TestEverything(t *testing.T) {
-	m := make(map[string]*Flag)
-	desired := "0"
-	visitor := func(f *Flag) {
-		if len(f.Name) > 5 && f.Name[0:5] == "test_" {
-			m[f.Name] = f
-			ok := false
-			switch {
-			case f.Value.String() == desired:
-				ok = true
-			case f.Name == "test_bool" && f.Value.String() == boolString(desired):
-				ok = true
-			case f.Name == "test_duration" && f.Value.String() == desired+"s":
-				ok = true
-			}
-			if !ok {
-				t.Error("Visit: bad value", f.Value.String(), "for", f.Name)
-			}
-		}
-	}
-	VisitAll(visitor)
-	if len(m) != 9 {
-		t.Error("VisitAll misses some flags")
-		for k, v := range m {
-			t.Log(k, *v)
-		}
-	}
-	m = make(map[string]*Flag)
-	Visit(visitor)
-	if len(m) != 0 {
-		t.Errorf("Visit sees unset flags")
-		for k, v := range m {
-			t.Log(k, *v)
-		}
-	}
-	// Now set all flags
-	Set("test_bool", "true")
-	Set("test_int", "1")
-	Set("test_int64", "1")
-	Set("test_uint", "1")
-	Set("test_uint64", "1")
-	Set("test_string", "1")
-	Set("test_float64", "1")
-	Set("test_duration", "1s")
-	Set("test_optional_int", "1")
-	desired = "1"
-	Visit(visitor)
-	if len(m) != 9 {
-		t.Error("Visit fails after set")
-		for k, v := range m {
-			t.Log(k, *v)
-		}
-	}
-	// Now test they're visited in sort order.
-	var flagNames []string
-	Visit(func(f *Flag) { flagNames = append(flagNames, f.Name) })
-	if !sort.StringsAreSorted(flagNames) {
-		t.Errorf("flag names not sorted: %v", flagNames)
-	}
-}
-
-func TestUsage(t *testing.T) {
-	called := false
-	ResetForTesting(func() { called = true })
-	if GetCommandLine().Parse([]string{"--x"}) == nil {
-		t.Error("parse did not fail for unknown flag")
-	}
-	if called {
-		t.Error("did call Usage while using ContinueOnError")
-	}
-}
-
-func TestAddFlagSet(t *testing.T) {
-	oldSet := NewFlagSet("old", ContinueOnError)
-	newSet := NewFlagSet("new", ContinueOnError)
-
-	oldSet.String("flag1", "flag1", "flag1")
-	oldSet.String("flag2", "flag2", "flag2")
-
-	newSet.String("flag2", "flag2", "flag2")
-	newSet.String("flag3", "flag3", "flag3")
-
-	oldSet.AddFlagSet(newSet)
-
-	if len(oldSet.formal) != 3 {
-		t.Errorf("Unexpected result adding a FlagSet to a FlagSet %v", oldSet)
-	}
-}
-
-func TestAnnotation(t *testing.T) {
-	f := NewFlagSet("shorthand", ContinueOnError)
-
-	if err := f.SetAnnotation("missing-flag", "key", nil); err == nil {
-		t.Errorf("Expected error setting annotation on non-existent flag")
-	}
-
-	f.StringP("stringa", "a", "", "string value")
-	if err := f.SetAnnotation("stringa", "key", nil); err != nil {
-		t.Errorf("Unexpected error setting new nil annotation: %v", err)
-	}
-	if annotation := f.Lookup("stringa").Annotations["key"]; annotation != nil {
-		t.Errorf("Unexpected annotation: %v", annotation)
-	}
-
-	f.StringP("stringb", "b", "", "string2 value")
-	if err := f.SetAnnotation("stringb", "key", []string{"value1"}); err != nil {
-		t.Errorf("Unexpected error setting new annotation: %v", err)
-	}
-	if annotation := f.Lookup("stringb").Annotations["key"]; !reflect.DeepEqual(annotation, []string{"value1"}) {
-		t.Errorf("Unexpected annotation: %v", annotation)
-	}
-
-	if err := f.SetAnnotation("stringb", "key", []string{"value2"}); err != nil {
-		t.Errorf("Unexpected error updating annotation: %v", err)
-	}
-	if annotation := f.Lookup("stringb").Annotations["key"]; !reflect.DeepEqual(annotation, []string{"value2"}) {
-		t.Errorf("Unexpected annotation: %v", annotation)
-	}
-}
-
-func testParse(f *FlagSet, t *testing.T) {
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-	boolFlag := f.Bool("bool", false, "bool value")
-	bool2Flag := f.Bool("bool2", false, "bool2 value")
-	bool3Flag := f.Bool("bool3", false, "bool3 value")
-	intFlag := f.Int("int", 0, "int value")
-	int8Flag := f.Int8("int8", 0, "int value")
-	int16Flag := f.Int16("int16", 0, "int value")
-	int32Flag := f.Int32("int32", 0, "int value")
-	int64Flag := f.Int64("int64", 0, "int64 value")
-	uintFlag := f.Uint("uint", 0, "uint value")
-	uint8Flag := f.Uint8("uint8", 0, "uint value")
-	uint16Flag := f.Uint16("uint16", 0, "uint value")
-	uint32Flag := f.Uint32("uint32", 0, "uint value")
-	uint64Flag := f.Uint64("uint64", 0, "uint64 value")
-	stringFlag := f.String("string", "0", "string value")
-	float32Flag := f.Float32("float32", 0, "float32 value")
-	float64Flag := f.Float64("float64", 0, "float64 value")
-	ipFlag := f.IP("ip", net.ParseIP("127.0.0.1"), "ip value")
-	maskFlag := f.IPMask("mask", ParseIPv4Mask("0.0.0.0"), "mask value")
-	durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value")
-	optionalIntNoValueFlag := f.Int("optional-int-no-value", 0, "int value")
-	f.Lookup("optional-int-no-value").NoOptDefVal = "9"
-	optionalIntWithValueFlag := f.Int("optional-int-with-value", 0, "int value")
-	f.Lookup("optional-int-no-value").NoOptDefVal = "9"
-	extra := "one-extra-argument"
-	args := []string{
-		"--bool",
-		"--bool2=true",
-		"--bool3=false",
-		"--int=22",
-		"--int8=-8",
-		"--int16=-16",
-		"--int32=-32",
-		"--int64=0x23",
-		"--uint", "24",
-		"--uint8=8",
-		"--uint16=16",
-		"--uint32=32",
-		"--uint64=25",
-		"--string=hello",
-		"--float32=-172e12",
-		"--float64=2718e28",
-		"--ip=10.11.12.13",
-		"--mask=255.255.255.0",
-		"--duration=2m",
-		"--optional-int-no-value",
-		"--optional-int-with-value=42",
-		extra,
-	}
-	if err := f.Parse(args); err != nil {
-		t.Fatal(err)
-	}
-	if !f.Parsed() {
-		t.Error("f.Parse() = false after Parse")
-	}
-	if *boolFlag != true {
-		t.Error("bool flag should be true, is ", *boolFlag)
-	}
-	if v, err := f.GetBool("bool"); err != nil || v != *boolFlag {
-		t.Error("GetBool does not work.")
-	}
-	if *bool2Flag != true {
-		t.Error("bool2 flag should be true, is ", *bool2Flag)
-	}
-	if *bool3Flag != false {
-		t.Error("bool3 flag should be false, is ", *bool2Flag)
-	}
-	if *intFlag != 22 {
-		t.Error("int flag should be 22, is ", *intFlag)
-	}
-	if v, err := f.GetInt("int"); err != nil || v != *intFlag {
-		t.Error("GetInt does not work.")
-	}
-	if *int8Flag != -8 {
-		t.Error("int8 flag should be 0x23, is ", *int8Flag)
-	}
-	if *int16Flag != -16 {
-		t.Error("int16 flag should be -16, is ", *int16Flag)
-	}
-	if v, err := f.GetInt8("int8"); err != nil || v != *int8Flag {
-		t.Error("GetInt8 does not work.")
-	}
-	if v, err := f.GetInt16("int16"); err != nil || v != *int16Flag {
-		t.Error("GetInt16 does not work.")
-	}
-	if *int32Flag != -32 {
-		t.Error("int32 flag should be 0x23, is ", *int32Flag)
-	}
-	if v, err := f.GetInt32("int32"); err != nil || v != *int32Flag {
-		t.Error("GetInt32 does not work.")
-	}
-	if *int64Flag != 0x23 {
-		t.Error("int64 flag should be 0x23, is ", *int64Flag)
-	}
-	if v, err := f.GetInt64("int64"); err != nil || v != *int64Flag {
-		t.Error("GetInt64 does not work.")
-	}
-	if *uintFlag != 24 {
-		t.Error("uint flag should be 24, is ", *uintFlag)
-	}
-	if v, err := f.GetUint("uint"); err != nil || v != *uintFlag {
-		t.Error("GetUint does not work.")
-	}
-	if *uint8Flag != 8 {
-		t.Error("uint8 flag should be 8, is ", *uint8Flag)
-	}
-	if v, err := f.GetUint8("uint8"); err != nil || v != *uint8Flag {
-		t.Error("GetUint8 does not work.")
-	}
-	if *uint16Flag != 16 {
-		t.Error("uint16 flag should be 16, is ", *uint16Flag)
-	}
-	if v, err := f.GetUint16("uint16"); err != nil || v != *uint16Flag {
-		t.Error("GetUint16 does not work.")
-	}
-	if *uint32Flag != 32 {
-		t.Error("uint32 flag should be 32, is ", *uint32Flag)
-	}
-	if v, err := f.GetUint32("uint32"); err != nil || v != *uint32Flag {
-		t.Error("GetUint32 does not work.")
-	}
-	if *uint64Flag != 25 {
-		t.Error("uint64 flag should be 25, is ", *uint64Flag)
-	}
-	if v, err := f.GetUint64("uint64"); err != nil || v != *uint64Flag {
-		t.Error("GetUint64 does not work.")
-	}
-	if *stringFlag != "hello" {
-		t.Error("string flag should be `hello`, is ", *stringFlag)
-	}
-	if v, err := f.GetString("string"); err != nil || v != *stringFlag {
-		t.Error("GetString does not work.")
-	}
-	if *float32Flag != -172e12 {
-		t.Error("float32 flag should be -172e12, is ", *float32Flag)
-	}
-	if v, err := f.GetFloat32("float32"); err != nil || v != *float32Flag {
-		t.Errorf("GetFloat32 returned %v but float32Flag was %v", v, *float32Flag)
-	}
-	if *float64Flag != 2718e28 {
-		t.Error("float64 flag should be 2718e28, is ", *float64Flag)
-	}
-	if v, err := f.GetFloat64("float64"); err != nil || v != *float64Flag {
-		t.Errorf("GetFloat64 returned %v but float64Flag was %v", v, *float64Flag)
-	}
-	if !(*ipFlag).Equal(net.ParseIP("10.11.12.13")) {
-		t.Error("ip flag should be 10.11.12.13, is ", *ipFlag)
-	}
-	if v, err := f.GetIP("ip"); err != nil || !v.Equal(*ipFlag) {
-		t.Errorf("GetIP returned %v but ipFlag was %v", v, *ipFlag)
-	}
-	if (*maskFlag).String() != ParseIPv4Mask("255.255.255.0").String() {
-		t.Error("mask flag should be 255.255.255.0, is ", (*maskFlag).String())
-	}
-	if v, err := f.GetIPv4Mask("mask"); err != nil || v.String() != (*maskFlag).String() {
-		t.Errorf("GetIP returned %v maskFlag was %v error was %v", v, *maskFlag, err)
-	}
-	if *durationFlag != 2*time.Minute {
-		t.Error("duration flag should be 2m, is ", *durationFlag)
-	}
-	if v, err := f.GetDuration("duration"); err != nil || v != *durationFlag {
-		t.Error("GetDuration does not work.")
-	}
-	if _, err := f.GetInt("duration"); err == nil {
-		t.Error("GetInt parsed a time.Duration?!?!")
-	}
-	if *optionalIntNoValueFlag != 9 {
-		t.Error("optional int flag should be the default value, is ", *optionalIntNoValueFlag)
-	}
-	if *optionalIntWithValueFlag != 42 {
-		t.Error("optional int flag should be 42, is ", *optionalIntWithValueFlag)
-	}
-	if len(f.Args()) != 1 {
-		t.Error("expected one argument, got", len(f.Args()))
-	} else if f.Args()[0] != extra {
-		t.Errorf("expected argument %q got %q", extra, f.Args()[0])
-	}
-}
-
-func testParseAll(f *FlagSet, t *testing.T) {
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-	f.BoolP("boola", "a", false, "bool value")
-	f.BoolP("boolb", "b", false, "bool2 value")
-	f.BoolP("boolc", "c", false, "bool3 value")
-	f.BoolP("boold", "d", false, "bool4 value")
-	f.StringP("stringa", "s", "0", "string value")
-	f.StringP("stringz", "z", "0", "string value")
-	f.StringP("stringx", "x", "0", "string value")
-	f.StringP("stringy", "y", "0", "string value")
-	f.Lookup("stringx").NoOptDefVal = "1"
-	args := []string{
-		"-ab",
-		"-cs=xx",
-		"--stringz=something",
-		"-d=true",
-		"-x",
-		"-y",
-		"ee",
-	}
-	want := []string{
-		"boola", "true",
-		"boolb", "true",
-		"boolc", "true",
-		"stringa", "xx",
-		"stringz", "something",
-		"boold", "true",
-		"stringx", "1",
-		"stringy", "ee",
-	}
-	got := []string{}
-	store := func(flag *Flag, value string) error {
-		got = append(got, flag.Name)
-		if len(value) > 0 {
-			got = append(got, value)
-		}
-		return nil
-	}
-	if err := f.ParseAll(args, store); err != nil {
-		t.Errorf("expected no error, got %s", err)
-	}
-	if !f.Parsed() {
-		t.Errorf("f.Parse() = false after Parse")
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("f.ParseAll() fail to restore the args")
-		t.Errorf("Got:  %v", got)
-		t.Errorf("Want: %v", want)
-	}
-}
-
-func testParseWithUnknownFlags(f *FlagSet, t *testing.T) {
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-	f.ParseErrorsWhitelist.UnknownFlags = true
-
-	f.BoolP("boola", "a", false, "bool value")
-	f.BoolP("boolb", "b", false, "bool2 value")
-	f.BoolP("boolc", "c", false, "bool3 value")
-	f.BoolP("boold", "d", false, "bool4 value")
-	f.BoolP("boole", "e", false, "bool4 value")
-	f.StringP("stringa", "s", "0", "string value")
-	f.StringP("stringz", "z", "0", "string value")
-	f.StringP("stringx", "x", "0", "string value")
-	f.StringP("stringy", "y", "0", "string value")
-	f.StringP("stringo", "o", "0", "string value")
-	f.Lookup("stringx").NoOptDefVal = "1"
-	args := []string{
-		"-ab",
-		"-cs=xx",
-		"--stringz=something",
-		"--unknown1",
-		"unknown1Value",
-		"-d=true",
-		"-x",
-		"--unknown2=unknown2Value",
-		"-u=unknown3Value",
-		"-p",
-		"unknown4Value",
-		"-q", //another unknown with bool value
-		"-y",
-		"ee",
-		"--unknown7=unknown7value",
-		"--stringo=ovalue",
-		"--unknown8=unknown8value",
-		"--boole",
-		"--unknown6",
-	}
-	want := []string{
-		"boola", "true",
-		"boolb", "true",
-		"boolc", "true",
-		"stringa", "xx",
-		"stringz", "something",
-		"boold", "true",
-		"stringx", "1",
-		"stringy", "ee",
-		"stringo", "ovalue",
-		"boole", "true",
-	}
-	got := []string{}
-	store := func(flag *Flag, value string) error {
-		got = append(got, flag.Name)
-		if len(value) > 0 {
-			got = append(got, value)
-		}
-		return nil
-	}
-	if err := f.ParseAll(args, store); err != nil {
-		t.Errorf("expected no error, got %s", err)
-	}
-	if !f.Parsed() {
-		t.Errorf("f.Parse() = false after Parse")
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("f.ParseAll() fail to restore the args")
-		t.Errorf("Got:  %v", got)
-		t.Errorf("Want: %v", want)
-	}
-}
-
-func TestShorthand(t *testing.T) {
-	f := NewFlagSet("shorthand", ContinueOnError)
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-	boolaFlag := f.BoolP("boola", "a", false, "bool value")
-	boolbFlag := f.BoolP("boolb", "b", false, "bool2 value")
-	boolcFlag := f.BoolP("boolc", "c", false, "bool3 value")
-	booldFlag := f.BoolP("boold", "d", false, "bool4 value")
-	stringaFlag := f.StringP("stringa", "s", "0", "string value")
-	stringzFlag := f.StringP("stringz", "z", "0", "string value")
-	extra := "interspersed-argument"
-	notaflag := "--i-look-like-a-flag"
-	args := []string{
-		"-ab",
-		extra,
-		"-cs",
-		"hello",
-		"-z=something",
-		"-d=true",
-		"--",
-		notaflag,
-	}
-	f.SetOutput(ioutil.Discard)
-	if err := f.Parse(args); err != nil {
-		t.Error("expected no error, got ", err)
-	}
-	if !f.Parsed() {
-		t.Error("f.Parse() = false after Parse")
-	}
-	if *boolaFlag != true {
-		t.Error("boola flag should be true, is ", *boolaFlag)
-	}
-	if *boolbFlag != true {
-		t.Error("boolb flag should be true, is ", *boolbFlag)
-	}
-	if *boolcFlag != true {
-		t.Error("boolc flag should be true, is ", *boolcFlag)
-	}
-	if *booldFlag != true {
-		t.Error("boold flag should be true, is ", *booldFlag)
-	}
-	if *stringaFlag != "hello" {
-		t.Error("stringa flag should be `hello`, is ", *stringaFlag)
-	}
-	if *stringzFlag != "something" {
-		t.Error("stringz flag should be `something`, is ", *stringzFlag)
-	}
-	if len(f.Args()) != 2 {
-		t.Error("expected one argument, got", len(f.Args()))
-	} else if f.Args()[0] != extra {
-		t.Errorf("expected argument %q got %q", extra, f.Args()[0])
-	} else if f.Args()[1] != notaflag {
-		t.Errorf("expected argument %q got %q", notaflag, f.Args()[1])
-	}
-	if f.ArgsLenAtDash() != 1 {
-		t.Errorf("expected argsLenAtDash %d got %d", f.ArgsLenAtDash(), 1)
-	}
-}
-
-func TestShorthandLookup(t *testing.T) {
-	f := NewFlagSet("shorthand", ContinueOnError)
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-	f.BoolP("boola", "a", false, "bool value")
-	f.BoolP("boolb", "b", false, "bool2 value")
-	args := []string{
-		"-ab",
-	}
-	f.SetOutput(ioutil.Discard)
-	if err := f.Parse(args); err != nil {
-		t.Error("expected no error, got ", err)
-	}
-	if !f.Parsed() {
-		t.Error("f.Parse() = false after Parse")
-	}
-	flag := f.ShorthandLookup("a")
-	if flag == nil {
-		t.Errorf("f.ShorthandLookup(\"a\") returned nil")
-	}
-	if flag.Name != "boola" {
-		t.Errorf("f.ShorthandLookup(\"a\") found %q instead of \"boola\"", flag.Name)
-	}
-	flag = f.ShorthandLookup("")
-	if flag != nil {
-		t.Errorf("f.ShorthandLookup(\"\") did not return nil")
-	}
-	defer func() {
-		recover()
-	}()
-	flag = f.ShorthandLookup("ab")
-	// should NEVER get here. lookup should panic. defer'd func should recover it.
-	t.Errorf("f.ShorthandLookup(\"ab\") did not panic")
-}
-
-func TestParse(t *testing.T) {
-	ResetForTesting(func() { t.Error("bad parse") })
-	testParse(GetCommandLine(), t)
-}
-
-func TestParseAll(t *testing.T) {
-	ResetForTesting(func() { t.Error("bad parse") })
-	testParseAll(GetCommandLine(), t)
-}
-
-func TestIgnoreUnknownFlags(t *testing.T) {
-	ResetForTesting(func() { t.Error("bad parse") })
-	testParseWithUnknownFlags(GetCommandLine(), t)
-}
-
-func TestFlagSetParse(t *testing.T) {
-	testParse(NewFlagSet("test", ContinueOnError), t)
-}
-
-func TestChangedHelper(t *testing.T) {
-	f := NewFlagSet("changedtest", ContinueOnError)
-	f.Bool("changed", false, "changed bool")
-	f.Bool("settrue", true, "true to true")
-	f.Bool("setfalse", false, "false to false")
-	f.Bool("unchanged", false, "unchanged bool")
-
-	args := []string{"--changed", "--settrue", "--setfalse=false"}
-	if err := f.Parse(args); err != nil {
-		t.Error("f.Parse() = false after Parse")
-	}
-	if !f.Changed("changed") {
-		t.Errorf("--changed wasn't changed!")
-	}
-	if !f.Changed("settrue") {
-		t.Errorf("--settrue wasn't changed!")
-	}
-	if !f.Changed("setfalse") {
-		t.Errorf("--setfalse wasn't changed!")
-	}
-	if f.Changed("unchanged") {
-		t.Errorf("--unchanged was changed!")
-	}
-	if f.Changed("invalid") {
-		t.Errorf("--invalid was changed!")
-	}
-	if f.ArgsLenAtDash() != -1 {
-		t.Errorf("Expected argsLenAtDash: %d but got %d", -1, f.ArgsLenAtDash())
-	}
-}
-
-func replaceSeparators(name string, from []string, to string) string {
-	result := name
-	for _, sep := range from {
-		result = strings.Replace(result, sep, to, -1)
-	}
-	// Type convert to indicate normalization has been done.
-	return result
-}
-
-func wordSepNormalizeFunc(f *FlagSet, name string) NormalizedName {
-	seps := []string{"-", "_"}
-	name = replaceSeparators(name, seps, ".")
-	normalizeFlagNameInvocations++
-
-	return NormalizedName(name)
-}
-
-func testWordSepNormalizedNames(args []string, t *testing.T) {
-	f := NewFlagSet("normalized", ContinueOnError)
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-	withDashFlag := f.Bool("with-dash-flag", false, "bool value")
-	// Set this after some flags have been added and before others.
-	f.SetNormalizeFunc(wordSepNormalizeFunc)
-	withUnderFlag := f.Bool("with_under_flag", false, "bool value")
-	withBothFlag := f.Bool("with-both_flag", false, "bool value")
-	if err := f.Parse(args); err != nil {
-		t.Fatal(err)
-	}
-	if !f.Parsed() {
-		t.Error("f.Parse() = false after Parse")
-	}
-	if *withDashFlag != true {
-		t.Error("withDashFlag flag should be true, is ", *withDashFlag)
-	}
-	if *withUnderFlag != true {
-		t.Error("withUnderFlag flag should be true, is ", *withUnderFlag)
-	}
-	if *withBothFlag != true {
-		t.Error("withBothFlag flag should be true, is ", *withBothFlag)
-	}
-}
-
-func TestWordSepNormalizedNames(t *testing.T) {
-	args := []string{
-		"--with-dash-flag",
-		"--with-under-flag",
-		"--with-both-flag",
-	}
-	testWordSepNormalizedNames(args, t)
-
-	args = []string{
-		"--with_dash_flag",
-		"--with_under_flag",
-		"--with_both_flag",
-	}
-	testWordSepNormalizedNames(args, t)
-
-	args = []string{
-		"--with-dash_flag",
-		"--with-under_flag",
-		"--with-both_flag",
-	}
-	testWordSepNormalizedNames(args, t)
-}
-
-func aliasAndWordSepFlagNames(f *FlagSet, name string) NormalizedName {
-	seps := []string{"-", "_"}
-
-	oldName := replaceSeparators("old-valid_flag", seps, ".")
-	newName := replaceSeparators("valid-flag", seps, ".")
-
-	name = replaceSeparators(name, seps, ".")
-	switch name {
-	case oldName:
-		name = newName
-	}
-
-	return NormalizedName(name)
-}
-
-func TestCustomNormalizedNames(t *testing.T) {
-	f := NewFlagSet("normalized", ContinueOnError)
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-
-	validFlag := f.Bool("valid-flag", false, "bool value")
-	f.SetNormalizeFunc(aliasAndWordSepFlagNames)
-	someOtherFlag := f.Bool("some-other-flag", false, "bool value")
-
-	args := []string{"--old_valid_flag", "--some-other_flag"}
-	if err := f.Parse(args); err != nil {
-		t.Fatal(err)
-	}
-
-	if *validFlag != true {
-		t.Errorf("validFlag is %v even though we set the alias --old_valid_falg", *validFlag)
-	}
-	if *someOtherFlag != true {
-		t.Error("someOtherFlag should be true, is ", *someOtherFlag)
-	}
-}
-
-// Every flag we add, the name (displayed also in usage) should normalized
-func TestNormalizationFuncShouldChangeFlagName(t *testing.T) {
-	// Test normalization after addition
-	f := NewFlagSet("normalized", ContinueOnError)
-
-	f.Bool("valid_flag", false, "bool value")
-	if f.Lookup("valid_flag").Name != "valid_flag" {
-		t.Error("The new flag should have the name 'valid_flag' instead of ", f.Lookup("valid_flag").Name)
-	}
-
-	f.SetNormalizeFunc(wordSepNormalizeFunc)
-	if f.Lookup("valid_flag").Name != "valid.flag" {
-		t.Error("The new flag should have the name 'valid.flag' instead of ", f.Lookup("valid_flag").Name)
-	}
-
-	// Test normalization before addition
-	f = NewFlagSet("normalized", ContinueOnError)
-	f.SetNormalizeFunc(wordSepNormalizeFunc)
-
-	f.Bool("valid_flag", false, "bool value")
-	if f.Lookup("valid_flag").Name != "valid.flag" {
-		t.Error("The new flag should have the name 'valid.flag' instead of ", f.Lookup("valid_flag").Name)
-	}
-}
-
-// Related to https://github.com/spf13/cobra/issues/521.
-func TestNormalizationSharedFlags(t *testing.T) {
-	f := NewFlagSet("set f", ContinueOnError)
-	g := NewFlagSet("set g", ContinueOnError)
-	nfunc := wordSepNormalizeFunc
-	testName := "valid_flag"
-	normName := nfunc(nil, testName)
-	if testName == string(normName) {
-		t.Error("TestNormalizationSharedFlags meaningless: the original and normalized flag names are identical:", testName)
-	}
-
-	f.Bool(testName, false, "bool value")
-	g.AddFlagSet(f)
-
-	f.SetNormalizeFunc(nfunc)
-	g.SetNormalizeFunc(nfunc)
-
-	if len(f.formal) != 1 {
-		t.Error("Normalizing flags should not result in duplications in the flag set:", f.formal)
-	}
-	if f.orderedFormal[0].Name != string(normName) {
-		t.Error("Flag name not normalized")
-	}
-	for k := range f.formal {
-		if k != "valid.flag" {
-			t.Errorf("The key in the flag map should have been normalized: wanted \"%s\", got \"%s\" instead", normName, k)
-		}
-	}
-
-	if !reflect.DeepEqual(f.formal, g.formal) || !reflect.DeepEqual(f.orderedFormal, g.orderedFormal) {
-		t.Error("Two flag sets sharing the same flags should stay consistent after being normalized. Original set:", f.formal, "Duplicate set:", g.formal)
-	}
-}
-
-func TestNormalizationSetFlags(t *testing.T) {
-	f := NewFlagSet("normalized", ContinueOnError)
-	nfunc := wordSepNormalizeFunc
-	testName := "valid_flag"
-	normName := nfunc(nil, testName)
-	if testName == string(normName) {
-		t.Error("TestNormalizationSetFlags meaningless: the original and normalized flag names are identical:", testName)
-	}
-
-	f.Bool(testName, false, "bool value")
-	f.Set(testName, "true")
-	f.SetNormalizeFunc(nfunc)
-
-	if len(f.formal) != 1 {
-		t.Error("Normalizing flags should not result in duplications in the flag set:", f.formal)
-	}
-	if f.orderedFormal[0].Name != string(normName) {
-		t.Error("Flag name not normalized")
-	}
-	for k := range f.formal {
-		if k != "valid.flag" {
-			t.Errorf("The key in the flag map should have been normalized: wanted \"%s\", got \"%s\" instead", normName, k)
-		}
-	}
-
-	if !reflect.DeepEqual(f.formal, f.actual) {
-		t.Error("The map of set flags should get normalized. Formal:", f.formal, "Actual:", f.actual)
-	}
-}
-
-// Declare a user-defined flag type.
-type flagVar []string
-
-func (f *flagVar) String() string {
-	return fmt.Sprint([]string(*f))
-}
-
-func (f *flagVar) Set(value string) error {
-	*f = append(*f, value)
-	return nil
-}
-
-func (f *flagVar) Type() string {
-	return "flagVar"
-}
-
-func TestUserDefined(t *testing.T) {
-	var flags FlagSet
-	flags.Init("test", ContinueOnError)
-	var v flagVar
-	flags.VarP(&v, "v", "v", "usage")
-	if err := flags.Parse([]string{"--v=1", "-v2", "-v", "3"}); err != nil {
-		t.Error(err)
-	}
-	if len(v) != 3 {
-		t.Fatal("expected 3 args; got ", len(v))
-	}
-	expect := "[1 2 3]"
-	if v.String() != expect {
-		t.Errorf("expected value %q got %q", expect, v.String())
-	}
-}
-
-func TestSetOutput(t *testing.T) {
-	var flags FlagSet
-	var buf bytes.Buffer
-	flags.SetOutput(&buf)
-	flags.Init("test", ContinueOnError)
-	flags.Parse([]string{"--unknown"})
-	if out := buf.String(); !strings.Contains(out, "--unknown") {
-		t.Logf("expected output mentioning unknown; got %q", out)
-	}
-}
-
-// This tests that one can reset the flags. This still works but not well, and is
-// superseded by FlagSet.
-func TestChangingArgs(t *testing.T) {
-	ResetForTesting(func() { t.Fatal("bad parse") })
-	oldArgs := os.Args
-	defer func() { os.Args = oldArgs }()
-	os.Args = []string{"cmd", "--before", "subcmd"}
-	before := Bool("before", false, "")
-	if err := GetCommandLine().Parse(os.Args[1:]); err != nil {
-		t.Fatal(err)
-	}
-	cmd := Arg(0)
-	os.Args = []string{"subcmd", "--after", "args"}
-	after := Bool("after", false, "")
-	Parse()
-	args := Args()
-
-	if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" {
-		t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args)
-	}
-}
-
-// Test that -help invokes the usage message and returns ErrHelp.
-func TestHelp(t *testing.T) {
-	var helpCalled = false
-	fs := NewFlagSet("help test", ContinueOnError)
-	fs.Usage = func() { helpCalled = true }
-	var flag bool
-	fs.BoolVar(&flag, "flag", false, "regular flag")
-	// Regular flag invocation should work
-	err := fs.Parse([]string{"--flag=true"})
-	if err != nil {
-		t.Fatal("expected no error; got ", err)
-	}
-	if !flag {
-		t.Error("flag was not set by --flag")
-	}
-	if helpCalled {
-		t.Error("help called for regular flag")
-		helpCalled = false // reset for next test
-	}
-	// Help flag should work as expected.
-	err = fs.Parse([]string{"--help"})
-	if err == nil {
-		t.Fatal("error expected")
-	}
-	if err != ErrHelp {
-		t.Fatal("expected ErrHelp; got ", err)
-	}
-	if !helpCalled {
-		t.Fatal("help was not called")
-	}
-	// If we define a help flag, that should override.
-	var help bool
-	fs.BoolVar(&help, "help", false, "help flag")
-	helpCalled = false
-	err = fs.Parse([]string{"--help"})
-	if err != nil {
-		t.Fatal("expected no error for defined --help; got ", err)
-	}
-	if helpCalled {
-		t.Fatal("help was called; should not have been for defined help flag")
-	}
-}
-
-func TestNoInterspersed(t *testing.T) {
-	f := NewFlagSet("test", ContinueOnError)
-	f.SetInterspersed(false)
-	f.Bool("true", true, "always true")
-	f.Bool("false", false, "always false")
-	err := f.Parse([]string{"--true", "break", "--false"})
-	if err != nil {
-		t.Fatal("expected no error; got ", err)
-	}
-	args := f.Args()
-	if len(args) != 2 || args[0] != "break" || args[1] != "--false" {
-		t.Fatal("expected interspersed options/non-options to fail")
-	}
-}
-
-func TestTermination(t *testing.T) {
-	f := NewFlagSet("termination", ContinueOnError)
-	boolFlag := f.BoolP("bool", "l", false, "bool value")
-	if f.Parsed() {
-		t.Error("f.Parse() = true before Parse")
-	}
-	arg1 := "ls"
-	arg2 := "-l"
-	args := []string{
-		"--",
-		arg1,
-		arg2,
-	}
-	f.SetOutput(ioutil.Discard)
-	if err := f.Parse(args); err != nil {
-		t.Fatal("expected no error; got ", err)
-	}
-	if !f.Parsed() {
-		t.Error("f.Parse() = false after Parse")
-	}
-	if *boolFlag {
-		t.Error("expected boolFlag=false, got true")
-	}
-	if len(f.Args()) != 2 {
-		t.Errorf("expected 2 arguments, got %d: %v", len(f.Args()), f.Args())
-	}
-	if f.Args()[0] != arg1 {
-		t.Errorf("expected argument %q got %q", arg1, f.Args()[0])
-	}
-	if f.Args()[1] != arg2 {
-		t.Errorf("expected argument %q got %q", arg2, f.Args()[1])
-	}
-	if f.ArgsLenAtDash() != 0 {
-		t.Errorf("expected argsLenAtDash %d got %d", 0, f.ArgsLenAtDash())
-	}
-}
-
-func getDeprecatedFlagSet() *FlagSet {
-	f := NewFlagSet("bob", ContinueOnError)
-	f.Bool("badflag", true, "always true")
-	f.MarkDeprecated("badflag", "use --good-flag instead")
-	return f
-}
-func TestDeprecatedFlagInDocs(t *testing.T) {
-	f := getDeprecatedFlagSet()
-
-	out := new(bytes.Buffer)
-	f.SetOutput(out)
-	f.PrintDefaults()
-
-	if strings.Contains(out.String(), "badflag") {
-		t.Errorf("found deprecated flag in usage!")
-	}
-}
-
-func TestUnHiddenDeprecatedFlagInDocs(t *testing.T) {
-	f := getDeprecatedFlagSet()
-	flg := f.Lookup("badflag")
-	if flg == nil {
-		t.Fatalf("Unable to lookup 'bob' in TestUnHiddenDeprecatedFlagInDocs")
-	}
-	flg.Hidden = false
-
-	out := new(bytes.Buffer)
-	f.SetOutput(out)
-	f.PrintDefaults()
-
-	defaults := out.String()
-	if !strings.Contains(defaults, "badflag") {
-		t.Errorf("Did not find deprecated flag in usage!")
-	}
-	if !strings.Contains(defaults, "use --good-flag instead") {
-		t.Errorf("Did not find 'use --good-flag instead' in defaults")
-	}
-}
-
-func TestDeprecatedFlagShorthandInDocs(t *testing.T) {
-	f := NewFlagSet("bob", ContinueOnError)
-	name := "noshorthandflag"
-	f.BoolP(name, "n", true, "always true")
-	f.MarkShorthandDeprecated("noshorthandflag", fmt.Sprintf("use --%s instead", name))
-
-	out := new(bytes.Buffer)
-	f.SetOutput(out)
-	f.PrintDefaults()
-
-	if strings.Contains(out.String(), "-n,") {
-		t.Errorf("found deprecated flag shorthand in usage!")
-	}
-}
-
-func parseReturnStderr(t *testing.T, f *FlagSet, args []string) (string, error) {
-	oldStderr := os.Stderr
-	r, w, _ := os.Pipe()
-	os.Stderr = w
-
-	err := f.Parse(args)
-
-	outC := make(chan string)
-	// copy the output in a separate goroutine so printing can't block indefinitely
-	go func() {
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-		outC <- buf.String()
-	}()
-
-	w.Close()
-	os.Stderr = oldStderr
-	out := <-outC
-
-	return out, err
-}
-
-func TestDeprecatedFlagUsage(t *testing.T) {
-	f := NewFlagSet("bob", ContinueOnError)
-	f.Bool("badflag", true, "always true")
-	usageMsg := "use --good-flag instead"
-	f.MarkDeprecated("badflag", usageMsg)
-
-	args := []string{"--badflag"}
-	out, err := parseReturnStderr(t, f, args)
-	if err != nil {
-		t.Fatal("expected no error; got ", err)
-	}
-
-	if !strings.Contains(out, usageMsg) {
-		t.Errorf("usageMsg not printed when using a deprecated flag!")
-	}
-}
-
-func TestDeprecatedFlagShorthandUsage(t *testing.T) {
-	f := NewFlagSet("bob", ContinueOnError)
-	name := "noshorthandflag"
-	f.BoolP(name, "n", true, "always true")
-	usageMsg := fmt.Sprintf("use --%s instead", name)
-	f.MarkShorthandDeprecated(name, usageMsg)
-
-	args := []string{"-n"}
-	out, err := parseReturnStderr(t, f, args)
-	if err != nil {
-		t.Fatal("expected no error; got ", err)
-	}
-
-	if !strings.Contains(out, usageMsg) {
-		t.Errorf("usageMsg not printed when using a deprecated flag!")
-	}
-}
-
-func TestDeprecatedFlagUsageNormalized(t *testing.T) {
-	f := NewFlagSet("bob", ContinueOnError)
-	f.Bool("bad-double_flag", true, "always true")
-	f.SetNormalizeFunc(wordSepNormalizeFunc)
-	usageMsg := "use --good-flag instead"
-	f.MarkDeprecated("bad_double-flag", usageMsg)
-
-	args := []string{"--bad_double_flag"}
-	out, err := parseReturnStderr(t, f, args)
-	if err != nil {
-		t.Fatal("expected no error; got ", err)
-	}
-
-	if !strings.Contains(out, usageMsg) {
-		t.Errorf("usageMsg not printed when using a deprecated flag!")
-	}
-}
-
-// Name normalization function should be called only once on flag addition
-func TestMultipleNormalizeFlagNameInvocations(t *testing.T) {
-	normalizeFlagNameInvocations = 0
-
-	f := NewFlagSet("normalized", ContinueOnError)
-	f.SetNormalizeFunc(wordSepNormalizeFunc)
-	f.Bool("with_under_flag", false, "bool value")
-
-	if normalizeFlagNameInvocations != 1 {
-		t.Fatal("Expected normalizeFlagNameInvocations to be 1; got ", normalizeFlagNameInvocations)
-	}
-}
-
-//
-func TestHiddenFlagInUsage(t *testing.T) {
-	f := NewFlagSet("bob", ContinueOnError)
-	f.Bool("secretFlag", true, "shhh")
-	f.MarkHidden("secretFlag")
-
-	out := new(bytes.Buffer)
-	f.SetOutput(out)
-	f.PrintDefaults()
-
-	if strings.Contains(out.String(), "secretFlag") {
-		t.Errorf("found hidden flag in usage!")
-	}
-}
-
-//
-func TestHiddenFlagUsage(t *testing.T) {
-	f := NewFlagSet("bob", ContinueOnError)
-	f.Bool("secretFlag", true, "shhh")
-	f.MarkHidden("secretFlag")
-
-	args := []string{"--secretFlag"}
-	out, err := parseReturnStderr(t, f, args)
-	if err != nil {
-		t.Fatal("expected no error; got ", err)
-	}
-
-	if strings.Contains(out, "shhh") {
-		t.Errorf("usage message printed when using a hidden flag!")
-	}
-}
-
-const defaultOutput = `      --A                         for bootstrapping, allow 'any' type
-      --Alongflagname             disable bounds checking
-  -C, --CCC                       a boolean defaulting to true (default true)
-      --D path                    set relative path for local imports
-  -E, --EEE num[=1234]            a num with NoOptDefVal (default 4321)
-      --F number                  a non-zero number (default 2.7)
-      --G float                   a float that defaults to zero
-      --IP ip                     IP address with no default
-      --IPMask ipMask             Netmask address with no default
-      --IPNet ipNet               IP network with no default
-      --Ints ints                 int slice with zero default
-      --N int                     a non-zero int (default 27)
-      --ND1 string[="bar"]        a string with NoOptDefVal (default "foo")
-      --ND2 num[=4321]            a num with NoOptDefVal (default 1234)
-      --StringArray stringArray   string array with zero default
-      --StringSlice strings       string slice with zero default
-      --Z int                     an int that defaults to zero
-      --custom custom             custom Value implementation
-      --customP custom            a VarP with default (default 10)
-      --maxT timeout              set timeout for dial
-  -v, --verbose count             verbosity
-`
-
-// Custom value that satisfies the Value interface.
-type customValue int
-
-func (cv *customValue) String() string { return fmt.Sprintf("%v", *cv) }
-
-func (cv *customValue) Set(s string) error {
-	v, err := strconv.ParseInt(s, 0, 64)
-	*cv = customValue(v)
-	return err
-}
-
-func (cv *customValue) Type() string { return "custom" }
-
-func TestPrintDefaults(t *testing.T) {
-	fs := NewFlagSet("print defaults test", ContinueOnError)
-	var buf bytes.Buffer
-	fs.SetOutput(&buf)
-	fs.Bool("A", false, "for bootstrapping, allow 'any' type")
-	fs.Bool("Alongflagname", false, "disable bounds checking")
-	fs.BoolP("CCC", "C", true, "a boolean defaulting to true")
-	fs.String("D", "", "set relative `path` for local imports")
-	fs.Float64("F", 2.7, "a non-zero `number`")
-	fs.Float64("G", 0, "a float that defaults to zero")
-	fs.Int("N", 27, "a non-zero int")
-	fs.IntSlice("Ints", []int{}, "int slice with zero default")
-	fs.IP("IP", nil, "IP address with no default")
-	fs.IPMask("IPMask", nil, "Netmask address with no default")
-	fs.IPNet("IPNet", net.IPNet{}, "IP network with no default")
-	fs.Int("Z", 0, "an int that defaults to zero")
-	fs.Duration("maxT", 0, "set `timeout` for dial")
-	fs.String("ND1", "foo", "a string with NoOptDefVal")
-	fs.Lookup("ND1").NoOptDefVal = "bar"
-	fs.Int("ND2", 1234, "a `num` with NoOptDefVal")
-	fs.Lookup("ND2").NoOptDefVal = "4321"
-	fs.IntP("EEE", "E", 4321, "a `num` with NoOptDefVal")
-	fs.ShorthandLookup("E").NoOptDefVal = "1234"
-	fs.StringSlice("StringSlice", []string{}, "string slice with zero default")
-	fs.StringArray("StringArray", []string{}, "string array with zero default")
-	fs.CountP("verbose", "v", "verbosity")
-
-	var cv customValue
-	fs.Var(&cv, "custom", "custom Value implementation")
-
-	cv2 := customValue(10)
-	fs.VarP(&cv2, "customP", "", "a VarP with default")
-
-	fs.PrintDefaults()
-	got := buf.String()
-	if got != defaultOutput {
-		fmt.Println("\n" + got)
-		fmt.Println("\n" + defaultOutput)
-		t.Errorf("got %q want %q\n", got, defaultOutput)
-	}
-}
-
-func TestVisitAllFlagOrder(t *testing.T) {
-	fs := NewFlagSet("TestVisitAllFlagOrder", ContinueOnError)
-	fs.SortFlags = false
-	// https://github.com/spf13/pflag/issues/120
-	fs.SetNormalizeFunc(func(f *FlagSet, name string) NormalizedName {
-		return NormalizedName(name)
-	})
-
-	names := []string{"C", "B", "A", "D"}
-	for _, name := range names {
-		fs.Bool(name, false, "")
-	}
-
-	i := 0
-	fs.VisitAll(func(f *Flag) {
-		if names[i] != f.Name {
-			t.Errorf("Incorrect order. Expected %v, got %v", names[i], f.Name)
-		}
-		i++
-	})
-}
-
-func TestVisitFlagOrder(t *testing.T) {
-	fs := NewFlagSet("TestVisitFlagOrder", ContinueOnError)
-	fs.SortFlags = false
-	names := []string{"C", "B", "A", "D"}
-	for _, name := range names {
-		fs.Bool(name, false, "")
-		fs.Set(name, "true")
-	}
-
-	i := 0
-	fs.Visit(func(f *Flag) {
-		if names[i] != f.Name {
-			t.Errorf("Incorrect order. Expected %v, got %v", names[i], f.Name)
-		}
-		i++
-	})
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/golangflag_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/golangflag_test.go
deleted file mode 100644
index 5bd831b..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/golangflag_test.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	goflag "flag"
-	"testing"
-)
-
-func TestGoflags(t *testing.T) {
-	goflag.String("stringFlag", "stringFlag", "stringFlag")
-	goflag.Bool("boolFlag", false, "boolFlag")
-
-	f := NewFlagSet("test", ContinueOnError)
-
-	f.AddGoFlagSet(goflag.CommandLine)
-	err := f.Parse([]string{"--stringFlag=bob", "--boolFlag"})
-	if err != nil {
-		t.Fatal("expected no error; get", err)
-	}
-
-	getString, err := f.GetString("stringFlag")
-	if err != nil {
-		t.Fatal("expected no error; get", err)
-	}
-	if getString != "bob" {
-		t.Fatalf("expected getString=bob but got getString=%s", getString)
-	}
-
-	getBool, err := f.GetBool("boolFlag")
-	if err != nil {
-		t.Fatal("expected no error; get", err)
-	}
-	if getBool != true {
-		t.Fatalf("expected getBool=true but got getBool=%v", getBool)
-	}
-	if !f.Parsed() {
-		t.Fatal("f.Parsed() return false after f.Parse() called")
-	}
-
-	// in fact it is useless. because `go test` called flag.Parse()
-	if !goflag.CommandLine.Parsed() {
-		t.Fatal("goflag.CommandLine.Parsed() return false after f.Parse() called")
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/int_slice_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/int_slice_test.go
deleted file mode 100644
index 745aecb..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/int_slice_test.go
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func setUpISFlagSet(isp *[]int) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IntSliceVar(isp, "is", []int{}, "Command separated list!")
-	return f
-}
-
-func setUpISFlagSetWithDefault(isp *[]int) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IntSliceVar(isp, "is", []int{0, 1}, "Command separated list!")
-	return f
-}
-
-func TestEmptyIS(t *testing.T) {
-	var is []int
-	f := setUpISFlagSet(&is)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatal("got an error from GetIntSlice():", err)
-	}
-	if len(getIS) != 0 {
-		t.Fatalf("got is %v with len=%d but expected length=0", getIS, len(getIS))
-	}
-}
-
-func TestIS(t *testing.T) {
-	var is []int
-	f := setUpISFlagSet(&is)
-
-	vals := []string{"1", "2", "4", "3"}
-	arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %s but got: %d", i, vals[i], v)
-		}
-	}
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatalf("got error: %v", err)
-	}
-	for i, v := range getIS {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %s but got: %d from GetIntSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestISDefault(t *testing.T) {
-	var is []int
-	f := setUpISFlagSetWithDefault(&is)
-
-	vals := []string{"0", "1"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
-		}
-	}
-
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatal("got an error from GetIntSlice():", err)
-	}
-	for i, v := range getIS {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatal("got an error from GetIntSlice():", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
-		}
-	}
-}
-
-func TestISWithDefault(t *testing.T) {
-	var is []int
-	f := setUpISFlagSetWithDefault(&is)
-
-	vals := []string{"1", "2"}
-	arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
-		}
-	}
-
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatal("got an error from GetIntSlice():", err)
-	}
-	for i, v := range getIS {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
-		}
-	}
-}
-
-func TestISCalledTwice(t *testing.T) {
-	var is []int
-	f := setUpISFlagSet(&is)
-
-	in := []string{"1,2", "3"}
-	expected := []int{1, 2, 3}
-	argfmt := "--is=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		if expected[i] != v {
-			t.Fatalf("expected is[%d] to be %d but got: %d", i, expected[i], v)
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/ip_slice_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/ip_slice_test.go
deleted file mode 100644
index b0c681c..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/ip_slice_test.go
+++ /dev/null
@@ -1,222 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"strings"
-	"testing"
-)
-
-func setUpIPSFlagSet(ipsp *[]net.IP) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IPSliceVar(ipsp, "ips", []net.IP{}, "Command separated list!")
-	return f
-}
-
-func setUpIPSFlagSetWithDefault(ipsp *[]net.IP) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IPSliceVar(ipsp, "ips",
-		[]net.IP{
-			net.ParseIP("192.168.1.1"),
-			net.ParseIP("0:0:0:0:0:0:0:1"),
-		},
-		"Command separated list!")
-	return f
-}
-
-func TestEmptyIP(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSet(&ips)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getIPS, err := f.GetIPSlice("ips")
-	if err != nil {
-		t.Fatal("got an error from GetIPSlice():", err)
-	}
-	if len(getIPS) != 0 {
-		t.Fatalf("got ips %v with len=%d but expected length=0", getIPS, len(getIPS))
-	}
-}
-
-func TestIPS(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSet(&ips)
-
-	vals := []string{"192.168.1.1", "10.0.0.1", "0:0:0:0:0:0:0:2"}
-	arg := fmt.Sprintf("--ips=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s from GetIPSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestIPSDefault(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSetWithDefault(&ips)
-
-	vals := []string{"192.168.1.1", "0:0:0:0:0:0:0:1"}
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getIPS, err := f.GetIPSlice("ips")
-	if err != nil {
-		t.Fatal("got an error from GetIPSlice")
-	}
-	for i, v := range getIPS {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestIPSWithDefault(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSetWithDefault(&ips)
-
-	vals := []string{"192.168.1.1", "0:0:0:0:0:0:0:1"}
-	arg := fmt.Sprintf("--ips=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getIPS, err := f.GetIPSlice("ips")
-	if err != nil {
-		t.Fatal("got an error from GetIPSlice")
-	}
-	for i, v := range getIPS {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestIPSCalledTwice(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSet(&ips)
-
-	in := []string{"192.168.1.2,0:0:0:0:0:0:0:1", "10.0.0.1"}
-	expected := []net.IP{net.ParseIP("192.168.1.2"), net.ParseIP("0:0:0:0:0:0:0:1"), net.ParseIP("10.0.0.1")}
-	argfmt := "ips=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if !expected[i].Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestIPSBadQuoting(t *testing.T) {
-
-	tests := []struct {
-		Want    []net.IP
-		FlagArg []string
-	}{
-		{
-			Want: []net.IP{
-				net.ParseIP("a4ab:61d:f03e:5d7d:fad7:d4c2:a1a5:568"),
-				net.ParseIP("203.107.49.208"),
-				net.ParseIP("14.57.204.90"),
-			},
-			FlagArg: []string{
-				"a4ab:61d:f03e:5d7d:fad7:d4c2:a1a5:568",
-				"203.107.49.208",
-				"14.57.204.90",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("204.228.73.195"),
-				net.ParseIP("86.141.15.94"),
-			},
-			FlagArg: []string{
-				"204.228.73.195",
-				"86.141.15.94",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("c70c:db36:3001:890f:c6ea:3f9b:7a39:cc3f"),
-				net.ParseIP("4d17:1d6e:e699:bd7a:88c5:5e7e:ac6a:4472"),
-			},
-			FlagArg: []string{
-				"c70c:db36:3001:890f:c6ea:3f9b:7a39:cc3f",
-				"4d17:1d6e:e699:bd7a:88c5:5e7e:ac6a:4472",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("5170:f971:cfac:7be3:512a:af37:952c:bc33"),
-				net.ParseIP("93.21.145.140"),
-				net.ParseIP("2cac:61d3:c5ff:6caf:73e0:1b1a:c336:c1ca"),
-			},
-			FlagArg: []string{
-				" 5170:f971:cfac:7be3:512a:af37:952c:bc33  , 93.21.145.140     ",
-				"2cac:61d3:c5ff:6caf:73e0:1b1a:c336:c1ca",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-			},
-			FlagArg: []string{
-				`"2e5e:66b2:6441:848:5b74:76ea:574c:3a7b,        2e5e:66b2:6441:848:5b74:76ea:574c:3a7b,2e5e:66b2:6441:848:5b74:76ea:574c:3a7b     "`,
-				" 2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"},
-		},
-	}
-
-	for i, test := range tests {
-
-		var ips []net.IP
-		f := setUpIPSFlagSet(&ips)
-
-		if err := f.Parse([]string{fmt.Sprintf("--ips=%s", strings.Join(test.FlagArg, ","))}); err != nil {
-			t.Fatalf("flag parsing failed with error: %s\nparsing:\t%#v\nwant:\t\t%s",
-				err, test.FlagArg, test.Want[i])
-		}
-
-		for j, b := range ips {
-			if !b.Equal(test.Want[j]) {
-				t.Fatalf("bad value parsed for test %d on net.IP %d:\nwant:\t%s\ngot:\t%s", i, j, test.Want[j], b)
-			}
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/ip_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/ip_test.go
deleted file mode 100644
index 1fec50e..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/ip_test.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"testing"
-)
-
-func setUpIP(ip *net.IP) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IPVar(ip, "address", net.ParseIP("0.0.0.0"), "IP Address")
-	return f
-}
-
-func TestIP(t *testing.T) {
-	testCases := []struct {
-		input    string
-		success  bool
-		expected string
-	}{
-		{"0.0.0.0", true, "0.0.0.0"},
-		{" 0.0.0.0 ", true, "0.0.0.0"},
-		{"1.2.3.4", true, "1.2.3.4"},
-		{"127.0.0.1", true, "127.0.0.1"},
-		{"255.255.255.255", true, "255.255.255.255"},
-		{"", false, ""},
-		{"0", false, ""},
-		{"localhost", false, ""},
-		{"0.0.0", false, ""},
-		{"0.0.0.", false, ""},
-		{"0.0.0.0.", false, ""},
-		{"0.0.0.256", false, ""},
-		{"0 . 0 . 0 . 0", false, ""},
-	}
-
-	devnull, _ := os.Open(os.DevNull)
-	os.Stderr = devnull
-	for i := range testCases {
-		var addr net.IP
-		f := setUpIP(&addr)
-
-		tc := &testCases[i]
-
-		arg := fmt.Sprintf("--address=%s", tc.input)
-		err := f.Parse([]string{arg})
-		if err != nil && tc.success == true {
-			t.Errorf("expected success, got %q", err)
-			continue
-		} else if err == nil && tc.success == false {
-			t.Errorf("expected failure")
-			continue
-		} else if tc.success {
-			ip, err := f.GetIP("address")
-			if err != nil {
-				t.Errorf("Got error trying to fetch the IP flag: %v", err)
-			}
-			if ip.String() != tc.expected {
-				t.Errorf("expected %q, got %q", tc.expected, ip.String())
-			}
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/ipnet_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/ipnet_test.go
deleted file mode 100644
index 335b6fa..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/ipnet_test.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"testing"
-)
-
-func setUpIPNet(ip *net.IPNet) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	_, def, _ := net.ParseCIDR("0.0.0.0/0")
-	f.IPNetVar(ip, "address", *def, "IP Address")
-	return f
-}
-
-func TestIPNet(t *testing.T) {
-	testCases := []struct {
-		input    string
-		success  bool
-		expected string
-	}{
-		{"0.0.0.0/0", true, "0.0.0.0/0"},
-		{" 0.0.0.0/0 ", true, "0.0.0.0/0"},
-		{"1.2.3.4/8", true, "1.0.0.0/8"},
-		{"127.0.0.1/16", true, "127.0.0.0/16"},
-		{"255.255.255.255/19", true, "255.255.224.0/19"},
-		{"255.255.255.255/32", true, "255.255.255.255/32"},
-		{"", false, ""},
-		{"/0", false, ""},
-		{"0", false, ""},
-		{"0/0", false, ""},
-		{"localhost/0", false, ""},
-		{"0.0.0/4", false, ""},
-		{"0.0.0./8", false, ""},
-		{"0.0.0.0./12", false, ""},
-		{"0.0.0.256/16", false, ""},
-		{"0.0.0.0 /20", false, ""},
-		{"0.0.0.0/ 24", false, ""},
-		{"0 . 0 . 0 . 0 / 28", false, ""},
-		{"0.0.0.0/33", false, ""},
-	}
-
-	devnull, _ := os.Open(os.DevNull)
-	os.Stderr = devnull
-	for i := range testCases {
-		var addr net.IPNet
-		f := setUpIPNet(&addr)
-
-		tc := &testCases[i]
-
-		arg := fmt.Sprintf("--address=%s", tc.input)
-		err := f.Parse([]string{arg})
-		if err != nil && tc.success == true {
-			t.Errorf("expected success, got %q", err)
-			continue
-		} else if err == nil && tc.success == false {
-			t.Errorf("expected failure")
-			continue
-		} else if tc.success {
-			ip, err := f.GetIPNet("address")
-			if err != nil {
-				t.Errorf("Got error trying to fetch the IP flag: %v", err)
-			}
-			if ip.String() != tc.expected {
-				t.Errorf("expected %q, got %q", tc.expected, ip.String())
-			}
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/printusage_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/printusage_test.go
deleted file mode 100644
index df982aa..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/printusage_test.go
+++ /dev/null
@@ -1,74 +0,0 @@
-package pflag
-
-import (
-	"bytes"
-	"io"
-	"testing"
-)
-
-const expectedOutput = `      --long-form    Some description
-      --long-form2   Some description
-                       with multiline
-  -s, --long-name    Some description
-  -t, --long-name2   Some description with
-                       multiline
-`
-
-func setUpPFlagSet(buf io.Writer) *FlagSet {
-	f := NewFlagSet("test", ExitOnError)
-	f.Bool("long-form", false, "Some description")
-	f.Bool("long-form2", false, "Some description\n  with multiline")
-	f.BoolP("long-name", "s", false, "Some description")
-	f.BoolP("long-name2", "t", false, "Some description with\n  multiline")
-	f.SetOutput(buf)
-	return f
-}
-
-func TestPrintUsage(t *testing.T) {
-	buf := bytes.Buffer{}
-	f := setUpPFlagSet(&buf)
-	f.PrintDefaults()
-	res := buf.String()
-	if res != expectedOutput {
-		t.Errorf("Expected \n%s \nActual \n%s", expectedOutput, res)
-	}
-}
-
-func setUpPFlagSet2(buf io.Writer) *FlagSet {
-	f := NewFlagSet("test", ExitOnError)
-	f.Bool("long-form", false, "Some description")
-	f.Bool("long-form2", false, "Some description\n  with multiline")
-	f.BoolP("long-name", "s", false, "Some description")
-	f.BoolP("long-name2", "t", false, "Some description with\n  multiline")
-	f.StringP("some-very-long-arg", "l", "test", "Some very long description having break the limit")
-	f.StringP("other-very-long-arg", "o", "long-default-value", "Some very long description having break the limit")
-	f.String("some-very-long-arg2", "very long default value", "Some very long description\nwith line break\nmultiple")
-	f.SetOutput(buf)
-	return f
-}
-
-const expectedOutput2 = `      --long-form                    Some description
-      --long-form2                   Some description
-                                       with multiline
-  -s, --long-name                    Some description
-  -t, --long-name2                   Some description with
-                                       multiline
-  -o, --other-very-long-arg string   Some very long description having
-                                     break the limit (default
-                                     "long-default-value")
-  -l, --some-very-long-arg string    Some very long description having
-                                     break the limit (default "test")
-      --some-very-long-arg2 string   Some very long description
-                                     with line break
-                                     multiple (default "very long default
-                                     value")
-`
-
-func TestPrintUsage_2(t *testing.T) {
-	buf := bytes.Buffer{}
-	f := setUpPFlagSet2(&buf)
-	res := f.FlagUsagesWrapped(80)
-	if res != expectedOutput2 {
-		t.Errorf("Expected \n%q \nActual \n%q", expectedOutput2, res)
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/string_array_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/string_array_test.go
deleted file mode 100644
index 1ceac8c..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/string_array_test.go
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"fmt"
-	"testing"
-)
-
-func setUpSAFlagSet(sap *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringArrayVar(sap, "sa", []string{}, "Command separated list!")
-	return f
-}
-
-func setUpSAFlagSetWithDefault(sap *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringArrayVar(sap, "sa", []string{"default", "values"}, "Command separated list!")
-	return f
-}
-
-func TestEmptySA(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-	if len(getSA) != 0 {
-		t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
-	}
-}
-
-func TestEmptySAValue(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-	err := f.Parse([]string{"--sa="})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-	if len(getSA) != 0 {
-		t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
-	}
-}
-
-func TestSADefault(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSetWithDefault(&sa)
-
-	vals := []string{"default", "values"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range sa {
-		if vals[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-	for i, v := range getSA {
-		if vals[i] != v {
-			t.Fatalf("expected sa[%d] to be %s from GetStringArray but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSAWithDefault(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSetWithDefault(&sa)
-
-	val := "one"
-	arg := fmt.Sprintf("--sa=%s", val)
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(sa) != 1 {
-		t.Fatalf("expected number of values to be %d but %d", 1, len(sa))
-	}
-
-	if sa[0] != val {
-		t.Fatalf("expected value to be %s but got: %s", sa[0], val)
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-
-	if len(getSA) != 1 {
-		t.Fatalf("expected number of values to be %d but %d", 1, len(getSA))
-	}
-
-	if getSA[0] != val {
-		t.Fatalf("expected value to be %s but got: %s", getSA[0], val)
-	}
-}
-
-func TestSACalledTwice(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-
-	in := []string{"one", "two"}
-	expected := []string{"one", "two"}
-	argfmt := "--sa=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(sa) {
-		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range sa {
-		if expected[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSAWithSpecialChar(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-
-	in := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
-	expected := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
-	argfmt := "--sa=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	arg3 := fmt.Sprintf(argfmt, in[2])
-	arg4 := fmt.Sprintf(argfmt, in[3])
-	err := f.Parse([]string{arg1, arg2, arg3, arg4})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(sa) {
-		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range sa {
-		if expected[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSAWithSquareBrackets(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-
-	in := []string{"][]-[", "[a-z]", "[a-z]+"}
-	expected := []string{"][]-[", "[a-z]", "[a-z]+"}
-	argfmt := "--sa=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	arg3 := fmt.Sprintf(argfmt, in[2])
-	err := f.Parse([]string{arg1, arg2, arg3})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(sa) {
-		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range sa {
-		if expected[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/string_slice_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/string_slice_test.go
deleted file mode 100644
index c41f3bd..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/string_slice_test.go
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-func setUpSSFlagSet(ssp *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringSliceVar(ssp, "ss", []string{}, "Command separated list!")
-	return f
-}
-
-func setUpSSFlagSetWithDefault(ssp *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringSliceVar(ssp, "ss", []string{"default", "values"}, "Command separated list!")
-	return f
-}
-
-func TestEmptySS(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	if len(getSS) != 0 {
-		t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
-	}
-}
-
-func TestEmptySSValue(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-	err := f.Parse([]string{"--ss="})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	if len(getSS) != 0 {
-		t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
-	}
-}
-
-func TestSS(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	vals := []string{"one", "two", "4", "3"}
-	arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ss {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	for i, v := range getSS {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSSDefault(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSetWithDefault(&ss)
-
-	vals := []string{"default", "values"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ss {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	for i, v := range getSS {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSSWithDefault(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSetWithDefault(&ss)
-
-	vals := []string{"one", "two", "4", "3"}
-	arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ss {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	for i, v := range getSS {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSSCalledTwice(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	in := []string{"one,two", "three"}
-	expected := []string{"one", "two", "three"}
-	argfmt := "--ss=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(ss) {
-		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range ss {
-		if expected[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSSWithComma(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	in := []string{`"one,two"`, `"three"`, `"four,five",six`}
-	expected := []string{"one,two", "three", "four,five", "six"}
-	argfmt := "--ss=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	arg3 := fmt.Sprintf(argfmt, in[2])
-	err := f.Parse([]string{arg1, arg2, arg3})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(ss) {
-		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range ss {
-		if expected[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSSWithSquareBrackets(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	in := []string{`"[a-z]"`, `"[a-z]+"`}
-	expected := []string{"[a-z]", "[a-z]+"}
-	argfmt := "--ss=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(ss) {
-		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range ss {
-		if expected[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/github.com/spf13/pflag/uint_slice_test.go b/cmd/viewcore/vendor/github.com/spf13/pflag/uint_slice_test.go
deleted file mode 100644
index db1a19d..0000000
--- a/cmd/viewcore/vendor/github.com/spf13/pflag/uint_slice_test.go
+++ /dev/null
@@ -1,161 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func setUpUISFlagSet(uisp *[]uint) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.UintSliceVar(uisp, "uis", []uint{}, "Command separated list!")
-	return f
-}
-
-func setUpUISFlagSetWithDefault(uisp *[]uint) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.UintSliceVar(uisp, "uis", []uint{0, 1}, "Command separated list!")
-	return f
-}
-
-func TestEmptyUIS(t *testing.T) {
-	var uis []uint
-	f := setUpUISFlagSet(&uis)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getUIS, err := f.GetUintSlice("uis")
-	if err != nil {
-		t.Fatal("got an error from GetUintSlice():", err)
-	}
-	if len(getUIS) != 0 {
-		t.Fatalf("got is %v with len=%d but expected length=0", getUIS, len(getUIS))
-	}
-}
-
-func TestUIS(t *testing.T) {
-	var uis []uint
-	f := setUpUISFlagSet(&uis)
-
-	vals := []string{"1", "2", "4", "3"}
-	arg := fmt.Sprintf("--uis=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range uis {
-		u, err := strconv.ParseUint(vals[i], 10, 0)
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if uint(u) != v {
-			t.Fatalf("expected uis[%d] to be %s but got %d", i, vals[i], v)
-		}
-	}
-	getUIS, err := f.GetUintSlice("uis")
-	if err != nil {
-		t.Fatalf("got error: %v", err)
-	}
-	for i, v := range getUIS {
-		u, err := strconv.ParseUint(vals[i], 10, 0)
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if uint(u) != v {
-			t.Fatalf("expected uis[%d] to be %s but got: %d from GetUintSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestUISDefault(t *testing.T) {
-	var uis []uint
-	f := setUpUISFlagSetWithDefault(&uis)
-
-	vals := []string{"0", "1"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range uis {
-		u, err := strconv.ParseUint(vals[i], 10, 0)
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if uint(u) != v {
-			t.Fatalf("expect uis[%d] to be %d but got: %d", i, u, v)
-		}
-	}
-
-	getUIS, err := f.GetUintSlice("uis")
-	if err != nil {
-		t.Fatal("got an error from GetUintSlice():", err)
-	}
-	for i, v := range getUIS {
-		u, err := strconv.ParseUint(vals[i], 10, 0)
-		if err != nil {
-			t.Fatal("got an error from GetIntSlice():", err)
-		}
-		if uint(u) != v {
-			t.Fatalf("expected uis[%d] to be %d from GetUintSlice but got: %d", i, u, v)
-		}
-	}
-}
-
-func TestUISWithDefault(t *testing.T) {
-	var uis []uint
-	f := setUpUISFlagSetWithDefault(&uis)
-
-	vals := []string{"1", "2"}
-	arg := fmt.Sprintf("--uis=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range uis {
-		u, err := strconv.ParseUint(vals[i], 10, 0)
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if uint(u) != v {
-			t.Fatalf("expected uis[%d] to be %d from GetUintSlice but got: %d", i, u, v)
-		}
-	}
-
-	getUIS, err := f.GetUintSlice("uis")
-	if err != nil {
-		t.Fatal("got an error from GetUintSlice():", err)
-	}
-	for i, v := range getUIS {
-		u, err := strconv.ParseUint(vals[i], 10, 0)
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if uint(u) != v {
-			t.Fatalf("expected uis[%d] to be %d from GetUintSlice but got: %d", i, u, v)
-		}
-	}
-}
-
-func TestUISCalledTwice(t *testing.T) {
-	var uis []uint
-	f := setUpUISFlagSet(&uis)
-
-	in := []string{"1,2", "3"}
-	expected := []int{1, 2, 3}
-	argfmt := "--uis=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range uis {
-		if uint(expected[i]) != v {
-			t.Fatalf("expected uis[%d] to be %d but got: %d", i, expected[i], v)
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/creds_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/creds_test.go
deleted file mode 100644
index 1b50831..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/creds_test.go
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux
-
-package unix_test
-
-import (
-	"bytes"
-	"go/build"
-	"net"
-	"os"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-// TestSCMCredentials tests the sending and receiving of credentials
-// (PID, UID, GID) in an ancillary message between two UNIX
-// sockets. The SO_PASSCRED socket option is enabled on the sending
-// socket for this to work.
-func TestSCMCredentials(t *testing.T) {
-	socketTypeTests := []struct {
-		socketType int
-		dataLen    int
-	}{
-		{
-			unix.SOCK_STREAM,
-			1,
-		}, {
-			unix.SOCK_DGRAM,
-			0,
-		},
-	}
-
-	for _, tt := range socketTypeTests {
-		if tt.socketType == unix.SOCK_DGRAM && !atLeast1p10() {
-			t.Log("skipping DGRAM test on pre-1.10")
-			continue
-		}
-
-		fds, err := unix.Socketpair(unix.AF_LOCAL, tt.socketType, 0)
-		if err != nil {
-			t.Fatalf("Socketpair: %v", err)
-		}
-		defer unix.Close(fds[0])
-		defer unix.Close(fds[1])
-
-		err = unix.SetsockoptInt(fds[0], unix.SOL_SOCKET, unix.SO_PASSCRED, 1)
-		if err != nil {
-			t.Fatalf("SetsockoptInt: %v", err)
-		}
-
-		srvFile := os.NewFile(uintptr(fds[0]), "server")
-		defer srvFile.Close()
-		srv, err := net.FileConn(srvFile)
-		if err != nil {
-			t.Errorf("FileConn: %v", err)
-			return
-		}
-		defer srv.Close()
-
-		cliFile := os.NewFile(uintptr(fds[1]), "client")
-		defer cliFile.Close()
-		cli, err := net.FileConn(cliFile)
-		if err != nil {
-			t.Errorf("FileConn: %v", err)
-			return
-		}
-		defer cli.Close()
-
-		var ucred unix.Ucred
-		ucred.Pid = int32(os.Getpid())
-		ucred.Uid = uint32(os.Getuid())
-		ucred.Gid = uint32(os.Getgid())
-		oob := unix.UnixCredentials(&ucred)
-
-		// On SOCK_STREAM, this is internally going to send a dummy byte
-		n, oobn, err := cli.(*net.UnixConn).WriteMsgUnix(nil, oob, nil)
-		if err != nil {
-			t.Fatalf("WriteMsgUnix: %v", err)
-		}
-		if n != 0 {
-			t.Fatalf("WriteMsgUnix n = %d, want 0", n)
-		}
-		if oobn != len(oob) {
-			t.Fatalf("WriteMsgUnix oobn = %d, want %d", oobn, len(oob))
-		}
-
-		oob2 := make([]byte, 10*len(oob))
-		n, oobn2, flags, _, err := srv.(*net.UnixConn).ReadMsgUnix(nil, oob2)
-		if err != nil {
-			t.Fatalf("ReadMsgUnix: %v", err)
-		}
-		if flags != 0 {
-			t.Fatalf("ReadMsgUnix flags = 0x%x, want 0", flags)
-		}
-		if n != tt.dataLen {
-			t.Fatalf("ReadMsgUnix n = %d, want %d", n, tt.dataLen)
-		}
-		if oobn2 != oobn {
-			// without SO_PASSCRED set on the socket, ReadMsgUnix will
-			// return zero oob bytes
-			t.Fatalf("ReadMsgUnix oobn = %d, want %d", oobn2, oobn)
-		}
-		oob2 = oob2[:oobn2]
-		if !bytes.Equal(oob, oob2) {
-			t.Fatal("ReadMsgUnix oob bytes don't match")
-		}
-
-		scm, err := unix.ParseSocketControlMessage(oob2)
-		if err != nil {
-			t.Fatalf("ParseSocketControlMessage: %v", err)
-		}
-		newUcred, err := unix.ParseUnixCredentials(&scm[0])
-		if err != nil {
-			t.Fatalf("ParseUnixCredentials: %v", err)
-		}
-		if *newUcred != ucred {
-			t.Fatalf("ParseUnixCredentials = %+v, want %+v", newUcred, ucred)
-		}
-	}
-}
-
-// atLeast1p10 reports whether we are running on Go 1.10 or later.
-func atLeast1p10() bool {
-	for _, ver := range build.Default.ReleaseTags {
-		if ver == "go1.10" {
-			return true
-		}
-	}
-	return false
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/dev_linux_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/dev_linux_test.go
deleted file mode 100644
index 5164528..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/dev_linux_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.7
-
-package unix_test
-
-import (
-	"fmt"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestDevices(t *testing.T) {
-	testCases := []struct {
-		path  string
-		major uint32
-		minor uint32
-	}{
-		// well known major/minor numbers according to
-		// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/admin-guide/devices.txt
-		{"/dev/null", 1, 3},
-		{"/dev/zero", 1, 5},
-		{"/dev/random", 1, 8},
-		{"/dev/full", 1, 7},
-		{"/dev/urandom", 1, 9},
-		{"/dev/tty", 5, 0},
-	}
-	for _, tc := range testCases {
-		t.Run(fmt.Sprintf("%s %v:%v", tc.path, tc.major, tc.minor), func(t *testing.T) {
-			var stat unix.Stat_t
-			err := unix.Stat(tc.path, &stat)
-			if err != nil {
-				if err == unix.EACCES {
-					t.Skip("no permission to stat device, skipping test")
-				}
-				t.Errorf("failed to stat device: %v", err)
-				return
-			}
-
-			dev := uint64(stat.Rdev)
-			if unix.Major(dev) != tc.major {
-				t.Errorf("for %s Major(%#x) == %d, want %d", tc.path, dev, unix.Major(dev), tc.major)
-			}
-			if unix.Minor(dev) != tc.minor {
-				t.Errorf("for %s Minor(%#x) == %d, want %d", tc.path, dev, unix.Minor(dev), tc.minor)
-			}
-			if unix.Mkdev(tc.major, tc.minor) != dev {
-				t.Errorf("for %s Mkdev(%d, %d) == %#x, want %#x", tc.path, tc.major, tc.minor, unix.Mkdev(tc.major, tc.minor), dev)
-			}
-		})
-
-	}
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/example_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/example_test.go
deleted file mode 100644
index 10619af..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/example_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package unix_test
-
-import (
-	"log"
-	"os"
-
-	"golang.org/x/sys/unix"
-)
-
-func ExampleExec() {
-	err := unix.Exec("/bin/ls", []string{"ls", "-al"}, os.Environ())
-	log.Fatal(err)
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/export_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/export_test.go
deleted file mode 100644
index e802469..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/export_test.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package unix
-
-var Itoa = itoa
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/fcntl.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/fcntl.go
index 0c58c7e..9379ba9 100644
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/fcntl.go
+++ b/cmd/viewcore/vendor/golang.org/x/sys/unix/fcntl.go
@@ -14,7 +14,11 @@
 
 // FcntlInt performs a fcntl syscall on fd with the provided command and argument.
 func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
-	valptr, _, err := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(arg))
+	valptr, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(arg))
+	var err error
+	if errno != 0 {
+		err = errno
+	}
 	return int(valptr), err
 }
 
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/mmap_unix_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/mmap_unix_test.go
deleted file mode 100644
index 3258ca3..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/mmap_unix_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package unix_test
-
-import (
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestMmap(t *testing.T) {
-	b, err := unix.Mmap(-1, 0, unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE)
-	if err != nil {
-		t.Fatalf("Mmap: %v", err)
-	}
-	if err := unix.Mprotect(b, unix.PROT_READ|unix.PROT_WRITE); err != nil {
-		t.Fatalf("Mprotect: %v", err)
-	}
-
-	b[0] = 42
-
-	if err := unix.Msync(b, unix.MS_SYNC); err != nil {
-		t.Fatalf("Msync: %v", err)
-	}
-	if err := unix.Madvise(b, unix.MADV_DONTNEED); err != nil {
-		t.Fatalf("Madvise: %v", err)
-	}
-	if err := unix.Munmap(b); err != nil {
-		t.Fatalf("Munmap: %v", err)
-	}
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/openbsd_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/openbsd_test.go
deleted file mode 100644
index 734d765..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/openbsd_test.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build openbsd
-
-// This, on the face of it, bizarre testing mechanism is necessary because
-// the only reliable way to gauge whether or not a pledge(2) call has succeeded
-// is that the program has been killed as a result of breaking its pledge.
-
-package unix_test
-
-import (
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-type testProc struct {
-	fn      func()       // should always exit instead of returning
-	cleanup func() error // for instance, delete coredumps from testing pledge
-	success bool         // whether zero-exit means success or failure
-}
-
-var (
-	testProcs = map[string]testProc{}
-	procName  = ""
-)
-
-const (
-	optName = "sys-unix-internal-procname"
-)
-
-func init() {
-	flag.StringVar(&procName, optName, "", "internal use only")
-}
-
-// testCmd generates a proper command that, when executed, runs the test
-// corresponding to the given key.
-func testCmd(procName string) (*exec.Cmd, error) {
-	exe, err := filepath.Abs(os.Args[0])
-	if err != nil {
-		return nil, err
-	}
-	cmd := exec.Command(exe, "-"+optName+"="+procName)
-	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
-	return cmd, nil
-}
-
-// ExitsCorrectly is a comprehensive, one-line-of-use wrapper for testing
-// a testProc with a key.
-func ExitsCorrectly(procName string, t *testing.T) {
-	s := testProcs[procName]
-	c, err := testCmd(procName)
-	defer func() {
-		if s.cleanup() != nil {
-			t.Fatalf("Failed to run cleanup for %s", procName)
-		}
-	}()
-	if err != nil {
-		t.Fatalf("Failed to construct command for %s", procName)
-	}
-	if (c.Run() == nil) != s.success {
-		result := "succeed"
-		if !s.success {
-			result = "fail"
-		}
-		t.Fatalf("Process did not %s when it was supposed to", result)
-	}
-}
-
-func TestMain(m *testing.M) {
-	flag.Parse()
-	if procName != "" {
-		testProcs[procName].fn()
-	}
-	os.Exit(m.Run())
-}
-
-// For example, add a test for pledge.
-func init() {
-	testProcs["pledge"] = testProc{
-		func() {
-			fmt.Println(unix.Pledge("", nil))
-			os.Exit(0)
-		},
-		func() error {
-			files, err := ioutil.ReadDir(".")
-			if err != nil {
-				return err
-			}
-			for _, file := range files {
-				if filepath.Ext(file.Name()) == ".core" {
-					if err := os.Remove(file.Name()); err != nil {
-						return err
-					}
-				}
-			}
-			return nil
-		},
-		false,
-	}
-}
-
-func TestPledge(t *testing.T) {
-	ExitsCorrectly("pledge", t)
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_bsd_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_bsd_test.go
deleted file mode 100644
index 6c4e2ac..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_bsd_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd openbsd
-
-package unix_test
-
-import (
-	"os/exec"
-	"runtime"
-	"testing"
-	"time"
-
-	"golang.org/x/sys/unix"
-)
-
-const MNT_WAIT = 1
-const MNT_NOWAIT = 2
-
-func TestGetfsstat(t *testing.T) {
-	const flags = MNT_NOWAIT // see golang.org/issue/16937
-	n, err := unix.Getfsstat(nil, flags)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	data := make([]unix.Statfs_t, n)
-	n2, err := unix.Getfsstat(data, flags)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if n != n2 {
-		t.Errorf("Getfsstat(nil) = %d, but subsequent Getfsstat(slice) = %d", n, n2)
-	}
-	for i, stat := range data {
-		if stat == (unix.Statfs_t{}) {
-			t.Errorf("index %v is an empty Statfs_t struct", i)
-		}
-	}
-	if t.Failed() {
-		for i, stat := range data[:n2] {
-			t.Logf("data[%v] = %+v", i, stat)
-		}
-		mount, err := exec.Command("mount").CombinedOutput()
-		if err != nil {
-			t.Logf("mount: %v\n%s", err, mount)
-		} else {
-			t.Logf("mount: %s", mount)
-		}
-	}
-}
-
-func TestSelect(t *testing.T) {
-	err := unix.Select(0, nil, nil, nil, &unix.Timeval{Sec: 0, Usec: 0})
-	if err != nil {
-		t.Fatalf("Select: %v", err)
-	}
-
-	dur := 250 * time.Millisecond
-	tv := unix.NsecToTimeval(int64(dur))
-	start := time.Now()
-	err = unix.Select(0, nil, nil, nil, &tv)
-	took := time.Since(start)
-	if err != nil {
-		t.Fatalf("Select: %v", err)
-	}
-
-	// On some BSDs the actual timeout might also be slightly less than the requested.
-	// Add an acceptable margin to avoid flaky tests.
-	if took < dur*2/3 {
-		t.Errorf("Select: timeout should have been at least %v, got %v", dur, took)
-	}
-}
-
-func TestSysctlRaw(t *testing.T) {
-	if runtime.GOOS == "openbsd" {
-		t.Skip("kern.proc.pid does not exist on OpenBSD")
-	}
-
-	_, err := unix.SysctlRaw("kern.proc.pid", unix.Getpid())
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestSysctlUint32(t *testing.T) {
-	maxproc, err := unix.SysctlUint32("kern.maxproc")
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Logf("kern.maxproc: %v", maxproc)
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_darwin_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_darwin_test.go
deleted file mode 100644
index 65691d5..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_darwin_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package unix_test
-
-// stringsFromByteSlice converts a sequence of attributes to a []string.
-// On Darwin, each entry is a NULL-terminated string.
-func stringsFromByteSlice(buf []byte) []string {
-	var result []string
-	off := 0
-	for i, b := range buf {
-		if b == 0 {
-			result = append(result, string(buf[off:i]))
-			off = i + 1
-		}
-	}
-	return result
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_freebsd_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_freebsd_test.go
deleted file mode 100644
index 0fec1a8..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_freebsd_test.go
+++ /dev/null
@@ -1,312 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build freebsd
-
-package unix_test
-
-import (
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestSysctlUint64(t *testing.T) {
-	_, err := unix.SysctlUint64("vm.swap_total")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-// FIXME: Infrastructure for launching tests in subprocesses stolen from openbsd_test.go - refactor?
-// testCmd generates a proper command that, when executed, runs the test
-// corresponding to the given key.
-
-type testProc struct {
-	fn      func()                    // should always exit instead of returning
-	arg     func(t *testing.T) string // generate argument for test
-	cleanup func(arg string) error    // for instance, delete coredumps from testing pledge
-	success bool                      // whether zero-exit means success or failure
-}
-
-var (
-	testProcs = map[string]testProc{}
-	procName  = ""
-	procArg   = ""
-)
-
-const (
-	optName = "sys-unix-internal-procname"
-	optArg  = "sys-unix-internal-arg"
-)
-
-func init() {
-	flag.StringVar(&procName, optName, "", "internal use only")
-	flag.StringVar(&procArg, optArg, "", "internal use only")
-
-}
-
-func testCmd(procName string, procArg string) (*exec.Cmd, error) {
-	exe, err := filepath.Abs(os.Args[0])
-	if err != nil {
-		return nil, err
-	}
-	cmd := exec.Command(exe, "-"+optName+"="+procName, "-"+optArg+"="+procArg)
-	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
-	return cmd, nil
-}
-
-// ExitsCorrectly is a comprehensive, one-line-of-use wrapper for testing
-// a testProc with a key.
-func ExitsCorrectly(t *testing.T, procName string) {
-	s := testProcs[procName]
-	arg := "-"
-	if s.arg != nil {
-		arg = s.arg(t)
-	}
-	c, err := testCmd(procName, arg)
-	defer func(arg string) {
-		if err := s.cleanup(arg); err != nil {
-			t.Fatalf("Failed to run cleanup for %s %s %#v", procName, err, err)
-		}
-	}(arg)
-	if err != nil {
-		t.Fatalf("Failed to construct command for %s", procName)
-	}
-	if (c.Run() == nil) != s.success {
-		result := "succeed"
-		if !s.success {
-			result = "fail"
-		}
-		t.Fatalf("Process did not %s when it was supposed to", result)
-	}
-}
-
-func TestMain(m *testing.M) {
-	flag.Parse()
-	if procName != "" {
-		t := testProcs[procName]
-		t.fn()
-		os.Stderr.WriteString("test function did not exit\n")
-		if t.success {
-			os.Exit(1)
-		} else {
-			os.Exit(0)
-		}
-	}
-	os.Exit(m.Run())
-}
-
-// end of infrastructure
-
-const testfile = "gocapmodetest"
-const testfile2 = testfile + "2"
-
-func CapEnterTest() {
-	_, err := os.OpenFile(path.Join(procArg, testfile), os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
-	if err != nil {
-		panic(fmt.Sprintf("OpenFile: %s", err))
-	}
-
-	err = unix.CapEnter()
-	if err != nil {
-		panic(fmt.Sprintf("CapEnter: %s", err))
-	}
-
-	_, err = os.OpenFile(path.Join(procArg, testfile2), os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
-	if err == nil {
-		panic("OpenFile works!")
-	}
-	if err.(*os.PathError).Err != unix.ECAPMODE {
-		panic(fmt.Sprintf("OpenFile failed wrong: %s %#v", err, err))
-	}
-	os.Exit(0)
-}
-
-func makeTempDir(t *testing.T) string {
-	d, err := ioutil.TempDir("", "go_openat_test")
-	if err != nil {
-		t.Fatalf("TempDir failed: %s", err)
-	}
-	return d
-}
-
-func removeTempDir(arg string) error {
-	err := os.RemoveAll(arg)
-	if err != nil && err.(*os.PathError).Err == unix.ENOENT {
-		return nil
-	}
-	return err
-}
-
-func init() {
-	testProcs["cap_enter"] = testProc{
-		CapEnterTest,
-		makeTempDir,
-		removeTempDir,
-		true,
-	}
-}
-
-func TestCapEnter(t *testing.T) {
-	if runtime.GOARCH != "amd64" {
-		t.Skipf("skipping test on %s", runtime.GOARCH)
-	}
-	ExitsCorrectly(t, "cap_enter")
-}
-
-func OpenatTest() {
-	f, err := os.Open(procArg)
-	if err != nil {
-		panic(err)
-	}
-
-	err = unix.CapEnter()
-	if err != nil {
-		panic(fmt.Sprintf("CapEnter: %s", err))
-	}
-
-	fxx, err := unix.Openat(int(f.Fd()), "xx", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
-	if err != nil {
-		panic(err)
-	}
-	unix.Close(fxx)
-
-	// The right to open BASE/xx is not ambient
-	_, err = os.OpenFile(procArg+"/xx", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
-	if err == nil {
-		panic("OpenFile succeeded")
-	}
-	if err.(*os.PathError).Err != unix.ECAPMODE {
-		panic(fmt.Sprintf("OpenFile failed wrong: %s %#v", err, err))
-	}
-
-	// Can't make a new directory either
-	err = os.Mkdir(procArg+"2", 0777)
-	if err == nil {
-		panic("MKdir succeeded")
-	}
-	if err.(*os.PathError).Err != unix.ECAPMODE {
-		panic(fmt.Sprintf("Mkdir failed wrong: %s %#v", err, err))
-	}
-
-	// Remove all caps except read and lookup.
-	r, err := unix.CapRightsInit([]uint64{unix.CAP_READ, unix.CAP_LOOKUP})
-	if err != nil {
-		panic(fmt.Sprintf("CapRightsInit failed: %s %#v", err, err))
-	}
-	err = unix.CapRightsLimit(f.Fd(), r)
-	if err != nil {
-		panic(fmt.Sprintf("CapRightsLimit failed: %s %#v", err, err))
-	}
-
-	// Check we can get the rights back again
-	r, err = unix.CapRightsGet(f.Fd())
-	if err != nil {
-		panic(fmt.Sprintf("CapRightsGet failed: %s %#v", err, err))
-	}
-	b, err := unix.CapRightsIsSet(r, []uint64{unix.CAP_READ, unix.CAP_LOOKUP})
-	if err != nil {
-		panic(fmt.Sprintf("CapRightsIsSet failed: %s %#v", err, err))
-	}
-	if !b {
-		panic(fmt.Sprintf("Unexpected rights"))
-	}
-	b, err = unix.CapRightsIsSet(r, []uint64{unix.CAP_READ, unix.CAP_LOOKUP, unix.CAP_WRITE})
-	if err != nil {
-		panic(fmt.Sprintf("CapRightsIsSet failed: %s %#v", err, err))
-	}
-	if b {
-		panic(fmt.Sprintf("Unexpected rights (2)"))
-	}
-
-	// Can no longer create a file
-	_, err = unix.Openat(int(f.Fd()), "xx2", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
-	if err == nil {
-		panic("Openat succeeded")
-	}
-	if err != unix.ENOTCAPABLE {
-		panic(fmt.Sprintf("OpenFileAt failed wrong: %s %#v", err, err))
-	}
-
-	// But can read an existing one
-	_, err = unix.Openat(int(f.Fd()), "xx", os.O_RDONLY, 0666)
-	if err != nil {
-		panic(fmt.Sprintf("Openat failed: %s %#v", err, err))
-	}
-
-	os.Exit(0)
-}
-
-func init() {
-	testProcs["openat"] = testProc{
-		OpenatTest,
-		makeTempDir,
-		removeTempDir,
-		true,
-	}
-}
-
-func TestOpenat(t *testing.T) {
-	if runtime.GOARCH != "amd64" {
-		t.Skipf("skipping test on %s", runtime.GOARCH)
-	}
-	ExitsCorrectly(t, "openat")
-}
-
-func TestCapRightsSetAndClear(t *testing.T) {
-	r, err := unix.CapRightsInit([]uint64{unix.CAP_READ, unix.CAP_WRITE, unix.CAP_PDWAIT})
-	if err != nil {
-		t.Fatalf("CapRightsInit failed: %s", err)
-	}
-
-	err = unix.CapRightsSet(r, []uint64{unix.CAP_EVENT, unix.CAP_LISTEN})
-	if err != nil {
-		t.Fatalf("CapRightsSet failed: %s", err)
-	}
-
-	b, err := unix.CapRightsIsSet(r, []uint64{unix.CAP_READ, unix.CAP_WRITE, unix.CAP_PDWAIT, unix.CAP_EVENT, unix.CAP_LISTEN})
-	if err != nil {
-		t.Fatalf("CapRightsIsSet failed: %s", err)
-	}
-	if !b {
-		t.Fatalf("Wrong rights set")
-	}
-
-	err = unix.CapRightsClear(r, []uint64{unix.CAP_READ, unix.CAP_PDWAIT})
-	if err != nil {
-		t.Fatalf("CapRightsClear failed: %s", err)
-	}
-
-	b, err = unix.CapRightsIsSet(r, []uint64{unix.CAP_WRITE, unix.CAP_EVENT, unix.CAP_LISTEN})
-	if err != nil {
-		t.Fatalf("CapRightsIsSet failed: %s", err)
-	}
-	if !b {
-		t.Fatalf("Wrong rights set")
-	}
-}
-
-// stringsFromByteSlice converts a sequence of attributes to a []string.
-// On FreeBSD, each entry consists of a single byte containing the length
-// of the attribute name, followed by the attribute name.
-// The name is _not_ NULL-terminated.
-func stringsFromByteSlice(buf []byte) []string {
-	var result []string
-	i := 0
-	for i < len(buf) {
-		next := i + 1 + int(buf[i])
-		result = append(result, string(buf[i+1:next]))
-		i = next
-	}
-	return result
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_linux_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_linux_test.go
deleted file mode 100644
index eed1726..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_linux_test.go
+++ /dev/null
@@ -1,421 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux
-
-package unix_test
-
-import (
-	"os"
-	"runtime"
-	"runtime/debug"
-	"testing"
-	"time"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestIoctlGetInt(t *testing.T) {
-	f, err := os.Open("/dev/random")
-	if err != nil {
-		t.Fatalf("failed to open device: %v", err)
-	}
-	defer f.Close()
-
-	v, err := unix.IoctlGetInt(int(f.Fd()), unix.RNDGETENTCNT)
-	if err != nil {
-		t.Fatalf("failed to perform ioctl: %v", err)
-	}
-
-	t.Logf("%d bits of entropy available", v)
-}
-
-func TestPpoll(t *testing.T) {
-	if runtime.GOOS == "android" {
-		t.Skip("mkfifo syscall is not available on android, skipping test")
-	}
-
-	f, cleanup := mktmpfifo(t)
-	defer cleanup()
-
-	const timeout = 100 * time.Millisecond
-
-	ok := make(chan bool, 1)
-	go func() {
-		select {
-		case <-time.After(10 * timeout):
-			t.Errorf("Ppoll: failed to timeout after %d", 10*timeout)
-		case <-ok:
-		}
-	}()
-
-	fds := []unix.PollFd{{Fd: int32(f.Fd()), Events: unix.POLLIN}}
-	timeoutTs := unix.NsecToTimespec(int64(timeout))
-	n, err := unix.Ppoll(fds, &timeoutTs, nil)
-	ok <- true
-	if err != nil {
-		t.Errorf("Ppoll: unexpected error: %v", err)
-		return
-	}
-	if n != 0 {
-		t.Errorf("Ppoll: wrong number of events: got %v, expected %v", n, 0)
-		return
-	}
-}
-
-func TestTime(t *testing.T) {
-	var ut unix.Time_t
-	ut2, err := unix.Time(&ut)
-	if err != nil {
-		t.Fatalf("Time: %v", err)
-	}
-	if ut != ut2 {
-		t.Errorf("Time: return value %v should be equal to argument %v", ut2, ut)
-	}
-
-	var now time.Time
-
-	for i := 0; i < 10; i++ {
-		ut, err = unix.Time(nil)
-		if err != nil {
-			t.Fatalf("Time: %v", err)
-		}
-
-		now = time.Now()
-
-		if int64(ut) == now.Unix() {
-			return
-		}
-	}
-
-	t.Errorf("Time: return value %v should be nearly equal to time.Now().Unix() %v", ut, now.Unix())
-}
-
-func TestUtime(t *testing.T) {
-	defer chtmpdir(t)()
-
-	touch(t, "file1")
-
-	buf := &unix.Utimbuf{
-		Modtime: 12345,
-	}
-
-	err := unix.Utime("file1", buf)
-	if err != nil {
-		t.Fatalf("Utime: %v", err)
-	}
-
-	fi, err := os.Stat("file1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if fi.ModTime().Unix() != 12345 {
-		t.Errorf("Utime: failed to change modtime: expected %v, got %v", 12345, fi.ModTime().Unix())
-	}
-}
-
-func TestUtimesNanoAt(t *testing.T) {
-	defer chtmpdir(t)()
-
-	symlink := "symlink1"
-	os.Remove(symlink)
-	err := os.Symlink("nonexisting", symlink)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ts := []unix.Timespec{
-		{Sec: 1111, Nsec: 2222},
-		{Sec: 3333, Nsec: 4444},
-	}
-	err = unix.UtimesNanoAt(unix.AT_FDCWD, symlink, ts, unix.AT_SYMLINK_NOFOLLOW)
-	if err != nil {
-		t.Fatalf("UtimesNanoAt: %v", err)
-	}
-
-	var st unix.Stat_t
-	err = unix.Lstat(symlink, &st)
-	if err != nil {
-		t.Fatalf("Lstat: %v", err)
-	}
-
-	// Only check Mtim, Atim might not be supported by the underlying filesystem
-	expected := ts[1]
-	if st.Mtim.Nsec == 0 {
-		// Some filesystems only support 1-second time stamp resolution
-		// and will always set Nsec to 0.
-		expected.Nsec = 0
-	}
-	if st.Mtim != expected {
-		t.Errorf("UtimesNanoAt: wrong mtime: expected %v, got %v", expected, st.Mtim)
-	}
-}
-
-func TestRlimitAs(t *testing.T) {
-	// disable GC during to avoid flaky test
-	defer debug.SetGCPercent(debug.SetGCPercent(-1))
-
-	var rlim unix.Rlimit
-	err := unix.Getrlimit(unix.RLIMIT_AS, &rlim)
-	if err != nil {
-		t.Fatalf("Getrlimit: %v", err)
-	}
-	var zero unix.Rlimit
-	if zero == rlim {
-		t.Fatalf("Getrlimit: got zero value %#v", rlim)
-	}
-	set := rlim
-	set.Cur = uint64(unix.Getpagesize())
-	err = unix.Setrlimit(unix.RLIMIT_AS, &set)
-	if err != nil {
-		t.Fatalf("Setrlimit: set failed: %#v %v", set, err)
-	}
-
-	// RLIMIT_AS was set to the page size, so mmap()'ing twice the page size
-	// should fail. See 'man 2 getrlimit'.
-	_, err = unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE)
-	if err == nil {
-		t.Fatal("Mmap: unexpectedly suceeded after setting RLIMIT_AS")
-	}
-
-	err = unix.Setrlimit(unix.RLIMIT_AS, &rlim)
-	if err != nil {
-		t.Fatalf("Setrlimit: restore failed: %#v %v", rlim, err)
-	}
-
-	b, err := unix.Mmap(-1, 0, 2*unix.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_PRIVATE)
-	if err != nil {
-		t.Fatalf("Mmap: %v", err)
-	}
-	err = unix.Munmap(b)
-	if err != nil {
-		t.Fatalf("Munmap: %v", err)
-	}
-}
-
-func TestSelect(t *testing.T) {
-	_, err := unix.Select(0, nil, nil, nil, &unix.Timeval{Sec: 0, Usec: 0})
-	if err != nil {
-		t.Fatalf("Select: %v", err)
-	}
-
-	dur := 150 * time.Millisecond
-	tv := unix.NsecToTimeval(int64(dur))
-	start := time.Now()
-	_, err = unix.Select(0, nil, nil, nil, &tv)
-	took := time.Since(start)
-	if err != nil {
-		t.Fatalf("Select: %v", err)
-	}
-
-	if took < dur {
-		t.Errorf("Select: timeout should have been at least %v, got %v", dur, took)
-	}
-}
-
-func TestPselect(t *testing.T) {
-	_, err := unix.Pselect(0, nil, nil, nil, &unix.Timespec{Sec: 0, Nsec: 0}, nil)
-	if err != nil {
-		t.Fatalf("Pselect: %v", err)
-	}
-
-	dur := 2500 * time.Microsecond
-	ts := unix.NsecToTimespec(int64(dur))
-	start := time.Now()
-	_, err = unix.Pselect(0, nil, nil, nil, &ts, nil)
-	took := time.Since(start)
-	if err != nil {
-		t.Fatalf("Pselect: %v", err)
-	}
-
-	if took < dur {
-		t.Errorf("Pselect: timeout should have been at least %v, got %v", dur, took)
-	}
-}
-
-func TestSchedSetaffinity(t *testing.T) {
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	var oldMask unix.CPUSet
-	err := unix.SchedGetaffinity(0, &oldMask)
-	if err != nil {
-		t.Fatalf("SchedGetaffinity: %v", err)
-	}
-
-	var newMask unix.CPUSet
-	newMask.Zero()
-	if newMask.Count() != 0 {
-		t.Errorf("CpuZero: didn't zero CPU set: %v", newMask)
-	}
-	cpu := 1
-	newMask.Set(cpu)
-	if newMask.Count() != 1 || !newMask.IsSet(cpu) {
-		t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask)
-	}
-	cpu = 5
-	newMask.Set(cpu)
-	if newMask.Count() != 2 || !newMask.IsSet(cpu) {
-		t.Errorf("CpuSet: didn't set CPU %d in set: %v", cpu, newMask)
-	}
-	newMask.Clear(cpu)
-	if newMask.Count() != 1 || newMask.IsSet(cpu) {
-		t.Errorf("CpuClr: didn't clear CPU %d in set: %v", cpu, newMask)
-	}
-
-	if runtime.NumCPU() < 2 {
-		t.Skip("skipping setaffinity tests on single CPU system")
-	}
-	if runtime.GOOS == "android" {
-		t.Skip("skipping setaffinity tests on android")
-	}
-
-	err = unix.SchedSetaffinity(0, &newMask)
-	if err != nil {
-		t.Fatalf("SchedSetaffinity: %v", err)
-	}
-
-	var gotMask unix.CPUSet
-	err = unix.SchedGetaffinity(0, &gotMask)
-	if err != nil {
-		t.Fatalf("SchedGetaffinity: %v", err)
-	}
-
-	if gotMask != newMask {
-		t.Errorf("SchedSetaffinity: returned affinity mask does not match set affinity mask")
-	}
-
-	// Restore old mask so it doesn't affect successive tests
-	err = unix.SchedSetaffinity(0, &oldMask)
-	if err != nil {
-		t.Fatalf("SchedSetaffinity: %v", err)
-	}
-}
-
-func TestStatx(t *testing.T) {
-	var stx unix.Statx_t
-	err := unix.Statx(unix.AT_FDCWD, ".", 0, 0, &stx)
-	if err == unix.ENOSYS || err == unix.EPERM {
-		t.Skip("statx syscall is not available, skipping test")
-	} else if err != nil {
-		t.Fatalf("Statx: %v", err)
-	}
-
-	defer chtmpdir(t)()
-	touch(t, "file1")
-
-	var st unix.Stat_t
-	err = unix.Stat("file1", &st)
-	if err != nil {
-		t.Fatalf("Stat: %v", err)
-	}
-
-	flags := unix.AT_STATX_SYNC_AS_STAT
-	err = unix.Statx(unix.AT_FDCWD, "file1", flags, unix.STATX_ALL, &stx)
-	if err != nil {
-		t.Fatalf("Statx: %v", err)
-	}
-
-	if uint32(stx.Mode) != st.Mode {
-		t.Errorf("Statx: returned stat mode does not match Stat")
-	}
-
-	ctime := unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)}
-	mtime := unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)}
-
-	if stx.Ctime != ctime {
-		t.Errorf("Statx: returned stat ctime does not match Stat")
-	}
-	if stx.Mtime != mtime {
-		t.Errorf("Statx: returned stat mtime does not match Stat")
-	}
-
-	err = os.Symlink("file1", "symlink1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = unix.Lstat("symlink1", &st)
-	if err != nil {
-		t.Fatalf("Lstat: %v", err)
-	}
-
-	err = unix.Statx(unix.AT_FDCWD, "symlink1", flags, unix.STATX_BASIC_STATS, &stx)
-	if err != nil {
-		t.Fatalf("Statx: %v", err)
-	}
-
-	// follow symlink, expect a regulat file
-	if stx.Mode&unix.S_IFREG == 0 {
-		t.Errorf("Statx: didn't follow symlink")
-	}
-
-	err = unix.Statx(unix.AT_FDCWD, "symlink1", flags|unix.AT_SYMLINK_NOFOLLOW, unix.STATX_ALL, &stx)
-	if err != nil {
-		t.Fatalf("Statx: %v", err)
-	}
-
-	// follow symlink, expect a symlink
-	if stx.Mode&unix.S_IFLNK == 0 {
-		t.Errorf("Statx: unexpectedly followed symlink")
-	}
-	if uint32(stx.Mode) != st.Mode {
-		t.Errorf("Statx: returned stat mode does not match Lstat")
-	}
-
-	ctime = unix.StatxTimestamp{Sec: int64(st.Ctim.Sec), Nsec: uint32(st.Ctim.Nsec)}
-	mtime = unix.StatxTimestamp{Sec: int64(st.Mtim.Sec), Nsec: uint32(st.Mtim.Nsec)}
-
-	if stx.Ctime != ctime {
-		t.Errorf("Statx: returned stat ctime does not match Lstat")
-	}
-	if stx.Mtime != mtime {
-		t.Errorf("Statx: returned stat mtime does not match Lstat")
-	}
-}
-
-// stringsFromByteSlice converts a sequence of attributes to a []string.
-// On Linux, each entry is a NULL-terminated string.
-func stringsFromByteSlice(buf []byte) []string {
-	var result []string
-	off := 0
-	for i, b := range buf {
-		if b == 0 {
-			result = append(result, string(buf[off:i]))
-			off = i + 1
-		}
-	}
-	return result
-}
-
-func TestFaccessat(t *testing.T) {
-	defer chtmpdir(t)()
-	touch(t, "file1")
-
-	err := unix.Faccessat(unix.AT_FDCWD, "file1", unix.O_RDONLY, 0)
-	if err != nil {
-		t.Errorf("Faccessat: unexpected error: %v", err)
-	}
-
-	err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.O_RDONLY, 2)
-	if err != unix.EINVAL {
-		t.Errorf("Faccessat: unexpected error: %v, want EINVAL", err)
-	}
-
-	err = unix.Faccessat(unix.AT_FDCWD, "file1", unix.O_RDONLY, unix.AT_EACCESS)
-	if err != unix.EOPNOTSUPP {
-		t.Errorf("Faccessat: unexpected error: %v, want EOPNOTSUPP", err)
-	}
-
-	err = os.Symlink("file1", "symlink1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = unix.Faccessat(unix.AT_FDCWD, "symlink1", unix.O_RDONLY, unix.AT_SYMLINK_NOFOLLOW)
-	if err != unix.EOPNOTSUPP {
-		t.Errorf("Faccessat: unexpected error: %v, want EOPNOTSUPP", err)
-	}
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_solaris.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_solaris.go
index 4d7efbc..820ef77 100644
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -314,7 +314,11 @@
 
 // FcntlInt performs a fcntl syscall on fd with the provided command and argument.
 func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
-	valptr, _, err := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
+	valptr, _, errno := sysvicall6(uintptr(unsafe.Pointer(&procfcntl)), 3, uintptr(fd), uintptr(cmd), uintptr(arg), 0, 0, 0)
+	var err error
+	if errno != 0 {
+		err = errno
+	}
 	return int(valptr), err
 }
 
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_solaris_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_solaris_test.go
deleted file mode 100644
index 57dba88..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_solaris_test.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build solaris
-
-package unix_test
-
-import (
-	"os/exec"
-	"testing"
-	"time"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestSelect(t *testing.T) {
-	err := unix.Select(0, nil, nil, nil, &unix.Timeval{Sec: 0, Usec: 0})
-	if err != nil {
-		t.Fatalf("Select: %v", err)
-	}
-
-	dur := 150 * time.Millisecond
-	tv := unix.NsecToTimeval(int64(dur))
-	start := time.Now()
-	err = unix.Select(0, nil, nil, nil, &tv)
-	took := time.Since(start)
-	if err != nil {
-		t.Fatalf("Select: %v", err)
-	}
-
-	if took < dur {
-		t.Errorf("Select: timeout should have been at least %v, got %v", dur, took)
-	}
-}
-
-func TestStatvfs(t *testing.T) {
-	if err := unix.Statvfs("", nil); err == nil {
-		t.Fatal(`Statvfs("") expected failure`)
-	}
-
-	statvfs := unix.Statvfs_t{}
-	if err := unix.Statvfs("/", &statvfs); err != nil {
-		t.Errorf(`Statvfs("/") failed: %v`, err)
-	}
-
-	if t.Failed() {
-		mount, err := exec.Command("mount").CombinedOutput()
-		if err != nil {
-			t.Logf("mount: %v\n%s", err, mount)
-		} else {
-			t.Logf("mount: %s", mount)
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_test.go
deleted file mode 100644
index a8eef7c..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_test.go
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package unix_test
-
-import (
-	"fmt"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-func testSetGetenv(t *testing.T, key, value string) {
-	err := unix.Setenv(key, value)
-	if err != nil {
-		t.Fatalf("Setenv failed to set %q: %v", value, err)
-	}
-	newvalue, found := unix.Getenv(key)
-	if !found {
-		t.Fatalf("Getenv failed to find %v variable (want value %q)", key, value)
-	}
-	if newvalue != value {
-		t.Fatalf("Getenv(%v) = %q; want %q", key, newvalue, value)
-	}
-}
-
-func TestEnv(t *testing.T) {
-	testSetGetenv(t, "TESTENV", "AVALUE")
-	// make sure TESTENV gets set to "", not deleted
-	testSetGetenv(t, "TESTENV", "")
-}
-
-func TestItoa(t *testing.T) {
-	// Make most negative integer: 0x8000...
-	i := 1
-	for i<<1 != 0 {
-		i <<= 1
-	}
-	if i >= 0 {
-		t.Fatal("bad math")
-	}
-	s := unix.Itoa(i)
-	f := fmt.Sprint(i)
-	if s != f {
-		t.Fatalf("itoa(%d) = %s, want %s", i, s, f)
-	}
-}
-
-func TestUname(t *testing.T) {
-	var utsname unix.Utsname
-	err := unix.Uname(&utsname)
-	if err != nil {
-		t.Fatalf("Uname: %v", err)
-	}
-
-	t.Logf("OS: %s/%s %s", utsname.Sysname[:], utsname.Machine[:], utsname.Release[:])
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_unix_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_unix_test.go
deleted file mode 100644
index ad09716..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/syscall_unix_test.go
+++ /dev/null
@@ -1,639 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package unix_test
-
-import (
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"net"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"syscall"
-	"testing"
-	"time"
-
-	"golang.org/x/sys/unix"
-)
-
-// Tests that below functions, structures and constants are consistent
-// on all Unix-like systems.
-func _() {
-	// program scheduling priority functions and constants
-	var (
-		_ func(int, int, int) error   = unix.Setpriority
-		_ func(int, int) (int, error) = unix.Getpriority
-	)
-	const (
-		_ int = unix.PRIO_USER
-		_ int = unix.PRIO_PROCESS
-		_ int = unix.PRIO_PGRP
-	)
-
-	// termios constants
-	const (
-		_ int = unix.TCIFLUSH
-		_ int = unix.TCIOFLUSH
-		_ int = unix.TCOFLUSH
-	)
-
-	// fcntl file locking structure and constants
-	var (
-		_ = unix.Flock_t{
-			Type:   int16(0),
-			Whence: int16(0),
-			Start:  int64(0),
-			Len:    int64(0),
-			Pid:    int32(0),
-		}
-	)
-	const (
-		_ = unix.F_GETLK
-		_ = unix.F_SETLK
-		_ = unix.F_SETLKW
-	)
-}
-
-func TestErrnoSignalName(t *testing.T) {
-	testErrors := []struct {
-		num  syscall.Errno
-		name string
-	}{
-		{syscall.EPERM, "EPERM"},
-		{syscall.EINVAL, "EINVAL"},
-		{syscall.ENOENT, "ENOENT"},
-	}
-
-	for _, te := range testErrors {
-		t.Run(fmt.Sprintf("%d/%s", te.num, te.name), func(t *testing.T) {
-			e := unix.ErrnoName(te.num)
-			if e != te.name {
-				t.Errorf("ErrnoName(%d) returned %s, want %s", te.num, e, te.name)
-			}
-		})
-	}
-
-	testSignals := []struct {
-		num  syscall.Signal
-		name string
-	}{
-		{syscall.SIGHUP, "SIGHUP"},
-		{syscall.SIGPIPE, "SIGPIPE"},
-		{syscall.SIGSEGV, "SIGSEGV"},
-	}
-
-	for _, ts := range testSignals {
-		t.Run(fmt.Sprintf("%d/%s", ts.num, ts.name), func(t *testing.T) {
-			s := unix.SignalName(ts.num)
-			if s != ts.name {
-				t.Errorf("SignalName(%d) returned %s, want %s", ts.num, s, ts.name)
-			}
-		})
-	}
-}
-
-// TestFcntlFlock tests whether the file locking structure matches
-// the calling convention of each kernel.
-func TestFcntlFlock(t *testing.T) {
-	name := filepath.Join(os.TempDir(), "TestFcntlFlock")
-	fd, err := unix.Open(name, unix.O_CREAT|unix.O_RDWR|unix.O_CLOEXEC, 0)
-	if err != nil {
-		t.Fatalf("Open failed: %v", err)
-	}
-	defer unix.Unlink(name)
-	defer unix.Close(fd)
-	flock := unix.Flock_t{
-		Type:  unix.F_RDLCK,
-		Start: 0, Len: 0, Whence: 1,
-	}
-	if err := unix.FcntlFlock(uintptr(fd), unix.F_GETLK, &flock); err != nil {
-		t.Fatalf("FcntlFlock failed: %v", err)
-	}
-}
-
-// TestPassFD tests passing a file descriptor over a Unix socket.
-//
-// This test involved both a parent and child process. The parent
-// process is invoked as a normal test, with "go test", which then
-// runs the child process by running the current test binary with args
-// "-test.run=^TestPassFD$" and an environment variable used to signal
-// that the test should become the child process instead.
-func TestPassFD(t *testing.T) {
-	if runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") {
-		t.Skip("cannot exec subprocess on iOS, skipping test")
-	}
-
-	if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
-		passFDChild()
-		return
-	}
-
-	tempDir, err := ioutil.TempDir("", "TestPassFD")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	fds, err := unix.Socketpair(unix.AF_LOCAL, unix.SOCK_STREAM, 0)
-	if err != nil {
-		t.Fatalf("Socketpair: %v", err)
-	}
-	defer unix.Close(fds[0])
-	defer unix.Close(fds[1])
-	writeFile := os.NewFile(uintptr(fds[0]), "child-writes")
-	readFile := os.NewFile(uintptr(fds[1]), "parent-reads")
-	defer writeFile.Close()
-	defer readFile.Close()
-
-	cmd := exec.Command(os.Args[0], "-test.run=^TestPassFD$", "--", tempDir)
-	cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"}
-	if lp := os.Getenv("LD_LIBRARY_PATH"); lp != "" {
-		cmd.Env = append(cmd.Env, "LD_LIBRARY_PATH="+lp)
-	}
-	cmd.ExtraFiles = []*os.File{writeFile}
-
-	out, err := cmd.CombinedOutput()
-	if len(out) > 0 || err != nil {
-		t.Fatalf("child process: %q, %v", out, err)
-	}
-
-	c, err := net.FileConn(readFile)
-	if err != nil {
-		t.Fatalf("FileConn: %v", err)
-	}
-	defer c.Close()
-
-	uc, ok := c.(*net.UnixConn)
-	if !ok {
-		t.Fatalf("unexpected FileConn type; expected UnixConn, got %T", c)
-	}
-
-	buf := make([]byte, 32) // expect 1 byte
-	oob := make([]byte, 32) // expect 24 bytes
-	closeUnix := time.AfterFunc(5*time.Second, func() {
-		t.Logf("timeout reading from unix socket")
-		uc.Close()
-	})
-	_, oobn, _, _, err := uc.ReadMsgUnix(buf, oob)
-	if err != nil {
-		t.Fatalf("ReadMsgUnix: %v", err)
-	}
-	closeUnix.Stop()
-
-	scms, err := unix.ParseSocketControlMessage(oob[:oobn])
-	if err != nil {
-		t.Fatalf("ParseSocketControlMessage: %v", err)
-	}
-	if len(scms) != 1 {
-		t.Fatalf("expected 1 SocketControlMessage; got scms = %#v", scms)
-	}
-	scm := scms[0]
-	gotFds, err := unix.ParseUnixRights(&scm)
-	if err != nil {
-		t.Fatalf("unix.ParseUnixRights: %v", err)
-	}
-	if len(gotFds) != 1 {
-		t.Fatalf("wanted 1 fd; got %#v", gotFds)
-	}
-
-	f := os.NewFile(uintptr(gotFds[0]), "fd-from-child")
-	defer f.Close()
-
-	got, err := ioutil.ReadAll(f)
-	want := "Hello from child process!\n"
-	if string(got) != want {
-		t.Errorf("child process ReadAll: %q, %v; want %q", got, err, want)
-	}
-}
-
-// passFDChild is the child process used by TestPassFD.
-func passFDChild() {
-	defer os.Exit(0)
-
-	// Look for our fd. It should be fd 3, but we work around an fd leak
-	// bug here (http://golang.org/issue/2603) to let it be elsewhere.
-	var uc *net.UnixConn
-	for fd := uintptr(3); fd <= 10; fd++ {
-		f := os.NewFile(fd, "unix-conn")
-		var ok bool
-		netc, _ := net.FileConn(f)
-		uc, ok = netc.(*net.UnixConn)
-		if ok {
-			break
-		}
-	}
-	if uc == nil {
-		fmt.Println("failed to find unix fd")
-		return
-	}
-
-	// Make a file f to send to our parent process on uc.
-	// We make it in tempDir, which our parent will clean up.
-	flag.Parse()
-	tempDir := flag.Arg(0)
-	f, err := ioutil.TempFile(tempDir, "")
-	if err != nil {
-		fmt.Printf("TempFile: %v", err)
-		return
-	}
-
-	f.Write([]byte("Hello from child process!\n"))
-	f.Seek(0, 0)
-
-	rights := unix.UnixRights(int(f.Fd()))
-	dummyByte := []byte("x")
-	n, oobn, err := uc.WriteMsgUnix(dummyByte, rights, nil)
-	if err != nil {
-		fmt.Printf("WriteMsgUnix: %v", err)
-		return
-	}
-	if n != 1 || oobn != len(rights) {
-		fmt.Printf("WriteMsgUnix = %d, %d; want 1, %d", n, oobn, len(rights))
-		return
-	}
-}
-
-// TestUnixRightsRoundtrip tests that UnixRights, ParseSocketControlMessage,
-// and ParseUnixRights are able to successfully round-trip lists of file descriptors.
-func TestUnixRightsRoundtrip(t *testing.T) {
-	testCases := [...][][]int{
-		{{42}},
-		{{1, 2}},
-		{{3, 4, 5}},
-		{{}},
-		{{1, 2}, {3, 4, 5}, {}, {7}},
-	}
-	for _, testCase := range testCases {
-		b := []byte{}
-		var n int
-		for _, fds := range testCase {
-			// Last assignment to n wins
-			n = len(b) + unix.CmsgLen(4*len(fds))
-			b = append(b, unix.UnixRights(fds...)...)
-		}
-		// Truncate b
-		b = b[:n]
-
-		scms, err := unix.ParseSocketControlMessage(b)
-		if err != nil {
-			t.Fatalf("ParseSocketControlMessage: %v", err)
-		}
-		if len(scms) != len(testCase) {
-			t.Fatalf("expected %v SocketControlMessage; got scms = %#v", len(testCase), scms)
-		}
-		for i, scm := range scms {
-			gotFds, err := unix.ParseUnixRights(&scm)
-			if err != nil {
-				t.Fatalf("ParseUnixRights: %v", err)
-			}
-			wantFds := testCase[i]
-			if len(gotFds) != len(wantFds) {
-				t.Fatalf("expected %v fds, got %#v", len(wantFds), gotFds)
-			}
-			for j, fd := range gotFds {
-				if fd != wantFds[j] {
-					t.Fatalf("expected fd %v, got %v", wantFds[j], fd)
-				}
-			}
-		}
-	}
-}
-
-func TestRlimit(t *testing.T) {
-	var rlimit, zero unix.Rlimit
-	err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rlimit)
-	if err != nil {
-		t.Fatalf("Getrlimit: save failed: %v", err)
-	}
-	if zero == rlimit {
-		t.Fatalf("Getrlimit: save failed: got zero value %#v", rlimit)
-	}
-	set := rlimit
-	set.Cur = set.Max - 1
-	err = unix.Setrlimit(unix.RLIMIT_NOFILE, &set)
-	if err != nil {
-		t.Fatalf("Setrlimit: set failed: %#v %v", set, err)
-	}
-	var get unix.Rlimit
-	err = unix.Getrlimit(unix.RLIMIT_NOFILE, &get)
-	if err != nil {
-		t.Fatalf("Getrlimit: get failed: %v", err)
-	}
-	set = rlimit
-	set.Cur = set.Max - 1
-	if set != get {
-		// Seems like Darwin requires some privilege to
-		// increase the soft limit of rlimit sandbox, though
-		// Setrlimit never reports an error.
-		switch runtime.GOOS {
-		case "darwin":
-		default:
-			t.Fatalf("Rlimit: change failed: wanted %#v got %#v", set, get)
-		}
-	}
-	err = unix.Setrlimit(unix.RLIMIT_NOFILE, &rlimit)
-	if err != nil {
-		t.Fatalf("Setrlimit: restore failed: %#v %v", rlimit, err)
-	}
-}
-
-func TestSeekFailure(t *testing.T) {
-	_, err := unix.Seek(-1, 0, 0)
-	if err == nil {
-		t.Fatalf("Seek(-1, 0, 0) did not fail")
-	}
-	str := err.Error() // used to crash on Linux
-	t.Logf("Seek: %v", str)
-	if str == "" {
-		t.Fatalf("Seek(-1, 0, 0) return error with empty message")
-	}
-}
-
-func TestDup(t *testing.T) {
-	file, err := ioutil.TempFile("", "TestDup")
-	if err != nil {
-		t.Fatalf("Tempfile failed: %v", err)
-	}
-	defer os.Remove(file.Name())
-	defer file.Close()
-	f := int(file.Fd())
-
-	newFd, err := unix.Dup(f)
-	if err != nil {
-		t.Fatalf("Dup: %v", err)
-	}
-
-	err = unix.Dup2(newFd, newFd+1)
-	if err != nil {
-		t.Fatalf("Dup2: %v", err)
-	}
-
-	b1 := []byte("Test123")
-	b2 := make([]byte, 7)
-	_, err = unix.Write(newFd+1, b1)
-	if err != nil {
-		t.Fatalf("Write to dup2 fd failed: %v", err)
-	}
-	_, err = unix.Seek(f, 0, 0)
-	if err != nil {
-		t.Fatalf("Seek failed: %v", err)
-	}
-	_, err = unix.Read(f, b2)
-	if err != nil {
-		t.Fatalf("Read back failed: %v", err)
-	}
-	if string(b1) != string(b2) {
-		t.Errorf("Dup: stdout write not in file, expected %v, got %v", string(b1), string(b2))
-	}
-}
-
-func TestPoll(t *testing.T) {
-	if runtime.GOOS == "android" ||
-		(runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64")) {
-		t.Skip("mkfifo syscall is not available on android and iOS, skipping test")
-	}
-
-	f, cleanup := mktmpfifo(t)
-	defer cleanup()
-
-	const timeout = 100
-
-	ok := make(chan bool, 1)
-	go func() {
-		select {
-		case <-time.After(10 * timeout * time.Millisecond):
-			t.Errorf("Poll: failed to timeout after %d milliseconds", 10*timeout)
-		case <-ok:
-		}
-	}()
-
-	fds := []unix.PollFd{{Fd: int32(f.Fd()), Events: unix.POLLIN}}
-	n, err := unix.Poll(fds, timeout)
-	ok <- true
-	if err != nil {
-		t.Errorf("Poll: unexpected error: %v", err)
-		return
-	}
-	if n != 0 {
-		t.Errorf("Poll: wrong number of events: got %v, expected %v", n, 0)
-		return
-	}
-}
-
-func TestGetwd(t *testing.T) {
-	fd, err := os.Open(".")
-	if err != nil {
-		t.Fatalf("Open .: %s", err)
-	}
-	defer fd.Close()
-	// These are chosen carefully not to be symlinks on a Mac
-	// (unlike, say, /var, /etc)
-	dirs := []string{"/", "/usr/bin"}
-	switch runtime.GOOS {
-	case "android":
-		dirs = []string{"/", "/system/bin"}
-	case "darwin":
-		switch runtime.GOARCH {
-		case "arm", "arm64":
-			d1, err := ioutil.TempDir("", "d1")
-			if err != nil {
-				t.Fatalf("TempDir: %v", err)
-			}
-			d2, err := ioutil.TempDir("", "d2")
-			if err != nil {
-				t.Fatalf("TempDir: %v", err)
-			}
-			dirs = []string{d1, d2}
-		}
-	}
-	oldwd := os.Getenv("PWD")
-	for _, d := range dirs {
-		err = os.Chdir(d)
-		if err != nil {
-			t.Fatalf("Chdir: %v", err)
-		}
-		pwd, err := unix.Getwd()
-		if err != nil {
-			t.Fatalf("Getwd in %s: %s", d, err)
-		}
-		os.Setenv("PWD", oldwd)
-		err = fd.Chdir()
-		if err != nil {
-			// We changed the current directory and cannot go back.
-			// Don't let the tests continue; they'll scribble
-			// all over some other directory.
-			fmt.Fprintf(os.Stderr, "fchdir back to dot failed: %s\n", err)
-			os.Exit(1)
-		}
-		if pwd != d {
-			t.Fatalf("Getwd returned %q want %q", pwd, d)
-		}
-	}
-}
-
-func TestFstatat(t *testing.T) {
-	defer chtmpdir(t)()
-
-	touch(t, "file1")
-
-	var st1 unix.Stat_t
-	err := unix.Stat("file1", &st1)
-	if err != nil {
-		t.Fatalf("Stat: %v", err)
-	}
-
-	var st2 unix.Stat_t
-	err = unix.Fstatat(unix.AT_FDCWD, "file1", &st2, 0)
-	if err != nil {
-		t.Fatalf("Fstatat: %v", err)
-	}
-
-	if st1 != st2 {
-		t.Errorf("Fstatat: returned stat does not match Stat")
-	}
-
-	err = os.Symlink("file1", "symlink1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = unix.Lstat("symlink1", &st1)
-	if err != nil {
-		t.Fatalf("Lstat: %v", err)
-	}
-
-	err = unix.Fstatat(unix.AT_FDCWD, "symlink1", &st2, unix.AT_SYMLINK_NOFOLLOW)
-	if err != nil {
-		t.Fatalf("Fstatat: %v", err)
-	}
-
-	if st1 != st2 {
-		t.Errorf("Fstatat: returned stat does not match Lstat")
-	}
-}
-
-func TestFchmodat(t *testing.T) {
-	defer chtmpdir(t)()
-
-	touch(t, "file1")
-	err := os.Symlink("file1", "symlink1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	mode := os.FileMode(0444)
-	err = unix.Fchmodat(unix.AT_FDCWD, "symlink1", uint32(mode), 0)
-	if err != nil {
-		t.Fatalf("Fchmodat: unexpected error: %v", err)
-	}
-
-	fi, err := os.Stat("file1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if fi.Mode() != mode {
-		t.Errorf("Fchmodat: failed to change file mode: expected %v, got %v", mode, fi.Mode())
-	}
-
-	mode = os.FileMode(0644)
-	didChmodSymlink := true
-	err = unix.Fchmodat(unix.AT_FDCWD, "symlink1", uint32(mode), unix.AT_SYMLINK_NOFOLLOW)
-	if err != nil {
-		if (runtime.GOOS == "android" || runtime.GOOS == "linux" || runtime.GOOS == "solaris") && err == unix.EOPNOTSUPP {
-			// Linux and Illumos don't support flags != 0
-			didChmodSymlink = false
-		} else {
-			t.Fatalf("Fchmodat: unexpected error: %v", err)
-		}
-	}
-
-	if !didChmodSymlink {
-		// Didn't change mode of the symlink. On Linux, the permissions
-		// of a symbolic link are always 0777 according to symlink(7)
-		mode = os.FileMode(0777)
-	}
-
-	var st unix.Stat_t
-	err = unix.Lstat("symlink1", &st)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	got := os.FileMode(st.Mode & 0777)
-	if got != mode {
-		t.Errorf("Fchmodat: failed to change symlink mode: expected %v, got %v", mode, got)
-	}
-}
-
-func TestMkdev(t *testing.T) {
-	major := uint32(42)
-	minor := uint32(7)
-	dev := unix.Mkdev(major, minor)
-
-	if unix.Major(dev) != major {
-		t.Errorf("Major(%#x) == %d, want %d", dev, unix.Major(dev), major)
-	}
-	if unix.Minor(dev) != minor {
-		t.Errorf("Minor(%#x) == %d, want %d", dev, unix.Minor(dev), minor)
-	}
-}
-
-// mktmpfifo creates a temporary FIFO and provides a cleanup function.
-func mktmpfifo(t *testing.T) (*os.File, func()) {
-	err := unix.Mkfifo("fifo", 0666)
-	if err != nil {
-		t.Fatalf("mktmpfifo: failed to create FIFO: %v", err)
-	}
-
-	f, err := os.OpenFile("fifo", os.O_RDWR, 0666)
-	if err != nil {
-		os.Remove("fifo")
-		t.Fatalf("mktmpfifo: failed to open FIFO: %v", err)
-	}
-
-	return f, func() {
-		f.Close()
-		os.Remove("fifo")
-	}
-}
-
-// utilities taken from os/os_test.go
-
-func touch(t *testing.T, name string) {
-	f, err := os.Create(name)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := f.Close(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// chtmpdir changes the working directory to a new temporary directory and
-// provides a cleanup function. Used when PWD is read-only.
-func chtmpdir(t *testing.T) func() {
-	oldwd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("chtmpdir: %v", err)
-	}
-	d, err := ioutil.TempDir("", "test")
-	if err != nil {
-		t.Fatalf("chtmpdir: %v", err)
-	}
-	if err := os.Chdir(d); err != nil {
-		t.Fatalf("chtmpdir: %v", err)
-	}
-	return func() {
-		if err := os.Chdir(oldwd); err != nil {
-			t.Fatalf("chtmpdir: %v", err)
-		}
-		os.RemoveAll(d)
-	}
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/timestruct_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/timestruct_test.go
deleted file mode 100644
index 4215f46..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/timestruct_test.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2017 The Go Authors. All right reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package unix_test
-
-import (
-	"testing"
-	"time"
-	"unsafe"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestTimeToTimespec(t *testing.T) {
-	timeTests := []struct {
-		time  time.Time
-		valid bool
-	}{
-		{time.Unix(0, 0), true},
-		{time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC), true},
-		{time.Date(2262, time.December, 31, 23, 0, 0, 0, time.UTC), false},
-		{time.Unix(0x7FFFFFFF, 0), true},
-		{time.Unix(0x80000000, 0), false},
-		{time.Unix(0x7FFFFFFF, 1000000000), false},
-		{time.Unix(0x7FFFFFFF, 999999999), true},
-		{time.Unix(-0x80000000, 0), true},
-		{time.Unix(-0x80000001, 0), false},
-		{time.Date(2038, time.January, 19, 3, 14, 7, 0, time.UTC), true},
-		{time.Date(2038, time.January, 19, 3, 14, 8, 0, time.UTC), false},
-		{time.Date(1901, time.December, 13, 20, 45, 52, 0, time.UTC), true},
-		{time.Date(1901, time.December, 13, 20, 45, 51, 0, time.UTC), false},
-	}
-
-	// Currently all targets have either int32 or int64 for Timespec.Sec.
-	// If there were a new target with unsigned or floating point type for
-	// it, this test must be adjusted.
-	have64BitTime := (unsafe.Sizeof(unix.Timespec{}.Sec) == 8)
-	for _, tt := range timeTests {
-		ts, err := unix.TimeToTimespec(tt.time)
-		tt.valid = tt.valid || have64BitTime
-		if tt.valid && err != nil {
-			t.Errorf("TimeToTimespec(%v): %v", tt.time, err)
-		}
-		if err == nil {
-			tstime := time.Unix(int64(ts.Sec), int64(ts.Nsec))
-			if !tstime.Equal(tt.time) {
-				t.Errorf("TimeToTimespec(%v) is the time %v", tt.time, tstime)
-			}
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/golang.org/x/sys/unix/xattr_test.go b/cmd/viewcore/vendor/golang.org/x/sys/unix/xattr_test.go
deleted file mode 100644
index b8b28d0..0000000
--- a/cmd/viewcore/vendor/golang.org/x/sys/unix/xattr_test.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin freebsd linux
-
-package unix_test
-
-import (
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-
-	"golang.org/x/sys/unix"
-)
-
-func TestXattr(t *testing.T) {
-	defer chtmpdir(t)()
-
-	f := "xattr1"
-	touch(t, f)
-
-	xattrName := "user.test"
-	xattrDataSet := "gopher"
-	err := unix.Setxattr(f, xattrName, []byte(xattrDataSet), 0)
-	if err == unix.ENOTSUP || err == unix.EOPNOTSUPP {
-		t.Skip("filesystem does not support extended attributes, skipping test")
-	} else if err != nil {
-		t.Fatalf("Setxattr: %v", err)
-	}
-
-	// find size
-	size, err := unix.Listxattr(f, nil)
-	if err != nil {
-		t.Fatalf("Listxattr: %v", err)
-	}
-
-	if size <= 0 {
-		t.Fatalf("Listxattr returned an empty list of attributes")
-	}
-
-	buf := make([]byte, size)
-	read, err := unix.Listxattr(f, buf)
-	if err != nil {
-		t.Fatalf("Listxattr: %v", err)
-	}
-
-	xattrs := stringsFromByteSlice(buf[:read])
-
-	xattrWant := xattrName
-	if runtime.GOOS == "freebsd" {
-		// On FreeBSD, the namespace is stored separately from the xattr
-		// name and Listxattr doesn't return the namespace prefix.
-		xattrWant = strings.TrimPrefix(xattrWant, "user.")
-	}
-	found := false
-	for _, name := range xattrs {
-		if name == xattrWant {
-			found = true
-		}
-	}
-
-	if !found {
-		t.Errorf("Listxattr did not return previously set attribute '%s'", xattrName)
-	}
-
-	// find size
-	size, err = unix.Getxattr(f, xattrName, nil)
-	if err != nil {
-		t.Fatalf("Getxattr: %v", err)
-	}
-
-	if size <= 0 {
-		t.Fatalf("Getxattr returned an empty attribute")
-	}
-
-	xattrDataGet := make([]byte, size)
-	_, err = unix.Getxattr(f, xattrName, xattrDataGet)
-	if err != nil {
-		t.Fatalf("Getxattr: %v", err)
-	}
-
-	got := string(xattrDataGet)
-	if got != xattrDataSet {
-		t.Errorf("Getxattr: expected attribute value %s, got %s", xattrDataSet, got)
-	}
-
-	err = unix.Removexattr(f, xattrName)
-	if err != nil {
-		t.Fatalf("Removexattr: %v", err)
-	}
-
-	n := "nonexistent"
-	err = unix.Lsetxattr(n, xattrName, []byte(xattrDataSet), 0)
-	if err != unix.ENOENT {
-		t.Errorf("Lsetxattr: expected %v on non-existent file, got %v", unix.ENOENT, err)
-	}
-
-	_, err = unix.Lgetxattr(n, xattrName, nil)
-	if err != unix.ENOENT {
-		t.Errorf("Lgetxattr: %v", err)
-	}
-
-	s := "symlink1"
-	err = os.Symlink(n, s)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = unix.Lsetxattr(s, xattrName, []byte(xattrDataSet), 0)
-	if err != nil {
-		// Linux and Android doen't support xattrs on symlinks according
-		// to xattr(7), so just test that we get the proper error.
-		if (runtime.GOOS != "linux" && runtime.GOOS != "android") || err != unix.EPERM {
-			t.Fatalf("Lsetxattr: %v", err)
-		}
-	}
-}
diff --git a/cmd/viewcore/vendor/vendor.json b/cmd/viewcore/vendor/vendor.json
index 229db5a..f42e20c 100644
--- a/cmd/viewcore/vendor/vendor.json
+++ b/cmd/viewcore/vendor/vendor.json
@@ -1,48 +1,36 @@
 {
 	"comment": "",
-	"ignore": "",
+	"ignore": "test",
 	"package": [
 		{
-			"checksumSHA1": "pccX+tLMoPXwqW6wFXOHQxq23eU=",
-			"path": "github.com/chzyer/logex",
-			"revision": "445be9e134b204a8c920a30fedad02b2f2ab1efd",
-			"revisionTime": "2017-03-29T06:48:20Z"
-		},
-		{
-			"checksumSHA1": "R/zioKKcEGi2axgzZMdBhWugP+E=",
+			"checksumSHA1": "cJ/yTXO11AXO9FJaVKcL78x6LyU=",
 			"path": "github.com/chzyer/readline",
 			"revision": "2972be24d48e78746da79ba8e24e8b488c9880de",
 			"revisionTime": "2018-06-03T13:26:55Z"
 		},
 		{
-			"checksumSHA1": "dFr+xfpmqeLbtAbZUGxIpPuo7Kc=",
-			"path": "github.com/chzyer/test",
-			"revision": "a1ea475d72b168a29f44221e0ad031a842642302",
-			"revisionTime": "2018-02-12T23:58:34Z"
-		},
-		{
 			"checksumSHA1": "40vJyUB4ezQSn/NSadsKEOrudMc=",
 			"path": "github.com/inconshreveable/mousetrap",
 			"revision": "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75",
 			"revisionTime": "2014-10-17T20:07:13Z"
 		},
 		{
-			"checksumSHA1": "D7hWCay3XKO5RjeVj7C1ACkHk6s=",
+			"checksumSHA1": "Xnlls27MEcxIHhpRdsiUa2BqcFk=",
 			"path": "github.com/spf13/cobra",
-			"revision": "ef82de70bb3f60c65fb8eebacbb2d122ef517385",
-			"revisionTime": "2018-04-27T13:45:50Z"
+			"revision": "1e58aa3361fd650121dceeedc399e7189c05674a",
+			"revisionTime": "2018-05-31T18:03:38Z"
 		},
 		{
-			"checksumSHA1": "fTUB2LRINzrW2q0Wp5h9VILSu6A=",
+			"checksumSHA1": "OJI0OgC5V8gZtfS1e0CDYMhkDNc=",
 			"path": "github.com/spf13/pflag",
-			"revision": "583c0c0531f06d5278b7d917446061adc344b5cd",
-			"revisionTime": "2018-04-12T12:09:13Z"
+			"revision": "3ebe029320b2676d667ae88da602a5f854788a8a",
+			"revisionTime": "2018-06-01T13:25:42Z"
 		},
 		{
-			"checksumSHA1": "fQRmHeOLiQ/Lbklrl9BfevodvEM=",
+			"checksumSHA1": "e66DmNWQKgI97tvj4BH7rHYnyJs=",
 			"path": "golang.org/x/sys/unix",
-			"revision": "c4afb3effaa53fd9a06ca61262dc7ce8df4c081b",
-			"revisionTime": "2018-06-26T06:41:42Z"
+			"revision": "7138fd3d9dc8335c567ca206f4333fb75eb05d56",
+			"revisionTime": "2018-06-27T13:57:12Z"
 		}
 	],
 	"rootPath": "golang.org/x/debug/cmd/viewcore"