f7b4312f |
1 | #INTERFACE CAF |
2 | puts "================" |
3 | puts "bug0023850: Speed-up storage of OCAF document in XML file format" |
4 | puts "================" |
5 | puts "" |
6 | ###################################################### |
7 | # Speed-up storage of OCAF document in XML file format |
8 | ###################################################### |
9 | |
10 | # Create an OCAF document. Use XML as a test storage schema. |
11 | NewDocument DOC XmlOcaf |
12 | |
13 | # Set a long byte array of many-many values. Here it is an array of 10 values. |
14 | SetByteArray DOC 0:1 0 1 10 1 2 3 4 5 6 7 8 9 10 |
15 | |
16 | # Set a list of tree nodes. |
17 | SetNode DOC 0:1 |
18 | SetNode DOC 0:1:1 |
19 | SetNode DOC 0:1:2 |
20 | SetNode DOC 0:1:3 |
21 | SetNode DOC 0:1:4 |
22 | SetNode DOC 0:1:5 |
23 | SetNode DOC 0:1:6 |
24 | SetNode DOC 0:1:7 |
25 | SetNode DOC 0:1:8 |
26 | AppendNode DOC 0:1 0:1:1 |
27 | AppendNode DOC 0:1 0:1:2 |
28 | AppendNode DOC 0:1 0:1:3 |
29 | AppendNode DOC 0:1 0:1:4 |
30 | AppendNode DOC 0:1 0:1:5 |
31 | AppendNode DOC 0:1 0:1:6 |
32 | AppendNode DOC 0:1 0:1:7 |
33 | AppendNode DOC 0:1 0:1:8 |
34 | |
35 | # Set an array of integer values. |
36 | SetIntArray DOC 0:1 0 1 5 111 222 333 444 555 |
37 | |
38 | # Set an array of double values (one of them contains 17 digits!) |
39 | SetRealArray DOC 0:1 0 1 5 1.12345678987654321 2.2 3.3 4.4 5.5 |
40 | |
41 | # Set a packed map of integer values. |
42 | SetIntPackedMap DOC 0:1 0 1 10 100 1000 10000 |
43 | |
44 | # Set an array of boolean values. |
5a1271c8 |
45 | SetBooleanArray DOC 0:1 1 5 0 0 0 1 1 |
f7b4312f |
46 | |
47 | # Set a list of integer values. |
48 | SetIntegerList DOC 0:1 1971 1972 1973 1974 1975 |
49 | |
50 | # Set a list of boolean values. |
51 | SetBooleanList DOC 0:1 1 0 0 0 1 |
52 | |
53 | # Set a list of double values. |
54 | SetRealList DOC 0:1 0.98765432123456789e+21 0.98765432123456789e+22 0.98765432123456789e+23 |
55 | |
56 | set aFile ${imagedir}/bug23850_test.xml |
57 | # Save the document on disk. |
58 | SaveAs DOC ${aFile} |
59 | Close DOC |
60 | |
61 | # Open the document. |
62 | Open ${aFile} DOC |
63 | |
64 | # Get byte array and check its values. |
65 | set bytearray [GetByteArray DOC 0:1] |
66 | set bytearray1 [lindex ${bytearray} 0] |
67 | set bytearray2 [lindex ${bytearray} 1] |
68 | set bytearray3 [lindex ${bytearray} 2] |
69 | set bytearray4 [lindex ${bytearray} 3] |
70 | set bytearray5 [lindex ${bytearray} 4] |
71 | set bytearray6 [lindex ${bytearray} 5] |
72 | set bytearray7 [lindex ${bytearray} 6] |
73 | set bytearray8 [lindex ${bytearray} 7] |
74 | set bytearray9 [lindex ${bytearray} 8] |
75 | set bytearray10 [lindex ${bytearray} 9] |
76 | if { ${bytearray1} != 1 || |
77 | ${bytearray2} != 2 || |
78 | ${bytearray3} != 3 || |
79 | ${bytearray4} != 4 || |
80 | ${bytearray5} != 5 || |
81 | ${bytearray6} != 6 || |
82 | ${bytearray7} != 7 || |
83 | ${bytearray8} != 8 || |
84 | ${bytearray9} != 9 || |
85 | ${bytearray10} != 10 } { |
86 | puts "ByteArray failed..." |
87 | } else { |
88 | puts "ByteArray is OK" |
89 | } |
90 | |
91 | # Check tree nodes. |
92 | set nodes [ChildNodeIterate DOC 0:1 1] |
93 | set node1 [lindex ${nodes} 0] |
94 | set node2 [lindex ${nodes} 1] |
95 | set node3 [lindex ${nodes} 2] |
96 | set node4 [lindex ${nodes} 3] |
97 | set node5 [lindex ${nodes} 4] |
98 | set node6 [lindex ${nodes} 5] |
99 | set node7 [lindex ${nodes} 6] |
100 | set node8 [lindex ${nodes} 7] |
101 | if { ${node1} != "0:1:1" || |
102 | ${node2} != "0:1:2" || |
103 | ${node3} != "0:1:3" || |
104 | ${node4} != "0:1:4" || |
105 | ${node5} != "0:1:5" || |
106 | ${node6} != "0:1:6" || |
107 | ${node7} != "0:1:7" || |
108 | ${node8} != "0:1:8" } { |
109 | puts "TreeNode failed..." |
110 | } else { |
111 | puts "TreeNode is OK" |
112 | } |
113 | |
114 | # Check array of integer values. |
115 | set intarray [GetIntArray DOC 0:1] |
116 | set intarray1 [lindex ${intarray} 0] |
117 | set intarray2 [lindex ${intarray} 1] |
118 | set intarray3 [lindex ${intarray} 2] |
119 | set intarray4 [lindex ${intarray} 3] |
120 | set intarray5 [lindex ${intarray} 4] |
121 | if { ${intarray1} != 111 || |
122 | ${intarray2} != 222 || |
123 | ${intarray3} != 333 || |
124 | ${intarray4} != 444 || |
125 | ${intarray5} != 555 } { |
126 | puts "IntegerArray failed..." |
127 | } else { |
128 | puts "IntegerArray is OK" |
129 | } |
130 | |
131 | # Check array of double values. |
132 | # Warning!: It seems TCL uses 16 digits for manipulation with a double values... |
133 | set realarray [GetRealArray DOC 0:1] |
134 | set realarray1 [lindex ${realarray} 0] |
135 | set realarray2 [lindex ${realarray} 1] |
136 | set realarray3 [lindex ${realarray} 2] |
137 | set realarray4 [lindex ${realarray} 3] |
138 | set realarray5 [lindex ${realarray} 4] |
139 | if { ${realarray1} != 1.12345678987654321 || |
140 | ${realarray2} != 2.2 || |
141 | ${realarray3} != 3.3 || |
142 | ${realarray4} != 4.4 || |
143 | ${realarray5} != 5.5 } { |
144 | puts "RealArray failed..." |
145 | } else { |
146 | puts "RealArray is OK" |
147 | } |
148 | |
149 | # Check packed map of integer values. |
150 | set packedintmap [GetIntPackedMap DOC 0:1] |
151 | set nb [llength ${packedintmap}] |
152 | if { ${nb} != 5 } { |
153 | puts "IntPackedMap failed..." |
154 | } |
155 | set contains1 [lsearch ${packedintmap} 1] |
156 | set contains2 [lsearch ${packedintmap} 10] |
157 | set contains3 [lsearch ${packedintmap} 100] |
158 | set contains4 [lsearch ${packedintmap} 1000] |
159 | set contains5 [lsearch ${packedintmap} 10000] |
160 | if { ${contains1} == -1 || |
161 | ${contains2} == -1 || |
162 | ${contains3} == -1 || |
163 | ${contains4} == -1 || |
164 | ${contains5} == -1 } { |
165 | puts "Failed..." |
166 | } else { |
167 | puts "IntPackedMap is OK" |
168 | } |
169 | |
170 | # Get boolean array and check its values. |
171 | set boolarray [GetBooleanArray DOC 0:1] |
172 | set boolarray1 [lindex ${boolarray} 0] |
173 | set boolarray2 [lindex ${boolarray} 1] |
174 | set boolarray3 [lindex ${boolarray} 2] |
175 | set boolarray4 [lindex ${boolarray} 3] |
176 | set boolarray5 [lindex ${boolarray} 4] |
177 | if { ${boolarray1} != 0 || |
178 | ${boolarray2} != 0 || |
179 | ${boolarray3} != 0 || |
180 | ${boolarray4} != 1 || |
181 | ${boolarray5} != 1 } { |
182 | puts "BoolArray failed..." |
183 | } else { |
184 | puts "BoolArray is OK" |
185 | } |
186 | |
187 | # Get boolean list and check its values. |
188 | set boollist [GetBooleanList DOC 0:1] |
189 | set boollist1 [lindex ${boollist} 0] |
190 | set boollist2 [lindex ${boollist} 1] |
191 | set boollist3 [lindex ${boollist} 2] |
192 | set boollist4 [lindex ${boollist} 3] |
193 | set boollist5 [lindex ${boollist} 4] |
194 | if { ${boollist1} != 1 || |
195 | ${boollist2} != 0 || |
196 | ${boollist3} != 0 || |
197 | ${boollist4} != 0 || |
198 | ${boollist5} != 1 } { |
199 | puts "BoolList failed..." |
200 | } else { |
201 | puts "BoolList is OK" |
202 | } |
203 | |
204 | # Get integer list and check its values. |
205 | set intlist [GetIntegerList DOC 0:1] |
206 | set intlist1 [lindex ${intlist} 0] |
207 | set intlist2 [lindex ${intlist} 1] |
208 | set intlist3 [lindex ${intlist} 2] |
209 | set intlist4 [lindex ${intlist} 3] |
210 | set intlist5 [lindex ${intlist} 4] |
211 | if { ${intlist1} != 1971 || |
212 | ${intlist2} != 1972 || |
213 | ${intlist3} != 1973 || |
214 | ${intlist4} != 1974 || |
215 | ${intlist5} != 1975 } { |
216 | puts "IntList failed..." |
217 | } else { |
218 | puts "IntList is OK" |
219 | } |
220 | |
221 | # Get double list and check its values. |
222 | set reallist [GetRealList DOC 0:1] |
223 | set reallist1 [lindex ${reallist} 0] |
224 | set reallist2 [lindex ${reallist} 1] |
225 | set reallist3 [lindex ${reallist} 2] |
226 | if { ${reallist1} != 0.98765432123456789e+21 || |
227 | ${reallist2} != 0.98765432123456789e+22 || |
228 | ${reallist3} != 0.98765432123456789e+23 } { |
229 | puts "RealList failed..." |
230 | } else { |
231 | puts "RealList is OK" |
232 | } |
233 | |
234 | Close DOC |
235 | file delete test.xml |
236 | puts "bug0023850: OK" |