mirror of
https://github.com/vlang/v.git
synced 2023-08-10 21:13:21 +03:00
406 lines
14 KiB
V
406 lines
14 KiB
V
import os
|
|
import toml
|
|
import toml.ast
|
|
import x.json2
|
|
|
|
const hide_oks = os.getenv('VTEST_HIDE_OK') == '1'
|
|
|
|
// Can be set to `true` to process tests that stress test the parser
|
|
// by having large data amounts - these pass - but slow down the test run
|
|
const do_large_files = os.getenv('VTEST_TOML_DO_LARGE_FILES') == '1'
|
|
|
|
// Can be set to `true` to process tests that triggers a slow conversion
|
|
// process that uses `python` to convert from YAML to JSON.
|
|
const do_yaml_conversion = os.getenv('VTEST_TOML_DO_YAML_CONVERSION') == '1'
|
|
|
|
// Instructions for developers:
|
|
// The actual tests and data can be obtained by doing:
|
|
// `git clone --depth 1 https://github.com/iarna/toml-spec-tests.git vlib/toml/tests/testdata/iarna/toml-test`
|
|
// See also the CI toml tests
|
|
const (
|
|
// Kept for easier handling of future updates to the tests
|
|
valid_exceptions = []string{}
|
|
invalid_exceptions = []string{}
|
|
|
|
valid_value_exceptions = [
|
|
'values/spec-date-time-3.toml',
|
|
'values/spec-date-time-4.toml',
|
|
'values/spec-readme-example.toml',
|
|
'values/spec-date-time-6.toml',
|
|
'values/spec-date-time-5.toml',
|
|
'values/spec-date-time-1.toml',
|
|
'values/spec-date-time-2.toml',
|
|
'values/qa-table-inline-nested-1000.toml',
|
|
'values/qa-array-inline-nested-1000.toml',
|
|
]
|
|
|
|
yaml_value_exceptions = [
|
|
'values/spec-float-5.toml', // YAML: "1e6", V: 1000000
|
|
'values/spec-float-9.toml', // YAML: "-0e0", V: 0
|
|
'values/spec-float-6.toml', // YAML: "-2E-2", V: -0.02
|
|
'values/spec-float-4.toml', // YAML: "5e+22", V: 50000000000000004000000
|
|
]
|
|
|
|
jq = os.find_abs_path_of_executable('jq') or { '' }
|
|
python = os.find_abs_path_of_executable('python') or { '' }
|
|
compare_work_dir_root = os.join_path(os.vtmp_dir(), 'v', 'toml', 'iarna')
|
|
// From: https://stackoverflow.com/a/38266731/1904615
|
|
jq_normalize = r'# Apply f to composite entities recursively using keys[], and to atoms
|
|
def sorted_walk(f):
|
|
. as $in
|
|
| if type == "object" then
|
|
reduce keys[] as $key
|
|
( {}; . + { ($key): ($in[$key] | sorted_walk(f)) } ) | f
|
|
elif type == "array" then map( sorted_walk(f) ) | f
|
|
else f
|
|
end;
|
|
|
|
def normalize: sorted_walk(if type == "array" then sort else . end);
|
|
|
|
normalize'
|
|
)
|
|
|
|
fn run(args []string) ?string {
|
|
res := os.execute(args.join(' '))
|
|
if res.exit_code != 0 {
|
|
return error('${args[0]} failed with return code ${res.exit_code}.\n${res.output}')
|
|
}
|
|
return res.output
|
|
}
|
|
|
|
// test_iarna_toml_spec_tests run though 'testdata/iarna/toml-test/*' if found.
|
|
fn test_iarna_toml_spec_tests() {
|
|
this_file := @FILE
|
|
test_root := os.join_path(os.dir(this_file), 'testdata', 'iarna', 'toml-test')
|
|
if os.is_dir(test_root) {
|
|
valid_test_files := os.walk_ext(os.join_path(test_root, 'values'), '.toml')
|
|
println('Testing ${valid_test_files.len} valid TOML files...')
|
|
mut valid := 0
|
|
mut e := 0
|
|
for i, valid_test_file in valid_test_files {
|
|
mut relative := valid_test_file.all_after('toml-test').trim_left(os.path_separator)
|
|
$if windows {
|
|
relative = relative.replace('/', '\\')
|
|
}
|
|
|
|
if !do_large_files && valid_test_file.contains('qa-') {
|
|
e++
|
|
println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" LARGE FILE...')
|
|
continue
|
|
}
|
|
|
|
if relative in valid_exceptions {
|
|
e++
|
|
idx := valid_exceptions.index(relative) + 1
|
|
println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" VALID EXCEPTION [${idx}/${valid_exceptions.len}]...')
|
|
continue
|
|
}
|
|
|
|
if !hide_oks {
|
|
println('OK [${i + 1}/${valid_test_files.len}] "${valid_test_file}"...')
|
|
}
|
|
toml_doc := toml.parse_file(valid_test_file)!
|
|
valid++
|
|
}
|
|
println('${valid}/${valid_test_files.len} TOML files were parsed correctly')
|
|
if valid_exceptions.len > 0 {
|
|
println('TODO Skipped parsing of ${e} valid TOML files...')
|
|
}
|
|
|
|
// If the command-line tool `jq` is installed, value tests can be run as well.
|
|
if jq != '' {
|
|
println('Testing value output of ${valid_test_files.len} valid TOML files using "${jq}"...')
|
|
|
|
if os.exists(compare_work_dir_root) {
|
|
os.rmdir_all(compare_work_dir_root)!
|
|
}
|
|
os.mkdir_all(compare_work_dir_root)!
|
|
|
|
jq_normalize_path := os.join_path(compare_work_dir_root, 'normalize.jq')
|
|
os.write_file(jq_normalize_path, jq_normalize)!
|
|
|
|
valid = 0
|
|
e = 0
|
|
for i, valid_test_file in valid_test_files {
|
|
mut relative := valid_test_file.all_after('toml-test').trim_left(os.path_separator)
|
|
$if windows {
|
|
relative = relative.replace('/', '\\')
|
|
}
|
|
|
|
// Skip the file if we know it can't be parsed or we know that the value retrieval needs work.
|
|
if relative in valid_exceptions {
|
|
e++
|
|
idx := valid_exceptions.index(relative) + 1
|
|
println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" VALID EXCEPTION [${idx}/${valid_exceptions.len}]...')
|
|
continue
|
|
}
|
|
|
|
if relative in valid_value_exceptions {
|
|
e++
|
|
idx := valid_value_exceptions.index(relative) + 1
|
|
println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" VALID VALUE EXCEPTION [${idx}/${valid_value_exceptions.len}]...')
|
|
continue
|
|
}
|
|
|
|
valid_test_file_name := os.file_name(valid_test_file).all_before_last('.')
|
|
uses_json_format := os.exists(valid_test_file.all_before_last('.') + '.json')
|
|
|
|
// Use python to convert the YAML files to json - it yields some inconsistencies
|
|
// so we skip some of them
|
|
mut converted_from_yaml := false
|
|
mut converted_json_path := ''
|
|
if !uses_json_format {
|
|
$if windows {
|
|
println('N/A [${i + 1}/${valid_test_files.len}] "${valid_test_file}"...')
|
|
continue
|
|
}
|
|
if python == '' {
|
|
println('N/A [${i + 1}/${valid_test_files.len}] "${valid_test_file}"...')
|
|
continue
|
|
}
|
|
if !do_yaml_conversion || relative in yaml_value_exceptions {
|
|
e++
|
|
idx := yaml_value_exceptions.index(relative) + 1
|
|
println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" YAML VALUE EXCEPTION [${idx}/${valid_value_exceptions.len}]...')
|
|
continue
|
|
}
|
|
|
|
if !do_large_files && valid_test_file.contains('qa-') {
|
|
e++
|
|
println('SKIP [${i + 1}/${valid_test_files.len}] "${valid_test_file}" LARGE FILE...')
|
|
continue
|
|
}
|
|
|
|
iarna_yaml_path := valid_test_file.all_before_last('.') + '.yaml'
|
|
if os.exists(iarna_yaml_path) {
|
|
converted_json_path = os.join_path(compare_work_dir_root, '${valid_test_file_name}.yaml.json')
|
|
run([python, '-c',
|
|
"'import sys, yaml, json; json.dump(yaml.load(sys.stdin, Loader=yaml.FullLoader), sys.stdout, indent=4)'",
|
|
'<', iarna_yaml_path, '>', converted_json_path]) or {
|
|
contents := os.read_file(iarna_yaml_path)!
|
|
// NOTE there's known errors with the python convertion method.
|
|
// For now we just ignore them as it's a broken tool - not a wrong test-case.
|
|
// Uncomment this print to see/check them.
|
|
// eprintln(err.msg() + '\n$contents')
|
|
e++
|
|
println('ERR [${i + 1}/${valid_test_files.len}] "${valid_test_file}" EXCEPTION [${e}/${valid_value_exceptions.len}]...')
|
|
continue
|
|
}
|
|
converted_from_yaml = true
|
|
}
|
|
}
|
|
|
|
if !hide_oks {
|
|
println('OK [${i + 1}/${valid_test_files.len}] "${valid_test_file}"...')
|
|
}
|
|
toml_doc := toml.parse_file(valid_test_file)!
|
|
|
|
v_toml_json_path := os.join_path(compare_work_dir_root, '${valid_test_file_name}.v.json')
|
|
iarna_toml_json_path := os.join_path(compare_work_dir_root, '${valid_test_file_name}.json')
|
|
|
|
os.write_file(v_toml_json_path, to_iarna(toml_doc.ast.table, converted_from_yaml))!
|
|
|
|
if converted_json_path == '' {
|
|
converted_json_path = valid_test_file.all_before_last('.') + '.json'
|
|
}
|
|
iarna_json := os.read_file(converted_json_path)!
|
|
os.write_file(iarna_toml_json_path, iarna_json)!
|
|
|
|
v_normalized_json := run([jq, '-S', '-f "${jq_normalize_path}"', v_toml_json_path]) or {
|
|
contents := os.read_file(v_toml_json_path)!
|
|
panic(err.msg() + '\n${contents}')
|
|
}
|
|
cmd := [jq, '-S', '-f "${jq_normalize_path}"', iarna_toml_json_path]
|
|
iarna_normalized_json := run(cmd) or {
|
|
contents := os.read_file(v_toml_json_path)!
|
|
panic(err.msg() + '\n${contents}\n\ncmd: ${cmd.join(' ')}')
|
|
}
|
|
|
|
assert iarna_normalized_json == v_normalized_json
|
|
|
|
valid++
|
|
}
|
|
println('${valid}/${valid_test_files.len} TOML files were parsed correctly and value checked')
|
|
if valid_value_exceptions.len > 0 {
|
|
println('TODO Skipped value checks of ${e} valid TOML files...')
|
|
}
|
|
}
|
|
|
|
invalid_test_files := os.walk_ext(os.join_path(test_root, 'errors'), '.toml')
|
|
println('Testing ${invalid_test_files.len} invalid TOML files...')
|
|
mut invalid := 0
|
|
e = 0
|
|
for i, invalid_test_file in invalid_test_files {
|
|
mut relative := invalid_test_file.all_after('toml-test').trim_left(os.path_separator)
|
|
$if windows {
|
|
relative = relative.replace('/', '\\')
|
|
}
|
|
if relative in invalid_exceptions {
|
|
e++
|
|
idx := invalid_exceptions.index(relative) + 1
|
|
println('SKIP [${i + 1}/${invalid_test_files.len}] "${invalid_test_file}" INVALID EXCEPTION [${idx}/${invalid_exceptions.len}]...')
|
|
continue
|
|
}
|
|
if !hide_oks {
|
|
println('OK [${i + 1}/${invalid_test_files.len}] "${invalid_test_file}"...')
|
|
}
|
|
if toml_doc := toml.parse_file(invalid_test_file) {
|
|
content_that_should_have_failed := os.read_file(invalid_test_file)!
|
|
println(' This TOML should have failed:\n${'-'.repeat(40)}\n${content_that_should_have_failed}\n${'-'.repeat(40)}')
|
|
assert false
|
|
} else {
|
|
if !hide_oks {
|
|
println(' ${err.msg()}')
|
|
}
|
|
assert true
|
|
}
|
|
invalid++
|
|
}
|
|
println('${invalid}/${invalid_test_files.len} TOML files were parsed correctly')
|
|
if invalid_exceptions.len > 0 {
|
|
println('TODO Skipped parsing of ${invalid_exceptions.len} invalid TOML files...')
|
|
}
|
|
} else {
|
|
println('No test data directory found in "${test_root}"')
|
|
assert true
|
|
}
|
|
}
|
|
|
|
// to_iarna_time
|
|
fn to_iarna_time(time_str string) string {
|
|
if time_str.contains('.') {
|
|
date_and_time := time_str.all_before('.')
|
|
mut ms := time_str.all_after('.')
|
|
z := if ms.contains('Z') { 'Z' } else { '' }
|
|
ms = ms.replace('Z', '')
|
|
if ms.len > 3 {
|
|
ms = ms[..3]
|
|
}
|
|
return date_and_time + '.' + ms + z
|
|
} else {
|
|
return time_str + '.000'
|
|
}
|
|
}
|
|
|
|
// to_iarna returns a iarna compatible json string converted from the `value` ast.Value.
|
|
fn to_iarna(value ast.Value, skip_value_map bool) string {
|
|
match value {
|
|
ast.Quoted {
|
|
json_text := json2.Any(value.text).json_str()
|
|
if skip_value_map {
|
|
return json_text
|
|
}
|
|
return '{ "type": "string", "value": ${json_text} }'
|
|
}
|
|
ast.DateTime {
|
|
// Normalization for json
|
|
mut json_text := json2.Any(value.text).json_str().to_upper().replace(' ',
|
|
'T')
|
|
typ := if json_text.ends_with('Z"') || json_text.all_after('T').contains('-')
|
|
|| json_text.all_after('T').contains('+') {
|
|
'datetime'
|
|
} else {
|
|
'datetime-local'
|
|
}
|
|
// NOTE test suite inconsistency.
|
|
// It seems it's implementation specific how time and
|
|
// date-time values are represented in detail. For now we follow the BurntSushi format
|
|
// that expands to 6 digits which is also a valid RFC 3339 representation.
|
|
json_text = to_iarna_time(json_text[1..json_text.len - 1])
|
|
if skip_value_map {
|
|
return json_text
|
|
}
|
|
return '{ "type": "${typ}", "value": "${json_text}" }'
|
|
}
|
|
ast.Date {
|
|
json_text := json2.Any(value.text).json_str()
|
|
if skip_value_map {
|
|
return json_text
|
|
}
|
|
return '{ "type": "date", "value": ${json_text} }'
|
|
}
|
|
ast.Time {
|
|
mut json_text := json2.Any(value.text).json_str()
|
|
// Note: Removes the quotes of the encoded JSON string - Ned
|
|
json_text = to_iarna_time(json_text[1..json_text.len - 1])
|
|
if skip_value_map {
|
|
return json_text
|
|
}
|
|
return '{ "type": "time", "value": "${json_text}" }'
|
|
}
|
|
ast.Bool {
|
|
json_text := json2.Any(value.text.bool()).json_str()
|
|
if skip_value_map {
|
|
return json_text
|
|
}
|
|
return '{ "type": "bool", "value": "${json_text}" }'
|
|
}
|
|
ast.Null {
|
|
json_text := json2.Any(value.text).json_str()
|
|
if skip_value_map {
|
|
return json_text
|
|
}
|
|
return '{ "type": "null", "value": ${json_text} }'
|
|
}
|
|
ast.Number {
|
|
if value.text.contains('inf') {
|
|
mut json_text := value.text.replace('inf', '1.7976931348623157e+308') // Inconsistency ???
|
|
if skip_value_map {
|
|
return '${json_text}'
|
|
}
|
|
return '{ "type": "float", "value": "${json_text}" }'
|
|
}
|
|
if value.text.contains('nan') {
|
|
mut json_text := 'null'
|
|
if skip_value_map {
|
|
return '${json_text}'
|
|
}
|
|
return '{ "type": "float", "value": "${json_text}" }'
|
|
}
|
|
if !value.text.starts_with('0x')
|
|
&& (value.text.contains('.') || value.text.to_lower().contains('e')) {
|
|
mut val := '${value.f64()}'.replace('.e+', '.0e') // json notation
|
|
if !val.contains('.') && val != '0' { // json notation
|
|
val += '.0'
|
|
}
|
|
if skip_value_map {
|
|
return '${val}'
|
|
}
|
|
return '{ "type": "float", "value": "${val}" }'
|
|
}
|
|
v := value.i64()
|
|
// TODO workaround https://github.com/vlang/v/issues/9507
|
|
if v == i64(-9223372036854775807 - 1) {
|
|
if skip_value_map {
|
|
return '-9223372036854775808'
|
|
}
|
|
return '{ "type": "integer", "value": "-9223372036854775808" }'
|
|
}
|
|
if skip_value_map {
|
|
return '${v}'
|
|
}
|
|
return '{ "type": "integer", "value": "${v}" }'
|
|
}
|
|
map[string]ast.Value {
|
|
mut str := '{ '
|
|
for key, val in value {
|
|
json_key := json2.Any(key).json_str()
|
|
str += ' ${json_key}: ${to_iarna(val, skip_value_map)},'
|
|
}
|
|
str = str.trim_right(',')
|
|
str += ' }'
|
|
return str
|
|
}
|
|
[]ast.Value {
|
|
mut str := '[ '
|
|
for val in value {
|
|
str += ' ${to_iarna(val, skip_value_map)},'
|
|
}
|
|
str = str.trim_right(',')
|
|
str += ' ]\n'
|
|
return str
|
|
}
|
|
}
|
|
return '<error>'
|
|
}
|