Update testing

Author: subchen

command_line_parser_test.go

@@ -1,35 +1,18 @@
 package cli
 
 import (
-	"net"
-	"reflect"
 	"testing"
 )
 
-func TestCommandlineParse(t *testing.T) {
-	var (
-		oBool       bool
-		oInt        int
-		oInt64      int64
-		oFloat32    float32
-		oString     string
-		oStringList []string
-		oIntList    []int
-		oNetIP      net.IP
-		oNetIPMask  net.IPMask
-	)
+func TestCommandlineParseBoolFlag(t *testing.T) {
+	var b1, b2, b3, b4 bool
 
 	cl := &commandline{
 		flags: []*Flag{
-			{Name: "b", Value: &oBool},
-			{Name: "i, int", Value: &oInt},
-			{Name: "int64", Value: &oInt64},
-			{Name: "f, f32", Value: &oFloat32},
-			{Name: "s", Value: &oString},
-			{Name: "string-list", Value: &oStringList},
-			{Name: "int-list", Value: &oIntList},
-			{Name: "ip", Value: &oNetIP},
-			{Name: "ipmask", Value: &oNetIPMask},
+			{Name: "b1", Value: &b1},
+			{Name: "b2", Value: &b2},
+			{Name: "b3", Value: &b3},
+			{Name: "b4", Value: &b4, DefValue: "true"},
 		},
 	}
 
@@ -39,48 +22,160 @@ func TestCommandlineParse(t *testing.T) {
 	}
 
 	args := []string{
-		"-b",
-		"-i=12",
-		"--int64", "12345",
-		"-f0.1",
-		"-s='a b'",
-		"--string-list=a",
-		"--string-list", "b",
-		"--int-list=0",
-		"--int-list", "1",
-		"--ip=127.0.0.1",
-		"--ipmask=255.255.0.0",
+		"--b1",
+		"--b2=false",
+		"--b3=on",
 	}
+
 	err := cl.parse(args)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if oBool != true {
-		t.Error("flag bool value is wrong:", oBool)
+	if b1 != true {
+		t.Error("b1 != true")
 	}
-	if oInt != 12 {
-		t.Error("flag int value is wrong:", oInt)
+	if b2 != false {
+		t.Error("b2 != false")
 	}
-	if oInt64 != 12345 {
-		t.Error("flag int64 value is wrong:", oInt64)
+	if b3 != true {
+		t.Error("b3 != true")
 	}
-	if oFloat32 != 0.1 {
-		t.Error("flag float32 value is wrong:", oFloat32)
+	if b4 != true {
+		t.Error("b4 != true")
 	}
-	if oString != "a b" {
-		t.Error("flag string value is wrong:", oString)
+}
+
+func TestCommandlineParseStringFlag(t *testing.T) {
+	var a, b, c string
+	var s1, s2, s3, s4 string
+
+	cl := &commandline{
+		flags: []*Flag{
+			{Name: "s1", Value: &s1},
+			{Name: "s2", Value: &s2},
+			{Name: "s3", Value: &s3},
+			{Name: "s4", Value: &s4},
+			{Name: "a", Value: &a},
+			{Name: "b", Value: &b},
+			{Name: "c", Value: &c},
+		},
 	}
-	if !reflect.DeepEqual(oStringList, []string{"a", "b"}) {
-		t.Error("flag string list value is wrong:", oStringList)
+
+	// initialize flags
+	for _, f := range cl.flags {
+		f.initialize()
 	}
-	if !reflect.DeepEqual(oIntList, []int{0, 1}) {
-		t.Error("flag int list value is wrong:", oIntList)
+
+	args := []string{
+		"--s1=val",
+		`--s2="val"`,
+		`--s3='val'`,
+		"--s4", "val",
+
+		"-a", "val",
+		"-b=val",
+		"-cval",
 	}
-	if oNetIP.String() != "127.0.0.1" {
-		t.Error("flag net.ip value is wrong:", oNetIP.String())
+
+	err := cl.parse(args)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if a != "val" {
+		t.Error("wrong: -x arg")
+	}
+	if b != "val" {
+		t.Error("wrong -x=arg")
+	}
+	if c != "val" {
+		t.Error("wrong -xarg")
+	}
+
+	if s1 != "val" {
+		t.Error("wrong: --long=arg")
+	}
+	if s2 != "val" {
+		t.Error(`wrong --long="arg"`)
+	}
+	if s3 != "val" {
+		t.Error(`wrong --long='arg'`)
+	}
+	if s4 != "val" {
+		t.Error("wrong: --long arg")
+	}
+}
+
+func TestCommandlineParseRawFlag(t *testing.T) {
+	cl := &commandline{}
+
+	args := []string{"--", "-a", "--bb"}
+
+	err := cl.parse(args)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(cl.args) != 2 {
+		t.Error("wrong parse raw: -- arg ...")
+	}
+}
+
+func TestCommandlineParseFlagNotFound(t *testing.T) {
+	cl := &commandline{}
+
+	args := []string{"--test"}
+
+	err := cl.parse(args)
+	if err == nil {
+		t.Fatal("no error found")
+	}
+	if err.Error() != `unrecognized option '--test'` {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestCommandlineParseCommand(t *testing.T) {
+	cl := &commandline{
+		commands: []*Command{
+			{
+				Name: "debug",
+			},
+		},
+	}
+
+	args := []string{"debug", "-a", "--bb"}
+
+	err := cl.parse(args)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if cl.command == nil {
+		t.Fatal("no command found")
+	}
+	if cl.command.Name != "debug" {
+		t.Fatal("wrong parsed command")
+	}
+}
+
+func TestCommandlineParseCommandNotFound(t *testing.T) {
+	cl := &commandline{
+		commands: []*Command{
+			{
+				Name: "debug",
+			},
+		},
+	}
+
+	args := []string{"help"}
+
+	err := cl.parse(args)
+	if err != nil {
+		t.Fatal(err)
 	}
-	if oNetIPMask.String() != "ffff0000" {
-		t.Error("flag net.ipmask value is wrong:", oNetIPMask.String())
+	if cl.command != nil {
+		t.Fatal("command should be not found")
 	}
 }