v

1
import x.json2 as json
2

3
fn test_raw_decode_string() {
4
	str := json.raw_decode('"Hello!"')!
5
	assert str.str() == 'Hello!'
6
}
7

8
fn test_raw_decode_string_escape() {
9
	jstr := json.raw_decode('"\u001b"')!
10
	str := jstr.str()
11
	assert str.len == 1
12
	assert str[0] == 27
13
}
14

15
fn test_raw_decode_number() {
16
	num := json.raw_decode('123')!
17
	assert num.int() == 123
18
}
19

20
fn test_raw_decode_array() {
21
	raw_arr := json.raw_decode('["Foo", 1]')!
22
	arr := raw_arr.arr()
23
	assert arr[0] or { 0 }.str() == 'Foo'
24
	assert arr[1] or { 0 }.int() == 1
25
}
26

27
fn test_raw_decode_bool() {
28
	bol := json.raw_decode('false')!
29
	assert bol.bool() == false
30
}
31

32
fn test_raw_decode_map() {
33
	raw_mp := json.raw_decode('{"name":"Bob","age":20}')!
34
	mp := raw_mp.as_map()
35
	assert mp['name'] or { 0 }.str() == 'Bob'
36
	assert mp['age'] or { 0 }.int() == 20
37
}
38

39
fn test_raw_decode_null() {
40
	nul := json.raw_decode('null')!
41
	assert nul is json.Null
42
}
43

44
fn test_raw_decode_invalid() {
45
	json.raw_decode('1z') or {
46
		assert err.msg() == '[x.json2] invalid token `z` (0:17)'
47
		return
48
	}
49
	assert false
50
}
51

52
fn test_raw_decode_string_with_dollarsign() {
53
	str := json.raw_decode(r'"Hello $world"')!
54
	assert str.str() == r'Hello $world'
55
}
56

57
fn test_raw_decode_map_with_whitespaces() {
58
	raw_mp := json.raw_decode(' \n\t{"name":"Bob","age":20}\n\t')!
59
	mp := raw_mp.as_map()
60
	assert mp['name'] or { 0 }.str() == 'Bob'
61
	assert mp['age'] or { 0 }.int() == 20
62
}
63

64
fn test_nested_array_object() {
65
	mut parser := json.new_parser(r'[[[[[],[],[]]]],{"Test":{}},[[]]]', false)
66
	decoded := parser.decode()!
67
	assert parser.n_level == 0
68
}
69

70
fn test_raw_decode_map_invalid() {
71
	json.raw_decode('{"name","Bob","age":20}') or {
72
		assert err.msg() == '[x.json2] invalid token `comma`, expecting `colon` (0:5)'
73
		return
74
	}
75
	assert false
76
}
77

78
fn test_raw_decode_array_invalid() {
79
	json.raw_decode('["Foo", 1,}') or {
80
		assert err.msg() == '[x.json2] invalid token `rcbr` (0:5)'
81
		return
82
	}
83
	assert false
84
}
85

86
struct Foo {
87
	int  []int
88
	str  []string
89
	f32  []f32
90
	oint []?int
91
}
92

93
fn test_decode_array_fields() {
94
	input := '{"int":[0, 1], "str":["2", "3"], "f32": [4.0, 5.0], "oint": [6, null]}'
95
	foo := json.decode[Foo](input)!
96
	assert foo.int == [0, 1]
97
	assert foo.str == ['2', '3']
98
	assert foo.f32 == [f32(4.0), 5.0]
99
	a, b := foo.oint[0], foo.oint[1]
100
	assert a? == 6
101
	assert b? == 0
102
}
103

104
struct ContactItem {
105
	description string
106
	telnr       string
107
}
108

109
struct User {
110
	name    string
111
	age     int
112
	contact ContactItem
113
}
114

115
fn test_decode_missing_comma() {
116
	data := '{
117
				"name": "Frodo",
118
				"age": 25
119
				"contact": {
120
					"description": "descr",
121
					"telnr": "+32333"
122
				}
123
			}'
124
	user := json.decode[User](data) or {
125
		assert err.msg().contains('invalid token')
126
		return
127
	}
128
}
129