1 files changed, 182 insertions, 0 deletions
diff --git a/libgo/go/flag/flag_test.go b/libgo/go/flag/flag_test.go
new file mode 100644
index 00000000000..5fb76493f63
--- /dev/null
+++ b/libgo/go/flag/flag_test.go
@@ -0,0 +1,182 @@
+// 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 flag_test
+
+import (
+	. "flag"
+	"fmt"
+	"testing"
+)
+
+var (
+	test_bool    = Bool("test_bool", false, "bool value")
+	test_int     = Int("test_int", 0, "int value")
+	test_int64   = Int64("test_int64", 0, "int64 value")
+	test_uint    = Uint("test_uint", 0, "uint value")
+	test_uint64  = Uint64("test_uint64", 0, "uint64 value")
+	test_string  = String("test_string", "0", "string value")
+	test_float   = Float("test_float", 0, "float value")
+	test_float64 = Float("test_float64", 0, "float64 value")
+)
+
+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
+			}
+			if !ok {
+				t.Error("Visit: bad value", f.Value.String(), "for", f.Name)
+			}
+		}
+	}
+	VisitAll(visitor)
+	if len(m) != 8 {
+		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_float", "1")
+	Set("test_float64", "1")
+	desired = "1"
+	Visit(visitor)
+	if len(m) != 8 {
+		t.Error("Visit fails after set")
+		for k, v := range m {
+			t.Log(k, *v)
+		}
+	}
+}
+
+func TestUsage(t *testing.T) {
+	called := false
+	ResetForTesting(func() { called = true })
+	if ParseForTesting([]string{"a.out", "-x"}) {
+		t.Error("parse did not fail for unknown flag")
+	}
+	if !called {
+		t.Error("did not call Usage for unknown flag")
+	}
+}
+
+func TestParse(t *testing.T) {
+	ResetForTesting(func() { t.Error("bad parse") })
+	boolFlag := Bool("bool", false, "bool value")
+	bool2Flag := Bool("bool2", false, "bool2 value")
+	intFlag := Int("int", 0, "int value")
+	int64Flag := Int64("int64", 0, "int64 value")
+	uintFlag := Uint("uint", 0, "uint value")
+	uint64Flag := Uint64("uint64", 0, "uint64 value")
+	stringFlag := String("string", "0", "string value")
+	floatFlag := Float("float", 0, "float value")
+	float64Flag := Float("float64", 0, "float64 value")
+	extra := "one-extra-argument"
+	args := []string{
+		"a.out",
+		"-bool",
+		"-bool2=true",
+		"--int", "22",
+		"--int64", "23",
+		"-uint", "24",
+		"--uint64", "25",
+		"-string", "hello",
+		"--float", "3141.5",
+		"-float64", "2718e28",
+		extra,
+	}
+	if !ParseForTesting(args) {
+		t.Fatal("parse failed")
+	}
+	if *boolFlag != true {
+		t.Error("bool flag should be true, is ", *boolFlag)
+	}
+	if *bool2Flag != true {
+		t.Error("bool2 flag should be true, is ", *bool2Flag)
+	}
+	if *intFlag != 22 {
+		t.Error("int flag should be 22, is ", *intFlag)
+	}
+	if *int64Flag != 23 {
+		t.Error("int64 flag should be 23, is ", *int64Flag)
+	}
+	if *uintFlag != 24 {
+		t.Error("uint flag should be 24, is ", *uintFlag)
+	}
+	if *uint64Flag != 25 {
+		t.Error("uint64 flag should be 25, is ", *uint64Flag)
+	}
+	if *stringFlag != "hello" {
+		t.Error("string flag should be `hello`, is ", *stringFlag)
+	}
+	if *floatFlag != 3141.5 {
+		t.Error("float flag should be 3141.5, is ", *floatFlag)
+	}
+	if *float64Flag != 2718e28 {
+		t.Error("float64 flag should be 2718e28, is ", *float64Flag)
+	}
+	if len(Args()) != 1 {
+		t.Error("expected one argument, got", len(Args()))
+	} else if Args()[0] != extra {
+		t.Errorf("expected argument %q got %q", extra, Args()[0])
+	}
+}
+
+// Declare a user-defined flag.
+type flagVar []string
+
+func (f *flagVar) String() string {
+	return fmt.Sprint([]string(*f))
+}
+
+func (f *flagVar) Set(value string) bool {
+	*f = append(*f, value)
+	return true
+}
+
+func TestUserDefined(t *testing.T) {
+	ResetForTesting(func() { t.Fatal("bad parse") })
+	var v flagVar
+	Var(&v, "v", "usage")
+	if !ParseForTesting([]string{"a.out", "-v", "1", "-v", "2", "-v=3"}) {
+		t.Error("parse failed")
+	}
+	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())
+	}
+}