func setFromEnv(into flag.Value, envVars string) bool {
	multiValued, isMulti := into.(multiValued)

	if len(envVars) > 0 {
		for _, rev := range strings.Split(envVars, " ") {
			ev := strings.TrimSpace(rev)
			if len(ev) == 0 {
				continue
			}

			v := os.Getenv(ev)
			if len(v) == 0 {
				continue
			}
			if !isMulti {
				if err := into.Set(v); err == nil {
					return true
				}
				continue
			}

			vs := strings.Split(v, ",")
			if err := setMultivalued(multiValued, vs); err == nil {
				return true
			}
		}
	}
	return false
}

// Var defines a flag with the specified name and usage string. The type and
// value of the flag are represented by the first argument, of type Value, which
// typically holds a user-defined implementation of Value. For instance, the
// caller could create a flag that turns a comma-separated string into a slice
// of strings by giving the slice the methods of Value; in particular, Set would
// decompose the comma-separated string into the slice.
func (c *ConfigoSet) Var(value flag.Value, name string, usage string, isFlag, isConfig bool) {
	// Remember the default value as a string; it won't change.
	config := &Configo{name, usage, value, value.String(), isFlag, isConfig}
	_, alreadythere := c.formal[name]
	if alreadythere {
		msg := fmt.Sprintf("%s flag redefined: %s", c.name, name)
		fmt.Fprintln(c.out(), msg)
		panic(msg) // Happens only if flags are declared with identical names
	}
	if c.formal == nil {
		c.formal = make(map[string]*Configo)
	}
	c.formal[name] = config
}

// Var sets the value, name, and usage for an environment variable in the set
func (e *Set) Var(value flag.Value, name string, usage string) {
	v := &Variable{name, usage, value, value.String()}
	_, alreadythere := e.variables[name]
	if alreadythere {
		var msg string
		if e.name == "" {
			msg = fmt.Sprintf("flag redefined: %s", name)
		} else {
			msg = fmt.Sprintf("%s flag redefined: %s", e.name, name)
		}
		fmt.Fprintln(e.out(), msg)
		panic(msg) // Happens only if flags are declared with identical names
	}
	if e.variables == nil {
		e.variables = make(map[string]*Variable)
	}
	e.variables[name] = v
}

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, ""},
	}

	for i := range testCases {
		tc := &testCases[i]
		var f flag.Value = &IPNet{}
		err := f.Set(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")
			continue
		} else if tc.success {
			if f.String() != tc.expected {
				t.Errorf("expected %q, got %q", tc.expected, f.String())
			}
		}
	}
}

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, ""},
	}

	for i := range testCases {
		tc := &testCases[i]
		var f flag.Value = &IP{}
		err := f.Set(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")
			continue
		} else if tc.success {
			if f.String() != tc.expected {
				t.Errorf("expected %q, got %q", tc.expected, f.String())
			}
		}
	}
}

func (self *flagDummy) Var(value goflag.Value, name string, usage string) {
	flag := flag{name, value.String(), usage}
	*self.list = append(*self.list, flag)
}

func main() {
	var flag flag.Value = new(MyFlag)
	flag.Set("joe")
}