Example #1
0
//================================================================================
func TestStateStack(t *testing.T) {
	ts.LogAsserts("StateStack", t, func(tt *ts.T) {
		p0 := Bind(PushStateStack(555), func(c1 interface{}) Parser {
			return Bind(PushStateStack(556), func(c2 interface{}) Parser {
				return PushStateStack(557)
			})
		})

		p2 := SeqRight(
			SeqRight(p0, Bind(AnyChar, func(x interface{}) (p Parser) {
				if u8.Sur(x.(u8.Codepoint)) == "\n" {
					return PopStateStack()
				} else {
					return Return(nil)
				}
			})),
			GetState)

		tt.AssertEqual(parseStr(p2, "\naa"),
			PState{input: "aa", pos: 1, value: []interface{}{555, 556},
				ok: true, user: []interface{}{555, 556}})
		tt.AssertEqual(parseStr(p2, "abba"),
			PState{input: "bba", pos: 1, value: []interface{}{555, 556, 557},
				ok: true, user: []interface{}{555, 556, 557}})

		p3 := SeqRight(p0, Bind(AnyChar, func(x interface{}) (p Parser) {
			if u8.Sur(x.(u8.Codepoint)) == "\n" {
				return AlterTopStateStack(777)
			} else {
				return PeekStateStack()
			}
		}))

		tt.AssertEqual(parseStr(p3, "\nbc"),
			PState{input: "bc", pos: 1, ok: true, user: []interface{}{555, 556, 777}})
		tt.AssertEqual(parseStr(p3, "abc"),
			PState{input: "bc", pos: 1, value: 557, ok: true, user: []interface{}{555, 556, 557}})

		p4 := Bind(AnyChar, func(x interface{}) (p Parser) {
			if u8.Sur(x.(u8.Codepoint)) == "\n" {
				return AlterTopStateStack(777)
			} else {
				return PeekStateStack()
			}
		})

		tt.AssertEqual(parseStr(p4, "\naa"),
			PState{input: "aa", pos: 1, error: "AlterTopStateStack doesn't handle zero-sized stacks."})
		tt.AssertEqual(parseStr(p4, "abc"),
			PState{input: "bc", pos: 1, ok: true})
	})
}
Example #2
0
//================================================================================
func TestState(t *testing.T) {
	ts.LogAsserts("State", t, func(tt *ts.T) {
		incrIfNewline := func(x interface{}) Parser {
			if x.(u8.Codepoint) == u8.Codepoint('\n') {
				return ModifyState(func(n interface{}, _ ...interface{}) interface{} {
					return n.(int) + 1
				})
			} else {
				return Return(nil)
			}
		}

		p2 := SeqRight(PutState(21),
			Bind(AnyChar, incrIfNewline))
		tt.AssertEqual(parseStr(p2, "\naa"),
			PState{input: "aa", pos: 1, value: u8.Codepoint('\n'), ok: true, user: 22})
		tt.AssertEqual(parseStr(p2, "aaa"),
			PState{input: "aa", pos: 1, value: nil, ok: true, user: 21})
		tt.AssertEqual(parseStr(p2, "aa\naa\na"),
			PState{input: "a\naa\na", pos: 1, value: nil, ok: true, user: 21})

		p1 := SeqRight(PutState(21),
			Bind(AnyChar, incrIfNewline),
			GetState)
		tt.AssertEqual(parseStr(p1, "\naa"),
			PState{input: "aa", pos: 1, value: 22, ok: true, user: 22})
		tt.AssertEqual(parseStr(p1, "aaa"),
			PState{input: "aa", pos: 1, value: 21, ok: true, user: 21})
		tt.AssertEqual(parseStr(p1, "aa\naa\na"),
			PState{input: "a\naa\na", pos: 1, value: 21, ok: true, user: 21})

		p3 := SeqRight(PutState(21),
			Bind(AnyChar, incrIfNewline),
			AnyChar)
		tt.AssertEqual(parseStr(p3, "\naa"),
			PState{input: "a", pos: 2, value: u8.Codepoint('a'), ok: true, user: 22})
		tt.AssertEqual(parseStr(p3, "aaa"),
			PState{input: "a", pos: 2, value: u8.Codepoint('a'), ok: true, user: 21})
		tt.AssertEqual(parseStr(p3, "aa\naa\na"),
			PState{input: "\naa\na", pos: 2, value: u8.Codepoint('a'), ok: true, user: 21})
		tt.AssertEqual(parseStr(p3, "a\naa\na"),
			PState{input: "aa\na", pos: 2, value: u8.Codepoint('\n'), ok: true, user: 21})
	})
}
Example #3
0
//================================================================================
func TestAssertSkeletons(t *testing.T) {
	ts.LogAsserts("AssertSkeletons", t, func(tt *ts.T) {

		tt.Assert(true)
		tt.AssertEqual(1, 1)
		tt.AssertEqualN('a', 'a', 123)
		//tt.PrintValue("abcdefg")
		tt.AssertPanic(func() {
			if true {
				panic("X")
			}
		}, "X")
		tt.AssertAnyPanic(func() {
			if true {
				panic("X")
			}
		})
	})
}
Example #4
0
//================================================================================
func TestInputAndPosition(t *testing.T) {
	ts.LogAsserts("InputAndPosition", t, func(tt *ts.T) {
		letter := Regexp(`\pL`)
		p1 := Flatten(letter, letter, letter)

		tt.AssertEqual(parseStr(SeqRight(SetInput(u8.Desur("Hi!")), GetInput), "abcdefg"),
			PState{input: "Hi!", pos: 0, value: u8.Desur("Hi!"), empty: true, ok: true})
		tt.AssertEqual(parseStr(SeqRight(letter, GetInput), "abcdefg"),
			PState{input: "bcdefg", pos: 1, value: u8.Desur("bcdefg"), ok: true})

		tt.AssertEqual(parseStr(SeqRight(SetPosition(100), GetPosition), "abcdefg"),
			PState{input: "abcdefg", pos: 100, value: uint64(100), empty: true, ok: true})

		tt.AssertEqual(parseStr(SeqRight(SetInputAndPosition(InputAndPosition{u8.Desur("Hi there!"), 5}), GetInputAndPosition), "abcdefg"),
			PState{input: "Hi there!", pos: 5, value: InputAndPosition{u8.Desur("Hi there!"), 5}, empty: true, ok: true})

		tt.AssertEqual(parseStr(Collect(p1, SeqRight(SetInput(u8.Desur("XYZ")), p1)), "ABCDEFG"),
			PState{input: "", pos: 6, value: arrText("ABC", "XYZ"), ok: true}) //TODO: what should pos be?
		tt.AssertEqual(parseStr(Collect(p1, SeqRight(SetInput(u8.Desur("XYZ")), p1)), "ABC"),
			PState{input: "", pos: 6, value: arrText("ABC", "XYZ"), ok: true}) //TODO: ditto

		tt.AssertEqual(parseStr(Collect(p1), "ABC"),
			PState{input: "", pos: 3, value: arrText("ABC"), ok: true})

		p2 := SeqRight(Skip(SetInput(u8.Text("XY0")), SetPosition(0)), p1)
		tt.AssertEqual(parseStr(Collect(p1, p2), "ABC"),
			PState{input: "0", pos: 2, value: nil, error: makeUnexpInp("0")})

		p3 := SeqRight(Skip(SetInput(u8.Text("WXYZ")), SetPosition(0)), GetPosition)
		tt.AssertEqual(parseStr(SeqRight(p1, p3), "ABC"),
			PState{input: "WXYZ", pos: 0, value: uint64(0), ok: true})

		p4 := SeqRight(SetInput(u8.Text("XYZ")), GetInput)
		tt.AssertEqual(parseStr(SeqRight(p1, p4), "ABC"),
			PState{input: "XYZ", pos: 3, value: u8.Text("XYZ"), ok: true})

		tt.AssertEqual(parseStr(Collect(p1, SeqRight(SetInputAndPosition(InputAndPosition{u8.Desur("XYZ"), 2}), p1)), "ABCDEFG"), //posn changed from 3 to 2...
			PState{input: "", pos: 5, value: arrText("ABC", "XYZ"), ok: true}) //...so posn is 5 instead of 6

	})
}
Example #5
0
//================================================================================
func TestAssert(t *testing.T) {
	ts.LogAsserts("Assert", t, func(tt *ts.T) {

		a := &A{make([]interface{}, 0, 10)}
		tt.Assert(len(a.slice) == 0) //(1)
		b := a.lengthenByOne()

		//tt.PrintValue(1234567890) //print test

		tt.Assert(len(b.slice) == 1) //(2)
		tt.Assert(len(a.slice) == 1) //(3)

		a.slice = a.slice[:3]
		tt.Assert(len(a.slice) == 3) //(4)
		tt.Assert(len(b.slice) == 3) //(5)

		c := a.lengthenByOne()
		tt.Assert(len(a.slice) == 4) //(6)
		tt.Assert(len(b.slice) == 4) //(7)
		tt.Assert(len(c.slice) == 4) //(8)

		tt.AssertPanic(func() {
			if len(c.slice) == 4 {
				panic("X")
			} //(9)
		}, "X")

		tt.AssertAnyPanic(func() {
			if len(c.slice) == 4 {
				panic("X")
			} //(10)
		})

		/*tt.AssertPanic(func(){
		  if len(c.slice) == 4 { panic("X") } //(11)
		}, "Y")*/

		//tt.Assert(false) //(12) force failure
	})
}
Example #6
0
//================================================================================
func TestStateStruct(t *testing.T) {
	ts.LogAsserts("StateStruct", t, func(tt *ts.T) {

		type UserState struct {
			nlfound bool
			imports map[string]string
		}

		newUserState := UserState{
			nlfound: true,
			imports: map[string]string{},
		}

		tt.AssertEqual(parseStr(PutState(newUserState), ""),
			PState{ok: true, empty: true, user: UserState{nlfound: true, imports: map[string]string{}}})

		unsetNlFound := func(u UserState) UserState {
			u.nlfound = false
			m := make(map[string]string)
			for a, b := range u.imports {
				m[a] = b
			}
			u.imports = m
			return u
		}

		modifyUserStateP := func(f func(UserState) UserState) Parser {
			return Bind(GetState, func(s interface{}) Parser {
				r := f(s.(UserState))
				return SeqRight(PutState(r), Return(nil))
			})
		}

		tt.AssertEqual(parseStr(SeqRight(PutState(newUserState), modifyUserStateP(unsetNlFound)), ""),
			PState{ok: true, empty: true, user: UserState{imports: map[string]string{}}})

	})
}
Example #7
0
//================================================================================
func TestStateMap(t *testing.T) {
	ts.LogAsserts("StateMap", t, func(tt *ts.T) {
		init := PutStateMapEntry("counter", 123)

		//--------------------------------------------------------------------------------
		getB := func(x interface{}) Parser {
			if x.(u8.Codepoint) == u8.Codepoint('\n') {
				return GetStateMapEntry("counter")
			} else {
				return Return(nil)
			}
		}

		p1 := SeqRight(init, Bind(AnyChar, getB))
		tt.AssertEqual(parseStr(p1, "\nbc"),
			PState{input: "bc", pos: 1, value: 123, ok: true, user: map[string]interface{}{"counter": 123}})
		tt.AssertEqual(parseStr(p1, "abc"),
			PState{input: "bc", pos: 1, value: nil, ok: true, user: map[string]interface{}{"counter": 123}})

		//--------------------------------------------------------------------------------
		solePutB := func(x interface{}) (p Parser) {
			if x.(u8.Codepoint) == u8.Codepoint('\n') {
				return Return(nil)
			} else {
				return PutStateMapEntry("counter", 777)
			}
		}

		p2 := SeqRight(init, Bind(AnyChar, solePutB))
		tt.AssertEqual(parseStr(p2, "\nbc"),
			PState{input: "bc", pos: 1, value: nil, ok: true, user: map[string]interface{}{"counter": 123}})
		tt.AssertEqual(parseStr(p2, "abc"),
			PState{input: "bc", pos: 1, value: map[string]interface{}{"counter": 123}, ok: true, user: map[string]interface{}{"counter": 777}})

		//--------------------------------------------------------------------------------
		putB := func(x interface{}) (p Parser) {
			if x.(u8.Codepoint) == u8.Codepoint('\n') {
				return GetStateMapEntry("counter")
			} else {
				return Bind(PutStateMapEntry("counter", 777), func(_ interface{}) Parser { return GetStateMapEntry("counter") })
			}
		}

		p3 := SeqRight(init, Bind(AnyChar, putB))
		tt.AssertEqual(parseStr(p3, "\nbc"),
			PState{input: "bc", pos: 1, value: 123, ok: true, user: map[string]interface{}{"counter": 123}})
		tt.AssertEqual(parseStr(p3, "abc"),
			PState{input: "bc", pos: 1, value: 777, ok: true, user: map[string]interface{}{"counter": 777}})

		p4 := Bind(AnyChar, putB)
		tt.AssertEqual(parseStr(p4, "\nbc"),
			PState{input: "bc", pos: 1, value: nil, ok: true})
		tt.AssertEqual(parseStr(p4, "abc"),
			PState{input: "bc", pos: 1, value: 777, ok: true, user: map[string]interface{}{"counter": 777}})

		p5 := SeqRight(Return(nil), Bind(AnyChar, putB))
		tt.AssertEqual(parseStr(p5, "\nbc"),
			PState{input: "bc", pos: 1, value: nil, ok: true})
		tt.AssertEqual(parseStr(p5, "abc"),
			PState{input: "bc", pos: 1, value: 777, ok: true, user: map[string]interface{}{"counter": 777}})

		//--------------------------------------------------------------------------------
		soleIncrIfNewline := func(x interface{}) Parser {
			if x.(u8.Codepoint) == u8.Codepoint('\n') {
				return ModifyStateMapEntry("counter", func(n interface{}, _ ...interface{}) interface{} {
					return n.(int) + 1
				})
			} else {
				return Return(nil)
			}
		}

		p20 := SeqRight(init, Bind(AnyChar, soleIncrIfNewline))
		tt.AssertEqual(parseStr(p20, "\nbc"),
			PState{input: "bc", pos: 1, value: map[string]interface{}{"counter": 123}, ok: true, user: map[string]interface{}{"counter": 124}})
		tt.AssertEqual(parseStr(p20, "abc"),
			PState{input: "bc", pos: 1, value: nil, ok: true, user: map[string]interface{}{"counter": 123}})

		//--------------------------------------------------------------------------------
		incrIfNewline := func(x interface{}) Parser {
			if x.(u8.Codepoint) == u8.Codepoint('\n') {
				return Bind(ModifyStateMapEntry("counter", func(n interface{}, _ ...interface{}) interface{} {
					return n.(int) + 1
				}),
					func(_ interface{}) Parser { return GetStateMapEntry("counter") })
			} else {
				return GetStateMapEntry("counter")
			}
		}

		p21 := SeqRight(init, Bind(AnyChar, incrIfNewline))
		tt.AssertEqual(parseStr(p21, "\nbc"),
			PState{input: "bc", pos: 1, value: 124, ok: true, user: map[string]interface{}{"counter": 124}})
		tt.AssertEqual(parseStr(p21, "abc"),
			PState{input: "bc", pos: 1, value: 123, ok: true, user: map[string]interface{}{"counter": 123}})
	})
}
Example #8
0
//================================================================================
func TestLexer(t *testing.T) {
	ts.LogAsserts("Lexer", t, func(tt *ts.T) {
		u := NewUnicodeLexer()

		tt.AssertEqual(parseStr(u.Letter(), "defg"),
			PState{input: "efg", pos: 1, value: u8.Text("d"), ok: true})
		tt.AssertEqual(parseStr(u.Letter(), ";efg"),
			PState{input: ";efg", empty: true, error: makeUnexpInp(";")})

		tt.AssertEqual(parseStr(u.Lower(), "defg"),
			PState{input: "efg", pos: 1, value: u8.Text("d"), ok: true})
		tt.AssertEqual(parseStr(u.Lower(), "Defg"),
			PState{input: "Defg", empty: true, error: makeUnexpInp("D")})
		tt.AssertEqual(parseStr(u.Lower(), ";efg"),
			PState{input: ";efg", empty: true, error: makeUnexpInp(";")})

		tt.AssertEqual(parseStr(u.Upper(), "Defg"),
			PState{input: "efg", pos: 1, value: u8.Text("D"), ok: true})
		tt.AssertEqual(parseStr(u.Upper(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})
		tt.AssertEqual(parseStr(u.Upper(), ";efg"),
			PState{input: ";efg", empty: true, error: makeUnexpInp(";")})

		tt.AssertEqual(parseStr(u.Digit(), "6efg"),
			PState{input: "efg", pos: 1, value: u8.Text("6"), ok: true})
		tt.AssertEqual(parseStr(u.Digit(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})

		tt.AssertEqual(parseStr(u.Whitespace(), " efg"),
			PState{input: "efg", pos: 1, value: u8.Codepoint(' '), ok: true})
		tt.AssertEqual(parseStr(u.Whitespace(), "\tefg"),
			PState{input: "efg", pos: 1, value: u8.Codepoint('\t'), ok: true})
		tt.AssertEqual(parseStr(u.Whitespace(), "\refg"),
			PState{input: "efg", pos: 1, value: u8.Codepoint('\r'), ok: true})
		tt.AssertEqual(parseStr(u.Whitespace(), "\nefg"),
			PState{input: "efg", pos: 1, value: u8.Codepoint('\n'), ok: true})
		tt.AssertEqual(parseStr(u.Whitespace(), "\fefg"),
			PState{input: "efg", pos: 1, value: u8.Codepoint('\f'), ok: true})
		tt.AssertEqual(parseStr(u.Whitespace(), "\vefg"),
			PState{input: "efg", pos: 1, value: u8.Codepoint('\v'), ok: true})
		tt.AssertEqual(parseStr(u.Whitespace(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})

		tt.AssertEqual(parseStr(u.Space(), " efg"),
			PState{input: "efg", pos: 1, value: u8.Text(" "), ok: true})
		tt.AssertEqual(parseStr(u.Space(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})

		// TitlecaseLetter() Parser{  return Regexp(`\p{Lt}`)
		// ModifyingLetter() Parser{  return Regexp(`\p{Lm}`)
		// OtherLetter() Parser{  return Regexp(`\p{Lo}`)
		// Number() Parser{  return Regexp(`\pN`)
		// LetterNumber() Parser{  return Regexp(`\p{Nl}`)
		// OtherNumber() Parser{  return Regexp(`\p{No}`)
		// Mark() Parser{  return Regexp(`\pM`)
		// SpacingMark() Parser{  return Regexp(`\p{Mc}`)
		// EnclosingMark() Parser{  return Regexp(`\p{Me}`)
		// NonspacingMark() Parser{  return Regexp(`\p{Mn}`)
		// Punct() Parser{  return Regexp(`\pP`)
		// StartPunct() Parser{  return Regexp(`\p{Ps}`)
		// EndPunct() Parser{  return Regexp(`\p{Pe}`)
		// InitialPunct() Parser{  return Regexp(`\p{Pi}`)
		// FinalPunct() Parser{  return Regexp(`\p{Pf}`)
		// ConnectorPunct() Parser{  return Regexp(`\p{Pc}`)
		// DashPunct() Parser{  return Regexp(`\p{Pd}`)
		// OtherPunct() Parser{  return Regexp(`\p{Po}`)
		// Symbol() Parser{  return Regexp(`\pS`)
		// CurrencySymbol() Parser{  return Regexp(`\p{Sc}`)
		// MathSymbol() Parser{  return Regexp(`\p{Sm}`)
		// ModifierSymbol() Parser{  return Regexp(`\p{Sk}`)
		// OtherSymbol() Parser{  return Regexp(`\p{So}`)
		// Spacing() Parser{  return Regexp(`\pZ`)
		// LineSeparator() Parser{  return Regexp(`\p{Zl}`)
		// ParagraphSeparator() Parser{  return Regexp(`\p{Zp}`)
		// OtherCategory() Parser{  return Regexp(`\pC`)
		// Control() Parser{  return Regexp(`\p{Cc}`)
		// Format() Parser{  return Regexp(`\p{Cf}`)
		// PrivateUse() Parser{  return Regexp(`\p{Co}`)
		// Nonchar() Parser{  return Regexp(`\p{Cn}`)
		// Surrogate() Parser{  return Regexp(`\p{Cs}`)
		// Graphical() Parser{    return len(cc) == 1 && unicode.IsGraphic(cc[0])
		// Printable() Parser{    return len(cc) == 1 && unicode.IsPrint(cc[0])
		// SpecialControl() Parser{    return len(cc) == 1 && unicode.IsControl(cc[0])
		// CommonScript() Parser{    return len(cc) == 1 && unicode.In(cc[0], unicode.Common)
		// InheritedScript() Parser{    return len(cc) == 1 && unicode.In(cc[0], unicode.Inherited)
		// UnicodeIn(ranges ...*unicode.RangeTable) Parser {    return len(cc) == 1 && unicode.In(cc[0], ranges...)
	})
}
Example #9
0
//================================================================================
func TestAsciiLexer(t *testing.T) {
	ts.LogAsserts("AsciiLexer", t, func(tt *ts.T) {
		a := NewAsciiLexer(false)
		at := NewAsciiLexer(true)

		tt.AssertEqual(parseStr(a.Letter(), "defg"),
			PState{input: "efg", pos: 1, value: u8.Text("d"), ok: true})
		tt.AssertEqual(parseStr(a.Letter(), ";efg"),
			PState{input: ";efg", empty: true, error: makeUnexpInp(";")})

		tt.AssertEqual(parseStr(a.Lower(), "defg"),
			PState{input: "efg", pos: 1, value: u8.Text("d"), ok: true})
		tt.AssertEqual(parseStr(a.Lower(), "Defg"),
			PState{input: "Defg", empty: true, error: makeUnexpInp("D")})
		tt.AssertEqual(parseStr(a.Lower(), ";efg"),
			PState{input: ";efg", empty: true, error: makeUnexpInp(";")})

		tt.AssertEqual(parseStr(a.Upper(), "Defg"),
			PState{input: "efg", pos: 1, value: u8.Text("D"), ok: true})
		tt.AssertEqual(parseStr(a.Upper(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})
		tt.AssertEqual(parseStr(a.Upper(), ";efg"),
			PState{input: ";efg", empty: true, error: makeUnexpInp(";")})

		tt.AssertEqual(parseStr(a.Digit(), "6efg"),
			PState{input: "efg", pos: 1, value: u8.Text("6"), ok: true})
		tt.AssertEqual(parseStr(a.Digit(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})

		tt.AssertEqual(parseStr(a.Space(), " efg"),
			PState{input: "efg", pos: 1, value: u8.Text(" "), ok: true})
		tt.AssertEqual(parseStr(a.Space(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})

		tt.AssertEqual(parseStr(a.Tab(), "\tefg"),
			PState{input: "efg", pos: 1, value: u8.Text("\t"), ok: true})
		tt.AssertEqual(parseStr(a.Tab(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})

		tt.AssertEqual(parseStr(a.Newline(),
			"\nefg"), PState{input: "efg", pos: 1, value: u8.Text("\n"), ok: true})
		tt.AssertEqual(parseStr(a.Newline(),
			"\r\nefg"), PState{input: "\r\nefg", empty: true, error: makeUnexpInp("\r")})

		tt.AssertEqual(parseStr(at.Newline(),
			"\nefg"), PState{input: "efg", pos: 1, value: u8.Text("\n"), ok: true})
		tt.AssertEqual(parseStr(at.Newline(),
			"\r\nefg"), PState{input: "efg", pos: 2, value: u8.Text("\r\n"), ok: true})

		tt.AssertEqual(parseStr(a.Whitespace(), " efg"),
			PState{input: "efg", pos: 1, value: u8.Text(" "), ok: true})
		tt.AssertEqual(parseStr(a.Whitespace(), "\tefg"),
			PState{input: "efg", pos: 1, value: u8.Text("\t"), ok: true})
		tt.AssertEqual(parseStr(a.Whitespace(), "\refg"),
			PState{input: "efg", pos: 1, value: u8.Text("\r"), ok: true})
		tt.AssertEqual(parseStr(a.Whitespace(), "\nefg"),
			PState{input: "efg", pos: 1, value: u8.Text("\n"), ok: true})
		tt.AssertEqual(parseStr(a.Whitespace(), "\fefg"),
			PState{input: "efg", pos: 1, value: u8.Text("\f"), ok: true})
		tt.AssertEqual(parseStr(a.Whitespace(), "\vefg"),
			PState{input: "efg", pos: 1, value: u8.Text("\v"), ok: true})
		tt.AssertEqual(parseStr(a.Whitespace(), "defg"),
			PState{input: "defg", empty: true, error: makeUnexpInp("d")})

		// Punct() Parser{  return Regexp(`[!"#%&'()*,\-./:;[email protected][\\\]_{}]`)
		// StartPunct() Parser{  return Regexp(`[([{]`)
		// EndPunct() Parser{  return Regexp(`[)\]}]`)
		// ConnectorPunct() Parser{  return Regexp(`_`)
		// DashPunct() Parser{  return Regexp(`-`)
		// OtherPunct() Parser{  return Regexp(`[!"#%&'*,./:;[email protected]\\]`)
		// Symbol() Parser{  return Regexp(`[$+<=>^`+"`"+`|~]`)
		// CurrencySymbol() Parser{  return Regexp(`$`)
		// MathSymbol() Parser{  return Regexp(`[+<=>|~]`)
		// ModifierSymbol() Parser{  return Regexp(`[^`+"`"+`]`)
		// Control() Parser{  return Regexp(`[\x00-\x1F\x7F]`) //[:cntrl:]
		// Graphical() Parser{  return Regexp(`[\x21-\x7E]`) //[:graph:]
		// Printable() Parser{  return Regexp(`[\x20-\x7E]`) //[:print:]
	})
}