Function parseTest

docopt_test.go:1444–1496

(raw []byte)

}

func parseTest(raw []byte) ([]testcase, error) {
	var res []testcase
	commentPattern := regexp.MustCompile("#.*")
	raw = commentPattern.ReplaceAll(raw, []byte(""))
	raw = bytes.TrimSpace(raw)
	if bytes.HasPrefix(raw, []byte(`"""`)) {
		raw = raw[3:]
	}

	id := 0
	for _, fixture := range bytes.Split(raw, []byte(`r"""`)) {
		doc, _, body := stringPartition(string(fixture), `"""`)
		for _, cas := range strings.Split(body, "$")[1:] {
			argvString, _, expectString := stringPartition(strings.TrimSpace(cas), "\n")
			prog, _, argvString := stringPartition(strings.TrimSpace(argvString), " ")
			argv := []string{}
			if len(argvString) > 0 {
				argv = strings.Fields(argvString)
			}
			var expectUntyped interface{}
			err := json.Unmarshal([]byte(expectString), &expectUntyped)
			if err != nil {
				return nil, err
			}
			switch expect := expectUntyped.(type) {
			case string: // user-error
				res = append(res, testcase{id, doc, prog, argv, nil, true})
			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)
					}
				}
				res = append(res, testcase{id, doc, prog, argv, expect, false})
			default:
				return nil, fmt.Errorf("unhandled json data type")
			}
			id++
		}
	}
	return res, nil
}

// parseOutput wraps the Parse() function to also return stdout
func parseOutput(doc string, argv []string, help bool, version string,