Bump a few libs to latest tagged versions

vendor/github.com/codegangsta/cli/flag_test.go

@@ -1,6 +1,8 @@
-package cli
+package cli_test
 
 import (
+	"github.com/codegangsta/cli"
+
 	"fmt"
 	"os"
 	"reflect"
@@ -19,7 +21,7 @@ var boolFlagTests = []struct {
 func TestBoolFlagHelpOutput(t *testing.T) {
 
 	for _, test := range boolFlagTests {
-		flag := BoolFlag{Name: test.name}
+		flag := cli.BoolFlag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -36,13 +38,13 @@ var stringFlagTests = []struct {
 	{"help", "", "--help \t"},
 	{"h", "", "-h \t"},
 	{"h", "", "-h \t"},
-	{"test", "Something", "--test \"Something\"\t"},
+	{"test", "Something", "--test 'Something'\t"},
 }
 
 func TestStringFlagHelpOutput(t *testing.T) {
 
 	for _, test := range stringFlagTests {
-		flag := StringFlag{Name: test.name, Value: test.value}
+		flag := cli.StringFlag{Name: test.name, Value: test.value}
 		output := flag.String()
 
 		if output != test.expected {
@@ -52,10 +54,10 @@ func TestStringFlagHelpOutput(t *testing.T) {
 }
 
 func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
+
 	os.Setenv("APP_FOO", "derp")
 	for _, test := range stringFlagTests {
-		flag := StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
+		flag := cli.StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_FOO]") {
@@ -66,35 +68,35 @@ func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
 
 var stringSliceFlagTests = []struct {
 	name     string
-	value    *StringSlice
+	value    *cli.StringSlice
 	expected string
 }{
-	{"help", func() *StringSlice {
-		s := &StringSlice{}
+	{"help", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
 		s.Set("")
 		return s
-	}(), "--help [--help option --help option]\t"},
-	{"h", func() *StringSlice {
-		s := &StringSlice{}
+	}(), "--help '--help option --help option'\t"},
+	{"h", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
 		s.Set("")
 		return s
-	}(), "-h [-h option -h option]\t"},
-	{"h", func() *StringSlice {
-		s := &StringSlice{}
+	}(), "-h '-h option -h option'\t"},
+	{"h", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
 		s.Set("")
 		return s
-	}(), "-h [-h option -h option]\t"},
-	{"test", func() *StringSlice {
-		s := &StringSlice{}
+	}(), "-h '-h option -h option'\t"},
+	{"test", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
 		s.Set("Something")
 		return s
-	}(), "--test [--test option --test option]\t"},
+	}(), "--test '--test option --test option'\t"},
 }
 
 func TestStringSliceFlagHelpOutput(t *testing.T) {
 
 	for _, test := range stringSliceFlagTests {
-		flag := StringSliceFlag{Name: test.name, Value: test.value}
+		flag := cli.StringSliceFlag{Name: test.name, Value: test.value}
 		output := flag.String()
 
 		if output != test.expected {
@@ -104,10 +106,10 @@ func TestStringSliceFlagHelpOutput(t *testing.T) {
 }
 
 func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
+
 	os.Setenv("APP_QWWX", "11,4")
 	for _, test := range stringSliceFlagTests {
-		flag := StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
+		flag := cli.StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_QWWX]") {
@@ -120,14 +122,14 @@ var intFlagTests = []struct {
 	name     string
 	expected string
 }{
-	{"help", "--help \"0\"\t"},
-	{"h", "-h \"0\"\t"},
+	{"help", "--help '0'\t"},
+	{"h", "-h '0'\t"},
 }
 
 func TestIntFlagHelpOutput(t *testing.T) {
 
 	for _, test := range intFlagTests {
-		flag := IntFlag{Name: test.name}
+		flag := cli.IntFlag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -137,43 +139,10 @@ func TestIntFlagHelpOutput(t *testing.T) {
 }
 
 func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
+
 	os.Setenv("APP_BAR", "2")
 	for _, test := range intFlagTests {
-		flag := IntFlag{Name: test.name, EnvVar: "APP_BAR"}
-		output := flag.String()
-
-		if !strings.HasSuffix(output, " [$APP_BAR]") {
-			t.Errorf("%s does not end with [$APP_BAR]", output)
-		}
-	}
-}
-
-var durationFlagTests = []struct {
-	name     string
-	expected string
-}{
-	{"help", "--help \"0\"\t"},
-	{"h", "-h \"0\"\t"},
-}
-
-func TestDurationFlagHelpOutput(t *testing.T) {
-
-	for _, test := range durationFlagTests {
-		flag := DurationFlag{Name: test.name}
-		output := flag.String()
-
-		if output != test.expected {
-			t.Errorf("%s does not match %s", output, test.expected)
-		}
-	}
-}
-
-func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_BAR", "2h3m6s")
-	for _, test := range durationFlagTests {
-		flag := DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
+		flag := cli.IntFlag{Name: test.name, EnvVar: "APP_BAR"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_BAR]") {
@@ -184,23 +153,23 @@ func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
 
 var intSliceFlagTests = []struct {
 	name     string
-	value    *IntSlice
+	value    *cli.IntSlice
 	expected string
 }{
-	{"help", &IntSlice{}, "--help [--help option --help option]\t"},
-	{"h", &IntSlice{}, "-h [-h option -h option]\t"},
-	{"h", &IntSlice{}, "-h [-h option -h option]\t"},
-	{"test", func() *IntSlice {
-		i := &IntSlice{}
+	{"help", &cli.IntSlice{}, "--help '--help option --help option'\t"},
+	{"h", &cli.IntSlice{}, "-h '-h option -h option'\t"},
+	{"h", &cli.IntSlice{}, "-h '-h option -h option'\t"},
+	{"test", func() *cli.IntSlice {
+		i := &cli.IntSlice{}
 		i.Set("9")
 		return i
-	}(), "--test [--test option --test option]\t"},
+	}(), "--test '--test option --test option'\t"},
 }
 
 func TestIntSliceFlagHelpOutput(t *testing.T) {
 
 	for _, test := range intSliceFlagTests {
-		flag := IntSliceFlag{Name: test.name, Value: test.value}
+		flag := cli.IntSliceFlag{Name: test.name, Value: test.value}
 		output := flag.String()
 
 		if output != test.expected {
@@ -210,10 +179,10 @@ func TestIntSliceFlagHelpOutput(t *testing.T) {
 }
 
 func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
+
 	os.Setenv("APP_SMURF", "42,3")
 	for _, test := range intSliceFlagTests {
-		flag := IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
+		flag := cli.IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_SMURF]") {
@@ -226,14 +195,14 @@ var float64FlagTests = []struct {
 	name     string
 	expected string
 }{
-	{"help", "--help \"0\"\t"},
-	{"h", "-h \"0\"\t"},
+	{"help", "--help '0'\t"},
+	{"h", "-h '0'\t"},
 }
 
 func TestFloat64FlagHelpOutput(t *testing.T) {
 
 	for _, test := range float64FlagTests {
-		flag := Float64Flag{Name: test.name}
+		flag := cli.Float64Flag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -243,10 +212,10 @@ func TestFloat64FlagHelpOutput(t *testing.T) {
 }
 
 func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
+
 	os.Setenv("APP_BAZ", "99.4")
 	for _, test := range float64FlagTests {
-		flag := Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
+		flag := cli.Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_BAZ]") {
@@ -257,17 +226,18 @@ func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
 
 var genericFlagTests = []struct {
 	name     string
-	value    Generic
+	value    cli.Generic
 	expected string
 }{
-	{"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"},
-	{"t", &Parser{"abc", "def"}, "-t \"abc,def\"\ttest flag"},
+	{"help", &Parser{}, "--help <nil>\t`-help option -help option` "},
+	{"h", &Parser{}, "-h <nil>\t`-h option -h option` "},
+	{"test", &Parser{}, "--test <nil>\t`-test option -test option` "},
 }
 
 func TestGenericFlagHelpOutput(t *testing.T) {
 
 	for _, test := range genericFlagTests {
-		flag := GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
+		flag := cli.GenericFlag{Name: test.name}
 		output := flag.String()
 
 		if output != test.expected {
@@ -277,10 +247,10 @@ func TestGenericFlagHelpOutput(t *testing.T) {
 }
 
 func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
-	os.Clearenv()
+
 	os.Setenv("APP_ZAP", "3")
 	for _, test := range genericFlagTests {
-		flag := GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
+		flag := cli.GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
 		output := flag.String()
 
 		if !strings.HasSuffix(output, " [$APP_ZAP]") {
@@ -290,11 +260,11 @@ func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
 }
 
 func TestParseMultiString(t *testing.T) {
-	(&App{
-		Flags: []Flag{
-			StringFlag{Name: "serve, s"},
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.String("serve") != "10" {
 				t.Errorf("main name not set")
 			}
@@ -305,50 +275,13 @@ func TestParseMultiString(t *testing.T) {
 	}).Run([]string{"run", "-s", "10"})
 }
 
-func TestParseDestinationString(t *testing.T) {
-	var dest string
-	a := App{
-		Flags: []Flag{
-			StringFlag{
-				Name:        "dest",
-				Destination: &dest,
-			},
-		},
-		Action: func(ctx *Context) {
-			if dest != "10" {
-				t.Errorf("expected destination String 10")
-			}
-		},
-	}
-	a.Run([]string{"run", "--dest", "10"})
-}
-
 func TestParseMultiStringFromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_COUNT", "20")
-	(&App{
-		Flags: []Flag{
-			StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
 		},
-		Action: func(ctx *Context) {
-			if ctx.String("count") != "20" {
-				t.Errorf("main name not set")
-			}
-			if ctx.String("c") != "20" {
-				t.Errorf("short name not set")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiStringFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_COUNT", "20")
-	(&App{
-		Flags: []Flag{
-			StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
-		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.String("count") != "20" {
 				t.Errorf("main name not set")
 			}
@@ -360,11 +293,11 @@ func TestParseMultiStringFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiStringSlice(t *testing.T) {
-	(&App{
-		Flags: []Flag{
-			StringSliceFlag{Name: "serve, s", Value: &StringSlice{}},
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringSliceFlag{Name: "serve, s", Value: &cli.StringSlice{}},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
 				t.Errorf("main name not set")
 			}
@@ -376,33 +309,13 @@ func TestParseMultiStringSlice(t *testing.T) {
 }
 
 func TestParseMultiStringSliceFromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_INTERVALS", "20,30,40")
 
-	(&App{
-		Flags: []Flag{
-			StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "APP_INTERVALS"},
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "APP_INTERVALS"},
 		},
-		Action: func(ctx *Context) {
-			if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
-				t.Errorf("main name not set from env")
-			}
-			if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_INTERVALS", "20,30,40")
-
-	(&App{
-		Flags: []Flag{
-			StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
-		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
 				t.Errorf("main name not set from env")
 			}
@@ -414,11 +327,11 @@ func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiInt(t *testing.T) {
-	a := App{
-		Flags: []Flag{
-			IntFlag{Name: "serve, s"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.IntFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.Int("serve") != 10 {
 				t.Errorf("main name not set")
 			}
@@ -430,51 +343,13 @@ func TestParseMultiInt(t *testing.T) {
 	a.Run([]string{"run", "-s", "10"})
 }
 
-func TestParseDestinationInt(t *testing.T) {
-	var dest int
-	a := App{
-		Flags: []Flag{
-			IntFlag{
-				Name:        "dest",
-				Destination: &dest,
-			},
-		},
-		Action: func(ctx *Context) {
-			if dest != 10 {
-				t.Errorf("expected destination Int 10")
-			}
-		},
-	}
-	a.Run([]string{"run", "--dest", "10"})
-}
-
 func TestParseMultiIntFromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_TIMEOUT_SECONDS", "10")
-	a := App{
-		Flags: []Flag{
-			IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
 		},
-		Action: func(ctx *Context) {
-			if ctx.Int("timeout") != 10 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Int("t") != 10 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiIntFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "10")
-	a := App{
-		Flags: []Flag{
-			IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
-		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.Int("timeout") != 10 {
 				t.Errorf("main name not set")
 			}
@@ -487,11 +362,11 @@ func TestParseMultiIntFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiIntSlice(t *testing.T) {
-	(&App{
-		Flags: []Flag{
-			IntSliceFlag{Name: "serve, s", Value: &IntSlice{}},
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.IntSliceFlag{Name: "serve, s", Value: &cli.IntSlice{}},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
 				t.Errorf("main name not set")
 			}
@@ -503,33 +378,13 @@ func TestParseMultiIntSlice(t *testing.T) {
 }
 
 func TestParseMultiIntSliceFromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_INTERVALS", "20,30,40")
 
-	(&App{
-		Flags: []Flag{
-			IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "APP_INTERVALS"},
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "APP_INTERVALS"},
 		},
-		Action: func(ctx *Context) {
-			if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
-				t.Errorf("main name not set from env")
-			}
-			if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}).Run([]string{"run"})
-}
-
-func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_INTERVALS", "20,30,40")
-
-	(&App{
-		Flags: []Flag{
-			IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
-		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
 				t.Errorf("main name not set from env")
 			}
@@ -541,11 +396,11 @@ func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiFloat64(t *testing.T) {
-	a := App{
-		Flags: []Flag{
-			Float64Flag{Name: "serve, s"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.Float64Flag{Name: "serve, s"},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.Float64("serve") != 10.2 {
 				t.Errorf("main name not set")
 			}
@@ -557,51 +412,13 @@ func TestParseMultiFloat64(t *testing.T) {
 	a.Run([]string{"run", "-s", "10.2"})
 }
 
-func TestParseDestinationFloat64(t *testing.T) {
-	var dest float64
-	a := App{
-		Flags: []Flag{
-			Float64Flag{
-				Name:        "dest",
-				Destination: &dest,
-			},
-		},
-		Action: func(ctx *Context) {
-			if dest != 10.2 {
-				t.Errorf("expected destination Float64 10.2")
-			}
-		},
-	}
-	a.Run([]string{"run", "--dest", "10.2"})
-}
-
 func TestParseMultiFloat64FromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	a := App{
-		Flags: []Flag{
-			Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
 		},
-		Action: func(ctx *Context) {
-			if ctx.Float64("timeout") != 15.5 {
-				t.Errorf("main name not set")
-			}
-			if ctx.Float64("t") != 15.5 {
-				t.Errorf("short name not set")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
-	a := App{
-		Flags: []Flag{
-			Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
-		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.Float64("timeout") != 15.5 {
 				t.Errorf("main name not set")
 			}
@@ -614,11 +431,11 @@ func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiBool(t *testing.T) {
-	a := App{
-		Flags: []Flag{
-			BoolFlag{Name: "serve, s"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.Bool("serve") != true {
 				t.Errorf("main name not set")
 			}
@@ -630,51 +447,13 @@ func TestParseMultiBool(t *testing.T) {
 	a.Run([]string{"run", "--serve"})
 }
 
-func TestParseDestinationBool(t *testing.T) {
-	var dest bool
-	a := App{
-		Flags: []Flag{
-			BoolFlag{
-				Name:        "dest",
-				Destination: &dest,
-			},
-		},
-		Action: func(ctx *Context) {
-			if dest != true {
-				t.Errorf("expected destination Bool true")
-			}
-		},
-	}
-	a.Run([]string{"run", "--dest"})
-}
-
 func TestParseMultiBoolFromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_DEBUG", "1")
-	a := App{
-		Flags: []Flag{
-			BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
 		},
-		Action: func(ctx *Context) {
-			if ctx.Bool("debug") != true {
-				t.Errorf("main name not set from env")
-			}
-			if ctx.Bool("d") != true {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiBoolFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_DEBUG", "1")
-	a := App{
-		Flags: []Flag{
-			BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
-		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.Bool("debug") != true {
 				t.Errorf("main name not set from env")
 			}
@@ -687,11 +466,11 @@ func TestParseMultiBoolFromEnvCascade(t *testing.T) {
 }
 
 func TestParseMultiBoolT(t *testing.T) {
-	a := App{
-		Flags: []Flag{
-			BoolTFlag{Name: "serve, s"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolTFlag{Name: "serve, s"},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.BoolT("serve") != true {
 				t.Errorf("main name not set")
 			}
@@ -703,51 +482,13 @@ func TestParseMultiBoolT(t *testing.T) {
 	a.Run([]string{"run", "--serve"})
 }
 
-func TestParseDestinationBoolT(t *testing.T) {
-	var dest bool
-	a := App{
-		Flags: []Flag{
-			BoolTFlag{
-				Name:        "dest",
-				Destination: &dest,
-			},
-		},
-		Action: func(ctx *Context) {
-			if dest != true {
-				t.Errorf("expected destination BoolT true")
-			}
-		},
-	}
-	a.Run([]string{"run", "--dest"})
-}
-
 func TestParseMultiBoolTFromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_DEBUG", "0")
-	a := App{
-		Flags: []Flag{
-			BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
 		},
-		Action: func(ctx *Context) {
-			if ctx.BoolT("debug") != false {
-				t.Errorf("main name not set from env")
-			}
-			if ctx.BoolT("d") != false {
-				t.Errorf("short name not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}
-
-func TestParseMultiBoolTFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_DEBUG", "0")
-	a := App{
-		Flags: []Flag{
-			BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
-		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if ctx.BoolT("debug") != false {
 				t.Errorf("main name not set from env")
 			}
@@ -778,11 +519,11 @@ func (p *Parser) String() string {
 }
 
 func TestParseGeneric(t *testing.T) {
-	a := App{
-		Flags: []Flag{
-			GenericFlag{Name: "serve, s", Value: &Parser{}},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.GenericFlag{Name: "serve, s", Value: &Parser{}},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
 				t.Errorf("main name not set")
 			}
@@ -795,13 +536,12 @@ func TestParseGeneric(t *testing.T) {
 }
 
 func TestParseGenericFromEnv(t *testing.T) {
-	os.Clearenv()
 	os.Setenv("APP_SERVE", "20,30")
-	a := App{
-		Flags: []Flag{
-			GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
 		},
-		Action: func(ctx *Context) {
+		Action: func(ctx *cli.Context) {
 			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
 				t.Errorf("main name not set from env")
 			}
@@ -812,19 +552,3 @@ func TestParseGenericFromEnv(t *testing.T) {
 	}
 	a.Run([]string{"run"})
 }
-
-func TestParseGenericFromEnvCascade(t *testing.T) {
-	os.Clearenv()
-	os.Setenv("APP_FOO", "99,2000")
-	a := App{
-		Flags: []Flag{
-			GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
-		},
-		Action: func(ctx *Context) {
-			if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) {
-				t.Errorf("value not set from env")
-			}
-		},
-	}
-	a.Run([]string{"run"})
-}