Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(331)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: xfa/fde/xml/fde_xml_imp_unittest.cpp

Issue 2559763002: Refcount IFGAS_ streams all the time, too (Closed)
Patch Set: more Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « xfa/fde/xml/fde_xml_imp.cpp ('k') | xfa/fgas/crt/fgas_stream.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2016 PDFium Authors. All rights reserved. 1 // Copyright 2016 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "xfa/fde/xml/fde_xml_imp.h" 5 #include "xfa/fde/xml/fde_xml_imp.h"
6 6
7 #include <memory> 7 #include <memory>
8 8
9 #include "testing/gtest/include/gtest/gtest.h" 9 #include "testing/gtest/include/gtest/gtest.h"
10 #include "xfa/fgas/crt/fgas_stream.h" 10 #include "xfa/fgas/crt/fgas_stream.h"
11 11
12 TEST(CFDE_XMLSyntaxParser, CData) { 12 TEST(CFDE_XMLSyntaxParser, CData) {
13 const FX_WCHAR* input = 13 const FX_WCHAR* input =
14 L"<script contentType=\"application/x-javascript\">\n" 14 L"<script contentType=\"application/x-javascript\">\n"
15 L" <![CDATA[\n" 15 L" <![CDATA[\n"
16 L" if (a[1] < 3)\n" 16 L" if (a[1] < 3)\n"
17 L" app.alert(\"Tclams\");\n" 17 L" app.alert(\"Tclams\");\n"
18 L" ]]>\n" 18 L" ]]>\n"
19 L"</script>"; 19 L"</script>";
20 20
21 const FX_WCHAR* cdata = 21 const FX_WCHAR* cdata =
22 L"\n" 22 L"\n"
23 L" if (a[1] < 3)\n" 23 L" if (a[1] < 3)\n"
24 L" app.alert(\"Tclams\");\n" 24 L" app.alert(\"Tclams\");\n"
25 L" "; 25 L" ";
26 26
27 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 27 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
28 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 28 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
29 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 29 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
30 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 30 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
31 CFDE_XMLSyntaxParser parser; 31 CFDE_XMLSyntaxParser parser;
32 parser.Init(stream.get(), 256); 32 parser.Init(stream, 256);
33 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
34 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
33 35
34 CFX_WideString data; 36 CFX_WideString data;
35
36 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
37 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
38 parser.GetTagName(data); 37 parser.GetTagName(data);
39 EXPECT_EQ(L"script", data); 38 EXPECT_EQ(L"script", data);
40 39
41 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 40 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
42 parser.GetAttributeName(data); 41 parser.GetAttributeName(data);
43 EXPECT_EQ(L"contentType", data); 42 EXPECT_EQ(L"contentType", data);
44 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 43 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
45 parser.GetAttributeValue(data); 44 parser.GetAttributeValue(data);
46 EXPECT_EQ(L"application/x-javascript", data); 45 EXPECT_EQ(L"application/x-javascript", data);
47 46
(...skipping 29 matching lines...) Expand all
77 76
78 const FX_WCHAR* cdata = 77 const FX_WCHAR* cdata =
79 L"\n" 78 L"\n"
80 L" if (a[1] < 3)\n" 79 L" if (a[1] < 3)\n"
81 L" app.alert(\"Tclams\");\n" 80 L" app.alert(\"Tclams\");\n"
82 L" </script>\n" 81 L" </script>\n"
83 L" "; 82 L" ";
84 83
85 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 84 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
86 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 85 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
87 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 86 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
88 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 87 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
89 CFDE_XMLSyntaxParser parser; 88 CFDE_XMLSyntaxParser parser;
90 parser.Init(stream.get(), 256); 89 parser.Init(stream, 256);
90 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
91 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
91 92
92 CFX_WideString data; 93 CFX_WideString data;
93
94 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
95 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
96 parser.GetTagName(data); 94 parser.GetTagName(data);
97 EXPECT_EQ(L"script", data); 95 EXPECT_EQ(L"script", data);
98 96
99 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 97 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
100 parser.GetAttributeName(data); 98 parser.GetAttributeName(data);
101 EXPECT_EQ(L"contentType", data); 99 EXPECT_EQ(L"contentType", data);
102 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 100 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
103 parser.GetAttributeValue(data); 101 parser.GetAttributeValue(data);
104 EXPECT_EQ(L"application/x-javascript", data); 102 EXPECT_EQ(L"application/x-javascript", data);
105 103
(...skipping 18 matching lines...) Expand all
124 } 122 }
125 123
126 TEST(CFDE_XMLSyntaxParser, ArrowBangArrow) { 124 TEST(CFDE_XMLSyntaxParser, ArrowBangArrow) {
127 const FX_WCHAR* input = 125 const FX_WCHAR* input =
128 L"<script contentType=\"application/x-javascript\">\n" 126 L"<script contentType=\"application/x-javascript\">\n"
129 L" <!>\n" 127 L" <!>\n"
130 L"</script>"; 128 L"</script>";
131 129
132 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 130 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
133 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 131 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
134 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 132 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
135 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 133 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
136 CFDE_XMLSyntaxParser parser; 134 CFDE_XMLSyntaxParser parser;
137 parser.Init(stream.get(), 256); 135 parser.Init(stream, 256);
136 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
137 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
138 138
139 CFX_WideString data; 139 CFX_WideString data;
140
141 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
142 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
143 parser.GetTagName(data); 140 parser.GetTagName(data);
144 EXPECT_EQ(L"script", data); 141 EXPECT_EQ(L"script", data);
145 142
146 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 143 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
147 parser.GetAttributeName(data); 144 parser.GetAttributeName(data);
148 EXPECT_EQ(L"contentType", data); 145 EXPECT_EQ(L"contentType", data);
149 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 146 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
150 parser.GetAttributeValue(data); 147 parser.GetAttributeValue(data);
151 EXPECT_EQ(L"application/x-javascript", data); 148 EXPECT_EQ(L"application/x-javascript", data);
152 149
(...skipping 14 matching lines...) Expand all
167 } 164 }
168 165
169 TEST(CFDE_XMLSyntaxParser, ArrowBangBracketArrow) { 166 TEST(CFDE_XMLSyntaxParser, ArrowBangBracketArrow) {
170 const FX_WCHAR* input = 167 const FX_WCHAR* input =
171 L"<script contentType=\"application/x-javascript\">\n" 168 L"<script contentType=\"application/x-javascript\">\n"
172 L" <![>\n" 169 L" <![>\n"
173 L"</script>"; 170 L"</script>";
174 171
175 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 172 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
176 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 173 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
177 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 174 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
178 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 175 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
179 CFDE_XMLSyntaxParser parser; 176 CFDE_XMLSyntaxParser parser;
180 parser.Init(stream.get(), 256); 177 parser.Init(stream, 256);
178 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
179 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
181 180
182 CFX_WideString data; 181 CFX_WideString data;
183
184 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
185 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
186 parser.GetTagName(data); 182 parser.GetTagName(data);
187 EXPECT_EQ(L"script", data); 183 EXPECT_EQ(L"script", data);
188 184
189 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 185 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
190 parser.GetAttributeName(data); 186 parser.GetAttributeName(data);
191 EXPECT_EQ(L"contentType", data); 187 EXPECT_EQ(L"contentType", data);
192 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 188 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
193 parser.GetAttributeValue(data); 189 parser.GetAttributeValue(data);
194 EXPECT_EQ(L"application/x-javascript", data); 190 EXPECT_EQ(L"application/x-javascript", data);
195 191
196 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse()); 192 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse());
197 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse()); 193 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse());
198 parser.GetTextData(data); 194 parser.GetTextData(data);
199 EXPECT_EQ(L"\n ", data); 195 EXPECT_EQ(L"\n ", data);
200 196
201 // Parser walks to end of input. 197 // Parser walks to end of input.
202 198
203 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse()); 199 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse());
204 } 200 }
205 201
206 TEST(CFDE_XMLSyntaxParser, IncompleteCData) { 202 TEST(CFDE_XMLSyntaxParser, IncompleteCData) {
207 const FX_WCHAR* input = 203 const FX_WCHAR* input =
208 L"<script contentType=\"application/x-javascript\">\n" 204 L"<script contentType=\"application/x-javascript\">\n"
209 L" <![CDATA>\n" 205 L" <![CDATA>\n"
210 L"</script>"; 206 L"</script>";
211 207
212 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 208 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
213 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 209 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
214 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 210 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
215 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 211 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
216 CFDE_XMLSyntaxParser parser; 212 CFDE_XMLSyntaxParser parser;
217 parser.Init(stream.get(), 256); 213 parser.Init(stream, 256);
214 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
215 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
218 216
219 CFX_WideString data; 217 CFX_WideString data;
220
221 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
222 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
223 parser.GetTagName(data); 218 parser.GetTagName(data);
224 EXPECT_EQ(L"script", data); 219 EXPECT_EQ(L"script", data);
225 220
226 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 221 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
227 parser.GetAttributeName(data); 222 parser.GetAttributeName(data);
228 EXPECT_EQ(L"contentType", data); 223 EXPECT_EQ(L"contentType", data);
229 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 224 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
230 parser.GetAttributeValue(data); 225 parser.GetAttributeValue(data);
231 EXPECT_EQ(L"application/x-javascript", data); 226 EXPECT_EQ(L"application/x-javascript", data);
232 227
233 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse()); 228 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse());
234 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse()); 229 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse());
235 parser.GetTextData(data); 230 parser.GetTextData(data);
236 EXPECT_EQ(L"\n ", data); 231 EXPECT_EQ(L"\n ", data);
237 232
238 // Parser walks to end of input. 233 // Parser walks to end of input.
239 234
240 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse()); 235 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse());
241 } 236 }
242 237
243 TEST(CFDE_XMLSyntaxParser, UnClosedCData) { 238 TEST(CFDE_XMLSyntaxParser, UnClosedCData) {
244 const FX_WCHAR* input = 239 const FX_WCHAR* input =
245 L"<script contentType=\"application/x-javascript\">\n" 240 L"<script contentType=\"application/x-javascript\">\n"
246 L" <![CDATA[\n" 241 L" <![CDATA[\n"
247 L"</script>"; 242 L"</script>";
248 243
249 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 244 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
250 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 245 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
251 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 246 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
252 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 247 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
253 CFDE_XMLSyntaxParser parser; 248 CFDE_XMLSyntaxParser parser;
254 parser.Init(stream.get(), 256); 249 parser.Init(stream, 256);
250 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
251 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
255 252
256 CFX_WideString data; 253 CFX_WideString data;
257
258 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
259 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
260 parser.GetTagName(data); 254 parser.GetTagName(data);
261 EXPECT_EQ(L"script", data); 255 EXPECT_EQ(L"script", data);
262 256
263 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 257 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
264 parser.GetAttributeName(data); 258 parser.GetAttributeName(data);
265 EXPECT_EQ(L"contentType", data); 259 EXPECT_EQ(L"contentType", data);
266 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 260 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
267 parser.GetAttributeValue(data); 261 parser.GetAttributeValue(data);
268 EXPECT_EQ(L"application/x-javascript", data); 262 EXPECT_EQ(L"application/x-javascript", data);
269 263
270 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse()); 264 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse());
271 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse()); 265 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse());
272 parser.GetTextData(data); 266 parser.GetTextData(data);
273 EXPECT_EQ(L"\n ", data); 267 EXPECT_EQ(L"\n ", data);
274 268
275 // Parser walks to end of input. 269 // Parser walks to end of input.
276 270
277 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse()); 271 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse());
278 } 272 }
279 273
280 TEST(CFDE_XMLSyntaxParser, EmptyCData) { 274 TEST(CFDE_XMLSyntaxParser, EmptyCData) {
281 const FX_WCHAR* input = 275 const FX_WCHAR* input =
282 L"<script contentType=\"application/x-javascript\">\n" 276 L"<script contentType=\"application/x-javascript\">\n"
283 L" <![CDATA[]]>\n" 277 L" <![CDATA[]]>\n"
284 L"</script>"; 278 L"</script>";
285 279
286 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 280 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
287 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 281 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
288 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 282 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
289 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 283 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
290 CFDE_XMLSyntaxParser parser; 284 CFDE_XMLSyntaxParser parser;
291 parser.Init(stream.get(), 256); 285 parser.Init(stream, 256);
286 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
287 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
292 288
293 CFX_WideString data; 289 CFX_WideString data;
294
295 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
296 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
297 parser.GetTagName(data); 290 parser.GetTagName(data);
298 EXPECT_EQ(L"script", data); 291 EXPECT_EQ(L"script", data);
299 292
300 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 293 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
301 parser.GetAttributeName(data); 294 parser.GetAttributeName(data);
302 EXPECT_EQ(L"contentType", data); 295 EXPECT_EQ(L"contentType", data);
303 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 296 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
304 parser.GetAttributeValue(data); 297 parser.GetAttributeValue(data);
305 EXPECT_EQ(L"application/x-javascript", data); 298 EXPECT_EQ(L"application/x-javascript", data);
306 299
(...skipping 18 matching lines...) Expand all
325 } 318 }
326 319
327 TEST(CFDE_XMLSyntaxParser, Comment) { 320 TEST(CFDE_XMLSyntaxParser, Comment) {
328 const FX_WCHAR* input = 321 const FX_WCHAR* input =
329 L"<script contentType=\"application/x-javascript\">\n" 322 L"<script contentType=\"application/x-javascript\">\n"
330 L" <!-- A Comment -->\n" 323 L" <!-- A Comment -->\n"
331 L"</script>"; 324 L"</script>";
332 325
333 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 326 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
334 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 327 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
335 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 328 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
336 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 329 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
337 CFDE_XMLSyntaxParser parser; 330 CFDE_XMLSyntaxParser parser;
338 parser.Init(stream.get(), 256); 331 parser.Init(stream, 256);
332 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
333 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
339 334
340 CFX_WideString data; 335 CFX_WideString data;
341
342 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
343 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
344 parser.GetTagName(data); 336 parser.GetTagName(data);
345 EXPECT_EQ(L"script", data); 337 EXPECT_EQ(L"script", data);
346 338
347 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 339 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
348 parser.GetAttributeName(data); 340 parser.GetAttributeName(data);
349 EXPECT_EQ(L"contentType", data); 341 EXPECT_EQ(L"contentType", data);
350 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 342 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
351 parser.GetAttributeValue(data); 343 parser.GetAttributeValue(data);
352 EXPECT_EQ(L"application/x-javascript", data); 344 EXPECT_EQ(L"application/x-javascript", data);
353 345
(...skipping 14 matching lines...) Expand all
368 } 360 }
369 361
370 TEST(CFDE_XMLSyntaxParser, IncorrectCommentStart) { 362 TEST(CFDE_XMLSyntaxParser, IncorrectCommentStart) {
371 const FX_WCHAR* input = 363 const FX_WCHAR* input =
372 L"<script contentType=\"application/x-javascript\">\n" 364 L"<script contentType=\"application/x-javascript\">\n"
373 L" <!- A Comment -->\n" 365 L" <!- A Comment -->\n"
374 L"</script>"; 366 L"</script>";
375 367
376 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 368 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
377 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 369 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
378 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 370 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
379 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 371 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
380 CFDE_XMLSyntaxParser parser; 372 CFDE_XMLSyntaxParser parser;
381 parser.Init(stream.get(), 256); 373 parser.Init(stream, 256);
374 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
375 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
382 376
383 CFX_WideString data; 377 CFX_WideString data;
384
385 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
386 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
387 parser.GetTagName(data); 378 parser.GetTagName(data);
388 EXPECT_EQ(L"script", data); 379 EXPECT_EQ(L"script", data);
389 380
390 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 381 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
391 parser.GetAttributeName(data); 382 parser.GetAttributeName(data);
392 EXPECT_EQ(L"contentType", data); 383 EXPECT_EQ(L"contentType", data);
393 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 384 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
394 parser.GetAttributeValue(data); 385 parser.GetAttributeValue(data);
395 EXPECT_EQ(L"application/x-javascript", data); 386 EXPECT_EQ(L"application/x-javascript", data);
396 387
(...skipping 14 matching lines...) Expand all
411 } 402 }
412 403
413 TEST(CFDE_XMLSyntaxParser, CommentEmpty) { 404 TEST(CFDE_XMLSyntaxParser, CommentEmpty) {
414 const FX_WCHAR* input = 405 const FX_WCHAR* input =
415 L"<script contentType=\"application/x-javascript\">\n" 406 L"<script contentType=\"application/x-javascript\">\n"
416 L" <!---->\n" 407 L" <!---->\n"
417 L"</script>"; 408 L"</script>";
418 409
419 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 410 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
420 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 411 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
421 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 412 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
422 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 413 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
423 CFDE_XMLSyntaxParser parser; 414 CFDE_XMLSyntaxParser parser;
424 parser.Init(stream.get(), 256); 415 parser.Init(stream, 256);
416 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
417 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
425 418
426 CFX_WideString data; 419 CFX_WideString data;
427
428 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
429 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
430 parser.GetTagName(data); 420 parser.GetTagName(data);
431 EXPECT_EQ(L"script", data); 421 EXPECT_EQ(L"script", data);
432 422
433 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 423 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
434 parser.GetAttributeName(data); 424 parser.GetAttributeName(data);
435 EXPECT_EQ(L"contentType", data); 425 EXPECT_EQ(L"contentType", data);
436 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 426 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
437 parser.GetAttributeValue(data); 427 parser.GetAttributeValue(data);
438 EXPECT_EQ(L"application/x-javascript", data); 428 EXPECT_EQ(L"application/x-javascript", data);
439 429
(...skipping 14 matching lines...) Expand all
454 } 444 }
455 445
456 TEST(CFDE_XMLSyntaxParser, CommentThreeDash) { 446 TEST(CFDE_XMLSyntaxParser, CommentThreeDash) {
457 const FX_WCHAR* input = 447 const FX_WCHAR* input =
458 L"<script contentType=\"application/x-javascript\">\n" 448 L"<script contentType=\"application/x-javascript\">\n"
459 L" <!--->\n" 449 L" <!--->\n"
460 L"</script>"; 450 L"</script>";
461 451
462 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 452 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
463 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 453 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
464 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 454 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
465 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 455 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
466 CFDE_XMLSyntaxParser parser; 456 CFDE_XMLSyntaxParser parser;
467 parser.Init(stream.get(), 256); 457 parser.Init(stream, 256);
458 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
459 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
468 460
469 CFX_WideString data; 461 CFX_WideString data;
470
471 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
472 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
473 parser.GetTagName(data); 462 parser.GetTagName(data);
474 EXPECT_EQ(L"script", data); 463 EXPECT_EQ(L"script", data);
475 464
476 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 465 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
477 parser.GetAttributeName(data); 466 parser.GetAttributeName(data);
478 EXPECT_EQ(L"contentType", data); 467 EXPECT_EQ(L"contentType", data);
479 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 468 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
480 parser.GetAttributeValue(data); 469 parser.GetAttributeValue(data);
481 EXPECT_EQ(L"application/x-javascript", data); 470 EXPECT_EQ(L"application/x-javascript", data);
482 471
483 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse()); 472 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse());
484 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse()); 473 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse());
485 parser.GetTextData(data); 474 parser.GetTextData(data);
486 EXPECT_EQ(L"\n ", data); 475 EXPECT_EQ(L"\n ", data);
487 476
488 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse()); 477 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse());
489 } 478 }
490 479
491 TEST(CFDE_XMLSyntaxParser, CommentTwoDash) { 480 TEST(CFDE_XMLSyntaxParser, CommentTwoDash) {
492 const FX_WCHAR* input = 481 const FX_WCHAR* input =
493 L"<script contentType=\"application/x-javascript\">\n" 482 L"<script contentType=\"application/x-javascript\">\n"
494 L" <!-->\n" 483 L" <!-->\n"
495 L"</script>"; 484 L"</script>";
496 485
497 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 486 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
498 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 487 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
499 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 488 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
500 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 489 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
501 CFDE_XMLSyntaxParser parser; 490 CFDE_XMLSyntaxParser parser;
502 parser.Init(stream.get(), 256); 491 parser.Init(stream, 256);
492 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
493 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
503 494
504 CFX_WideString data; 495 CFX_WideString data;
505
506 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
507 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
508 parser.GetTagName(data); 496 parser.GetTagName(data);
509 EXPECT_EQ(L"script", data); 497 EXPECT_EQ(L"script", data);
510 498
511 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 499 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
512 parser.GetAttributeName(data); 500 parser.GetAttributeName(data);
513 EXPECT_EQ(L"contentType", data); 501 EXPECT_EQ(L"contentType", data);
514 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 502 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
515 parser.GetAttributeValue(data); 503 parser.GetAttributeValue(data);
516 EXPECT_EQ(L"application/x-javascript", data); 504 EXPECT_EQ(L"application/x-javascript", data);
517 505
(...skipping 10 matching lines...) Expand all
528 L"<script contentType=\"application/x-javascript\">" 516 L"<script contentType=\"application/x-javascript\">"
529 L"&#66;" 517 L"&#66;"
530 L"&#x54;" 518 L"&#x54;"
531 L"&#x00000000000000000048;" 519 L"&#x00000000000000000048;"
532 L"&#x0000000000000000AB48;" 520 L"&#x0000000000000000AB48;"
533 L"&#x0000000000000000000;" 521 L"&#x0000000000000000000;"
534 L"</script>"; 522 L"</script>";
535 523
536 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 524 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
537 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 525 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
538 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 526 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
539 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 527 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
540 CFDE_XMLSyntaxParser parser; 528 CFDE_XMLSyntaxParser parser;
541 parser.Init(stream.get(), 256); 529 parser.Init(stream, 256);
530 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
531 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
542 532
543 CFX_WideString data; 533 CFX_WideString data;
544
545 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
546 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
547 parser.GetTagName(data); 534 parser.GetTagName(data);
548 EXPECT_EQ(L"script", data); 535 EXPECT_EQ(L"script", data);
549 536
550 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 537 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
551 parser.GetAttributeName(data); 538 parser.GetAttributeName(data);
552 EXPECT_EQ(L"contentType", data); 539 EXPECT_EQ(L"contentType", data);
553 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 540 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
554 parser.GetAttributeValue(data); 541 parser.GetAttributeValue(data);
555 EXPECT_EQ(L"application/x-javascript", data); 542 EXPECT_EQ(L"application/x-javascript", data);
556 543
(...skipping 11 matching lines...) Expand all
568 555
569 TEST(CFDE_XMLSyntaxParser, EntityOverflowHex) { 556 TEST(CFDE_XMLSyntaxParser, EntityOverflowHex) {
570 const FX_WCHAR* input = 557 const FX_WCHAR* input =
571 L"<script contentType=\"application/x-javascript\">" 558 L"<script contentType=\"application/x-javascript\">"
572 L"&#xaDBDFFFFF;" 559 L"&#xaDBDFFFFF;"
573 L"&#xafffffffffffffffffffffffffffffffff;" 560 L"&#xafffffffffffffffffffffffffffffffff;"
574 L"</script>"; 561 L"</script>";
575 562
576 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 563 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
577 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 564 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
578 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 565 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
579 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 566 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
580 CFDE_XMLSyntaxParser parser; 567 CFDE_XMLSyntaxParser parser;
581 parser.Init(stream.get(), 256); 568 parser.Init(stream, 256);
569 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
570 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
582 571
583 CFX_WideString data; 572 CFX_WideString data;
584
585 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
586 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
587 parser.GetTagName(data); 573 parser.GetTagName(data);
588 EXPECT_EQ(L"script", data); 574 EXPECT_EQ(L"script", data);
589 575
590 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 576 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
591 parser.GetAttributeName(data); 577 parser.GetAttributeName(data);
592 EXPECT_EQ(L"contentType", data); 578 EXPECT_EQ(L"contentType", data);
593 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 579 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
594 parser.GetAttributeValue(data); 580 parser.GetAttributeValue(data);
595 EXPECT_EQ(L"application/x-javascript", data); 581 EXPECT_EQ(L"application/x-javascript", data);
596 582
(...skipping 11 matching lines...) Expand all
608 594
609 TEST(CFDE_XMLSyntaxParser, EntityOverflowDecimal) { 595 TEST(CFDE_XMLSyntaxParser, EntityOverflowDecimal) {
610 const FX_WCHAR* input = 596 const FX_WCHAR* input =
611 L"<script contentType=\"application/x-javascript\">" 597 L"<script contentType=\"application/x-javascript\">"
612 L"&#2914910205;" 598 L"&#2914910205;"
613 L"&#29149102052342342134521341234512351234213452315;" 599 L"&#29149102052342342134521341234512351234213452315;"
614 L"</script>"; 600 L"</script>";
615 601
616 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR. 602 // We * sizeof(FX_WCHAR) because we pass in the uint8_t, not the FX_WCHAR.
617 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR); 603 size_t len = FXSYS_wcslen(input) * sizeof(FX_WCHAR);
618 std::unique_ptr<IFGAS_Stream> stream(IFGAS_Stream::CreateStream( 604 CFX_RetainPtr<IFGAS_Stream> stream = IFGAS_Stream::CreateStream(
619 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0)); 605 reinterpret_cast<uint8_t*>(const_cast<FX_WCHAR*>(input)), len, 0);
620 CFDE_XMLSyntaxParser parser; 606 CFDE_XMLSyntaxParser parser;
621 parser.Init(stream.get(), 256); 607 parser.Init(stream, 256);
608 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
609 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
622 610
623 CFX_WideString data; 611 CFX_WideString data;
624
625 EXPECT_EQ(FDE_XmlSyntaxResult::ElementOpen, parser.DoSyntaxParse());
626 EXPECT_EQ(FDE_XmlSyntaxResult::TagName, parser.DoSyntaxParse());
627 parser.GetTagName(data); 612 parser.GetTagName(data);
628 EXPECT_EQ(L"script", data); 613 EXPECT_EQ(L"script", data);
629 614
630 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse()); 615 EXPECT_EQ(FDE_XmlSyntaxResult::AttriName, parser.DoSyntaxParse());
631 parser.GetAttributeName(data); 616 parser.GetAttributeName(data);
632 EXPECT_EQ(L"contentType", data); 617 EXPECT_EQ(L"contentType", data);
633 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse()); 618 EXPECT_EQ(FDE_XmlSyntaxResult::AttriValue, parser.DoSyntaxParse());
634 parser.GetAttributeValue(data); 619 parser.GetAttributeValue(data);
635 EXPECT_EQ(L"application/x-javascript", data); 620 EXPECT_EQ(L"application/x-javascript", data);
636 621
637 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse()); 622 EXPECT_EQ(FDE_XmlSyntaxResult::ElementBreak, parser.DoSyntaxParse());
638 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse()); 623 EXPECT_EQ(FDE_XmlSyntaxResult::Text, parser.DoSyntaxParse());
639 parser.GetTextData(data); 624 parser.GetTextData(data);
640 EXPECT_EQ(L" ", data); 625 EXPECT_EQ(L" ", data);
641 626
642 EXPECT_EQ(FDE_XmlSyntaxResult::ElementClose, parser.DoSyntaxParse()); 627 EXPECT_EQ(FDE_XmlSyntaxResult::ElementClose, parser.DoSyntaxParse());
643 parser.GetTagName(data); 628 parser.GetTagName(data);
644 EXPECT_EQ(L"script", data); 629 EXPECT_EQ(L"script", data);
645 630
646 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse()); 631 EXPECT_EQ(FDE_XmlSyntaxResult::EndOfString, parser.DoSyntaxParse());
647 } 632 }
OLDNEW
« no previous file with comments | « xfa/fde/xml/fde_xml_imp.cpp ('k') | xfa/fgas/crt/fgas_stream.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698