| package toml |
| |
| import "testing" |
| |
| func testFlow(t *testing.T, input string, expectedFlow []token) { |
| _, ch := lex(input) |
| for _, expected := range expectedFlow { |
| token := <-ch |
| if token != expected { |
| t.Log("While testing: ", input) |
| t.Log("compared", token, "to", expected) |
| t.Log(token.val, "<->", expected.val) |
| t.Log(token.typ, "<->", expected.typ) |
| t.Log(token.line, "<->", expected.line) |
| t.Log(token.col, "<->", expected.col) |
| t.FailNow() |
| } |
| } |
| |
| tok, ok := <-ch |
| if ok { |
| t.Log("channel is not closed!") |
| t.Log(len(ch)+1, "tokens remaining:") |
| |
| t.Log("token ->", tok) |
| for token := range ch { |
| t.Log("token ->", token) |
| } |
| t.FailNow() |
| } |
| } |
| |
| func TestValidKeyGroup(t *testing.T) { |
| testFlow(t, "[hello world]", []token{ |
| token{tokenLeftBracket, "[", 0, 0}, |
| token{tokenKeyGroup, "hello world", 0, 1}, |
| token{tokenRightBracket, "]", 0, 12}, |
| token{tokenEOF, "", 0, 13}, |
| }) |
| } |
| |
| func TestUnclosedKeyGroup(t *testing.T) { |
| testFlow(t, "[hello world", []token{ |
| token{tokenLeftBracket, "[", 0, 0}, |
| token{tokenError, "unclosed key group", 0, 1}, |
| }) |
| } |
| |
| func TestComment(t *testing.T) { |
| testFlow(t, "# blahblah", []token{ |
| token{tokenEOF, "", 0, 10}, |
| }) |
| } |
| |
| func TestKeyGroupComment(t *testing.T) { |
| testFlow(t, "[hello world] # blahblah", []token{ |
| token{tokenLeftBracket, "[", 0, 0}, |
| token{tokenKeyGroup, "hello world", 0, 1}, |
| token{tokenRightBracket, "]", 0, 12}, |
| token{tokenEOF, "", 0, 24}, |
| }) |
| } |
| |
| func TestMultipleKeyGroupsComment(t *testing.T) { |
| testFlow(t, "[hello world] # blahblah\n[test]", []token{ |
| token{tokenLeftBracket, "[", 0, 0}, |
| token{tokenKeyGroup, "hello world", 0, 1}, |
| token{tokenRightBracket, "]", 0, 12}, |
| token{tokenLeftBracket, "[", 1, 0}, |
| token{tokenKeyGroup, "test", 1, 1}, |
| token{tokenRightBracket, "]", 1, 5}, |
| token{tokenEOF, "", 1, 6}, |
| }) |
| } |
| |
| func TestBasicKey(t *testing.T) { |
| testFlow(t, "hello", []token{ |
| token{tokenKey, "hello", 0, 0}, |
| token{tokenEOF, "", 0, 5}, |
| }) |
| } |
| |
| func TestBasicKeyWithUnderscore(t *testing.T) { |
| testFlow(t, "hello_hello", []token{ |
| token{tokenKey, "hello_hello", 0, 0}, |
| token{tokenEOF, "", 0, 11}, |
| }) |
| } |
| |
| func TestBasicKeyWithDash(t *testing.T) { |
| testFlow(t, "hello-world", []token{ |
| token{tokenKey, "hello-world", 0, 0}, |
| token{tokenEOF, "", 0, 11}, |
| }) |
| } |
| |
| func TestBasicKeyWithUppercaseMix(t *testing.T) { |
| testFlow(t, "helloHELLOHello", []token{ |
| token{tokenKey, "helloHELLOHello", 0, 0}, |
| token{tokenEOF, "", 0, 15}, |
| }) |
| } |
| |
| func TestBasicKeyWithInternationalCharacters(t *testing.T) { |
| testFlow(t, "héllÖ", []token{ |
| token{tokenKey, "héllÖ", 0, 0}, |
| token{tokenEOF, "", 0, 5}, |
| }) |
| } |
| |
| func TestBasicKeyAndEqual(t *testing.T) { |
| testFlow(t, "hello =", []token{ |
| token{tokenKey, "hello", 0, 0}, |
| token{tokenEqual, "=", 0, 6}, |
| token{tokenEOF, "", 0, 7}, |
| }) |
| } |
| |
| func TestKeyWithSharpAndEqual(t *testing.T) { |
| testFlow(t, "key#name = 5", []token{ |
| token{tokenKey, "key#name", 0, 0}, |
| token{tokenEqual, "=", 0, 9}, |
| token{tokenInteger, "5", 0, 11}, |
| token{tokenEOF, "", 0, 12}, |
| }) |
| } |
| |
| func TestKeyWithSymbolsAndEqual(t *testing.T) { |
| testFlow(t, "~!@#$^&*()_+-`1234567890[]\\|/?><.,;:' = 5", []token{ |
| token{tokenKey, "~!@#$^&*()_+-`1234567890[]\\|/?><.,;:'", 0, 0}, |
| token{tokenEqual, "=", 0, 38}, |
| token{tokenInteger, "5", 0, 40}, |
| token{tokenEOF, "", 0, 41}, |
| }) |
| } |
| |
| func TestKeyEqualStringEscape(t *testing.T) { |
| testFlow(t, `foo = "hello\""`, []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenString, "hello\"", 0, 7}, |
| token{tokenEOF, "", 0, 15}, |
| }) |
| } |
| |
| func TestKeyEqualStringUnfinished(t *testing.T) { |
| testFlow(t, `foo = "bar`, []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenError, "unclosed string", 0, 7}, |
| }) |
| } |
| |
| func TestKeyEqualString(t *testing.T) { |
| testFlow(t, `foo = "bar"`, []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenString, "bar", 0, 7}, |
| token{tokenEOF, "", 0, 11}, |
| }) |
| } |
| |
| func TestKeyEqualTrue(t *testing.T) { |
| testFlow(t, "foo = true", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenTrue, "true", 0, 6}, |
| token{tokenEOF, "", 0, 10}, |
| }) |
| } |
| |
| func TestKeyEqualFalse(t *testing.T) { |
| testFlow(t, "foo = false", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenFalse, "false", 0, 6}, |
| token{tokenEOF, "", 0, 11}, |
| }) |
| } |
| |
| func TestArrayNestedString(t *testing.T) { |
| testFlow(t, `a = [ ["hello", "world"] ]`, []token{ |
| token{tokenKey, "a", 0, 0}, |
| token{tokenEqual, "=", 0, 2}, |
| token{tokenLeftBracket, "[", 0, 4}, |
| token{tokenLeftBracket, "[", 0, 6}, |
| token{tokenString, "hello", 0, 8}, |
| token{tokenComma, ",", 0, 14}, |
| token{tokenString, "world", 0, 17}, |
| token{tokenRightBracket, "]", 0, 23}, |
| token{tokenRightBracket, "]", 0, 25}, |
| token{tokenEOF, "", 0, 26}, |
| }) |
| } |
| |
| func TestArrayNestedInts(t *testing.T) { |
| testFlow(t, "a = [ [42, 21], [10] ]", []token{ |
| token{tokenKey, "a", 0, 0}, |
| token{tokenEqual, "=", 0, 2}, |
| token{tokenLeftBracket, "[", 0, 4}, |
| token{tokenLeftBracket, "[", 0, 6}, |
| token{tokenInteger, "42", 0, 7}, |
| token{tokenComma, ",", 0, 9}, |
| token{tokenInteger, "21", 0, 11}, |
| token{tokenRightBracket, "]", 0, 13}, |
| token{tokenComma, ",", 0, 14}, |
| token{tokenLeftBracket, "[", 0, 16}, |
| token{tokenInteger, "10", 0, 17}, |
| token{tokenRightBracket, "]", 0, 19}, |
| token{tokenRightBracket, "]", 0, 21}, |
| token{tokenEOF, "", 0, 22}, |
| }) |
| } |
| |
| func TestArrayInts(t *testing.T) { |
| testFlow(t, "a = [ 42, 21, 10, ]", []token{ |
| token{tokenKey, "a", 0, 0}, |
| token{tokenEqual, "=", 0, 2}, |
| token{tokenLeftBracket, "[", 0, 4}, |
| token{tokenInteger, "42", 0, 6}, |
| token{tokenComma, ",", 0, 8}, |
| token{tokenInteger, "21", 0, 10}, |
| token{tokenComma, ",", 0, 12}, |
| token{tokenInteger, "10", 0, 14}, |
| token{tokenComma, ",", 0, 16}, |
| token{tokenRightBracket, "]", 0, 18}, |
| token{tokenEOF, "", 0, 19}, |
| }) |
| } |
| |
| func TestMultilineArrayComments(t *testing.T) { |
| testFlow(t, "a = [1, # wow\n2, # such items\n3, # so array\n]", []token{ |
| token{tokenKey, "a", 0, 0}, |
| token{tokenEqual, "=", 0, 2}, |
| token{tokenLeftBracket, "[", 0, 4}, |
| token{tokenInteger, "1", 0, 5}, |
| token{tokenComma, ",", 0, 6}, |
| token{tokenInteger, "2", 1, 0}, |
| token{tokenComma, ",", 1, 1}, |
| token{tokenInteger, "3", 2, 0}, |
| token{tokenComma, ",", 2, 1}, |
| token{tokenRightBracket, "]", 3, 0}, |
| token{tokenEOF, "", 3, 1}, |
| }) |
| } |
| |
| func TestKeyEqualArrayBools(t *testing.T) { |
| testFlow(t, "foo = [true, false, true]", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenLeftBracket, "[", 0, 6}, |
| token{tokenTrue, "true", 0, 7}, |
| token{tokenComma, ",", 0, 11}, |
| token{tokenFalse, "false", 0, 13}, |
| token{tokenComma, ",", 0, 18}, |
| token{tokenTrue, "true", 0, 20}, |
| token{tokenRightBracket, "]", 0, 24}, |
| token{tokenEOF, "", 0, 25}, |
| }) |
| } |
| |
| func TestKeyEqualArrayBoolsWithComments(t *testing.T) { |
| testFlow(t, "foo = [true, false, true] # YEAH", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenLeftBracket, "[", 0, 6}, |
| token{tokenTrue, "true", 0, 7}, |
| token{tokenComma, ",", 0, 11}, |
| token{tokenFalse, "false", 0, 13}, |
| token{tokenComma, ",", 0, 18}, |
| token{tokenTrue, "true", 0, 20}, |
| token{tokenRightBracket, "]", 0, 24}, |
| token{tokenEOF, "", 0, 32}, |
| }) |
| } |
| |
| func TestDateRegexp(t *testing.T) { |
| if dateRegexp.FindString("1979-05-27T07:32:00Z") == "" { |
| t.Fail() |
| } |
| } |
| |
| func TestKeyEqualDate(t *testing.T) { |
| testFlow(t, "foo = 1979-05-27T07:32:00Z", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenDate, "1979-05-27T07:32:00Z", 0, 6}, |
| token{tokenEOF, "", 0, 26}, |
| }) |
| } |
| |
| func TestFloatEndingWithDot(t *testing.T) { |
| testFlow(t, "foo = 42.", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenError, "float cannot end with a dot", 0, 6}, |
| }) |
| } |
| |
| func TestFloatWithTwoDots(t *testing.T) { |
| testFlow(t, "foo = 4.2.", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenError, "cannot have two dots in one float", 0, 6}, |
| }) |
| } |
| |
| func TestDoubleEqualKey(t *testing.T) { |
| testFlow(t, "foo= = 2", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 3}, |
| token{tokenError, "cannot have multiple equals for the same key", 0, 4}, |
| }) |
| } |
| |
| func TestInvalidEsquapeSequence(t *testing.T) { |
| testFlow(t, `foo = "\x"`, []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenError, "invalid escape sequence: \\x", 0, 7}, |
| }) |
| } |
| |
| func TestNestedArrays(t *testing.T) { |
| testFlow(t, "foo = [[[]]]", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenLeftBracket, "[", 0, 6}, |
| token{tokenLeftBracket, "[", 0, 7}, |
| token{tokenLeftBracket, "[", 0, 8}, |
| token{tokenRightBracket, "]", 0, 9}, |
| token{tokenRightBracket, "]", 0, 10}, |
| token{tokenRightBracket, "]", 0, 11}, |
| token{tokenEOF, "", 0, 12}, |
| }) |
| } |
| |
| func TestKeyEqualNumber(t *testing.T) { |
| testFlow(t, "foo = 42", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenInteger, "42", 0, 6}, |
| token{tokenEOF, "", 0, 8}, |
| }) |
| |
| testFlow(t, "foo = +42", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenInteger, "+42", 0, 6}, |
| token{tokenEOF, "", 0, 9}, |
| }) |
| |
| testFlow(t, "foo = -42", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenInteger, "-42", 0, 6}, |
| token{tokenEOF, "", 0, 9}, |
| }) |
| |
| testFlow(t, "foo = 4.2", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenFloat, "4.2", 0, 6}, |
| token{tokenEOF, "", 0, 9}, |
| }) |
| |
| testFlow(t, "foo = +4.2", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenFloat, "+4.2", 0, 6}, |
| token{tokenEOF, "", 0, 10}, |
| }) |
| |
| testFlow(t, "foo = -4.2", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenFloat, "-4.2", 0, 6}, |
| token{tokenEOF, "", 0, 10}, |
| }) |
| } |
| |
| func TestMultiline(t *testing.T) { |
| testFlow(t, "foo = 42\nbar=21", []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenInteger, "42", 0, 6}, |
| token{tokenKey, "bar", 1, 0}, |
| token{tokenEqual, "=", 1, 3}, |
| token{tokenInteger, "21", 1, 4}, |
| token{tokenEOF, "", 1, 6}, |
| }) |
| } |
| |
| func TestKeyEqualStringUnicodeEscape(t *testing.T) { |
| testFlow(t, `foo = "hello \u2665"`, []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenString, "hello ♥", 0, 7}, |
| token{tokenEOF, "", 0, 20}, |
| }) |
| } |
| |
| func TestUnicodeString(t *testing.T) { |
| testFlow(t, `foo = "hello ♥ world"`, []token{ |
| token{tokenKey, "foo", 0, 0}, |
| token{tokenEqual, "=", 0, 4}, |
| token{tokenString, "hello ♥ world", 0, 7}, |
| token{tokenEOF, "", 0, 21}, |
| }) |
| } |
| |
| func TestKeyGroupArray(t *testing.T) { |
| testFlow(t, "[[foo]]", []token{ |
| token{tokenDoubleLeftBracket, "[[", 0, 0}, |
| token{tokenKeyGroupArray, "foo", 0, 2}, |
| token{tokenDoubleRightBracket, "]]", 0, 5}, |
| token{tokenEOF, "", 0, 7}, |
| }) |
| } |
