Thomas Pelletier
405d48dc28
* Port toml-test to pure Go This change basically ports the toml-test examples test suite to pure Go. This removes the snowflake test.sh required to run such tests, and allows us to the example tests on any platform (which includes Windows as part of the pull-request testing). * Allow CircleCI failure for go tip
944 lines
22 KiB
Go
944 lines
22 KiB
Go
// Generated by tomltestgen for toml-test ref 39e37e6 on 2019-03-19T23:58:45-07:00
|
|
package toml
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
func TestInvalidArrayMixedTypesArraysAndInts(t *testing.T) {
|
|
input := `arrays-and-ints = [1, ["Arrays are not integers."]]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidArrayMixedTypesIntsAndFloats(t *testing.T) {
|
|
input := `ints-and-floats = [1, 1.1]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidArrayMixedTypesStringsAndInts(t *testing.T) {
|
|
input := `strings-and-ints = ["hi", 42]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidDatetimeMalformedNoLeads(t *testing.T) {
|
|
input := `no-leads = 1987-7-05T17:45:00Z`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidDatetimeMalformedNoSecs(t *testing.T) {
|
|
input := `no-secs = 1987-07-05T17:45Z`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidDatetimeMalformedNoT(t *testing.T) {
|
|
input := `no-t = 1987-07-0517:45:00Z`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidDatetimeMalformedWithMilli(t *testing.T) {
|
|
input := `with-milli = 1987-07-5T17:45:00.12Z`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidDuplicateKeyTable(t *testing.T) {
|
|
input := `[fruit]
|
|
type = "apple"
|
|
|
|
[fruit.type]
|
|
apple = "yes"`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidDuplicateKeys(t *testing.T) {
|
|
input := `dupe = false
|
|
dupe = true`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidDuplicateTables(t *testing.T) {
|
|
input := `[a]
|
|
[a]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidEmptyImplicitTable(t *testing.T) {
|
|
input := `[naughty..naughty]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidEmptyTable(t *testing.T) {
|
|
input := `[]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidFloatNoLeadingZero(t *testing.T) {
|
|
input := `answer = .12345
|
|
neganswer = -.12345`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidFloatNoTrailingDigits(t *testing.T) {
|
|
input := `answer = 1.
|
|
neganswer = -1.`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeyEmpty(t *testing.T) {
|
|
input := ` = 1`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeyHash(t *testing.T) {
|
|
input := `a# = 1`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeyNewline(t *testing.T) {
|
|
input := `a
|
|
= 1`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeyOpenBracket(t *testing.T) {
|
|
input := `[abc = 1`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeySingleOpenBracket(t *testing.T) {
|
|
input := `[`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeySpace(t *testing.T) {
|
|
input := `a b = 1`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeyStartBracket(t *testing.T) {
|
|
input := `[a]
|
|
[xyz = 5
|
|
[b]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidKeyTwoEquals(t *testing.T) {
|
|
input := `key= = 1`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidStringBadByteEscape(t *testing.T) {
|
|
input := `naughty = "\xAg"`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidStringBadEscape(t *testing.T) {
|
|
input := `invalid-escape = "This string has a bad \a escape character."`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidStringByteEscapes(t *testing.T) {
|
|
input := `answer = "\x33"`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidStringNoClose(t *testing.T) {
|
|
input := `no-ending-quote = "One time, at band camp`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableArrayImplicit(t *testing.T) {
|
|
input := "# This test is a bit tricky. It should fail because the first use of\n" +
|
|
"# `[[albums.songs]]` without first declaring `albums` implies that `albums`\n" +
|
|
"# must be a table. The alternative would be quite weird. Namely, it wouldn't\n" +
|
|
"# comply with the TOML spec: \"Each double-bracketed sub-table will belong to \n" +
|
|
"# the most *recently* defined table element *above* it.\"\n" +
|
|
"#\n" +
|
|
"# This is in contrast to the *valid* test, table-array-implicit where\n" +
|
|
"# `[[albums.songs]]` works by itself, so long as `[[albums]]` isn't declared\n" +
|
|
"# later. (Although, `[albums]` could be.)\n" +
|
|
"[[albums.songs]]\n" +
|
|
"name = \"Glory Days\"\n" +
|
|
"\n" +
|
|
"[[albums]]\n" +
|
|
"name = \"Born in the USA\"\n"
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableArrayMalformedBracket(t *testing.T) {
|
|
input := `[[albums]
|
|
name = "Born to Run"`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableArrayMalformedEmpty(t *testing.T) {
|
|
input := `[[]]
|
|
name = "Born to Run"`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableEmpty(t *testing.T) {
|
|
input := `[]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableNestedBracketsClose(t *testing.T) {
|
|
input := `[a]b]
|
|
zyx = 42`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableNestedBracketsOpen(t *testing.T) {
|
|
input := `[a[b]
|
|
zyx = 42`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableWhitespace(t *testing.T) {
|
|
input := `[invalid key]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTableWithPound(t *testing.T) {
|
|
input := `[key#group]
|
|
answer = 42`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTextAfterArrayEntries(t *testing.T) {
|
|
input := `array = [
|
|
"Is there life after an array separator?", No
|
|
"Entry"
|
|
]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTextAfterInteger(t *testing.T) {
|
|
input := `answer = 42 the ultimate answer?`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTextAfterString(t *testing.T) {
|
|
input := `string = "Is there life after strings?" No.`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTextAfterTable(t *testing.T) {
|
|
input := `[error] this shouldn't be here`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTextBeforeArraySeparator(t *testing.T) {
|
|
input := `array = [
|
|
"Is there life before an array separator?" No,
|
|
"Entry"
|
|
]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestInvalidTextInArray(t *testing.T) {
|
|
input := `array = [
|
|
"Entry 1",
|
|
I don't belong,
|
|
"Entry 2",
|
|
]`
|
|
testgenInvalid(t, input)
|
|
}
|
|
|
|
func TestValidArrayEmpty(t *testing.T) {
|
|
input := `thevoid = [[[[[]]]]]`
|
|
jsonRef := `{
|
|
"thevoid": { "type": "array", "value": [
|
|
{"type": "array", "value": [
|
|
{"type": "array", "value": [
|
|
{"type": "array", "value": [
|
|
{"type": "array", "value": []}
|
|
]}
|
|
]}
|
|
]}
|
|
]}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidArrayNospaces(t *testing.T) {
|
|
input := `ints = [1,2,3]`
|
|
jsonRef := `{
|
|
"ints": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "integer", "value": "1"},
|
|
{"type": "integer", "value": "2"},
|
|
{"type": "integer", "value": "3"}
|
|
]
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidArraysHetergeneous(t *testing.T) {
|
|
input := `mixed = [[1, 2], ["a", "b"], [1.1, 2.1]]`
|
|
jsonRef := `{
|
|
"mixed": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "array", "value": [
|
|
{"type": "integer", "value": "1"},
|
|
{"type": "integer", "value": "2"}
|
|
]},
|
|
{"type": "array", "value": [
|
|
{"type": "string", "value": "a"},
|
|
{"type": "string", "value": "b"}
|
|
]},
|
|
{"type": "array", "value": [
|
|
{"type": "float", "value": "1.1"},
|
|
{"type": "float", "value": "2.1"}
|
|
]}
|
|
]
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidArraysNested(t *testing.T) {
|
|
input := `nest = [["a"], ["b"]]`
|
|
jsonRef := `{
|
|
"nest": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "array", "value": [
|
|
{"type": "string", "value": "a"}
|
|
]},
|
|
{"type": "array", "value": [
|
|
{"type": "string", "value": "b"}
|
|
]}
|
|
]
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidArrays(t *testing.T) {
|
|
input := `ints = [1, 2, 3]
|
|
floats = [1.1, 2.1, 3.1]
|
|
strings = ["a", "b", "c"]
|
|
dates = [
|
|
1987-07-05T17:45:00Z,
|
|
1979-05-27T07:32:00Z,
|
|
2006-06-01T11:00:00Z,
|
|
]`
|
|
jsonRef := `{
|
|
"ints": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "integer", "value": "1"},
|
|
{"type": "integer", "value": "2"},
|
|
{"type": "integer", "value": "3"}
|
|
]
|
|
},
|
|
"floats": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "float", "value": "1.1"},
|
|
{"type": "float", "value": "2.1"},
|
|
{"type": "float", "value": "3.1"}
|
|
]
|
|
},
|
|
"strings": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "string", "value": "a"},
|
|
{"type": "string", "value": "b"},
|
|
{"type": "string", "value": "c"}
|
|
]
|
|
},
|
|
"dates": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "datetime", "value": "1987-07-05T17:45:00Z"},
|
|
{"type": "datetime", "value": "1979-05-27T07:32:00Z"},
|
|
{"type": "datetime", "value": "2006-06-01T11:00:00Z"}
|
|
]
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidBool(t *testing.T) {
|
|
input := `t = true
|
|
f = false`
|
|
jsonRef := `{
|
|
"f": {"type": "bool", "value": "false"},
|
|
"t": {"type": "bool", "value": "true"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidCommentsEverywhere(t *testing.T) {
|
|
input := `# Top comment.
|
|
# Top comment.
|
|
# Top comment.
|
|
|
|
# [no-extraneous-groups-please]
|
|
|
|
[group] # Comment
|
|
answer = 42 # Comment
|
|
# no-extraneous-keys-please = 999
|
|
# Inbetween comment.
|
|
more = [ # Comment
|
|
# What about multiple # comments?
|
|
# Can you handle it?
|
|
#
|
|
# Evil.
|
|
# Evil.
|
|
42, 42, # Comments within arrays are fun.
|
|
# What about multiple # comments?
|
|
# Can you handle it?
|
|
#
|
|
# Evil.
|
|
# Evil.
|
|
# ] Did I fool you?
|
|
] # Hopefully not.`
|
|
jsonRef := `{
|
|
"group": {
|
|
"answer": {"type": "integer", "value": "42"},
|
|
"more": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "integer", "value": "42"},
|
|
{"type": "integer", "value": "42"}
|
|
]
|
|
}
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidDatetime(t *testing.T) {
|
|
input := `bestdayever = 1987-07-05T17:45:00Z`
|
|
jsonRef := `{
|
|
"bestdayever": {"type": "datetime", "value": "1987-07-05T17:45:00Z"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidEmpty(t *testing.T) {
|
|
input := ``
|
|
jsonRef := `{}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidExample(t *testing.T) {
|
|
input := `best-day-ever = 1987-07-05T17:45:00Z
|
|
|
|
[numtheory]
|
|
boring = false
|
|
perfection = [6, 28, 496]`
|
|
jsonRef := `{
|
|
"best-day-ever": {"type": "datetime", "value": "1987-07-05T17:45:00Z"},
|
|
"numtheory": {
|
|
"boring": {"type": "bool", "value": "false"},
|
|
"perfection": {
|
|
"type": "array",
|
|
"value": [
|
|
{"type": "integer", "value": "6"},
|
|
{"type": "integer", "value": "28"},
|
|
{"type": "integer", "value": "496"}
|
|
]
|
|
}
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidFloat(t *testing.T) {
|
|
input := `pi = 3.14
|
|
negpi = -3.14`
|
|
jsonRef := `{
|
|
"pi": {"type": "float", "value": "3.14"},
|
|
"negpi": {"type": "float", "value": "-3.14"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidImplicitAndExplicitAfter(t *testing.T) {
|
|
input := `[a.b.c]
|
|
answer = 42
|
|
|
|
[a]
|
|
better = 43`
|
|
jsonRef := `{
|
|
"a": {
|
|
"better": {"type": "integer", "value": "43"},
|
|
"b": {
|
|
"c": {
|
|
"answer": {"type": "integer", "value": "42"}
|
|
}
|
|
}
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidImplicitAndExplicitBefore(t *testing.T) {
|
|
input := `[a]
|
|
better = 43
|
|
|
|
[a.b.c]
|
|
answer = 42`
|
|
jsonRef := `{
|
|
"a": {
|
|
"better": {"type": "integer", "value": "43"},
|
|
"b": {
|
|
"c": {
|
|
"answer": {"type": "integer", "value": "42"}
|
|
}
|
|
}
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidImplicitGroups(t *testing.T) {
|
|
input := `[a.b.c]
|
|
answer = 42`
|
|
jsonRef := `{
|
|
"a": {
|
|
"b": {
|
|
"c": {
|
|
"answer": {"type": "integer", "value": "42"}
|
|
}
|
|
}
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidInteger(t *testing.T) {
|
|
input := `answer = 42
|
|
neganswer = -42`
|
|
jsonRef := `{
|
|
"answer": {"type": "integer", "value": "42"},
|
|
"neganswer": {"type": "integer", "value": "-42"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidKeyEqualsNospace(t *testing.T) {
|
|
input := `answer=42`
|
|
jsonRef := `{
|
|
"answer": {"type": "integer", "value": "42"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidKeySpace(t *testing.T) {
|
|
input := `"a b" = 1`
|
|
jsonRef := `{
|
|
"a b": {"type": "integer", "value": "1"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidKeySpecialChars(t *testing.T) {
|
|
input := "\"~!@$^&*()_+-`1234567890[]|/?><.,;:'\" = 1\n"
|
|
jsonRef := "{\n" +
|
|
" \"~!@$^&*()_+-`1234567890[]|/?><.,;:'\": {\n" +
|
|
" \"type\": \"integer\", \"value\": \"1\"\n" +
|
|
" }\n" +
|
|
"}\n"
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidLongFloat(t *testing.T) {
|
|
input := `longpi = 3.141592653589793
|
|
neglongpi = -3.141592653589793`
|
|
jsonRef := `{
|
|
"longpi": {"type": "float", "value": "3.141592653589793"},
|
|
"neglongpi": {"type": "float", "value": "-3.141592653589793"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidLongInteger(t *testing.T) {
|
|
input := `answer = 9223372036854775807
|
|
neganswer = -9223372036854775808`
|
|
jsonRef := `{
|
|
"answer": {"type": "integer", "value": "9223372036854775807"},
|
|
"neganswer": {"type": "integer", "value": "-9223372036854775808"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidMultilineString(t *testing.T) {
|
|
input := `multiline_empty_one = """"""
|
|
multiline_empty_two = """
|
|
"""
|
|
multiline_empty_three = """\
|
|
"""
|
|
multiline_empty_four = """\
|
|
\
|
|
\
|
|
"""
|
|
|
|
equivalent_one = "The quick brown fox jumps over the lazy dog."
|
|
equivalent_two = """
|
|
The quick brown \
|
|
|
|
|
|
fox jumps over \
|
|
the lazy dog."""
|
|
|
|
equivalent_three = """\
|
|
The quick brown \
|
|
fox jumps over \
|
|
the lazy dog.\
|
|
"""`
|
|
jsonRef := `{
|
|
"multiline_empty_one": {
|
|
"type": "string",
|
|
"value": ""
|
|
},
|
|
"multiline_empty_two": {
|
|
"type": "string",
|
|
"value": ""
|
|
},
|
|
"multiline_empty_three": {
|
|
"type": "string",
|
|
"value": ""
|
|
},
|
|
"multiline_empty_four": {
|
|
"type": "string",
|
|
"value": ""
|
|
},
|
|
"equivalent_one": {
|
|
"type": "string",
|
|
"value": "The quick brown fox jumps over the lazy dog."
|
|
},
|
|
"equivalent_two": {
|
|
"type": "string",
|
|
"value": "The quick brown fox jumps over the lazy dog."
|
|
},
|
|
"equivalent_three": {
|
|
"type": "string",
|
|
"value": "The quick brown fox jumps over the lazy dog."
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidRawMultilineString(t *testing.T) {
|
|
input := `oneline = '''This string has a ' quote character.'''
|
|
firstnl = '''
|
|
This string has a ' quote character.'''
|
|
multiline = '''
|
|
This string
|
|
has ' a quote character
|
|
and more than
|
|
one newline
|
|
in it.'''`
|
|
jsonRef := `{
|
|
"oneline": {
|
|
"type": "string",
|
|
"value": "This string has a ' quote character."
|
|
},
|
|
"firstnl": {
|
|
"type": "string",
|
|
"value": "This string has a ' quote character."
|
|
},
|
|
"multiline": {
|
|
"type": "string",
|
|
"value": "This string\nhas ' a quote character\nand more than\none newline\nin it."
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidRawString(t *testing.T) {
|
|
input := `backspace = 'This string has a \b backspace character.'
|
|
tab = 'This string has a \t tab character.'
|
|
newline = 'This string has a \n new line character.'
|
|
formfeed = 'This string has a \f form feed character.'
|
|
carriage = 'This string has a \r carriage return character.'
|
|
slash = 'This string has a \/ slash character.'
|
|
backslash = 'This string has a \\ backslash character.'`
|
|
jsonRef := `{
|
|
"backspace": {
|
|
"type": "string",
|
|
"value": "This string has a \\b backspace character."
|
|
},
|
|
"tab": {
|
|
"type": "string",
|
|
"value": "This string has a \\t tab character."
|
|
},
|
|
"newline": {
|
|
"type": "string",
|
|
"value": "This string has a \\n new line character."
|
|
},
|
|
"formfeed": {
|
|
"type": "string",
|
|
"value": "This string has a \\f form feed character."
|
|
},
|
|
"carriage": {
|
|
"type": "string",
|
|
"value": "This string has a \\r carriage return character."
|
|
},
|
|
"slash": {
|
|
"type": "string",
|
|
"value": "This string has a \\/ slash character."
|
|
},
|
|
"backslash": {
|
|
"type": "string",
|
|
"value": "This string has a \\\\ backslash character."
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidStringEmpty(t *testing.T) {
|
|
input := `answer = ""`
|
|
jsonRef := `{
|
|
"answer": {
|
|
"type": "string",
|
|
"value": ""
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidStringEscapes(t *testing.T) {
|
|
input := `backspace = "This string has a \b backspace character."
|
|
tab = "This string has a \t tab character."
|
|
newline = "This string has a \n new line character."
|
|
formfeed = "This string has a \f form feed character."
|
|
carriage = "This string has a \r carriage return character."
|
|
quote = "This string has a \" quote character."
|
|
backslash = "This string has a \\ backslash character."
|
|
notunicode1 = "This string does not have a unicode \\u escape."
|
|
notunicode2 = "This string does not have a unicode \u005Cu escape."
|
|
notunicode3 = "This string does not have a unicode \\u0075 escape."
|
|
notunicode4 = "This string does not have a unicode \\\u0075 escape."`
|
|
jsonRef := `{
|
|
"backspace": {
|
|
"type": "string",
|
|
"value": "This string has a \u0008 backspace character."
|
|
},
|
|
"tab": {
|
|
"type": "string",
|
|
"value": "This string has a \u0009 tab character."
|
|
},
|
|
"newline": {
|
|
"type": "string",
|
|
"value": "This string has a \u000A new line character."
|
|
},
|
|
"formfeed": {
|
|
"type": "string",
|
|
"value": "This string has a \u000C form feed character."
|
|
},
|
|
"carriage": {
|
|
"type": "string",
|
|
"value": "This string has a \u000D carriage return character."
|
|
},
|
|
"quote": {
|
|
"type": "string",
|
|
"value": "This string has a \u0022 quote character."
|
|
},
|
|
"backslash": {
|
|
"type": "string",
|
|
"value": "This string has a \u005C backslash character."
|
|
},
|
|
"notunicode1": {
|
|
"type": "string",
|
|
"value": "This string does not have a unicode \\u escape."
|
|
},
|
|
"notunicode2": {
|
|
"type": "string",
|
|
"value": "This string does not have a unicode \u005Cu escape."
|
|
},
|
|
"notunicode3": {
|
|
"type": "string",
|
|
"value": "This string does not have a unicode \\u0075 escape."
|
|
},
|
|
"notunicode4": {
|
|
"type": "string",
|
|
"value": "This string does not have a unicode \\\u0075 escape."
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidStringSimple(t *testing.T) {
|
|
input := `answer = "You are not drinking enough whisky."`
|
|
jsonRef := `{
|
|
"answer": {
|
|
"type": "string",
|
|
"value": "You are not drinking enough whisky."
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidStringWithPound(t *testing.T) {
|
|
input := `pound = "We see no # comments here."
|
|
poundcomment = "But there are # some comments here." # Did I # mess you up?`
|
|
jsonRef := `{
|
|
"pound": {"type": "string", "value": "We see no # comments here."},
|
|
"poundcomment": {
|
|
"type": "string",
|
|
"value": "But there are # some comments here."
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableArrayImplicit(t *testing.T) {
|
|
input := `[[albums.songs]]
|
|
name = "Glory Days"`
|
|
jsonRef := `{
|
|
"albums": {
|
|
"songs": [
|
|
{"name": {"type": "string", "value": "Glory Days"}}
|
|
]
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableArrayMany(t *testing.T) {
|
|
input := `[[people]]
|
|
first_name = "Bruce"
|
|
last_name = "Springsteen"
|
|
|
|
[[people]]
|
|
first_name = "Eric"
|
|
last_name = "Clapton"
|
|
|
|
[[people]]
|
|
first_name = "Bob"
|
|
last_name = "Seger"`
|
|
jsonRef := `{
|
|
"people": [
|
|
{
|
|
"first_name": {"type": "string", "value": "Bruce"},
|
|
"last_name": {"type": "string", "value": "Springsteen"}
|
|
},
|
|
{
|
|
"first_name": {"type": "string", "value": "Eric"},
|
|
"last_name": {"type": "string", "value": "Clapton"}
|
|
},
|
|
{
|
|
"first_name": {"type": "string", "value": "Bob"},
|
|
"last_name": {"type": "string", "value": "Seger"}
|
|
}
|
|
]
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableArrayNest(t *testing.T) {
|
|
input := `[[albums]]
|
|
name = "Born to Run"
|
|
|
|
[[albums.songs]]
|
|
name = "Jungleland"
|
|
|
|
[[albums.songs]]
|
|
name = "Meeting Across the River"
|
|
|
|
[[albums]]
|
|
name = "Born in the USA"
|
|
|
|
[[albums.songs]]
|
|
name = "Glory Days"
|
|
|
|
[[albums.songs]]
|
|
name = "Dancing in the Dark"`
|
|
jsonRef := `{
|
|
"albums": [
|
|
{
|
|
"name": {"type": "string", "value": "Born to Run"},
|
|
"songs": [
|
|
{"name": {"type": "string", "value": "Jungleland"}},
|
|
{"name": {"type": "string", "value": "Meeting Across the River"}}
|
|
]
|
|
},
|
|
{
|
|
"name": {"type": "string", "value": "Born in the USA"},
|
|
"songs": [
|
|
{"name": {"type": "string", "value": "Glory Days"}},
|
|
{"name": {"type": "string", "value": "Dancing in the Dark"}}
|
|
]
|
|
}
|
|
]
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableArrayOne(t *testing.T) {
|
|
input := `[[people]]
|
|
first_name = "Bruce"
|
|
last_name = "Springsteen"`
|
|
jsonRef := `{
|
|
"people": [
|
|
{
|
|
"first_name": {"type": "string", "value": "Bruce"},
|
|
"last_name": {"type": "string", "value": "Springsteen"}
|
|
}
|
|
]
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableEmpty(t *testing.T) {
|
|
input := `[a]`
|
|
jsonRef := `{
|
|
"a": {}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableSubEmpty(t *testing.T) {
|
|
input := `[a]
|
|
[a.b]`
|
|
jsonRef := `{
|
|
"a": { "b": {} }
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableWhitespace(t *testing.T) {
|
|
input := `["valid key"]`
|
|
jsonRef := `{
|
|
"valid key": {}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidTableWithPound(t *testing.T) {
|
|
input := `["key#group"]
|
|
answer = 42`
|
|
jsonRef := `{
|
|
"key#group": {
|
|
"answer": {"type": "integer", "value": "42"}
|
|
}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidUnicodeEscape(t *testing.T) {
|
|
input := `answer4 = "\u03B4"
|
|
answer8 = "\U000003B4"`
|
|
jsonRef := `{
|
|
"answer4": {"type": "string", "value": "\u03B4"},
|
|
"answer8": {"type": "string", "value": "\u03B4"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|
|
|
|
func TestValidUnicodeLiteral(t *testing.T) {
|
|
input := `answer = "δ"`
|
|
jsonRef := `{
|
|
"answer": {"type": "string", "value": "δ"}
|
|
}`
|
|
testgenValid(t, input, jsonRef)
|
|
}
|