v

1
import x.json2 as json
2

3
enum JobTitle {
4
	manager
5
	executive
6
	worker
7
}
8

9
struct Employee {
10
pub mut:
11
	name   string
12
	age    int
13
	salary f32
14
	title  JobTitle
15
}
16

17
fn test_fast_raw_decode() {
18
	s := '{"name":"Peter","age":28,"salary":95000.5,"title":2}'
19
	o := json.fast_raw_decode(s) or {
20
		assert false
21
		json.Any('')
22
	}
23
	str := o.str()
24
	assert str == '{"name":"Peter","age":"28","salary":"95000.5","title":"2"}'
25
}
26

27
fn test_character_unescape() {
28
	message := r'{
29
	"newline": "new\nline",
30
	"tab": "\ttab",
31
	"backslash": "back\\slash",
32
	"quotes": "\"quotes\"",
33
	"slash":"\/dev\/null"
34
}'
35
	mut obj := json.raw_decode(message) or {
36
		println(err)
37
		assert false
38
		return
39
	}
40
	lines := obj.as_map()
41
	assert lines['newline'] or { 0 }.str() == 'new\nline'
42
	assert lines['tab'] or { 0 }.str() == '\ttab'
43
	assert lines['backslash'] or { 0 }.str() == 'back\\slash'
44
	assert lines['quotes'] or { 0 }.str() == '"quotes"'
45
	assert lines['slash'] or { 0 }.str() == '/dev/null'
46
}
47

48
struct StructType[T] {
49
mut:
50
	val T
51
}
52

53
fn test_struct_with_bool_to_map() {
54
	array_of_struct := [StructType[bool]{
55
		val: true
56
	}, StructType[bool]{
57
		val: false
58
	}]
59

60
	mut array_of_map := []json.Any{}
61

62
	for variable in array_of_struct {
63
		array_of_map << json.map_from(variable)
64
	}
65

66
	assert array_of_map.str() == '[{"val":true},{"val":false}]'
67
}
68

69
fn test_struct_with_string_to_map() {
70
	array_of_struct := [StructType[string]{
71
		val: 'true'
72
	}, StructType[string]{
73
		val: 'false'
74
	}]
75

76
	mut array_of_map := []json.Any{}
77

78
	for variable in array_of_struct {
79
		array_of_map << json.map_from(variable)
80
	}
81

82
	assert array_of_map.str() == '[{"val":"true"},{"val":"false"}]'
83
}
84

85
fn test_struct_with_array_to_map() {
86
	array_of_struct := [StructType[[]bool]{
87
		val: [false, true]
88
	}, StructType[[]bool]{
89
		val: [true, false]
90
	}]
91

92
	mut array_of_map := []json.Any{}
93

94
	for variable in array_of_struct {
95
		array_of_map << json.map_from(variable)
96
	}
97

98
	assert array_of_map.str() == '[{"val":[false,true]},{"val":[true,false]}]'
99
}
100

101
fn test_struct_with_number_to_map() {
102
	assert json.map_from(StructType[string]{'3'}).str() == '{"val":"3"}'
103
	assert json.map_from(StructType[bool]{true}).str() == '{"val":true}'
104
	assert json.map_from(StructType[i8]{3}).str() == '{"val":3}'
105
	assert json.map_from(StructType[i16]{3}).str() == '{"val":3}'
106
	assert json.map_from(StructType[int]{3}).str() == '{"val":3}'
107
	assert json.map_from(StructType[i64]{3}).str() == '{"val":3}'
108
	assert json.map_from(StructType[i8]{-3}).str() == '{"val":-3}'
109
	assert json.map_from(StructType[i16]{i16(-3)}).str() == '{"val":-3}'
110
	assert json.map_from(StructType[int]{-3}).str() == '{"val":-3}'
111
	assert json.map_from(StructType[i64]{-3}).str() == '{"val":-3}'
112
	assert json.map_from(StructType[f32]{3.0}).str() == '{"val":3.0}'
113
	assert json.map_from(StructType[f64]{3.0}).str() == '{"val":3.0}'
114
	assert json.map_from(StructType[u8]{3}).str() == '{"val":3}'
115
	assert json.map_from(StructType[u16]{3}).str() == '{"val":3}'
116
	assert json.map_from(StructType[u32]{3}).str() == '{"val":3}'
117
	assert json.map_from(StructType[u64]{3}).str() == '{"val":3}'
118
}
119

120
fn test_struct_with_struct_to_map() {
121
	assert json.map_from(StructType[StructType[string]]{StructType[string]{'3'}}).str() == '{"val":{"val":"3"}}'
122
	assert json.map_from(StructType[StructType[int]]{StructType[int]{3}}).str() == '{"val":{"val":3}}'
123
}
124

125
fn test_maps() {
126
	assert json.decode[map[string]string]('{"test":"abc"}')! == {
127
		'test': 'abc'
128
	}
129

130
	// assert json.decode[map[string]StructType[bool]]('{"test":{"val":true}}') or {
131
	// 	dump(err)
132
	// 	assert false
133
	// } == {"test":StructType[bool]{true}}
134
}
135