%%%% Starting test phosphate
Group begin: phosphate
Group begin: fail/p
Test begin:
  test-name: "fail/p"
Test end:
  result-kind: pass
  actual-value: #t
Group end: fail/p
Group begin: return/p
Group begin: nothing on EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: nothing on EOF
Group begin: nothing with input
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: nothing with input
Group begin: single value on EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (x)
  expected-value: (x)
Group end: single value on EOF
Group begin: single value with input
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (x)
  expected-value: (x)
Group end: single value with input
Group begin: multiple values on EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (x y)
  expected-value: (x y)
Group end: multiple values on EOF
Group begin: multiple values with input
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (x y)
  expected-value: (x y)
Group end: multiple values with input
Group end: return/p
Group begin: ref/p
Test begin:
  test-name: "ref/p"
Test end:
  result-kind: pass
  actual-value: "efgh"
  expected-value: "efgh"
Group end: ref/p
Group begin: test/p
Group begin: true
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: true
Test begin:
  test-name: "false"
Test end:
  result-kind: pass
  actual-value: #t
Group end: test/p
Group begin: delay/p
Group begin: single argument
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (5)
  expected-value: (5)
Group end: single argument
Group begin: multiple arguments
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (5 6 7 8)
  expected-value: (5 6 7 8)
Group end: multiple arguments
Group end: delay/p
Group begin: eof/p
Group begin: on EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: on EOF
Test begin:
  test-name: "not on EOF"
Test end:
  result-kind: pass
  actual-value: #t
