diff --git a/docopt.go b/docopt.go
new file mode 100644
index 0000000..77c52ab
--- /dev/null
+++ b/docopt.go
@@ -0,0 +1,1213 @@
+/*
+Based of off docopt.py: https://github.com/docopt/docopt
+
+Licensed under terms of MIT license (see LICENSE-MIT)
+Copyright (c) 2013 Keith Batten, kbatten@gmail.com
+*/
+
+package docopt
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// parse and return a map of args, output and all errors
+func Parse(doc string, argv []string, help bool, version string, optionsFirst bool) (args map[string]interface{}, output string, err error) {
+	if argv == nil && len(os.Args) > 1 {
+		argv = os.Args[1:]
+	}
+
+	usageSections := parseSection("usage:", doc)
+
+	if len(usageSections) == 0 {
+		err = newLanguageError("\"usage:\" (case-insensitive) not found.")
+		return
+	}
+	if len(usageSections) > 1 {
+		err = newLanguageError("More than one \"usage:\" (case-insensitive).")
+		return
+	}
+	usage := usageSections[0]
+
+	options := parseDefaults(doc)
+	pat, err := parsePattern(formalUsage(usage), &options)
+	if err != nil {
+		output = handleError(err, usage)
+		return
+	}
+
+	patternArgv, err := parseArgv(newTokenList(argv, ERROR_USER), &options, optionsFirst)
+	if err != nil {
+		output = handleError(err, usage)
+		return
+	}
+	patFlat, err := pat.flat(PATTERN_OPTION)
+	if err != nil {
+		output = handleError(err, usage)
+		return
+	}
+	patternOptions := patFlat.unique()
+
+	patFlat, err = pat.flat(PATTERN_OPTIONSSHORTCUT)
+	if err != nil {
+		output = handleError(err, usage)
+		return
+	}
+	for _, optionsShortcut := range patFlat {
+		docOptions := parseDefaults(doc)
+		optionsShortcut.children = docOptions.unique().diff(patternOptions)
+	}
+
+	if output = extras(help, version, patternArgv, doc); len(output) > 0 {
+		return
+	}
+
+	err = pat.fix()
+	if err != nil {
+		output = handleError(err, usage)
+		return
+	}
+	matched, left, collected := pat.match(&patternArgv, nil)
+	if matched && len(*left) == 0 {
+		patFlat, err = pat.flat(PATTERN_DEFAULT)
+		if err != nil {
+			output = handleError(err, usage)
+			return
+		}
+		args = append(patFlat, *collected...).dictionary()
+		return
+	}
+
+	err = newUserError("")
+	output = handleError(err, usage)
+	return
+}
+
+// parse just doc and return a map of args
+// handle all printing and non-fatal errors
+// panic on fatal errors
+// exit on user error or help
+func ParseEasy(doc string) map[string]interface{} {
+	return ParseLoud(doc, nil, true, "", false)
+}
+
+// parse and return a map of args and fatal errors
+// handle printing of help
+// exit on user error or help
+func ParseQuiet(doc string, argv []string, help bool, version string, optionsFirst bool) (map[string]interface{}, error) {
+	args, output, err := Parse(doc, argv, help, version, optionsFirst)
+	if _, ok := err.(*UserError); ok {
+		fmt.Println(output)
+		os.Exit(1)
+	} else if len(output) > 0 && err == nil {
+		fmt.Println(output)
+		os.Exit(0)
+	}
+	return args, err
+}
+
+// parse and return a map of args
+// handle all printing and non-fatal errors
+// panic on fatal errors
+// exit on user error or help
+func ParseLoud(doc string, argv []string, help bool, version string, optionsFirst bool) map[string]interface{} {
+	args, err := ParseQuiet(doc, argv, help, version, optionsFirst)
+	if _, ok := err.(*LanguageError); ok {
+		panic(fmt.Sprintf("(language) %s", err))
+	} else if err != nil {
+		panic(fmt.Sprintf("(internal) %s", err))
+	}
+	return args
+}
+
+func handleError(err error, usage string) string {
+	if _, ok := err.(*UserError); ok {
+		return strings.TrimSpace(fmt.Sprintf("%s\n%s", err, usage))
+	}
+	return ""
+}
+
+func parseSection(name, source string) []string {
+	p := regexp.MustCompile(`(?im)^([^\n]*` + name + `[^\n]*\n?(?:[ \t].*?(?:\n|$))*)`)
+	s := p.FindAllString(source, -1)
+	if s == nil {
+		s = []string{}
+	}
+	for i, v := range s {
+		s[i] = strings.TrimSpace(v)
+	}
+	return s
+}
+
+func parseDefaults(doc string) patternList {
+	defaults := patternList{}
+	p := regexp.MustCompile(`\n[ \t]*(-\S+?)`)
+	for _, s := range parseSection("options:", doc) {
+		// FIXME corner case "bla: options: --foo"
+		_, _, s = stringPartition(s, ":") // get rid of "options:"
+		split := p.Split("\n"+s, -1)[1:]
+		match := p.FindAllStringSubmatch("\n"+s, -1)
+		for i := range split {
+			optionDescription := match[i][1] + split[i]
+			if strings.HasPrefix(optionDescription, "-") {
+				defaults = append(defaults, parseOption(optionDescription))
+			}
+		}
+	}
+	return defaults
+}
+
+func parsePattern(source string, options *patternList) (*pattern, error) {
+	tokens := tokenListFromPattern(source)
+	result, err := parseExpr(tokens, options)
+	if err != nil {
+		return nil, err
+	}
+	if tokens.current() != nil {
+		return nil, tokens.errorFunc("unexpected ending: %s" + strings.Join(tokens.tokens, " "))
+	}
+	return newRequired(result...), nil
+}
+
+func parseArgv(tokens *tokenList, options *patternList, optionsFirst bool) (patternList, error) {
+	/*
+		Parse command-line argument vector.
+
+		If options_first:
+			argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
+		else:
+			argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;
+	*/
+	parsed := patternList{}
+	for tokens.current() != nil {
+		if tokens.current().eq("--") {
+			for _, v := range tokens.tokens {
+				parsed = append(parsed, newArgument("", v))
+			}
+			return parsed, nil
+		} else if tokens.current().hasPrefix("--") {
+			pl, err := parseLong(tokens, options)
+			if err != nil {
+				return nil, err
+			}
+			parsed = append(parsed, pl...)
+		} else if tokens.current().hasPrefix("-") && !tokens.current().eq("-") {
+			ps, err := parseShorts(tokens, options)
+			if err != nil {
+				return nil, err
+			}
+			parsed = append(parsed, ps...)
+		} else if optionsFirst {
+			for _, v := range tokens.tokens {
+				parsed = append(parsed, newArgument("", v))
+			}
+			return parsed, nil
+		} else {
+			parsed = append(parsed, newArgument("", tokens.move().String()))
+		}
+	}
+	return parsed, nil
+}
+
+func parseOption(optionDescription string) *pattern {
+	optionDescription = strings.TrimSpace(optionDescription)
+	options, _, description := stringPartition(optionDescription, "  ")
+	options = strings.Replace(options, ",", " ", -1)
+	options = strings.Replace(options, "=", " ", -1)
+
+	short := ""
+	long := ""
+	argcount := 0
+	var value interface{}
+	value = false
+
+	reDefault := regexp.MustCompile(`(?i)\[default: (.*)\]`)
+	for _, s := range strings.Fields(options) {
+		if strings.HasPrefix(s, "--") {
+			long = s
+		} else if strings.HasPrefix(s, "-") {
+			short = s
+		} else {
+			argcount = 1
+		}
+		if argcount > 0 {
+			matched := reDefault.FindAllStringSubmatch(description, -1)
+			if len(matched) > 0 {
+				value = matched[0][1]
+			} else {
+				value = nil
+			}
+		}
+	}
+	return newOption(short, long, argcount, value)
+}
+
+func parseExpr(tokens *tokenList, options *patternList) (patternList, error) {
+	// expr ::= seq ( '|' seq )* ;
+	seq, err := parseSeq(tokens, options)
+	if err != nil {
+		return nil, err
+	}
+	if !tokens.current().eq("|") {
+		return seq, nil
+	}
+	var result patternList
+	if len(seq) > 1 {
+		result = patternList{newRequired(seq...)}
+	} else {
+		result = seq
+	}
+	for tokens.current().eq("|") {
+		tokens.move()
+		seq, err = parseSeq(tokens, options)
+		if err != nil {
+			return nil, err
+		}
+		if len(seq) > 1 {
+			result = append(result, newRequired(seq...))
+		} else {
+			result = append(result, seq...)
+		}
+	}
+	if len(result) > 1 {
+		return patternList{newEither(result...)}, nil
+	}
+	return result, nil
+}
+
+func parseSeq(tokens *tokenList, options *patternList) (patternList, error) {
+	// seq ::= ( atom [ '...' ] )* ;
+	result := patternList{}
+	for !tokens.current().match(true, "]", ")", "|") {
+		atom, err := parseAtom(tokens, options)
+		if err != nil {
+			return nil, err
+		}
+		if tokens.current().eq("...") {
+			atom = patternList{newOneOrMore(atom...)}
+			tokens.move()
+		}
+		result = append(result, atom...)
+	}
+	return result, nil
+}
+
+func parseAtom(tokens *tokenList, options *patternList) (patternList, error) {
+	// atom ::= '(' expr ')' | '[' expr ']' | 'options' | long | shorts | argument | command ;
+	tok := tokens.current()
+	result := patternList{}
+	if tokens.current().match(false, "(", "[") {
+		tokens.move()
+		var matching string
+		pl, err := parseExpr(tokens, options)
+		if err != nil {
+			return nil, err
+		}
+		if tok.eq("(") {
+			matching = ")"
+			result = patternList{newRequired(pl...)}
+		} else if tok.eq("[") {
+			matching = "]"
+			result = patternList{newOptional(pl...)}
+		}
+		moved := tokens.move()
+		if !moved.eq(matching) {
+			return nil, tokens.errorFunc("unmatched '%s', expected: '%s' got: '%s'", tok, matching, moved)
+		}
+		return result, nil
+	} else if tok.eq("options") {
+		tokens.move()
+		return patternList{newOptionsShortcut()}, nil
+	} else if tok.hasPrefix("--") && !tok.eq("--") {
+		return parseLong(tokens, options)
+	} else if tok.hasPrefix("-") && !tok.eq("-") && !tok.eq("--") {
+		return parseShorts(tokens, options)
+	} else if tok.hasPrefix("<") && tok.hasSuffix(">") || tok.isUpper() {
+		return patternList{newArgument(tokens.move().String(), nil)}, nil
+	}
+	return patternList{newCommand(tokens.move().String(), false)}, nil
+}
+
+func parseLong(tokens *tokenList, options *patternList) (patternList, error) {
+	// long ::= '--' chars [ ( ' ' | '=' ) chars ] ;
+	long, eq, v := stringPartition(tokens.move().String(), "=")
+	var value interface{}
+	var opt *pattern
+	if eq == "" && v == "" {
+		value = nil
+	} else {
+		value = v
+	}
+
+	if !strings.HasPrefix(long, "--") {
+		return nil, newError("long option '%s' doesn't start with --", long)
+	}
+	similar := patternList{}
+	for _, o := range *options {
+		if o.long == long {
+			similar = append(similar, o)
+		}
+	}
+	if tokens.err == ERROR_USER && len(similar) == 0 { // if no exact match
+		similar = patternList{}
+		for _, o := range *options {
+			if strings.HasPrefix(o.long, long) {
+				similar = append(similar, o)
+			}
+		}
+	}
+	if len(similar) > 1 { // might be simply specified ambiguously 2+ times?
+		similarLong := make([]string, len(similar))
+		for i, s := range similar {
+			similarLong[i] = s.long
+		}
+		return nil, tokens.errorFunc("%s is not a unique prefix: %s?", long, strings.Join(similarLong, ", "))
+	} else if len(similar) < 1 {
+		argcount := 0
+		if eq == "=" {
+			argcount = 1
+		}
+		opt = newOption("", long, argcount, false)
+		*options = append(*options, opt)
+		if tokens.err == ERROR_USER {
+			var val interface{}
+			if argcount > 0 {
+				val = value
+			} else {
+				val = true
+			}
+			opt = newOption("", long, argcount, val)
+		}
+	} else {
+		opt = newOption(similar[0].short, similar[0].long, similar[0].argcount, similar[0].value)
+		if opt.argcount == 0 {
+			if value != nil {
+				return nil, tokens.errorFunc("%s must not have an argument", opt.long)
+			}
+		} else {
+			if value == nil {
+				if tokens.current().match(true, "--") {
+					return nil, tokens.errorFunc("%s requires argument", opt.long)
+				}
+				moved := tokens.move()
+				if moved != nil {
+					value = moved.String() // only set as string if not nil
+				}
+			}
+		}
+		if tokens.err == ERROR_USER {
+			if value != nil {
+				opt.value = value
+			} else {
+				opt.value = true
+			}
+		}
+	}
+
+	return patternList{opt}, nil
+}
+
+func parseShorts(tokens *tokenList, options *patternList) (patternList, error) {
+	// shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;
+	tok := tokens.move()
+	if !tok.hasPrefix("-") || tok.hasPrefix("--") {
+		return nil, newError("short option '%s' doesn't start with -", tok)
+	}
+	left := strings.TrimLeft(tok.String(), "-")
+	parsed := patternList{}
+	for left != "" {
+		var opt *pattern
+		short := "-" + left[0:1]
+		left = left[1:]
+		similar := patternList{}
+		for _, o := range *options {
+			if o.short == short {
+				similar = append(similar, o)
+			}
+		}
+		if len(similar) > 1 {
+			return nil, tokens.errorFunc("%s is specified ambiguously %d times", short, len(similar))
+		} else if len(similar) < 1 {
+			opt = newOption(short, "", 0, false)
+			*options = append(*options, opt)
+			if tokens.err == ERROR_USER {
+				opt = newOption(short, "", 0, true)
+			}
+		} else { // why copying is necessary here?
+			opt = newOption(short, similar[0].long, similar[0].argcount, similar[0].value)
+			var value interface{}
+			if opt.argcount > 0 {
+				if left == "" {
+					if tokens.current().match(true, "--") {
+						return nil, tokens.errorFunc("%s requires argument", short)
+					}
+					value = tokens.move().String()
+				} else {
+					value = left
+					left = ""
+				}
+			}
+			if tokens.err == ERROR_USER {
+				if value != nil {
+					opt.value = value
+				} else {
+					opt.value = true
+				}
+			}
+		}
+		parsed = append(parsed, opt)
+	}
+	return parsed, nil
+}
+
+func newTokenList(source []string, err errorType) *tokenList {
+	errorFunc := newError
+	if err == ERROR_USER {
+		errorFunc = newUserError
+	} else if err == ERROR_LANGUAGE {
+		errorFunc = newLanguageError
+	}
+	return &tokenList{source, errorFunc, err}
+}
+
+func tokenListFromString(source string) *tokenList {
+	return newTokenList(strings.Fields(source), ERROR_USER)
+}
+
+func tokenListFromPattern(source string) *tokenList {
+	p := regexp.MustCompile(`([\[\]\(\)\|]|\.\.\.)`)
+	source = p.ReplaceAllString(source, ` $1 `)
+	p = regexp.MustCompile(`\s+|(\S*<.*?>)`)
+	split := p.Split(source, -1)
+	match := p.FindAllStringSubmatch(source, -1)
+	var result []string
+	l := len(split)
+	for i := 0; i < l; i++ {
+		if len(split[i]) > 0 {
+			result = append(result, split[i])
+		}
+		if i < l-1 && len(match[i][1]) > 0 {
+			result = append(result, match[i][1])
+		}
+	}
+	return newTokenList(result, ERROR_LANGUAGE)
+}
+
+func formalUsage(section string) string {
+	_, _, section = stringPartition(section, ":") // drop "usage:"
+	pu := strings.Fields(section)
+
+	result := "( "
+	for _, s := range pu[1:] {
+		if s == pu[0] {
+			result += ") | ( "
+		} else {
+			result += s + " "
+		}
+	}
+	result += ")"
+
+	return result
+}
+
+func extras(help bool, version string, options patternList, doc string) string {
+	if help {
+		for _, o := range options {
+			if (o.name == "-h" || o.name == "--help") && o.value == true {
+				return strings.Trim(doc, "\n")
+			}
+		}
+	}
+	if version != "" {
+		for _, o := range options {
+			if (o.name == "--version") && o.value == true {
+				return version
+			}
+		}
+	}
+	return ""
+}
+
+type errorType int
+
+const (
+	ERROR_USER errorType = iota
+	ERROR_LANGUAGE
+)
+
+func (self errorType) String() string {
+	switch self {
+	case ERROR_USER:
+		return "userError"
+	case ERROR_LANGUAGE:
+		return "languageError"
+	}
+	return ""
+}
+
+type UserError struct {
+	msg   string
+	Usage string
+}
+
+func (e UserError) Error() string {
+	return e.msg
+}
+func newUserError(msg string, f ...interface{}) error {
+	return &UserError{fmt.Sprintf(msg, f...), ""}
+}
+
+type LanguageError struct {
+	msg string
+}
+
+func (e LanguageError) Error() string {
+	return e.msg
+}
+func newLanguageError(msg string, f ...interface{}) error {
+	return &LanguageError{fmt.Sprintf(msg, f...)}
+}
+
+var newError = fmt.Errorf
+
+type tokenList struct {
+	tokens    []string
+	errorFunc func(string, ...interface{}) error
+	err       errorType
+}
+type token string
+
+func (self *token) eq(s string) bool {
+	if self == nil {
+		return false
+	}
+	return string(*self) == s
+}
+func (self *token) match(matchNil bool, tokenStrings ...string) bool {
+	if self == nil && matchNil {
+		return true
+	} else if self == nil && !matchNil {
+		return false
+	}
+
+	for _, t := range tokenStrings {
+		if t == string(*self) {
+			return true
+		}
+	}
+	return false
+}
+func (self *token) hasPrefix(prefix string) bool {
+	if self == nil {
+		return false
+	}
+	return strings.HasPrefix(string(*self), prefix)
+}
+func (self *token) hasSuffix(suffix string) bool {
+	if self == nil {
+		return false
+	}
+	return strings.HasSuffix(string(*self), suffix)
+}
+func (self *token) isUpper() bool {
+	if self == nil {
+		return false
+	}
+	return isStringUppercase(string(*self))
+}
+func (self *token) String() string {
+	if self == nil {
+		return ""
+	}
+	return string(*self)
+}
+
+func (self *tokenList) current() *token {
+	if len(self.tokens) > 0 {
+		return (*token)(&(self.tokens[0]))
+	}
+	return nil
+}
+
+func (self *tokenList) length() int {
+	return len(self.tokens)
+}
+
+func (self *tokenList) move() *token {
+	if len(self.tokens) > 0 {
+		t := self.tokens[0]
+		self.tokens = self.tokens[1:]
+		return (*token)(&t)
+	}
+	return nil
+}
+
+type patternType uint
+
+const (
+	// leaf
+	PATTERN_ARGUMENT patternType = 1 << iota
+	PATTERN_COMMAND
+	PATTERN_OPTION
+
+	// branch
+	PATTERN_REQUIRED
+	PATTERN_OPTIONAL
+	PATTERN_OPTIONSSHORTCUT // Marker/placeholder for [options] shortcut.
+	PATTERN_ONEORMORE
+	PATTERN_EITHER
+
+	PATTERN_LEAF = PATTERN_ARGUMENT +
+		PATTERN_COMMAND +
+		PATTERN_OPTION
+	PATTERN_BRANCH = PATTERN_REQUIRED +
+		PATTERN_OPTIONAL +
+		PATTERN_OPTIONSSHORTCUT +
+		PATTERN_ONEORMORE +
+		PATTERN_EITHER
+	PATTERN_ALL     = PATTERN_LEAF + PATTERN_BRANCH
+	PATTERN_DEFAULT = 0
+)
+
+func (self patternType) String() string {
+	switch self {
+	case PATTERN_ARGUMENT:
+		return "argument"
+	case PATTERN_COMMAND:
+		return "command"
+	case PATTERN_OPTION:
+		return "option"
+	case PATTERN_REQUIRED:
+		return "required"
+	case PATTERN_OPTIONAL:
+		return "optional"
+	case PATTERN_OPTIONSSHORTCUT:
+		return "optionsshortcut"
+	case PATTERN_ONEORMORE:
+		return "oneormore"
+	case PATTERN_EITHER:
+		return "either"
+	case PATTERN_LEAF:
+		return "leaf"
+	case PATTERN_BRANCH:
+		return "branch"
+	case PATTERN_ALL:
+		return "all"
+	case PATTERN_DEFAULT:
+		return "default"
+	}
+	return ""
+}
+
+type pattern struct {
+	t patternType
+
+	children patternList
+
+	name  string
+	value interface{}
+
+	short    string
+	long     string
+	argcount int
+}
+
+type patternList []*pattern
+
+func newBranchPattern(t patternType, pl ...*pattern) *pattern {
+	var p pattern
+	p.t = t
+	p.children = make(patternList, len(pl))
+	copy(p.children, pl)
+	return &p
+}
+
+func newRequired(pl ...*pattern) *pattern {
+	return newBranchPattern(PATTERN_REQUIRED, pl...)
+}
+
+func newEither(pl ...*pattern) *pattern {
+	return newBranchPattern(PATTERN_EITHER, pl...)
+}
+
+func newOneOrMore(pl ...*pattern) *pattern {
+	return newBranchPattern(PATTERN_ONEORMORE, pl...)
+}
+
+func newOptional(pl ...*pattern) *pattern {
+	return newBranchPattern(PATTERN_OPTIONAL, pl...)
+}
+
+func newOptionsShortcut() *pattern {
+	var p pattern
+	p.t = PATTERN_OPTIONSSHORTCUT
+	return &p
+}
+
+func newLeafPattern(t patternType, name string, value interface{}) *pattern {
+	// default: value=nil
+	var p pattern
+	p.t = t
+	p.name = name
+	p.value = value
+	return &p
+}
+
+func newArgument(name string, value interface{}) *pattern {
+	// default: value=nil
+	return newLeafPattern(PATTERN_ARGUMENT, name, value)
+}
+
+func newCommand(name string, value interface{}) *pattern {
+	// default: value=false
+	var p pattern
+	p.t = PATTERN_COMMAND
+	p.name = name
+	p.value = value
+	return &p
+}
+
+func newOption(short, long string, argcount int, value interface{}) *pattern {
+	// default: "", "", 0, false
+	var p pattern
+	p.t = PATTERN_OPTION
+	p.short = short
+	p.long = long
+	if long != "" {
+		p.name = long
+	} else {
+		p.name = short
+	}
+	p.argcount = argcount
+	if value == false && argcount > 0 {
+		p.value = nil
+	} else {
+		p.value = value
+	}
+	return &p
+}
+
+func (self *pattern) flat(types patternType) (patternList, error) {
+	if self.t&PATTERN_LEAF != 0 {
+		if types == PATTERN_DEFAULT {
+			types = PATTERN_ALL
+		}
+		if self.t&types != 0 {
+			return patternList{self}, nil
+		}
+		return patternList{}, nil
+	}
+
+	if self.t&PATTERN_BRANCH != 0 {
+		if self.t&types != 0 {
+			return patternList{self}, nil
+		}
+		result := patternList{}
+		for _, child := range self.children {
+			childFlat, err := child.flat(types)
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, childFlat...)
+		}
+		return result, nil
+	}
+	return nil, newError("unknown pattern type: %d, %d", self.t, types)
+}
+
+func (self *pattern) fix() error {
+	err := self.fixIdentities(nil)
+	if err != nil {
+		return err
+	}
+	self.fixRepeatingArguments()
+	return nil
+}
+
+func (self *pattern) fixIdentities(uniq patternList) error {
+	// Make pattern-tree tips point to same object if they are equal.
+	if self.t&PATTERN_BRANCH == 0 {
+		return nil
+	}
+	if uniq == nil {
+		selfFlat, err := self.flat(PATTERN_DEFAULT)
+		if err != nil {
+			return err
+		}
+		uniq = selfFlat.unique()
+	}
+	for i, child := range self.children {
+		if child.t&PATTERN_BRANCH == 0 {
+			ind, err := uniq.index(child)
+			if err != nil {
+				return err
+			}
+			self.children[i] = uniq[ind]
+		} else {
+			err := child.fixIdentities(uniq)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (self *pattern) fixRepeatingArguments() {
+	// Fix elements that should accumulate/increment values.
+	var either []patternList
+
+	for _, child := range self.transform().children {
+		either = append(either, child.children)
+	}
+	for _, cas := range either {
+		casMultiple := patternList{}
+		for _, e := range cas {
+			if cas.count(e) > 1 {
+				casMultiple = append(casMultiple, e)
+			}
+		}
+		for _, e := range casMultiple {
+			if e.t == PATTERN_ARGUMENT || e.t == PATTERN_OPTION && e.argcount > 0 {
+				switch e.value.(type) {
+				case string:
+					e.value = strings.Fields(e.value.(string))
+				case []string:
+				default:
+					e.value = []string{}
+				}
+			}
+			if e.t == PATTERN_COMMAND || e.t == PATTERN_OPTION && e.argcount == 0 {
+				e.value = 0
+			}
+		}
+	}
+}
+
+func (self *pattern) match(left *patternList, collected *patternList) (bool, *patternList, *patternList) {
+	if collected == nil {
+		collected = &patternList{}
+	}
+	if self.t&PATTERN_REQUIRED != 0 {
+		l := left
+		c := collected
+		for _, p := range self.children {
+			var matched bool
+			matched, l, c = p.match(l, c)
+			if !matched {
+				return false, left, collected
+			}
+		}
+		return true, l, c
+	} else if self.t&PATTERN_OPTIONAL != 0 || self.t&PATTERN_OPTIONSSHORTCUT != 0 {
+		for _, p := range self.children {
+			_, left, collected = p.match(left, collected)
+		}
+		return true, left, collected
+	} else if self.t&PATTERN_ONEORMORE != 0 {
+		if len(self.children) != 1 {
+			panic("OneOrMore.match(): assert len(self.children) == 1")
+		}
+		l := left
+		c := collected
+		var l_ *patternList
+		matched := true
+		times := 0
+		for matched {
+			// could it be that something didn't match but changed l or c?
+			matched, l, c = self.children[0].match(l, c)
+			if matched {
+				times += 1
+			}
+			if l_ == l {
+				break
+			}
+			l_ = l
+		}
+		if times >= 1 {
+			return true, l, c
+		}
+		return false, left, collected
+	} else if self.t&PATTERN_EITHER != 0 {
+		type outcomeStruct struct {
+			matched   bool
+			left      *patternList
+			collected *patternList
+			length    int
+		}
+		outcomes := []outcomeStruct{}
+		for _, p := range self.children {
+			matched, l, c := p.match(left, collected)
+			outcome := outcomeStruct{matched, l, c, len(*l)}
+			if matched {
+				outcomes = append(outcomes, outcome)
+			}
+		}
+		if len(outcomes) > 0 {
+			minLen := outcomes[0].length
+			minIndex := 0
+			for i, v := range outcomes {
+				if v.length < minLen {
+					minIndex = i
+				}
+			}
+			return outcomes[minIndex].matched, outcomes[minIndex].left, outcomes[minIndex].collected
+		}
+		return false, left, collected
+	} else if self.t&PATTERN_LEAF != 0 {
+		pos, match := self.singleMatch(left)
+		var increment interface{}
+		if match == nil {
+			return false, left, collected
+		}
+		left_ := make(patternList, len((*left)[:pos]), len((*left)[:pos])+len((*left)[pos+1:]))
+		copy(left_, (*left)[:pos])
+		left_ = append(left_, (*left)[pos+1:]...)
+		sameName := patternList{}
+		for _, a := range *collected {
+			if a.name == self.name {
+				sameName = append(sameName, a)
+			}
+		}
+
+		switch self.value.(type) {
+		case int, []string:
+			switch self.value.(type) {
+			case int:
+				increment = 1
+			case []string:
+				switch match.value.(type) {
+				case string:
+					increment = []string{match.value.(string)}
+				default:
+					increment = match.value
+				}
+			}
+			if len(sameName) == 0 {
+				match.value = increment
+				collectedMatch := make(patternList, len(*collected), len(*collected)+1)
+				copy(collectedMatch, *collected)
+				collectedMatch = append(collectedMatch, match)
+				return true, &left_, &collectedMatch
+			}
+			switch sameName[0].value.(type) {
+			case int:
+				sameName[0].value = sameName[0].value.(int) + increment.(int)
+			case []string:
+				sameName[0].value = append(sameName[0].value.([]string), increment.([]string)...)
+			}
+			return true, &left_, collected
+		}
+		collectedMatch := make(patternList, len(*collected), len(*collected)+1)
+		copy(collectedMatch, *collected)
+		collectedMatch = append(collectedMatch, match)
+		return true, &left_, &collectedMatch
+	}
+	panic("unmatched type")
+	return false, &patternList{}, &patternList{}
+}
+
+func (self *pattern) singleMatch(left *patternList) (int, *pattern) {
+	if self.t&PATTERN_ARGUMENT != 0 {
+		for n, p := range *left {
+			if p.t&PATTERN_ARGUMENT != 0 {
+				return n, newArgument(self.name, p.value)
+			}
+		}
+		return -1, nil
+	} else if self.t&PATTERN_COMMAND != 0 {
+		for n, p := range *left {
+			if p.t&PATTERN_ARGUMENT != 0 {
+				if p.value == self.name {
+					return n, newCommand(self.name, true)
+				} else {
+					break
+				}
+			}
+		}
+		return -1, nil
+	} else if self.t&PATTERN_OPTION != 0 {
+		for n, p := range *left {
+			if self.name == p.name {
+				return n, p
+			}
+		}
+		return -1, nil
+	}
+	panic("unmatched type")
+	return -1, nil
+}
+
+func (self *pattern) String() string {
+	if self.t&PATTERN_OPTION != 0 {
+		return fmt.Sprintf("%s(%s, %s, %d, %+v)", self.t, self.short, self.long, self.argcount, self.value)
+	} else if self.t&PATTERN_LEAF != 0 {
+		return fmt.Sprintf("%s(%s, %+v)", self.t, self.name, self.value)
+	} else if self.t&PATTERN_BRANCH != 0 {
+		result := ""
+		for i, child := range self.children {
+			if i > 0 {
+				result += ", "
+			}
+			result += child.String()
+		}
+		return fmt.Sprintf("%s(%s)", self.t, result)
+	}
+	panic("unmatched type")
+	return ""
+}
+
+func (self *pattern) transform() *pattern {
+	/*
+		Expand pattern into an (almost) equivalent one, but with single Either.
+
+		Example: ((-a | -b) (-c | -d)) => (-a -c | -a -d | -b -c | -b -d)
+		Quirks: [-a] => (-a), (-a...) => (-a -a)
+	*/
+	result := []patternList{}
+	groups := []patternList{patternList{self}}
+	parents := PATTERN_REQUIRED +
+		PATTERN_OPTIONAL +
+		PATTERN_OPTIONSSHORTCUT +
+		PATTERN_EITHER +
+		PATTERN_ONEORMORE
+	for len(groups) > 0 {
+		children := groups[0]
+		groups = groups[1:]
+		var child *pattern
+		for _, c := range children {
+			if c.t&parents != 0 {
+				child = c
+				break
+			}
+		}
+		if child != nil {
+			children.remove(child)
+			if child.t&PATTERN_EITHER != 0 {
+				for _, c := range child.children {
+					r := patternList{}
+					r = append(r, c)
+					r = append(r, children...)
+					groups = append(groups, r)
+				}
+			} else if child.t&PATTERN_ONEORMORE != 0 {
+				r := patternList{}
+				r = append(r, child.children.double()...)
+				r = append(r, children...)
+				groups = append(groups, r)
+			} else {
+				r := patternList{}
+				r = append(r, child.children...)
+				r = append(r, children...)
+				groups = append(groups, r)
+			}
+		} else {
+			result = append(result, children)
+		}
+	}
+	either := patternList{}
+	for _, e := range result {
+		either = append(either, newRequired(e...))
+	}
+	return newEither(either...)
+}
+
+func (self *pattern) eq(other *pattern) bool {
+	return reflect.DeepEqual(self, other)
+}
+
+func (pl patternList) unique() patternList {
+	table := make(map[string]bool)
+	result := patternList{}
+	for _, v := range pl {
+		if !table[v.String()] {
+			table[v.String()] = true
+			result = append(result, v)
+		}
+	}
+	return result
+}
+
+func (pl patternList) index(p *pattern) (int, error) {
+	for i, c := range pl {
+		if c.eq(p) {
+			return i, nil
+		}
+	}
+	return -1, newError("%s not in list", p)
+}
+
+func (pl patternList) count(p *pattern) int {
+	count := 0
+	for _, c := range pl {
+		if c.eq(p) {
+			count++
+		}
+	}
+	return count
+}
+
+func (pl patternList) diff(l patternList) patternList {
+	l_ := make(patternList, len(l))
+	copy(l_, l)
+	result := make(patternList, 0, len(pl))
+	for _, v := range pl {
+		if v != nil {
+			match := false
+			for i, w := range l_ {
+				if w.eq(v) {
+					match = true
+					l_[i] = nil
+					break
+				}
+			}
+			if match == false {
+				result = append(result, v)
+			}
+		}
+	}
+	return result
+}
+
+func (pl patternList) double() patternList {
+	l := len(pl)
+	result := make(patternList, l*2)
+	copy(result, pl)
+	copy(result[l:2*l], pl)
+	return result
+}
+
+func (self *patternList) remove(p *pattern) {
+	(*self) = self.diff(patternList{p})
+}
+
+func (pl patternList) dictionary() map[string]interface{} {
+	dict := make(map[string]interface{})
+	for _, a := range pl {
+		dict[a.name] = a.value
+	}
+	return dict
+}
+
+func stringPartition(s, sep string) (string, string, string) {
+	sepPos := strings.Index(s, sep)
+	if sepPos == -1 { // no seperator found
+		return s, "", ""
+	}
+	split := strings.SplitN(s, sep, 2)
+	return split[0], sep, split[1]
+}
+
+func isStringUppercase(s string) bool {
+	for _, c := range s {
+		if !unicode.IsUpper(c) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/docopt_test.go b/docopt_test.go
new file mode 100644
index 0000000..5f21d07
--- /dev/null
+++ b/docopt_test.go
@@ -0,0 +1,1541 @@
+/*
+Based of off docopt.py: https://github.com/docopt/docopt
+
+Licensed under terms of MIT license (see LICENSE-MIT)
+Copyright (c) 2013 Keith Batten, kbatten@gmail.com
+*/
+
+package docopt
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestPatternFlat(t *testing.T) {
+	q := patternList{
+		newArgument("N", nil),
+		newOption("-a", "", 0, false),
+		newArgument("M", nil)}
+	p, err := newRequired(
+		newOneOrMore(newArgument("N", nil)),
+		newOption("-a", "", 0, false),
+		newArgument("M", nil)).flat(PATTERN_DEFAULT)
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+
+	q = patternList{newOptionsShortcut()}
+	p, err = newRequired(
+		newOptional(newOptionsShortcut()),
+		newOptional(newOption("-a", "", 0, false))).flat(PATTERN_OPTIONSSHORTCUT)
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+	return
+}
+
+func TestOption(t *testing.T) {
+	if !parseOption("-h").eq(newOption("-h", "", 0, false)) {
+		t.Error()
+	}
+	if !parseOption("--help").eq(newOption("", "--help", 0, false)) {
+		t.Error()
+	}
+	if !parseOption("-h --help").eq(newOption("-h", "--help", 0, false)) {
+		t.Error()
+	}
+	if !parseOption("-h, --help").eq(newOption("-h", "--help", 0, false)) {
+		t.Error()
+	}
+
+	if !parseOption("-h TOPIC").eq(newOption("-h", "", 1, false)) {
+		t.Error()
+	}
+	if !parseOption("--help TOPIC").eq(newOption("", "--help", 1, false)) {
+		t.Error()
+	}
+	if !parseOption("-h TOPIC --help TOPIC").eq(newOption("-h", "--help", 1, false)) {
+		t.Error()
+	}
+	if !parseOption("-h TOPIC, --help TOPIC").eq(newOption("-h", "--help", 1, false)) {
+		t.Error()
+	}
+	if !parseOption("-h TOPIC, --help=TOPIC").eq(newOption("-h", "--help", 1, false)) {
+		t.Error()
+	}
+
+	if !parseOption("-h  Description...").eq(newOption("-h", "", 0, false)) {
+		t.Error()
+	}
+	if !parseOption("-h --help  Description...").eq(newOption("-h", "--help", 0, false)) {
+		t.Error()
+	}
+	if !parseOption("-h TOPIC  Description...").eq(newOption("-h", "", 1, false)) {
+		t.Error()
+	}
+
+	if !parseOption("    -h").eq(newOption("-h", "", 0, false)) {
+		t.Error()
+	}
+
+	if !parseOption("-h TOPIC  Description... [default: 2]").eq(newOption("-h", "", 1, "2")) {
+		t.Error()
+	}
+	if !parseOption("-h TOPIC  Descripton... [default: topic-1]").eq(newOption("-h", "", 1, "topic-1")) {
+		t.Error()
+	}
+	if !parseOption("--help=TOPIC  ... [default: 3.14]").eq(newOption("", "--help", 1, "3.14")) {
+		t.Error()
+	}
+	if !parseOption("-h, --help=DIR  ... [default: ./]").eq(newOption("-h", "--help", 1, "./")) {
+		t.Error()
+	}
+	if !parseOption("-h TOPIC  Descripton... [dEfAuLt: 2]").eq(newOption("-h", "", 1, "2")) {
+		t.Error()
+	}
+	return
+}
+
+func TestOptionName(t *testing.T) {
+	if newOption("-h", "", 0, false).name != "-h" {
+		t.Error()
+	}
+	if newOption("-h", "--help", 0, false).name != "--help" {
+		t.Error()
+	}
+	if newOption("", "--help", 0, false).name != "--help" {
+		t.Error()
+	}
+	return
+}
+
+func TestCommands(t *testing.T) {
+	if v, _, err := Parse("Usage: prog add", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("Usage: prog [add]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": false}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("Usage: prog [add]", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("Usage: prog (add|rm)", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true, "rm": false}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("Usage: prog (add|rm)", []string{"rm"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": false, "rm": true}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("Usage: prog a b", []string{"a", "b"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"a": true, "b": true}) != true {
+		t.Error(err)
+	}
+	_, _, err := Parse("Usage: prog a b", []string{"b", "a"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+	return
+}
+
+func TestFormalUsage(t *testing.T) {
+	doc := `
+    Usage: prog [-hv] ARG
+           prog N M
+
+    prog is a program`
+	usage := parseSection("usage:", doc)[0]
+	if usage != "Usage: prog [-hv] ARG\n           prog N M" {
+		t.Error()
+	}
+	if formalUsage(usage) != "( [-hv] ARG ) | ( N M )" {
+		t.Error()
+	}
+	return
+}
+
+func TestParseArgv(t *testing.T) {
+	o := patternList{
+		newOption("-h", "", 0, false),
+		newOption("-v", "--verbose", 0, false),
+		newOption("-f", "--file", 1, false),
+	}
+
+	p, err := parseArgv(tokenListFromString(""), &o, false)
+	q := patternList{}
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+
+	p, err = parseArgv(tokenListFromString("-h"), &o, false)
+	q = patternList{newOption("-h", "", 0, true)}
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+
+	p, err = parseArgv(tokenListFromString("-h --verbose"), &o, false)
+	q = patternList{
+		newOption("-h", "", 0, true),
+		newOption("-v", "--verbose", 0, true),
+	}
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+
+	p, err = parseArgv(tokenListFromString("-h --file f.txt"), &o, false)
+	q = patternList{
+		newOption("-h", "", 0, true),
+		newOption("-f", "--file", 1, "f.txt"),
+	}
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+
+	p, err = parseArgv(tokenListFromString("-h --file f.txt arg"), &o, false)
+	q = patternList{
+		newOption("-h", "", 0, true),
+		newOption("-f", "--file", 1, "f.txt"),
+		newArgument("", "arg"),
+	}
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+
+	p, err = parseArgv(tokenListFromString("-h --file f.txt arg arg2"), &o, false)
+	q = patternList{
+		newOption("-h", "", 0, true),
+		newOption("-f", "--file", 1, "f.txt"),
+		newArgument("", "arg"),
+		newArgument("", "arg2"),
+	}
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+
+	p, err = parseArgv(tokenListFromString("-h arg -- -v"), &o, false)
+	q = patternList{
+		newOption("-h", "", 0, true),
+		newArgument("", "arg"),
+		newArgument("", "--"),
+		newArgument("", "-v"),
+	}
+	if reflect.DeepEqual(p, q) != true {
+		t.Error(err)
+	}
+}
+
+func TestParsePattern(t *testing.T) {
+	o := patternList{
+		newOption("-h", "", 0, false),
+		newOption("-v", "--verbose", 0, false),
+		newOption("-f", "--file", 1, false),
+	}
+
+	p, err := parsePattern("[ -h ]", &o)
+	q := newRequired(newOptional(newOption("-h", "", 0, false)))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("[ ARG ... ]", &o)
+	q = newRequired(newOptional(
+		newOneOrMore(
+			newArgument("ARG", nil))))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("[ -h | -v ]", &o)
+	q = newRequired(
+		newOptional(
+			newEither(
+				newOption("-h", "", 0, false),
+				newOption("-v", "--verbose", 0, false))))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("( -h | -v [ --file <f> ] )", &o)
+	q = newRequired(
+		newRequired(
+			newEither(
+				newOption("-h", "", 0, false),
+				newRequired(
+					newOption("-v", "--verbose", 0, false),
+					newOptional(
+						newOption("-f", "--file", 1, nil))))))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("(-h|-v[--file=<f>]N...)", &o)
+	q = newRequired(
+		newRequired(
+			newEither(
+				newOption("-h", "", 0, false),
+				newRequired(
+					newOption("-v", "--verbose", 0, false),
+					newOptional(
+						newOption("-f", "--file", 1, nil)),
+					newOneOrMore(
+						newArgument("N", nil))))))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("(N [M | (K | L)] | O P)", &o)
+	q = newRequired(
+		newRequired(
+			newEither(
+				newRequired(
+					newArgument("N", nil),
+					newOptional(
+						newEither(
+							newArgument("M", nil),
+							newRequired(
+								newEither(
+									newArgument("K", nil),
+									newArgument("L", nil)))))),
+				newRequired(
+					newArgument("O", nil),
+					newArgument("P", nil)))))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("[ -h ] [N]", &o)
+	q = newRequired(
+		newOptional(
+			newOption("-h", "", 0, false)),
+		newOptional(
+			newArgument("N", nil)))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("[options]", &o)
+	q = newRequired(
+		newOptional(
+			newOptionsShortcut()))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("[options] A", &o)
+	q = newRequired(
+		newOptional(
+			newOptionsShortcut()),
+		newArgument("A", nil))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("-v [options]", &o)
+	q = newRequired(
+		newOption("-v", "--verbose", 0, false),
+		newOptional(
+			newOptionsShortcut()))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("ADD", &o)
+	q = newRequired(newArgument("ADD", nil))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("<add>", &o)
+	q = newRequired(newArgument("<add>", nil))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+
+	p, err = parsePattern("add", &o)
+	q = newRequired(newCommand("add", false))
+	if p.eq(q) != true {
+		t.Error(err)
+	}
+}
+
+func TestOptionMatch(t *testing.T) {
+	v, w, x := newOption("-a", "", 0, false).match(
+		&patternList{newOption("-a", "", 0, true)}, nil)
+	y := patternList{newOption("-a", "", 0, true)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newOption("-a", "", 0, false).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newOption("-a", "", 0, false).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+	v, w, x = newOption("-a", "", 0, false).match(
+		&patternList{newArgument("N", nil)}, nil)
+	y = patternList{newArgument("N", nil)}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newOption("-a", "", 0, false).match(
+		&patternList{
+			newOption("-x", "", 0, false),
+			newOption("-a", "", 0, false),
+			newArgument("N", nil)}, nil)
+	y = patternList{
+		newOption("-x", "", 0, false),
+		newArgument("N", nil)}
+	z := patternList{newOption("-a", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOption("-a", "", 0, false).match(
+		&patternList{
+			newOption("-a", "", 0, true),
+			newOption("-a", "", 0, false)}, nil)
+	y = patternList{newOption("-a", "", 0, false)}
+	z = patternList{newOption("-a", "", 0, true)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+}
+
+func TestArgumentMatch(t *testing.T) {
+	v, w, x := newArgument("N", nil).match(
+		&patternList{newArgument("N", 9)}, nil)
+	y := patternList{newArgument("N", 9)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newArgument("N", nil).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newArgument("N", nil).match(
+		&patternList{newOption("-x", "", 0, false),
+			newOption("-a", "", 0, false),
+			newArgument("", 5)}, nil)
+	y = patternList{newOption("-x", "", 0, false),
+		newOption("-a", "", 0, false)}
+	z := patternList{newArgument("N", 5)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newArgument("N", nil).match(
+		&patternList{newArgument("", 9),
+			newArgument("", 0)}, nil)
+	y = patternList{newArgument("", 0)}
+	z = patternList{newArgument("N", 9)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+}
+
+func TestCommandMatch(t *testing.T) {
+	v, w, x := newCommand("c", false).match(
+		&patternList{newArgument("", "c")}, nil)
+	y := patternList{newCommand("c", true)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newCommand("c", false).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newCommand("c", false).match(
+		&patternList{
+			newOption("-x", "", 0, false),
+			newOption("-a", "", 0, false),
+			newArgument("", "c")}, nil)
+	y = patternList{newOption("-x", "", 0, false),
+		newOption("-a", "", 0, false)}
+	z := patternList{newCommand("c", true)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newEither(
+		newCommand("add", false),
+		newCommand("rm", false)).match(
+		&patternList{newArgument("", "rm")}, nil)
+	y = patternList{newCommand("rm", true)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+}
+
+func TestOptionalMatch(t *testing.T) {
+	v, w, x := newOptional(newOption("-a", "", 0, false)).match(
+		&patternList{newOption("-a", "", 0, false)}, nil)
+	y := patternList{newOption("-a", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newOptional(newOption("-a", "", 0, false)).match(
+		&patternList{}, nil)
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newOptional(newOption("-a", "", 0, false)).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newOptional(newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(
+		&patternList{newOption("-a", "", 0, false)}, nil)
+	y = patternList{newOption("-a", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newOptional(newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(
+		&patternList{newOption("-b", "", 0, false)}, nil)
+	y = patternList{newOption("-b", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newOptional(newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newOptional(newArgument("N", nil)).match(
+		&patternList{newArgument("", 9)}, nil)
+	y = patternList{newArgument("N", 9)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newOptional(newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(
+		&patternList{newOption("-b", "", 0, false),
+			newOption("-x", "", 0, false),
+			newOption("-a", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	z := patternList{newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+}
+
+func TestRequiredMatch(t *testing.T) {
+	v, w, x := newRequired(newOption("-a", "", 0, false)).match(
+		&patternList{newOption("-a", "", 0, false)}, nil)
+	y := patternList{newOption("-a", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newRequired(newOption("-a", "", 0, false)).match(&patternList{}, nil)
+	if v != false ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+
+	v, w, x = newRequired(newOption("-a", "", 0, false)).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+	v, w, x = newRequired(newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(
+		&patternList{newOption("-a", "", 0, false)}, nil)
+	y = patternList{newOption("-a", "", 0, false)}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, patternList{}) != true {
+		t.Error()
+	}
+}
+
+func TestEitherMatch(t *testing.T) {
+	v, w, x := newEither(
+		newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(
+		&patternList{newOption("-a", "", 0, false)}, nil)
+	y := patternList{newOption("-a", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newEither(
+		newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(&patternList{
+		newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)}, nil)
+	y = patternList{newOption("-b", "", 0, false)}
+	z := patternList{newOption("-a", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newEither(
+		newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false)).match(&patternList{
+		newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	z = patternList{}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newEither(
+		newOption("-a", "", 0, false),
+		newOption("-b", "", 0, false),
+		newOption("-c", "", 0, false)).match(&patternList{
+		newOption("-x", "", 0, false),
+		newOption("-b", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	z = patternList{newOption("-b", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+	v, w, x = newEither(
+		newArgument("M", nil),
+		newRequired(newArgument("N", nil),
+			newArgument("M", nil))).match(&patternList{
+		newArgument("", 1),
+		newArgument("", 2)}, nil)
+	y = patternList{}
+	z = patternList{newArgument("N", 1), newArgument("M", 2)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+}
+
+func TestOneOrMoreMatch(t *testing.T) {
+	v, w, x := newOneOrMore(newArgument("N", nil)).match(
+		&patternList{newArgument("", 9)}, nil)
+	y := patternList{newArgument("N", 9)}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newArgument("N", nil)).match(
+		&patternList{}, nil)
+	y = patternList{}
+	z := patternList{}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newArgument("N", nil)).match(
+		&patternList{newOption("-x", "", 0, false)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	z = patternList{}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newArgument("N", nil)).match(
+		&patternList{newArgument("", 9), newArgument("", 8)}, nil)
+	y = patternList{}
+	z = patternList{newArgument("N", 9), newArgument("N", 8)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newArgument("N", nil)).match(&patternList{
+		newArgument("", 9),
+		newOption("-x", "", 0, false),
+		newArgument("", 8)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	z = patternList{newArgument("N", 9), newArgument("N", 8)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newOption("-a", "", 0, false)).match(&patternList{
+		newOption("-a", "", 0, false),
+		newArgument("", 8),
+		newOption("-a", "", 0, false)}, nil)
+	y = patternList{newArgument("", 8)}
+	z = patternList{newOption("-a", "", 0, false), newOption("-a", "", 0, false)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newOption("-a", "", 0, false)).match(&patternList{
+		newArgument("", 8),
+		newOption("-x", "", 0, false)}, nil)
+	y = patternList{newArgument("", 8), newOption("-x", "", 0, false)}
+	z = patternList{}
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newRequired(newOption("-a", "", 0, false),
+		newArgument("N", nil))).match(&patternList{
+		newOption("-a", "", 0, false),
+		newArgument("", 1),
+		newOption("-x", "", 0, false),
+		newOption("-a", "", 0, false),
+		newArgument("", 2)}, nil)
+	y = patternList{newOption("-x", "", 0, false)}
+	z = patternList{newOption("-a", "", 0, false),
+		newArgument("N", 1),
+		newOption("-a", "", 0, false),
+		newArgument("N", 2)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	v, w, x = newOneOrMore(newOptional(newArgument("N", nil))).match(
+		&patternList{newArgument("", 9)}, nil)
+	y = patternList{}
+	z = patternList{newArgument("N", 9)}
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+}
+
+func TestListArgumentMatch(t *testing.T) {
+	p := newRequired(
+		newArgument("N", nil),
+		newArgument("N", nil))
+	p.fix()
+	v, w, x := p.match(&patternList{newArgument("", "1"),
+		newArgument("", "2")}, nil)
+	y := patternList{newArgument("N", []string{"1", "2"})}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	p = newOneOrMore(newArgument("N", nil))
+	p.fix()
+	v, w, x = p.match(&patternList{newArgument("", "1"),
+		newArgument("", "2"), newArgument("", "3")}, nil)
+	y = patternList{newArgument("N", []string{"1", "2", "3"})}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	p = newRequired(newArgument("N", nil),
+		newOneOrMore(newArgument("N", nil)))
+	p.fix()
+	v, w, x = p.match(&patternList{
+		newArgument("", "1"),
+		newArgument("", "2"),
+		newArgument("", "3")}, nil)
+	y = patternList{newArgument("N", []string{"1", "2", "3"})}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	p = newRequired(newArgument("N", nil),
+		newRequired(newArgument("N", nil)))
+	p.fix()
+	v, w, x = p.match(&patternList{
+		newArgument("", "1"),
+		newArgument("", "2")}, nil)
+	y = patternList{newArgument("N", []string{"1", "2"})}
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+}
+
+func TestBasicPatternMatching(t *testing.T) {
+	// ( -a N [ -x Z ] )
+	p := newRequired(
+		newOption("-a", "", 0, false),
+		newArgument("N", nil),
+		newOptional(
+			newOption("-x", "", 0, false),
+			newArgument("Z", nil)))
+
+	// -a N
+	q := patternList{newOption("-a", "", 0, false), newArgument("", 9)}
+	y := patternList{newOption("-a", "", 0, false), newArgument("N", 9)}
+	v, w, x := p.match(&q, nil)
+	if v != true ||
+		reflect.DeepEqual(*w, patternList{}) != true ||
+		reflect.DeepEqual(*x, y) != true {
+		t.Error()
+	}
+
+	// -a -x N Z
+	q = patternList{newOption("-a", "", 0, false),
+		newOption("-x", "", 0, false),
+		newArgument("", 9), newArgument("", 5)}
+	y = patternList{}
+	z := patternList{newOption("-a", "", 0, false), newArgument("N", 9),
+		newOption("-x", "", 0, false), newArgument("Z", 5)}
+	v, w, x = p.match(&q, nil)
+	if v != true ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+
+	// -x N Z  # BZZ!
+	q = patternList{newOption("-x", "", 0, false),
+		newArgument("", 9), newArgument("", 5)}
+	y = patternList{newOption("-x", "", 0, false),
+		newArgument("", 9), newArgument("", 5)}
+	z = patternList{}
+	v, w, x = p.match(&q, nil)
+	if v != false ||
+		reflect.DeepEqual(*w, y) != true ||
+		reflect.DeepEqual(*x, z) != true {
+		t.Error()
+	}
+}
+
+func TestPatternEither(t *testing.T) {
+	p := newOption("-a", "", 0, false).transform()
+	q := newEither(newRequired(
+		newOption("-a", "", 0, false)))
+	if p.eq(q) != true {
+		t.Error()
+	}
+
+	p = newArgument("A", nil).transform()
+	q = newEither(newRequired(
+		newArgument("A", nil)))
+	if p.eq(q) != true {
+		t.Error()
+	}
+
+	p = newRequired(
+		newEither(
+			newOption("-a", "", 0, false),
+			newOption("-b", "", 0, false)),
+		newOption("-c", "", 0, false)).transform()
+	q = newEither(
+		newRequired(
+			newOption("-a", "", 0, false),
+			newOption("-c", "", 0, false)),
+		newRequired(
+			newOption("-b", "", 0, false),
+			newOption("-c", "", 0, false)))
+	if p.eq(q) != true {
+		t.Error()
+	}
+
+	p = newOptional(newOption("-a", "", 0, false),
+		newEither(newOption("-b", "", 0, false),
+			newOption("-c", "", 0, false))).transform()
+	q = newEither(
+		newRequired(
+			newOption("-b", "", 0, false), newOption("-a", "", 0, false)),
+		newRequired(
+			newOption("-c", "", 0, false), newOption("-a", "", 0, false)))
+	if p.eq(q) != true {
+		t.Error()
+	}
+
+	p = newEither(newOption("-x", "", 0, false),
+		newEither(newOption("-y", "", 0, false),
+			newOption("-z", "", 0, false))).transform()
+	q = newEither(
+		newRequired(newOption("-x", "", 0, false)),
+		newRequired(newOption("-y", "", 0, false)),
+		newRequired(newOption("-z", "", 0, false)))
+	if p.eq(q) != true {
+		t.Error()
+	}
+
+	p = newOneOrMore(newArgument("N", nil),
+		newArgument("M", nil)).transform()
+	q = newEither(
+		newRequired(newArgument("N", nil), newArgument("M", nil),
+			newArgument("N", nil), newArgument("M", nil)))
+	if p.eq(q) != true {
+		t.Error()
+	}
+}
+
+func TestPatternFixRepeatingArguments(t *testing.T) {
+	p := newOption("-a", "", 0, false)
+	p.fixRepeatingArguments()
+	if p.eq(newOption("-a", "", 0, false)) != true {
+		t.Error()
+	}
+
+	p = newArgument("N", nil)
+	p.fixRepeatingArguments()
+	if p.eq(newArgument("N", nil)) != true {
+		t.Error()
+	}
+
+	p = newRequired(
+		newArgument("N", nil),
+		newArgument("N", nil))
+	q := newRequired(
+		newArgument("N", []string{}),
+		newArgument("N", []string{}))
+	p.fixRepeatingArguments()
+	if p.eq(q) != true {
+		t.Error()
+	}
+
+	p = newEither(
+		newArgument("N", nil),
+		newOneOrMore(newArgument("N", nil)))
+	q = newEither(
+		newArgument("N", []string{}),
+		newOneOrMore(newArgument("N", []string{})))
+	p.fix()
+	if p.eq(q) != true {
+		t.Error()
+	}
+}
+
+func TestSet(t *testing.T) {
+	p := newArgument("N", nil)
+	q := newArgument("N", nil)
+	if reflect.DeepEqual(p, q) != true {
+		t.Error()
+	}
+	pl := patternList{newArgument("N", nil), newArgument("N", nil)}
+	ql := patternList{newArgument("N", nil)}
+	if reflect.DeepEqual(pl.unique(), ql.unique()) != true {
+		t.Error()
+	}
+}
+
+func TestPatternFixIdentities1(t *testing.T) {
+	p := newRequired(
+		newArgument("N", nil),
+		newArgument("N", nil))
+	if len(p.children) < 2 {
+		t.Fatal()
+	}
+	if p.children[0].eq(p.children[1]) != true {
+		t.Error()
+	}
+	if p.children[0] == p.children[1] {
+		t.Error()
+	}
+	p.fixIdentities(nil)
+	if p.children[0] != p.children[1] {
+		t.Error()
+	}
+}
+
+func TestPatternFixIdentities2(t *testing.T) {
+	p := newRequired(
+		newOptional(
+			newArgument("X", nil),
+			newArgument("N", nil)),
+		newArgument("N", nil))
+	if len(p.children) < 2 {
+		t.Fatal()
+	}
+	if len(p.children[0].children) < 2 {
+		t.Fatal()
+	}
+	if p.children[0].children[1].eq(p.children[1]) != true {
+		t.Error()
+	}
+	if p.children[0].children[1] == p.children[1] {
+		t.Error()
+	}
+	p.fixIdentities(nil)
+	if p.children[0].children[1] != p.children[1] {
+		t.Error()
+	}
+}
+
+func TestLongOptionsErrorHandling(t *testing.T) {
+	_, _, err := Parse("Usage: prog", []string{"--non-existent"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(fmt.Sprintf("(%s) %s", reflect.TypeOf(err), err))
+	}
+	_, _, err = Parse("Usage: prog [--version --verbose]\nOptions: --version\n --verbose",
+		[]string{"--ver"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse("Usage: prog --long\nOptions: --long ARG", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse("Usage: prog --long ARG\nOptions: --long ARG",
+		[]string{"--long"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(fmt.Sprintf("(%s) %s", reflect.TypeOf(err), err))
+	}
+	_, _, err = Parse("Usage: prog --long=ARG\nOptions: --long", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse("Usage: prog --long\nOptions: --long",
+		[]string{}, true, "--long=ARG", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+}
+
+func TestShortOptionsErrorHandling(t *testing.T) {
+	_, _, err := Parse("Usage: prog -x\nOptions: -x  this\n -x  that", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(fmt.Sprintf("(%s) %s", reflect.TypeOf(err), err))
+	}
+	_, _, err = Parse("Usage: prog", []string{"-x"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse("Usage: prog -o\nOptions: -o ARG", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse("Usage: prog -o ARG\nOptions: -o ARG", []string{"-o"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+}
+
+func TestMatchingParen(t *testing.T) {
+	_, _, err := Parse("Usage: prog [a [b]", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse("Usage: prog [a [b] ] c )", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(err)
+	}
+}
+
+func TestAllowDoubleDash(t *testing.T) {
+	if v, _, err := Parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"--", "-o"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-o": false, "<arg>": "-o", "--": true}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"-o", "1"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-o": true, "<arg>": "1", "--": false}) != true {
+		t.Error(err)
+	}
+	_, _, err := Parse("usage: prog [-o] <arg>\noptions:-o", []string{"-o"}, true, "", false)
+	if _, ok := err.(*UserError); !ok { //"--" is not allowed; FIXME?
+		t.Error(err)
+	}
+}
+
+func TestDocopt(t *testing.T) {
+	doc := `Usage: prog [-v] A
+
+                Options: -v  Be verbose.`
+	if v, _, err := Parse(doc, []string{"arg"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": false, "A": "arg"}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse(doc, []string{"-v", "arg"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "A": "arg"}) != true {
+		t.Error(err)
+	}
+
+	doc = `Usage: prog [-vqr] [FILE]
+              prog INPUT OUTPUT
+              prog --help
+
+    Options:
+      -v  print status messages
+      -q  report only file names
+      -r  show all occurrences of the same error
+      --help
+
+    `
+	if v, _, err := Parse(doc, []string{"-v", "file.py"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "-q": false, "-r": false, "--help": false, "FILE": "file.py", "INPUT": nil, "OUTPUT": nil}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse(doc, []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "-q": false, "-r": false, "--help": false, "FILE": nil, "INPUT": nil, "OUTPUT": nil}) != true {
+		t.Error(err)
+	}
+
+	_, _, err := Parse(doc, []string{"-v", "input.py", "output.py"}, true, "", false) // does not match
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse(doc, []string{"--fake"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+	_, output, err := Parse(doc, []string{"--hel"}, true, "", false)
+	if err != nil || len(output) == 0 {
+		t.Error(err)
+	}
+}
+
+func TestLanguageErrors(t *testing.T) {
+	_, _, err := Parse("no usage with colon here", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(err)
+	}
+	_, _, err = Parse("usage: here \n\n and again usage: here", []string{}, true, "", false)
+	if _, ok := err.(*LanguageError); !ok {
+		t.Error(err)
+	}
+}
+
+func TestIssue40(t *testing.T) {
+	_, output, err := Parse("usage: prog --help-commands | --help", []string{"--help"}, true, "", false)
+	if err != nil || len(output) == 0 {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog --aabb | --aa", []string{"--aa"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--aabb": false, "--aa": true}) != true {
+		t.Error(err)
+	}
+}
+
+func TestIssue34UnicodeStrings(t *testing.T) {
+	// TODO: see if applicable
+}
+
+func TestCountMultipleFlags(t *testing.T) {
+	if v, _, err := Parse("usage: prog [-v]", []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog [-vv]", nil, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 0}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog [-vv]", []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 1}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog [-vv]", []string{"-vv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 2}) != true {
+		t.Error(err)
+	}
+	_, _, err := Parse("usage: prog [-vv]", []string{"-vvv"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog [-v | -vv | -vvv]", []string{"-vvv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 3}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog [-v...]", []string{"-vvvvvv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 6}) != true {
+		t.Error(err)
+	}
+	if v, _, err := Parse("usage: prog [--ver --ver]", []string{"--ver", "--ver"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--ver": 2}) != true {
+		t.Error(err)
+	}
+}
+
+func TestAnyOptionsParameter(t *testing.T) {
+	_, _, err := Parse("usage: prog [options]",
+		[]string{"-foo", "--bar", "--spam=eggs"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error()
+	}
+
+	_, _, err = Parse("usage: prog [options]",
+		[]string{"--foo", "--bar", "--bar"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error()
+	}
+	_, _, err = Parse("usage: prog [options]",
+		[]string{"--bar", "--bar", "--bar", "-ffff"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error()
+	}
+	_, _, err = Parse("usage: prog [options]",
+		[]string{"--long=arg", "--long=another"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error()
+	}
+}
+
+func TestDefaultValueForPositionalArguments(t *testing.T) {
+	if v, _, err := Parse("usage: prog [<p>]\n\n<p>  [default: x]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": nil}) != true {
+		t.Error(err)
+	}
+
+	if v, _, err := Parse("usage: prog [<p>]...\n\n<p>  [default: x y]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": []string{}}) != true {
+		t.Error(err)
+	}
+
+	if v, _, err := Parse("usage: prog [<p>]...\n\n<p>  [default: x y]", []string{"this"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": []string{"this"}}) != true {
+		t.Error(err)
+	}
+}
+
+func TestIssue59(t *testing.T) {
+	if v, _, err := Parse("usage: prog --long=<a>", []string{"--long="}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--long": ""}) != true {
+		t.Error(err)
+	}
+
+	if v, _, err := Parse("usage: prog -l <a>\noptions: -l <a>", []string{"-l", ""}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-l": ""}) != true {
+		t.Error(err)
+	}
+}
+
+func TestOptionsFirst(t *testing.T) {
+	if v, _, err := Parse("usage: prog [--opt] [<args>...]", []string{"--opt", "this", "that"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--opt": true, "<args>": []string{"this", "that"}}) != true {
+		t.Error(err)
+	}
+
+	if v, _, err := Parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--opt": true, "<args>": []string{"this", "that"}}) != true {
+		t.Error(err)
+	}
+
+	if v, _, err := Parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", true); reflect.DeepEqual(v, map[string]interface{}{"--opt": false, "<args>": []string{"this", "that", "--opt"}}) != true {
+		t.Error(err)
+	}
+}
+
+func TestIssue68OptionsShortcutDoesNotIncludeOptionsInUsagePattern(t *testing.T) {
+	args, _, err := Parse("usage: prog [-ab] [options]\noptions: -x\n -y", []string{"-ax"}, true, "", false)
+
+	if args["-a"] != true {
+		t.Error(err)
+	}
+	if args["-b"] != false {
+		t.Error(err)
+	}
+	if args["-x"] != true {
+		t.Error(err)
+	}
+	if args["-y"] != false {
+		t.Error(err)
+	}
+}
+
+func TestIssue65EvaluateArgvWhenCalledNotWhenImported(t *testing.T) {
+	os.Args = strings.Fields("prog -a")
+	v, _, err := Parse("usage: prog [-ab]", nil, true, "", false)
+	w := map[string]interface{}{"-a": true, "-b": false}
+	if reflect.DeepEqual(v, w) != true {
+		t.Error(err)
+	}
+
+	os.Args = strings.Fields("prog -b")
+	v, _, err = Parse("usage: prog [-ab]", nil, true, "", false)
+	w = map[string]interface{}{"-a": false, "-b": true}
+	if reflect.DeepEqual(v, w) != true {
+		t.Error(err)
+	}
+}
+
+func TestIssue71DoubleDashIsNotAValidOptionArgument(t *testing.T) {
+	_, _, err := Parse("usage: prog [--log=LEVEL] [--] <args>...",
+		[]string{"--log", "--", "1", "2"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error()
+	}
+
+	_, _, err = Parse(`usage: prog [-l LEVEL] [--] <args>...
+                  options: -l LEVEL`, []string{"-l", "--", "1", "2"}, true, "", false)
+	if _, ok := err.(*UserError); !ok {
+		t.Error()
+	}
+}
+
+func TestParseSection(t *testing.T) {
+	v := parseSection("usage:", "foo bar fizz buzz")
+	w := []string{}
+	if reflect.DeepEqual(v, w) != true {
+		t.Error()
+	}
+
+	v = parseSection("usage:", "usage: prog")
+	w = []string{"usage: prog"}
+	if reflect.DeepEqual(v, w) != true {
+		t.Error()
+	}
+
+	v = parseSection("usage:", "usage: -x\n -y")
+	w = []string{"usage: -x\n -y"}
+	if reflect.DeepEqual(v, w) != true {
+		t.Error()
+	}
+
+	usage := `usage: this
+
+usage:hai
+usage: this that
+
+usage: foo
+       bar
+
+PROGRAM USAGE:
+ foo
+ bar
+usage:
+` + "\t" + `too
+` + "\t" + `tar
+Usage: eggs spam
+BAZZ
+usage: pit stop`
+
+	v = parseSection("usage:", usage)
+	w = []string{"usage: this",
+		"usage:hai",
+		"usage: this that",
+		"usage: foo\n       bar",
+		"PROGRAM USAGE:\n foo\n bar",
+		"usage:\n\ttoo\n\ttar",
+		"Usage: eggs spam",
+		"usage: pit stop",
+	}
+	if reflect.DeepEqual(v, w) != true {
+		t.Error()
+	}
+}
+
+func TestIssue126DefaultsNotParsedCorrectlyWhenTabs(t *testing.T) {
+	section := "Options:\n\t--foo=<arg>  [default: bar]"
+	v := patternList{newOption("", "--foo", 1, "bar")}
+	if reflect.DeepEqual(parseDefaults(section), v) != true {
+		t.Error()
+	}
+}
+
+// conf file based test cases
+func TestFileTestcases(t *testing.T) {
+	filename := "testcases.docopt"
+	file, err := os.Open(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+
+	for c := range parseTest(file) {
+		if c.err != nil {
+			t.Fatal(err)
+			break
+		}
+		result, _, err := Parse(c.doc, c.argv, true, "", false)
+		if _, ok := err.(*UserError); c.userError && !ok {
+			// expected a user-error
+			t.Error("testcase:", c.id, "result:", result)
+		} else if _, ok := err.(*UserError); !c.userError && ok {
+			// unexpected user-error
+			t.Error("testcase:", c.id, "error:", err, "result:", result)
+		} else if reflect.DeepEqual(c.expect, result) != true {
+			t.Error("testcase:", c.id, "result:", result)
+		}
+	}
+}
+
+type testcase struct {
+	id        int
+	doc       string
+	prog      string
+	argv      []string
+	expect    map[string]interface{}
+	userError bool
+	err       error
+}
+
+func parseTest(raw io.Reader) <-chan testcase {
+	c := make(chan testcase)
+
+	go func() {
+		scanner := bufio.NewScanner(raw)
+		commentPattern := regexp.MustCompile("#.*($|\n)")
+		scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+			// look for matching `r"""` or `r"""`+EOF
+			sep := []byte(`r"""`)
+			count := bytes.Count(data, sep)
+			start := bytes.Index(data, sep)
+			end := len(data)
+
+			if atEOF && count == 0 {
+				// no more matches, so consume everything
+				return end, nil, nil
+			}
+			if atEOF && count == 1 {
+				// already matched up to end
+			} else if count >= 2 {
+				end = start + len(sep) + bytes.Index(data[start+len(sep):], sep)
+			} else {
+				// haven't found a match yet so ask for more data
+				return 0, nil, nil
+			}
+			token = data[start:end]
+			token = commentPattern.ReplaceAllLiteral(token, []byte(""))
+			return end, token, nil
+		})
+
+		for id := 0; scanner.Scan(); {
+			data := scanner.Bytes()
+
+			offset := 4
+			end := offset + bytes.Index(data[offset:], []byte(`"""`))
+			doc := string(data[offset:end])
+			offset = end + 3
+
+			for offset < len(data) {
+				offset = offset + bytes.Index(data[offset:], []byte(`$ `)) + 2
+				end = offset + bytes.Index(data[offset:], []byte("\n"))
+				prog, _, args := stringPartition(string(data[offset:end]), " ")
+				argv := strings.Fields(args)
+				offset = end + 1
+
+				if bytes.Contains(data[offset:], []byte("$ ")) {
+					end = offset + bytes.Index(data[offset:], []byte("$ "))
+				} else {
+					end = len(data)
+				}
+				var expectUntyped interface{}
+				err := json.Unmarshal(data[offset:end], &expectUntyped)
+				offset = end
+
+				if err != nil {
+					c <- testcase{id, doc, prog, argv, nil, false, err}
+					break
+				}
+
+				switch expect := expectUntyped.(type) {
+				case string: // user-error
+					c <- testcase{id, doc, prog, argv, nil, true, nil}
+				case map[string]interface{}:
+					// convert []interface{} values to []string
+					// convert float64 values to int
+					for k, vUntyped := range expect {
+						switch v := vUntyped.(type) {
+						case []interface{}:
+							itemList := make([]string, len(v))
+							for i, itemUntyped := range v {
+								if item, ok := itemUntyped.(string); ok {
+									itemList[i] = item
+								}
+							}
+							expect[k] = itemList
+						case float64:
+							expect[k] = int(v)
+						}
+					}
+					c <- testcase{id, doc, prog, argv, expect, false, nil}
+				}
+				id++
+			}
+		}
+		close(c)
+	}()
+	return c
+}
+
+var debugEnabled = false
+
+func debugOn(l ...interface{}) {
+	debugEnabled = true
+	debug(l...)
+}
+func debugOff(l ...interface{}) {
+	debug(l...)
+	debugEnabled = false
+}
+
+func debug(l ...interface{}) {
+	if debugEnabled {
+		fmt.Println(l...)
+	}
+}
diff --git a/testcases.docopt b/testcases.docopt
new file mode 100644
index 0000000..efe9a07
--- /dev/null
+++ b/testcases.docopt
@@ -0,0 +1,957 @@
+r"""Usage: prog
+
+"""
+$ prog
+{}
+
+$ prog --xxx
+"user-error"
+
+
+r"""Usage: prog [options]
+
+Options: -a  All.
+
+"""
+$ prog
+{"-a": false}
+
+$ prog -a
+{"-a": true}
+
+$ prog -x
+"user-error"
+
+
+r"""Usage: prog [options]
+
+Options: --all  All.
+
+"""
+$ prog
+{"--all": false}
+
+$ prog --all
+{"--all": true}
+
+$ prog --xxx
+"user-error"
+
+
+r"""Usage: prog [options]
+
+Options: -v, --verbose  Verbose.
+
+"""
+$ prog --verbose
+{"--verbose": true}
+
+$ prog --ver
+{"--verbose": true}
+
+$ prog -v
+{"--verbose": true}
+
+
+r"""Usage: prog [options]
+
+Options: -p PATH
+
+"""
+$ prog -p home/
+{"-p": "home/"}
+
+$ prog -phome/
+{"-p": "home/"}
+
+$ prog -p
+"user-error"
+
+
+r"""Usage: prog [options]
+
+Options: --path <path>
+
+"""
+$ prog --path home/
+{"--path": "home/"}
+
+$ prog --path=home/
+{"--path": "home/"}
+
+$ prog --pa home/
+{"--path": "home/"}
+
+$ prog --pa=home/
+{"--path": "home/"}
+
+$ prog --path
+"user-error"
+
+
+r"""Usage: prog [options]
+
+Options: -p PATH, --path=<path>  Path to files.
+
+"""
+$ prog -proot
+{"--path": "root"}
+
+
+r"""Usage: prog [options]
+
+Options:    -p --path PATH  Path to files.
+
+"""
+$ prog -p root
+{"--path": "root"}
+
+$ prog --path root
+{"--path": "root"}
+
+
+r"""Usage: prog [options]
+
+Options:
+ -p PATH  Path to files [default: ./]
+
+"""
+$ prog
+{"-p": "./"}
+
+$ prog -phome
+{"-p": "home"}
+
+
+r"""UsAgE: prog [options]
+
+OpTiOnS: --path=<files>  Path to files
+                [dEfAuLt: /root]
+
+"""
+$ prog
+{"--path": "/root"}
+
+$ prog --path=home
+{"--path": "home"}
+
+
+r"""usage: prog [options]
+
+options:
+    -a        Add
+    -r        Remote
+    -m <msg>  Message
+
+"""
+$ prog -a -r -m Hello
+{"-a": true,
+ "-r": true,
+ "-m": "Hello"}
+
+$ prog -armyourass
+{"-a": true,
+ "-r": true,
+ "-m": "yourass"}
+
+$ prog -a -r
+{"-a": true,
+ "-r": true,
+ "-m": null}
+
+
+r"""Usage: prog [options]
+
+Options: --version
+         --verbose
+
+"""
+$ prog --version
+{"--version": true,
+ "--verbose": false}
+
+$ prog --verbose
+{"--version": false,
+ "--verbose": true}
+
+$ prog --ver
+"user-error"
+
+$ prog --verb
+{"--version": false,
+ "--verbose": true}
+
+
+r"""usage: prog [-a -r -m <msg>]
+
+options:
+ -a        Add
+ -r        Remote
+ -m <msg>  Message
+
+"""
+$ prog -armyourass
+{"-a": true,
+ "-r": true,
+ "-m": "yourass"}
+
+
+r"""usage: prog [-armmsg]
+
+options: -a        Add
+         -r        Remote
+         -m <msg>  Message
+
+"""
+$ prog -a -r -m Hello
+{"-a": true,
+ "-r": true,
+ "-m": "Hello"}
+
+
+r"""usage: prog -a -b
+
+options:
+ -a
+ -b
+
+"""
+$ prog -a -b
+{"-a": true, "-b": true}
+
+$ prog -b -a
+{"-a": true, "-b": true}
+
+$ prog -a
+"user-error"
+
+$ prog
+"user-error"
+
+
+r"""usage: prog (-a -b)
+
+options: -a
+         -b
+
+"""
+$ prog -a -b
+{"-a": true, "-b": true}
+
+$ prog -b -a
+{"-a": true, "-b": true}
+
+$ prog -a
+"user-error"
+
+$ prog
+"user-error"
+
+
+r"""usage: prog [-a] -b
+
+options: -a
+ -b
+
+"""
+$ prog -a -b
+{"-a": true, "-b": true}
+
+$ prog -b -a
+{"-a": true, "-b": true}
+
+$ prog -a
+"user-error"
+
+$ prog -b
+{"-a": false, "-b": true}
+
+$ prog
+"user-error"
+
+
+r"""usage: prog [(-a -b)]
+
+options: -a
+         -b
+
+"""
+$ prog -a -b
+{"-a": true, "-b": true}
+
+$ prog -b -a
+{"-a": true, "-b": true}
+
+$ prog -a
+"user-error"
+
+$ prog -b
+"user-error"
+
+$ prog
+{"-a": false, "-b": false}
+
+
+r"""usage: prog (-a|-b)
+
+options: -a
+         -b
+
+"""
+$ prog -a -b
+"user-error"
+
+$ prog
+"user-error"
+
+$ prog -a
+{"-a": true, "-b": false}
+
+$ prog -b
+{"-a": false, "-b": true}
+
+
+r"""usage: prog [ -a | -b ]
+
+options: -a
+         -b
+
+"""
+$ prog -a -b
+"user-error"
+
+$ prog
+{"-a": false, "-b": false}
+
+$ prog -a
+{"-a": true, "-b": false}
+
+$ prog -b
+{"-a": false, "-b": true}
+
+
+r"""usage: prog <arg>"""
+$ prog 10
+{"<arg>": "10"}
+
+$ prog 10 20
+"user-error"
+
+$ prog
+"user-error"
+
+
+r"""usage: prog [<arg>]"""
+$ prog 10
+{"<arg>": "10"}
+
+$ prog 10 20
+"user-error"
+
+$ prog
+{"<arg>": null}
+
+
+r"""usage: prog <kind> <name> <type>"""
+$ prog 10 20 40
+{"<kind>": "10", "<name>": "20", "<type>": "40"}
+
+$ prog 10 20
+"user-error"
+
+$ prog
+"user-error"
+
+
+r"""usage: prog <kind> [<name> <type>]"""
+$ prog 10 20 40
+{"<kind>": "10", "<name>": "20", "<type>": "40"}
+
+$ prog 10 20
+{"<kind>": "10", "<name>": "20", "<type>": null}
+
+$ prog
+"user-error"
+
+
+r"""usage: prog [<kind> | <name> <type>]"""
+$ prog 10 20 40
+"user-error"
+
+$ prog 20 40
+{"<kind>": null, "<name>": "20", "<type>": "40"}
+
+$ prog
+{"<kind>": null, "<name>": null, "<type>": null}
+
+
+r"""usage: prog (<kind> --all | <name>)
+
+options:
+ --all
+
+"""
+$ prog 10 --all
+{"<kind>": "10", "--all": true, "<name>": null}
+
+$ prog 10
+{"<kind>": null, "--all": false, "<name>": "10"}
+
+$ prog
+"user-error"
+
+
+r"""usage: prog [<name> <name>]"""
+$ prog 10 20
+{"<name>": ["10", "20"]}
+
+$ prog 10
+{"<name>": ["10"]}
+
+$ prog
+{"<name>": []}
+
+
+r"""usage: prog [(<name> <name>)]"""
+$ prog 10 20
+{"<name>": ["10", "20"]}
+
+$ prog 10
+"user-error"
+
+$ prog
+{"<name>": []}
+
+
+r"""usage: prog NAME..."""
+$ prog 10 20
+{"NAME": ["10", "20"]}
+
+$ prog 10
+{"NAME": ["10"]}
+
+$ prog
+"user-error"
+
+
+r"""usage: prog [NAME]..."""
+$ prog 10 20
+{"NAME": ["10", "20"]}
+
+$ prog 10
+{"NAME": ["10"]}
+
+$ prog
+{"NAME": []}
+
+
+r"""usage: prog [NAME...]"""
+$ prog 10 20
+{"NAME": ["10", "20"]}
+
+$ prog 10
+{"NAME": ["10"]}
+
+$ prog
+{"NAME": []}
+
+
+r"""usage: prog [NAME [NAME ...]]"""
+$ prog 10 20
+{"NAME": ["10", "20"]}
+
+$ prog 10
+{"NAME": ["10"]}
+
+$ prog
+{"NAME": []}
+
+
+r"""usage: prog (NAME | --foo NAME)
+
+options: --foo
+
+"""
+$ prog 10
+{"NAME": "10", "--foo": false}
+
+$ prog --foo 10
+{"NAME": "10", "--foo": true}
+
+$ prog --foo=10
+"user-error"
+
+
+r"""usage: prog (NAME | --foo) [--bar | NAME]
+
+options: --foo
+options: --bar
+
+"""
+$ prog 10
+{"NAME": ["10"], "--foo": false, "--bar": false}
+
+$ prog 10 20
+{"NAME": ["10", "20"], "--foo": false, "--bar": false}
+
+$ prog --foo --bar
+{"NAME": [], "--foo": true, "--bar": true}
+
+
+r"""Naval Fate.
+
+Usage:
+  prog ship new <name>...
+  prog ship [<name>] move <x> <y> [--speed=<kn>]
+  prog ship shoot <x> <y>
+  prog mine (set|remove) <x> <y> [--moored|--drifting]
+  prog -h | --help
+  prog --version
+
+Options:
+  -h --help     Show this screen.
+  --version     Show version.
+  --speed=<kn>  Speed in knots [default: 10].
+  --moored      Mored (anchored) mine.
+  --drifting    Drifting mine.
+
+"""
+$ prog ship Guardian move 150 300 --speed=20
+{"--drifting": false,
+ "--help": false,
+ "--moored": false,
+ "--speed": "20",
+ "--version": false,
+ "<name>": ["Guardian"],
+ "<x>": "150",
+ "<y>": "300",
+ "mine": false,
+ "move": true,
+ "new": false,
+ "remove": false,
+ "set": false,
+ "ship": true,
+ "shoot": false}
+
+
+r"""usage: prog --hello"""
+$ prog --hello
+{"--hello": true}
+
+
+r"""usage: prog [--hello=<world>]"""
+$ prog
+{"--hello": null}
+
+$ prog --hello wrld
+{"--hello": "wrld"}
+
+
+r"""usage: prog [-o]"""
+$ prog
+{"-o": false}
+
+$ prog -o
+{"-o": true}
+
+
+r"""usage: prog [-opr]"""
+$ prog -op
+{"-o": true, "-p": true, "-r": false}
+
+
+r"""usage: prog --aabb | --aa"""
+$ prog --aa
+{"--aabb": false, "--aa": true}
+
+$ prog --a
+"user-error"  # not a unique prefix
+
+#
+# Counting number of flags
+#
+
+r"""Usage: prog -v"""
+$ prog -v
+{"-v": true}
+
+
+r"""Usage: prog [-v -v]"""
+$ prog
+{"-v": 0}
+
+$ prog -v
+{"-v": 1}
+
+$ prog -vv
+{"-v": 2}
+
+
+r"""Usage: prog -v ..."""
+$ prog
+"user-error"
+
+$ prog -v
+{"-v": 1}
+
+$ prog -vv
+{"-v": 2}
+
+$ prog -vvvvvv
+{"-v": 6}
+
+
+r"""Usage: prog [-v | -vv | -vvv]
+
+This one is probably most readable user-friednly variant.
+
+"""
+$ prog
+{"-v": 0}
+
+$ prog -v
+{"-v": 1}
+
+$ prog -vv
+{"-v": 2}
+
+$ prog -vvvv
+"user-error"
+
+
+r"""usage: prog [--ver --ver]"""
+$ prog --ver --ver
+{"--ver": 2}
+
+
+#
+# Counting commands
+#
+
+r"""usage: prog [go]"""
+$ prog go
+{"go": true}
+
+
+r"""usage: prog [go go]"""
+$ prog
+{"go": 0}
+
+$ prog go
+{"go": 1}
+
+$ prog go go
+{"go": 2}
+
+$ prog go go go
+"user-error"
+
+r"""usage: prog go..."""
+$ prog go go go go go
+{"go": 5}
+
+#
+# [options] does not include options from usage-pattern
+#
+r"""usage: prog [options] [-a]
+
+options: -a
+         -b
+"""
+$ prog -a
+{"-a": true, "-b": false}
+
+$ prog -aa
+"user-error"
+
+#
+# Test [options] shourtcut
+#
+
+r"""Usage: prog [options] A
+Options:
+    -q  Be quiet
+    -v  Be verbose.
+
+"""
+$ prog arg
+{"A": "arg", "-v": false, "-q": false}
+
+$ prog -v arg
+{"A": "arg", "-v": true, "-q": false}
+
+$ prog -q arg
+{"A": "arg", "-v": false, "-q": true}
+
+#
+# Test single dash
+#
+
+r"""usage: prog [-]"""
+
+$ prog -
+{"-": true}
+
+$ prog
+{"-": false}
+
+#
+# If argument is repeated, its value should always be a list
+#
+
+r"""usage: prog [NAME [NAME ...]]"""
+
+$ prog a b
+{"NAME": ["a", "b"]}
+
+$ prog
+{"NAME": []}
+
+#
+# Option's argument defaults to null/None
+#
+
+r"""usage: prog [options]
+options:
+ -a        Add
+ -m <msg>  Message
+
+"""
+$ prog -a
+{"-m": null, "-a": true}
+
+#
+# Test options without description
+#
+
+r"""usage: prog --hello"""
+$ prog --hello
+{"--hello": true}
+
+r"""usage: prog [--hello=<world>]"""
+$ prog
+{"--hello": null}
+
+$ prog --hello wrld
+{"--hello": "wrld"}
+
+r"""usage: prog [-o]"""
+$ prog
+{"-o": false}
+
+$ prog -o
+{"-o": true}
+
+r"""usage: prog [-opr]"""
+$ prog -op
+{"-o": true, "-p": true, "-r": false}
+
+r"""usage: git [-v | --verbose]"""
+$ prog -v
+{"-v": true, "--verbose": false}
+
+r"""usage: git remote [-v | --verbose]"""
+$ prog remote -v
+{"remote": true, "-v": true, "--verbose": false}
+
+#
+# Test empty usage pattern
+#
+
+r"""usage: prog"""
+$ prog
+{}
+
+r"""usage: prog
+           prog <a> <b>
+"""
+$ prog 1 2
+{"<a>": "1", "<b>": "2"}
+
+$ prog
+{"<a>": null, "<b>": null}
+
+r"""usage: prog <a> <b>
+           prog
+"""
+$ prog
+{"<a>": null, "<b>": null}
+
+#
+# Option's argument should not capture default value from usage pattern
+#
+
+r"""usage: prog [--file=<f>]"""
+$ prog
+{"--file": null}
+
+r"""usage: prog [--file=<f>]
+
+options: --file <a>
+
+"""
+$ prog
+{"--file": null}
+
+r"""Usage: prog [-a <host:port>]
+
+Options: -a, --address <host:port>  TCP address [default: localhost:6283].
+
+"""
+$ prog
+{"--address": "localhost:6283"}
+
+#
+# If option with argument could be repeated,
+# its arguments should be accumulated into a list
+#
+
+r"""usage: prog --long=<arg> ..."""
+
+$ prog --long one
+{"--long": ["one"]}
+
+$ prog --long one --long two
+{"--long": ["one", "two"]}
+
+#
+# Test multiple elements repeated at once
+#
+
+r"""usage: prog (go <direction> --speed=<km/h>)..."""
+$ prog  go left --speed=5  go right --speed=9
+{"go": 2, "<direction>": ["left", "right"], "--speed": ["5", "9"]}
+
+#
+# Required options should work with option shortcut
+#
+
+r"""usage: prog [options] -a
+
+options: -a
+
+"""
+$ prog -a
+{"-a": true}
+
+#
+# If option could be repeated its defaults should be split into a list
+#
+
+r"""usage: prog [-o <o>]...
+
+options: -o <o>  [default: x]
+
+"""
+$ prog -o this -o that
+{"-o": ["this", "that"]}
+
+$ prog
+{"-o": ["x"]}
+
+r"""usage: prog [-o <o>]...
+
+options: -o <o>  [default: x y]
+
+"""
+$ prog -o this
+{"-o": ["this"]}
+
+$ prog
+{"-o": ["x", "y"]}
+
+#
+# Test stacked option's argument
+#
+
+r"""usage: prog -pPATH
+
+options: -p PATH
+
+"""
+$ prog -pHOME
+{"-p": "HOME"}
+
+#
+# Issue 56: Repeated mutually exclusive args give nested lists sometimes
+#
+
+r"""Usage: foo (--xx=x|--yy=y)..."""
+$ prog --xx=1 --yy=2
+{"--xx": ["1"], "--yy": ["2"]}
+
+#
+# POSIXly correct tokenization
+#
+
+r"""usage: prog [<input file>]"""
+$ prog f.txt
+{"<input file>": "f.txt"}
+
+r"""usage: prog [--input=<file name>]..."""
+$ prog --input a.txt --input=b.txt
+{"--input": ["a.txt", "b.txt"]}
+
+#
+# Issue 85: `[options]` shourtcut with multiple subcommands
+#
+
+r"""usage: prog good [options]
+           prog fail [options]
+
+options: --loglevel=N
+
+"""
+$ prog fail --loglevel 5
+{"--loglevel": "5", "fail": true, "good": false}
+
+#
+# Usage-section syntax
+#
+
+r"""usage:prog --foo"""
+$ prog --foo
+{"--foo": true}
+
+r"""PROGRAM USAGE: prog --foo"""
+$ prog --foo
+{"--foo": true}
+
+r"""Usage: prog --foo
+           prog --bar
+NOT PART OF SECTION"""
+$ prog --foo
+{"--foo": true, "--bar": false}
+
+r"""Usage:
+ prog --foo
+ prog --bar
+
+NOT PART OF SECTION"""
+$ prog --foo
+{"--foo": true, "--bar": false}
+
+r"""Usage:
+ prog --foo
+ prog --bar
+NOT PART OF SECTION"""
+$ prog --foo
+{"--foo": true, "--bar": false}
+
+#
+# Options-section syntax
+#
+
+r"""Usage: prog [options]
+
+global options: --foo
+local options: --baz
+               --bar
+other options:
+ --egg
+ --spam
+-not-an-option-
+
+"""
+$ prog --baz --egg
+{"--foo": false, "--baz": true, "--bar": false, "--egg": true, "--spam": false}