diff --git a/docopt.go b/docopt.go
index 1e4ab0b..e513ae5 100644
--- a/docopt.go
+++ b/docopt.go
@@ -85,14 +85,24 @@
 //   "<port>": "8"',
 //   "serial": false,
 //   "tcp": true}
-func Parse(doc string, argv []string, help bool, version string, optionsFirst bool) (map[string]interface{}, error) {
+func Parse(doc string, argv []string, help bool, version string,
+	optionsFirst bool, exit ...bool) (map[string]interface{}, error) {
+	// if "false" was the (optional) last arg, don't call os.Exit()
+	exitOk := true
+	if len(exit) > 0 {
+		exitOk = exit[0]
+	}
 	args, output, err := parse(doc, argv, help, version, optionsFirst)
 	if _, ok := err.(*UserError); ok {
 		fmt.Println(output)
-		os.Exit(1)
+		if exitOk {
+			os.Exit(1)
+		}
 	} else if len(output) > 0 && err == nil {
 		fmt.Println(output)
-		os.Exit(0)
+		if exitOk {
+			os.Exit(0)
+		}
 	}
 	return args, err
 }
diff --git a/docopt_test.go b/docopt_test.go
index 6609acc..6354b00 100644
--- a/docopt_test.go
+++ b/docopt_test.go
@@ -11,6 +11,7 @@
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"reflect"
@@ -118,25 +119,25 @@
 }
 
 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 {
+	if v, err := Parse("Usage: prog add", []string{"add"}, true, "", false, 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 {
+	if v, err := Parse("Usage: prog [add]", []string{}, true, "", false, 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 {
+	if v, err := Parse("Usage: prog [add]", []string{"add"}, true, "", false, 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 {
+	if v, err := Parse("Usage: prog (add|rm)", []string{"add"}, true, "", false, 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 {
+	if v, err := Parse("Usage: prog (add|rm)", []string{"rm"}, true, "", false, 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 {
+	if v, err := Parse("Usage: prog a b", []string{"a", "b"}, true, "", false, 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)
+	_, err := Parse("Usage: prog a b", []string{"b", "a"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
@@ -1063,73 +1064,73 @@
 }
 
 func TestLongOptionsErrorHandling(t *testing.T) {
-	_, _, err := parse("Usage: prog", []string{"--non-existent"}, true, "", false)
+	_, err := Parse("Usage: prog", []string{"--non-existent"}, true, "", false, 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)
+	_, err = Parse("Usage: prog [--version --verbose]\nOptions: --version\n --verbose",
+		[]string{"--ver"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse("Usage: prog --long\nOptions: --long ARG", []string{}, true, "", false)
+	_, err = Parse("Usage: prog --long\nOptions: --long ARG", []string{}, true, "", false, false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse("Usage: prog --long ARG\nOptions: --long ARG",
-		[]string{"--long"}, true, "", false)
+	_, err = Parse("Usage: prog --long ARG\nOptions: --long ARG",
+		[]string{"--long"}, true, "", false, 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)
+	_, err = Parse("Usage: prog --long=ARG\nOptions: --long", []string{}, true, "", false, false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse("Usage: prog --long\nOptions: --long",
-		[]string{}, true, "--long=ARG", false)
+	_, err = Parse("Usage: prog --long\nOptions: --long",
+		[]string{}, true, "--long=ARG", false, 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)
+	_, err := Parse("Usage: prog -x\nOptions: -x  this\n -x  that", []string{}, true, "", false, false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(fmt.Sprintf("(%s) %s", reflect.TypeOf(err), err))
 	}
-	_, _, err = parse("Usage: prog", []string{"-x"}, true, "", false)
+	_, err = Parse("Usage: prog", []string{"-x"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse("Usage: prog -o\nOptions: -o ARG", []string{}, true, "", false)
+	_, err = Parse("Usage: prog -o\nOptions: -o ARG", []string{}, true, "", false, false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse("Usage: prog -o ARG\nOptions: -o ARG", []string{"-o"}, true, "", false)
+	_, err = Parse("Usage: prog -o ARG\nOptions: -o ARG", []string{"-o"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
 }
 
 func TestMatchingParen(t *testing.T) {
-	_, _, err := parse("Usage: prog [a [b]", []string{}, true, "", false)
+	_, err := Parse("Usage: prog [a [b]", []string{}, true, "", false, false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse("Usage: prog [a [b] ] c )", []string{}, true, "", false)
+	_, err = Parse("Usage: prog [a [b] ] c )", []string{}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"--", "-o"}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"-o", "1"}, true, "", false, 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)
+	_, err := Parse("usage: prog [-o] <arg>\noptions:-o", []string{"-o"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok { //"--" is not allowed; FIXME?
 		t.Error(err)
 	}
@@ -1139,10 +1140,10 @@
 	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 {
+	if v, err := Parse(doc, []string{"arg"}, true, "", false, 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 {
+	if v, err := Parse(doc, []string{"-v", "arg"}, true, "", false, false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "A": "arg"}) != true {
 		t.Error(err)
 	}
 
@@ -1157,44 +1158,44 @@
       --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 {
+	if v, err := Parse(doc, []string{"-v", "file.py"}, true, "", false, 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 {
+	if v, err := Parse(doc, []string{"-v"}, true, "", false, 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
+	_, err := Parse(doc, []string{"-v", "input.py", "output.py"}, true, "", false, false) // does not match
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse(doc, []string{"--fake"}, true, "", false)
+	_, err = Parse(doc, []string{"--fake"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, output, err := parse(doc, []string{"--hel"}, true, "", false)
+	_, output, err := parseOutput(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)
+	_, err := Parse("no usage with colon here", []string{}, true, "", false, false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = parse("usage: here \n\n and again usage: here", []string{}, true, "", false)
+	_, err = Parse("usage: here \n\n and again usage: here", []string{}, true, "", false, 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)
+	_, output, err := parseOutput("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 {
+	if v, err := Parse("usage: prog --aabb | --aa", []string{"--aa"}, true, "", false, false); reflect.DeepEqual(v, map[string]interface{}{"--aabb": false, "--aa": true}) != true {
 		t.Error(err)
 	}
 }
@@ -1204,52 +1205,52 @@
 }
 
 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 {
+	if v, err := Parse("usage: prog [-v]", []string{"-v"}, true, "", false, false); reflect.DeepEqual(v, map[string]interface{}{"-v": true}) != true {
 		t.Error(err)
 	}
-	if v, _, err := parse("usage: prog [-vv]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 0}) != true {
+	if v, err := Parse("usage: prog [-vv]", []string{}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [-vv]", []string{"-v"}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [-vv]", []string{"-vv"}, true, "", false, false); reflect.DeepEqual(v, map[string]interface{}{"-v": 2}) != true {
 		t.Error(err)
 	}
-	_, _, err := parse("usage: prog [-vv]", []string{"-vvv"}, true, "", false)
+	_, err := Parse("usage: prog [-vv]", []string{"-vvv"}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [-v | -vv | -vvv]", []string{"-vvv"}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [-v...]", []string{"-vvvvvv"}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [--ver --ver]", []string{"--ver", "--ver"}, true, "", false, 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)
+	_, err := Parse("usage: prog [options]",
+		[]string{"-foo", "--bar", "--spam=eggs"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
 
-	_, _, err = parse("usage: prog [options]",
-		[]string{"--foo", "--bar", "--bar"}, true, "", false)
+	_, err = Parse("usage: prog [options]",
+		[]string{"--foo", "--bar", "--bar"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
-	_, _, err = parse("usage: prog [options]",
-		[]string{"--bar", "--bar", "--bar", "-ffff"}, true, "", false)
+	_, err = Parse("usage: prog [options]",
+		[]string{"--bar", "--bar", "--bar", "-ffff"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
-	_, _, err = parse("usage: prog [options]",
-		[]string{"--long=arg", "--long=another"}, true, "", false)
+	_, err = Parse("usage: prog [options]",
+		[]string{"--long=arg", "--long=another"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
@@ -1257,47 +1258,47 @@
 
 func TestDefaultValueForPositionalArguments(t *testing.T) {
 	doc := "Usage: prog [--data=<data>...]\nOptions:\n\t-d --data=<arg>    Input data [default: x]"
-	if v, _, err := parse(doc, []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--data": []string{"x"}}) != true {
+	if v, err := Parse(doc, []string{}, true, "", false, false); reflect.DeepEqual(v, map[string]interface{}{"--data": []string{"x"}}) != true {
 		t.Error(err)
 	}
 
 	doc = "Usage: prog [--data=<data>...]\nOptions:\n\t-d --data=<arg>    Input data [default: x y]"
-	if v, _, err := parse(doc, []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--data": []string{"x", "y"}}) != true {
+	if v, err := Parse(doc, []string{}, true, "", false, false); reflect.DeepEqual(v, map[string]interface{}{"--data": []string{"x", "y"}}) != true {
 		t.Error(err)
 	}
 
 	doc = "Usage: prog [--data=<data>...]\nOptions:\n\t-d --data=<arg>    Input data [default: x y]"
-	if v, _, err := parse(doc, []string{"--data=this"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--data": []string{"this"}}) != true {
+	if v, err := Parse(doc, []string{"--data=this"}, true, "", false, false); reflect.DeepEqual(v, map[string]interface{}{"--data": []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 {
+	if v, err := Parse("usage: prog --long=<a>", []string{"--long="}, true, "", false, 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 {
+	if v, err := Parse("usage: prog -l <a>\noptions: -l <a>", []string{"-l", ""}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [--opt] [<args>...]", []string{"--opt", "this", "that"}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", false, 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 {
+	if v, err := Parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", true, false); 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)
+	args, err := Parse("usage: prog [-ab] [options]\noptions: -x\n -y", []string{"-ax"}, true, "", false, false)
 
 	if args["-a"] != true {
 		t.Error(err)
@@ -1315,14 +1316,14 @@
 
 func TestIssue65EvaluateArgvWhenCalledNotWhenImported(t *testing.T) {
 	os.Args = strings.Fields("prog -a")
-	v, _, err := parse("usage: prog [-ab]", nil, true, "", false)
+	v, err := Parse("usage: prog [-ab]", nil, true, "", false, 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)
+	v, err = Parse("usage: prog [-ab]", nil, true, "", false, false)
 	w = map[string]interface{}{"-a": false, "-b": true}
 	if reflect.DeepEqual(v, w) != true {
 		t.Error(err)
@@ -1330,14 +1331,14 @@
 }
 
 func TestIssue71DoubleDashIsNotAValidOptionArgument(t *testing.T) {
-	_, _, err := parse("usage: prog [--log=LEVEL] [--] <args>...",
-		[]string{"--log", "--", "1", "2"}, true, "", false)
+	_, err := Parse("usage: prog [--log=LEVEL] [--] <args>...",
+		[]string{"--log", "--", "1", "2"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
 
-	_, _, err = parse(`usage: prog [-l LEVEL] [--] <args>...
-                  options: -l LEVEL`, []string{"-l", "--", "1", "2"}, true, "", false)
+	_, err = Parse(`usage: prog [-l LEVEL] [--] <args>...
+                  options: -l LEVEL`, []string{"-l", "--", "1", "2"}, true, "", false, false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
@@ -1417,7 +1418,7 @@
 			t.Fatal(err)
 		}
 		for _, c := range tests {
-			result, _, err := parse(c.doc, c.argv, true, "", false)
+			result, err := Parse(c.doc, c.argv, true, "", false, false)
 			if _, ok := err.(*UserError); c.userError && !ok {
 				// expected a user-error
 				t.Error("testcase:", c.id, "result:", result)
@@ -1494,6 +1495,29 @@
 	return res, nil
 }
 
+// parseOutput wraps the Parse() function to also return stdout
+func parseOutput(doc string, argv []string, help bool, version string,
+	optionsFirst bool) (map[string]interface{}, string, error) {
+	stdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	args, err := Parse(doc, argv, help, version, optionsFirst, false)
+
+	outChan := make(chan string)
+	go func() {
+		var buf bytes.Buffer
+		io.Copy(&buf, r)
+		outChan <- buf.String()
+	}()
+
+	w.Close()
+	os.Stdout = stdout
+	output := <-outChan
+
+	return args, output, err
+}
+
 var debugEnabled = false
 
 func debugOn(l ...interface{}) {