Group end: eof/p
Group begin: satisfy/p
Group begin: on char
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: on char
Test begin:
  test-name: "on EOF"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: on non-matching
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: on non-matching
Group end: satisfy/p
Group begin: advance/p
Group begin: single char then EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: single char then EOF
Group begin: double char then EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: double char then EOF
Test begin:
  test-name: "not successful"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: advance twice
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: advance twice
Group end: advance/p
Group begin: ==/p
Group begin: single
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: single
Test begin:
  test-name: "no match"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "==/p, EOF"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: sequenced
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: sequenced
Group end: ==/p
Group begin: !==/p
Group begin: !==/p, single
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: !==/p, single
Test begin:
  test-name: "!==/p, EOF"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "!==/p, no match"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: sequenced
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: sequenced
Group end: !==/p
Group begin: lv/p
Group begin: single value then EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: single value then EOF
Test begin:
  test-name: "single value then EOF, fail"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: multiple values then EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a #\b)
  expected-value: (#\a #\b)
Group end: multiple values then EOF
Test begin:
  test-name: "multiple values then EOF, too short"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "multiple values then EOF, too long"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: lv/p final parser step
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: lv/p final parser step
Group end: lv/p
Group begin: ==seq/p
Group begin: empty
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: empty
Group begin: one char
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: one char
Group begin: multiple chars
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: multiple chars
Group begin: matches with rest
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: matches with rest
Test begin:
  test-name: "too short"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: composing
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: composing
Group end: ==seq/p
Group begin: one-of/p
Group begin: one-of/p, first
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: one-of/p, first
Group begin: one-of/p, second
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: one-of/p, second
Test begin:
  test-name: "one-of/p on EOF"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "one-of/p fails"
Test end:
  result-kind: pass
  actual-value: #t
Group end: one-of/p
Group begin: values/p
Group begin: values/p
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a #\b)
  expected-value: (#\a #\b)
Group end: values/p
Test begin:
  test-name: "values/p fails"
Test end:
  result-kind: pass
  actual-value: #t
Group end: values/p
Group begin: and/p
Group begin: with no arguments on EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: with no arguments on EOF
Group begin: with no arguments on input
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: with no arguments on input
Group begin: with a single argument
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: with a single argument
Group begin: with two arguments
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: with two arguments
Group end: and/p
Group begin: or/p
Group begin: first success
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: first success
Group begin: second success
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: second success
Test begin:
  test-name: "fail"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: backtracks on failure
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#t)
  expected-value: (#t)
Group end: backtracks on failure
Group end: or/p
Group begin: if/p
Group begin: branch 1
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\c)
  expected-value: (#\c)
Group end: branch 1
Group begin: branch 2
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: branch 2
Test begin:
  test-name: "neither branch"
Test end:
  result-kind: pass
  actual-value: #t
Group end: if/p
Group begin: cond/p
Group begin: cond/p, branch 1
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b)
  expected-value: (#\b)
Group end: cond/p, branch 1
Group begin: cond/p, branch 2
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\b #\c)
  expected-value: (#\b #\c)
Group end: cond/p, branch 2
Group begin: cond/p, else
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\z)
  expected-value: (#\z)
Group end: cond/p, else
Group end: cond/p
Group begin: error/p
Group begin: error/p
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (error 1 2 3)
  expected-value: (error 1 2 3)
Group end: error/p
Group end: error/p
Group begin: as-error/p
Group begin: as-error/p
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (error 1 2 3)
  expected-value: (error 1 2 3)
Group end: as-error/p
Group begin: as-error/p without a failure
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (#\a)
  expected-value: (#\a)
Group end: as-error/p without a failure
Group end: as-error/p
Group begin: not/p
Group begin: not/p, success
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: not/p, success
Test begin:
  test-name: "not/p, fails"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: not/p does not advance the input
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: not/p does not advance the input
Group end: not/p
Group begin: lookahead/p
Group begin: lookahead/p, success
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: lookahead/p, success
Test begin:
  test-name: "lookahead/p, failure"
Test end:
  result-kind: pass
  actual-value: #t
Group end: lookahead/p
Group begin: many/p
Group begin: zero
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (())
  expected-value: (())
Group end: zero
Group begin: one
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a))
  expected-value: ((#\a))
Group end: one
Group begin: four
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a #\a))
  expected-value: ((#\a #\a #\a #\a))
Group end: four
Group begin: returns zero
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (())
  expected-value: (())
Group end: returns zero
Group begin: lower limit
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a))
  expected-value: ((#\a #\a))
Group end: lower limit
Group begin: beyond lower limit
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a))
  expected-value: ((#\a #\a #\a))
Group end: beyond lower limit
Group begin: below lower limit with special mark
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (t 1 2 #f (#\a) <procedure>)
  expected-value: (t 1 2 #f (#\a) <procedure>)
Group end: below lower limit with special mark
Group begin: below lower limit, reinvoke
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a #\a #\a))
  expected-value: ((#\a #\a #\a #\a #\a))
Group end: below lower limit, reinvoke
Group begin: between lower and upper limit
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a))
  expected-value: ((#\a #\a))
Group end: between lower and upper limit
Group begin: above upper limit
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a))
  expected-value: ((#\a))
Group end: above upper limit
Group begin: at upper limit
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a #\a))
  expected-value: ((#\a #\a #\a #\a))
Group end: at upper limit
Group begin: above upper limit, right next to
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a #\a))
  expected-value: ((#\a #\a #\a #\a))
Group end: above upper limit, right next to
Group begin: with separator
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\space #\a #\space #\a #\space #\a))
  expected-value: ((#\a #\space #\a #\space #\a #\space #\a))
Group end: with separator
Group begin: with separator, returns zero
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a #\a))
  expected-value: ((#\a #\a #\a #\a))
Group end: with separator, returns zero
Test begin:
  test-name: "with separator, fails at separator"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: with separator, return at separator
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a))
  expected-value: ((#\a #\a #\a))
Group end: with separator, return at separator
Group begin: with separator, reinvoke at separator
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\a #\a #\a #\a #\a))
  expected-value: ((#\a #\a #\a #\a #\a))
Group end: with separator, reinvoke at separator
Group end: many/p
Group begin: many-until/p
Group begin: simple without separator
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3 #\4))
  expected-value: ((#\1 #\2 #\3 #\4))
Group end: simple without separator
Group begin: empty
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (())
  expected-value: (())
Group end: empty
Group begin: expected-sep-or-end-error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (error 4 0 #f (#\4 #\3 #\2 #\1) <procedure>)
  expected-value: (error 4 0 #f (#\4 #\3 #\2 #\1) <procedure>)
Group end: expected-sep-or-end-error
Group begin: recover after expected-sep-or-end-error, hits end
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3 #\4 #\5))
  expected-value: ((#\1 #\2 #\3 #\4 #\5))
Group end: recover after expected-sep-or-end-error, hits end
Group begin: recover after expected-sep-or-end-error, hits EOF
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3 #\4 #\5))
  expected-value: ((#\1 #\2 #\3 #\4 #\5))
Group end: recover after expected-sep-or-end-error, hits EOF
Group begin: return after expected-sep-or-end-error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3 #\4))
  expected-value: ((#\1 #\2 #\3 #\4))
Group end: return after expected-sep-or-end-error
Group begin: too-little-error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (error 3 4 #f (#\3 #\2 #\1) <procedure>)
  expected-value: (error 3 4 #f (#\3 #\2 #\1) <procedure>)
Group end: too-little-error
Group begin: return after too-little-error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3))
  expected-value: ((#\1 #\2 #\3))
Group end: return after too-little-error
Group begin: below maximum
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2))
  expected-value: ((#\1 #\2))
Group end: below maximum
Group begin: at maximum
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3))
  expected-value: ((#\1 #\2 #\3))
Group end: at maximum
Test begin:
  test-name: "fails beyond maximum"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: expected-end-error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (e 3 0 3 (#\1 #\2 #\3))
  expected-value: (e 3 0 3 (#\1 #\2 #\3))
Group end: expected-end-error
Group begin: returns after expected-end-error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3))
  expected-value: ((#\1 #\2 #\3))
Group end: returns after expected-end-error
Group begin: with separator
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\, #\2 #\, #\3))
  expected-value: ((#\1 #\, #\2 #\, #\3))
Group end: with separator
Test begin:
  test-name: "fails if parses separator without value"
Test end:
  result-kind: pass
  actual-value: #t
Group begin: expected-after-sep-error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: (e 2 0 #f (#\2 #\, #\1) <procedure> (#\,))
  expected-value: (e 2 0 #f (#\2 #\, #\1) <procedure> (#\,))
Group end: expected-after-sep-error
Group begin: expected-after-sep-error, return
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2))
  expected-value: ((#\1 #\2))
Group end: expected-after-sep-error, return
Group begin: expected-after-sep-error, recover
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3))
  expected-value: ((#\1 #\2 #\3))
Group end: expected-after-sep-error, recover
Group end: many-until/p
Group begin: inject/p
Group begin: inject into the input stream
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Group end: inject into the input stream
Group end: inject/p
Group begin: handlers
Group begin: simple error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "continuation"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dto"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dict"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "mark"
Test end:
  result-kind: pass
  actual-value: my-error
  expected-value: my-error
Test begin:
  test-name: "arg1"
Test end:
  result-kind: pass
  actual-value: 1
  expected-value: 1
Test begin:
  test-name: "arg2"
Test end:
  result-kind: pass
  actual-value: 2
  expected-value: 2
Test begin:
  test-name: "arg3"
Test end:
  result-kind: pass
  actual-value: 3
  expected-value: 3
Group end: simple error
Group begin: recovering from a parse error
Test begin:
  test-name: "parses"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "dictionary?"
Test end:
  result-kind: pass
  actual-value: #t
Test begin:
  test-name: "returned"
Test end:
  result-kind: pass
  actual-value: ((#\1 #\2 #\3 #\4))
  expected-value: ((#\1 #\2 #\3 #\4))
Group end: recovering from a parse error
Group end: handlers
Group begin: parameters
Test begin:
  test-name: "parameterization for nesting levels"
Test end:
  result-kind: pass
  actual-value: 3
  expected-value: 3
Group end: parameters
Group begin: simple CSV example
Test begin:
  test-name: "empty"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Test begin:
  test-name: "single line"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c"))
  expected-value: (("a" "b" "c"))
Test begin:
  test-name: "empty field"
Test end:
  result-kind: pass
  actual-value: (("a" "" "b"))
  expected-value: (("a" "" "b"))
Test begin:
  test-name: "invalid text in field"
Test end:
  result-kind: pass
  actual-value: #f
  expected-value: #f
Test begin:
  test-name: "single line, terminated with CRLF"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c"))
  expected-value: (("a" "b" "c"))
Test begin:
  test-name: "two lines"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") ("d" "e" "f"))
  expected-value: (("a" "b" "c") ("d" "e" "f"))
Test begin:
  test-name: "two lines, terminated with CRLF"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") ("d" "e" "f"))
  expected-value: (("a" "b" "c") ("d" "e" "f"))
Test begin:
  test-name: "three lines, one empty"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") () ("d" "e" "f"))
  expected-value: (("a" "b" "c") () ("d" "e" "f"))
Test begin:
  test-name: "single record"
Test end:
  result-kind: pass
  actual-value: (("ababababab"))
  expected-value: (("ababababab"))
Test begin:
  test-name: "long text"
Test end:
  result-kind: pass
  actual-value: (("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
  expected-value: (("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
Test begin:
  test-name: "escaped field"
Test end:
  result-kind: pass
  actual-value: (("abcd\r\n\"efgh"))
  expected-value: (("abcd\r\n\"efgh"))
Test begin:
  test-name: "EOF in escaped field"
Test end:
  result-kind: pass
  actual-value: #f
  expected-value: #f
Test begin:
  test-name: "escaped fields"
Test end:
  result-kind: pass
  actual-value: (("this" "is" "\"escaped\"" "fields"))
  expected-value: (("this" "is" "\"escaped\"" "fields"))
Test begin:
  test-name: "multiple records with escaped fields"
Test end:
  result-kind: pass
  actual-value: (("here is an\r\nescaped field" "in the first record") ("here is \"another\""))
  expected-value: (("here is an\r\nescaped field" "in the first record") ("here is \"another\""))
Group end: simple CSV example
Group begin: simple CSV example with errors
Test begin:
  test-name: "empty"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Test begin:
  test-name: "single line"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c"))
  expected-value: (("a" "b" "c"))
Test begin:
  test-name: "empty field"
Test end:
  result-kind: pass
  actual-value: (("a" "" "b"))
  expected-value: (("a" "" "b"))
Test begin:
  test-name: "single line, terminated with CRLF"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c"))
  expected-value: (("a" "b" "c"))
Test begin:
  test-name: "two lines"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") ("d" "e" "f"))
  expected-value: (("a" "b" "c") ("d" "e" "f"))
Test begin:
  test-name: "two lines, terminated with CRLF"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") ("d" "e" "f"))
  expected-value: (("a" "b" "c") ("d" "e" "f"))
Test begin:
  test-name: "three lines, one empty"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") () ("d" "e" "f"))
  expected-value: (("a" "b" "c") () ("d" "e" "f"))
Test begin:
  test-name: "single record"
Test end:
  result-kind: pass
  actual-value: (("ababababab"))
  expected-value: (("ababababab"))
Test begin:
  test-name: "long text"
Test end:
  result-kind: pass
  actual-value: (("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
  expected-value: (("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
Test begin:
  test-name: "escaped field"
Test end:
  result-kind: pass
  actual-value: (("abcd\r\n\"efgh"))
  expected-value: (("abcd\r\n\"efgh"))
Test begin:
  test-name: "escaped fields"
Test end:
  result-kind: pass
  actual-value: (("this" "is" "\"escaped\"" "fields"))
  expected-value: (("this" "is" "\"escaped\"" "fields"))
Test begin:
  test-name: "multiple records with escaped fields"
Test end:
  result-kind: pass
  actual-value: (("here is an\r\nescaped field" "in the first record") ("here is \"another\""))
  expected-value: (("here is an\r\nescaped field" "in the first record") ("here is \"another\""))
Test begin:
  test-name: "garbage after escaped"
Test end:
  result-kind: pass
  actual-value: (("field" "my \"escaped\" field" "next field") ("other" "field"))
  expected-value: (("field" "my \"escaped\" field" "next field") ("other" "field"))
Test begin:
  test-name: "garbage after unescaped"
Test end:
  result-kind: pass
  actual-value: (#f ("but" "this" "will") ("and" "this" "one"))
  expected-value: (#f ("but" "this" "will") ("and" "this" "one"))
Test begin:
  test-name: "multiple garbage"
Test end:
  result-kind: pass
  actual-value: (#f #f ("this" "is OK"))
  expected-value: (#f #f ("this" "is OK"))
Test begin:
  test-name: "EOF in escaped"
Test end:
  result-kind: pass
  actual-value: (("a" "record" "with" #f))
  expected-value: (("a" "record" "with" #f))
Group end: simple CSV example with errors
Group begin: simple CSV example with limits
Test begin:
  test-name: "empty"
Test end:
  result-kind: pass
  actual-value: ()
  expected-value: ()
Test begin:
  test-name: "single line"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c"))
  expected-value: (("a" "b" "c"))
Test begin:
  test-name: "empty field"
Test end:
  result-kind: pass
  actual-value: (("a" "" "b"))
  expected-value: (("a" "" "b"))
Test begin:
  test-name: "single line, terminated with CRLF"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c"))
  expected-value: (("a" "b" "c"))
Test begin:
  test-name: "two lines"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") ("d" "e" "f"))
  expected-value: (("a" "b" "c") ("d" "e" "f"))
Test begin:
  test-name: "two lines, terminated with CRLF"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") ("d" "e" "f"))
  expected-value: (("a" "b" "c") ("d" "e" "f"))
Test begin:
  test-name: "three lines, one empty"
Test end:
  result-kind: pass
  actual-value: (("a" "b" "c") () ("d" "e" "f"))
  expected-value: (("a" "b" "c") () ("d" "e" "f"))
Test begin:
  test-name: "single record"
Test end:
  result-kind: pass
  actual-value: (("ababababab"))
  expected-value: (("ababababab"))
Test begin:
  test-name: "long text"
Test end:
  result-kind: pass
  actual-value: (("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
  expected-value: (("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
Test begin:
  test-name: "escaped field"
Test end:
  result-kind: pass
  actual-value: (("abcd\r\n\"efgh"))
  expected-value: (("abcd\r\n\"efgh"))
Test begin:
  test-name: "escaped fields"
Test end:
  result-kind: pass
  actual-value: (("this" "is" "\"escaped\"" "fields"))
  expected-value: (("this" "is" "\"escaped\"" "fields"))
Test begin:
  test-name: "multiple records with escaped fields"
Test end:
  result-kind: pass
  actual-value: (("here is an\r\nescaped field" "in the first record") ("here is \"another\""))
  expected-value: (("here is an\r\nescaped field" "in the first record") ("here is \"another\""))
Test begin:
  test-name: "garbage after escaped"
Test end:
  result-kind: pass
  actual-value: (("field" "my \"escaped\" field" "next field") ("other" "field"))
  expected-value: (("field" "my \"escaped\" field" "next field") ("other" "field"))
Test begin:
  test-name: "garbage after unescaped"
Test end:
  result-kind: pass
  actual-value: (#f ("but" "this" "will") ("and" "this" "one"))
  expected-value: (#f ("but" "this" "will") ("and" "this" "one"))
Test begin:
  test-name: "multiple garbage"
Test end:
  result-kind: pass
  actual-value: (#f #f ("this" "is OK"))
  expected-value: (#f #f ("this" "is OK"))
Test begin:
  test-name: "EOF in escaped"
Test end:
  result-kind: pass
  actual-value: (("a" "record" "with" #f))
  expected-value: (("a" "record" "with" #f))
Test begin:
  test-name: "field limit reached, unescaped"
Test end:
  result-kind: pass
  actual-value: unescaped-too-big
  expected-value: unescaped-too-big
Test begin:
  test-name: "field limit reached, escaped"
Test end:
  result-kind: pass
  actual-value: escaped-too-big
  expected-value: escaped-too-big
Test begin:
  test-name: "field limit not reached due to escape sequences"
Test end:
  result-kind: pass
  actual-value: (("this" "is" "mine" "\"!\"" "only"))
  expected-value: (("this" "is" "mine" "\"!\"" "only"))
Test begin:
  test-name: "record limit reached"
Test end:
  result-kind: pass
  actual-value: record-too-big
  expected-value: record-too-big
Test begin:
  test-name: "file limit reached"
Test end:
  result-kind: pass
  actual-value: file-too-big
  expected-value: file-too-big
Group end: simple CSV example with limits
Group end: phosphate
# of expected passes      330