spectests.cpp 43 KB
Newer Older
1
#include "spectests.h"
2
3
4
5
#include "specexamples.h"
#include "yaml-cpp/yaml.h"

#define YAML_ASSERT(cond) do { if(!(cond)) return "  Assert failed: " #cond; } while(false)
6

7
8
9
namespace Test
{
	namespace Spec
10
	{
11
		// 2.1
12
		TEST SeqScalars() {
13
			YAML::Node doc = YAML::Load(ex2_1);
14
			YAML_ASSERT(doc.IsSequence());
15
16
17
18
19
20
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].as<std::string>() == "Mark McGwire");
			YAML_ASSERT(doc[1].as<std::string>() == "Sammy Sosa");
			YAML_ASSERT(doc[2].as<std::string>() == "Ken Griffey");
			return true;
		}
21
22
		
		// 2.2
23
		TEST MappingScalarsToScalars() {
24
			YAML::Node doc = YAML::Load(ex2_2);
25
			YAML_ASSERT(doc.IsMap());
26
27
28
29
30
31
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["hr"].as<std::string>() == "65");
			YAML_ASSERT(doc["avg"].as<std::string>() == "0.278");
			YAML_ASSERT(doc["rbi"].as<std::string>() == "147");
			return true;
		}
32
33
		
		// 2.3
34
		TEST MappingScalarsToSequences() {
35
			YAML::Node doc = YAML::Load(ex2_3);
36
			YAML_ASSERT(doc.IsMap());
37
38
39
40
41
42
43
44
45
46
47
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["american"].size() == 3);
			YAML_ASSERT(doc["american"][0].as<std::string>() == "Boston Red Sox");
			YAML_ASSERT(doc["american"][1].as<std::string>() == "Detroit Tigers");
			YAML_ASSERT(doc["american"][2].as<std::string>() == "New York Yankees");
			YAML_ASSERT(doc["national"].size() == 3);
			YAML_ASSERT(doc["national"][0].as<std::string>() == "New York Mets");
			YAML_ASSERT(doc["national"][1].as<std::string>() == "Chicago Cubs");
			YAML_ASSERT(doc["national"][2].as<std::string>() == "Atlanta Braves");
			return true;
		}
48
49
		
		// 2.4
50
		TEST SequenceOfMappings() {
51
			YAML::Node doc = YAML::Load(ex2_4);
52
53
54
55
56
57
58
59
60
61
62
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc[0].size() == 3);
			YAML_ASSERT(doc[0]["name"].as<std::string>() == "Mark McGwire");
			YAML_ASSERT(doc[0]["hr"].as<std::string>() == "65");
			YAML_ASSERT(doc[0]["avg"].as<std::string>() == "0.278");
			YAML_ASSERT(doc[1].size() == 3);
			YAML_ASSERT(doc[1]["name"].as<std::string>() == "Sammy Sosa");
			YAML_ASSERT(doc[1]["hr"].as<std::string>() == "63");
			YAML_ASSERT(doc[1]["avg"].as<std::string>() == "0.288");
			return true;
		}
63
64
		
		// 2.5
65
		TEST SequenceOfSequences() {
66
			YAML::Node doc = YAML::Load(ex2_5);
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].size() == 3);
			YAML_ASSERT(doc[0][0].as<std::string>() == "name");
			YAML_ASSERT(doc[0][1].as<std::string>() == "hr");
			YAML_ASSERT(doc[0][2].as<std::string>() == "avg");
			YAML_ASSERT(doc[1].size() == 3);
			YAML_ASSERT(doc[1][0].as<std::string>() == "Mark McGwire");
			YAML_ASSERT(doc[1][1].as<std::string>() == "65");
			YAML_ASSERT(doc[1][2].as<std::string>() == "0.278");
			YAML_ASSERT(doc[2].size() == 3);
			YAML_ASSERT(doc[2][0].as<std::string>() == "Sammy Sosa");
			YAML_ASSERT(doc[2][1].as<std::string>() == "63");
			YAML_ASSERT(doc[2][2].as<std::string>() == "0.288");
			return true;
		}
82
83
		
		// 2.6
84
		TEST MappingOfMappings() {
85
			YAML::Node doc = YAML::Load(ex2_6);
86
87
88
89
90
91
92
93
94
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["Mark McGwire"].size() == 2);
			YAML_ASSERT(doc["Mark McGwire"]["hr"].as<std::string>() == "65");
			YAML_ASSERT(doc["Mark McGwire"]["avg"].as<std::string>() == "0.278");
			YAML_ASSERT(doc["Sammy Sosa"].size() == 2);
			YAML_ASSERT(doc["Sammy Sosa"]["hr"].as<std::string>() == "63");
			YAML_ASSERT(doc["Sammy Sosa"]["avg"].as<std::string>() == "0.288");
			return true;
		}
95
96
		
		// 2.7
97
		TEST TwoDocumentsInAStream() {
Jesse Beder's avatar
Jesse Beder committed
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
			std::vector<YAML::Node> docs = YAML::LoadAll(ex2_7);
			YAML_ASSERT(docs.size() == 2);
			
			{
				YAML::Node doc = docs[0];
				YAML_ASSERT(doc.size() == 3);
				YAML_ASSERT(doc[0].as<std::string>() == "Mark McGwire");
				YAML_ASSERT(doc[1].as<std::string>() == "Sammy Sosa");
				YAML_ASSERT(doc[2].as<std::string>() == "Ken Griffey");
			}

			{
				YAML::Node doc = docs[1];
				YAML_ASSERT(doc.size() == 2);
				YAML_ASSERT(doc[0].as<std::string>() == "Chicago Cubs");
				YAML_ASSERT(doc[1].as<std::string>() == "St Louis Cardinals");
			}
			return true;
116
		}
117
118
		
		// 2.8
119
		TEST PlayByPlayFeed() {
Jesse Beder's avatar
Jesse Beder committed
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
			std::vector<YAML::Node> docs = YAML::LoadAll(ex2_8);
			YAML_ASSERT(docs.size() == 2);
			
			{
				YAML::Node doc = docs[0];
				YAML_ASSERT(doc.size() == 3);
				YAML_ASSERT(doc["time"].as<std::string>() == "20:03:20");
				YAML_ASSERT(doc["player"].as<std::string>() == "Sammy Sosa");
				YAML_ASSERT(doc["action"].as<std::string>() == "strike (miss)");
			}

			{
				YAML::Node doc = docs[1];
				YAML_ASSERT(doc.size() == 3);
				YAML_ASSERT(doc["time"].as<std::string>() == "20:03:47");
				YAML_ASSERT(doc["player"].as<std::string>() == "Sammy Sosa");
				YAML_ASSERT(doc["action"].as<std::string>() == "grand slam");
			}
			return true;
139
		}
140
141
		
		// 2.9
142
		TEST SingleDocumentWithTwoComments() {
143
			YAML::Node doc = YAML::Load(ex2_9);
144
145
146
147
148
149
150
151
152
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["hr"].size() == 2);
			YAML_ASSERT(doc["hr"][0].as<std::string>() == "Mark McGwire");
			YAML_ASSERT(doc["hr"][1].as<std::string>() == "Sammy Sosa");
			YAML_ASSERT(doc["rbi"].size() == 2);
			YAML_ASSERT(doc["rbi"][0].as<std::string>() == "Sammy Sosa");
			YAML_ASSERT(doc["rbi"][1].as<std::string>() == "Ken Griffey");
			return true;
		}
153
154
		
		// 2.10
155
		TEST SimpleAnchor() {
156
			YAML::Node doc = YAML::Load(ex2_10);
157
158
159
160
161
162
163
164
165
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["hr"].size() == 2);
			YAML_ASSERT(doc["hr"][0].as<std::string>() == "Mark McGwire");
			YAML_ASSERT(doc["hr"][1].as<std::string>() == "Sammy Sosa");
			YAML_ASSERT(doc["rbi"].size() == 2);
			YAML_ASSERT(doc["rbi"][0].as<std::string>() == "Sammy Sosa");
			YAML_ASSERT(doc["rbi"][1].as<std::string>() == "Ken Griffey");
			return true;
		}
166
167
		
		// 2.11
168
		TEST MappingBetweenSequences() {
169
			YAML::Node doc = YAML::Load(ex2_11);
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

			std::vector<std::string> tigers_cubs;
			tigers_cubs.push_back("Detroit Tigers");
			tigers_cubs.push_back("Chicago cubs");
			
			std::vector<std::string> yankees_braves;
			yankees_braves.push_back("New York Yankees");
			yankees_braves.push_back("Atlanta Braves");
			
			
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc[tigers_cubs].size() == 1);
			YAML_ASSERT(doc[tigers_cubs][0].as<std::string>() == "2001-07-23");
			YAML_ASSERT(doc[yankees_braves].size() == 3);
			YAML_ASSERT(doc[yankees_braves][0].as<std::string>() == "2001-07-02");
			YAML_ASSERT(doc[yankees_braves][1].as<std::string>() == "2001-08-12");
			YAML_ASSERT(doc[yankees_braves][2].as<std::string>() == "2001-08-14");
			return true;
		}
189
190
		
		// 2.12
191
		TEST CompactNestedMapping() {
192
			YAML::Node doc = YAML::Load(ex2_12);
193
194
195
196
197
198
199
200
201
202
203
204
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].size() == 2);
			YAML_ASSERT(doc[0]["item"].as<std::string>() == "Super Hoop");
			YAML_ASSERT(doc[0]["quantity"].as<int>() == 1);
			YAML_ASSERT(doc[1].size() == 2);
			YAML_ASSERT(doc[1]["item"].as<std::string>() == "Basketball");
			YAML_ASSERT(doc[1]["quantity"].as<int>() == 4);
			YAML_ASSERT(doc[2].size() == 2);
			YAML_ASSERT(doc[2]["item"].as<std::string>() == "Big Shoes");
			YAML_ASSERT(doc[2]["quantity"].as<int>() == 1);
			return true;
		}
205
206
		
		// 2.13
207
		TEST InLiteralsNewlinesArePreserved() {
208
			YAML::Node doc = YAML::Load(ex2_13);
209
210
211
212
213
			YAML_ASSERT(doc.as<std::string>() ==
						"\\//||\\/||\n"
						"// ||  ||__");
			return true;
		}
214
215
		
		// 2.14
216
		TEST InFoldedScalarsNewlinesBecomeSpaces() {
217
			YAML::Node doc = YAML::Load(ex2_14);
218
219
220
			YAML_ASSERT(doc.as<std::string>() == "Mark McGwire's year was crippled by a knee injury.");
			return true;
		}
221
222
		
		// 2.15
223
		TEST FoldedNewlinesArePreservedForMoreIndentedAndBlankLines() {
224
			YAML::Node doc = YAML::Load(ex2_15);
225
226
227
228
229
230
231
			YAML_ASSERT(doc.as<std::string>() ==
						"Sammy Sosa completed another fine season with great stats.\n\n"
						"  63 Home Runs\n"
						"  0.288 Batting Average\n\n"
						"What a year!");
			return true;
		}
232
233
		
		// 2.16
234
		TEST IndentationDeterminesScope() {
235
			YAML::Node doc = YAML::Load(ex2_16);
236
237
238
239
240
241
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["name"].as<std::string>() == "Mark McGwire");
			YAML_ASSERT(doc["accomplishment"].as<std::string>() == "Mark set a major league home run record in 1998.\n");
			YAML_ASSERT(doc["stats"].as<std::string>() == "65 Home Runs\n0.278 Batting Average\n");
			return true;
		}
242
243
		
		// 2.17
244
		TEST QuotedScalars() {
245
			YAML::Node doc = YAML::Load(ex2_17);
246
247
248
249
250
251
252
253
254
			YAML_ASSERT(doc.size() == 6);
			YAML_ASSERT(doc["unicode"].as<std::string>() == "Sosa did fine.\xe2\x98\xba");
			YAML_ASSERT(doc["control"].as<std::string>() == "\b1998\t1999\t2000\n");
			YAML_ASSERT(doc["hex esc"].as<std::string>() == "\x0d\x0a is \r\n");
			YAML_ASSERT(doc["single"].as<std::string>() == "\"Howdy!\" he cried.");
			YAML_ASSERT(doc["quoted"].as<std::string>() == " # Not a 'comment'.");
			YAML_ASSERT(doc["tie-fighter"].as<std::string>() == "|\\-*-/|");
			return true;
		}
255
256
		
		// 2.18
257
		TEST MultiLineFlowScalars() {
258
			YAML::Node doc = YAML::Load(ex2_18);
259
260
261
262
263
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["plain"].as<std::string>() == "This unquoted scalar spans many lines.");
			YAML_ASSERT(doc["quoted"].as<std::string>() == "So does this quoted scalar.\n");
			return true;
		}
264
265
266
267
		
		// TODO: 2.19 - 2.22 schema tags
		
		// 2.23
Jesse Beder's avatar
Jesse Beder committed
268
		TEST VariousExplicitTags() {
269
			YAML::Node doc = YAML::Load(ex2_23);
Jesse Beder's avatar
Jesse Beder committed
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["not-date"].Tag() == "tag:yaml.org,2002:str");
			YAML_ASSERT(doc["not-date"].as<std::string>() == "2002-04-28");
			YAML_ASSERT(doc["picture"].Tag() == "tag:yaml.org,2002:binary");
			YAML_ASSERT(doc["picture"].as<std::string>() ==
						"R0lGODlhDAAMAIQAAP//9/X\n"
						"17unp5WZmZgAAAOfn515eXv\n"
						"Pz7Y6OjuDg4J+fn5OTk6enp\n"
						"56enmleECcgggoBADs=\n"
						);
			YAML_ASSERT(doc["application specific tag"].Tag() == "!something");
			YAML_ASSERT(doc["application specific tag"].as<std::string>() ==
						"The semantics of the tag\n"
						"above may be different for\n"
						"different documents."
						);
			return true;
		}
288
289
		
		// 2.24
Jesse Beder's avatar
Jesse Beder committed
290
		TEST GlobalTags() {
291
			YAML::Node doc = YAML::Load(ex2_24);
Jesse Beder's avatar
Jesse Beder committed
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
			YAML_ASSERT(doc.Tag() == "tag:clarkevans.com,2002:shape");
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].Tag() == "tag:clarkevans.com,2002:circle");
			YAML_ASSERT(doc[0].size() == 2);
			YAML_ASSERT(doc[0]["center"].size() == 2);
			YAML_ASSERT(doc[0]["center"]["x"].as<int>() == 73);
			YAML_ASSERT(doc[0]["center"]["y"].as<int>() == 129);
			YAML_ASSERT(doc[0]["radius"].as<int>() == 7);
			YAML_ASSERT(doc[1].Tag() == "tag:clarkevans.com,2002:line");
			YAML_ASSERT(doc[1].size() == 2);
			YAML_ASSERT(doc[1]["start"].size() == 2);
			YAML_ASSERT(doc[1]["start"]["x"].as<int>() == 73);
			YAML_ASSERT(doc[1]["start"]["y"].as<int>() == 129);
			YAML_ASSERT(doc[1]["finish"].size() == 2);
			YAML_ASSERT(doc[1]["finish"]["x"].as<int>() == 89);
			YAML_ASSERT(doc[1]["finish"]["y"].as<int>() == 102);
			YAML_ASSERT(doc[2].Tag() == "tag:clarkevans.com,2002:label");
			YAML_ASSERT(doc[2].size() == 3);
			YAML_ASSERT(doc[2]["start"].size() == 2);
			YAML_ASSERT(doc[2]["start"]["x"].as<int>() == 73);
			YAML_ASSERT(doc[2]["start"]["y"].as<int>() == 129);
			YAML_ASSERT(doc[2]["color"].as<std::string>() == "0xFFEEBB");
			YAML_ASSERT(doc[2]["text"].as<std::string>() == "Pretty vector drawing.");
			return true;
		}
317
318
		
		// 2.25
Jesse Beder's avatar
Jesse Beder committed
319
		TEST UnorderedSets() {
320
			YAML::Node doc = YAML::Load(ex2_25);
Jesse Beder's avatar
Jesse Beder committed
321
322
			YAML_ASSERT(doc.Tag() == "tag:yaml.org,2002:set");
			YAML_ASSERT(doc.size() == 3);
323
324
325
			YAML_ASSERT(doc["Mark McGwire"].IsNull());
			YAML_ASSERT(doc["Sammy Sosa"].IsNull());
			YAML_ASSERT(doc["Ken Griffey"].IsNull());
Jesse Beder's avatar
Jesse Beder committed
326
327
			return true;
		}
328
329
		
		// 2.26
Jesse Beder's avatar
Jesse Beder committed
330
		TEST OrderedMappings() {
331
			YAML::Node doc = YAML::Load(ex2_26);
Jesse Beder's avatar
Jesse Beder committed
332
333
334
335
336
337
338
339
340
341
			YAML_ASSERT(doc.Tag() == "tag:yaml.org,2002:omap");
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].size() == 1);
			YAML_ASSERT(doc[0]["Mark McGwire"].as<int>() == 65);
			YAML_ASSERT(doc[1].size() == 1);
			YAML_ASSERT(doc[1]["Sammy Sosa"].as<int>() == 63);
			YAML_ASSERT(doc[2].size() == 1);
			YAML_ASSERT(doc[2]["Ken Griffey"].as<int>() == 58);
			return true;
		}
342
343
		
		// 2.27
Jesse Beder's avatar
Jesse Beder committed
344
		TEST Invoice() {
345
			YAML::Node doc = YAML::Load(ex2_27);
Jesse Beder's avatar
Jesse Beder committed
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
			YAML_ASSERT(doc.Tag() == "tag:clarkevans.com,2002:invoice");
			YAML_ASSERT(doc.size() == 8);
			YAML_ASSERT(doc["invoice"].as<int>() == 34843);
			YAML_ASSERT(doc["date"].as<std::string>() == "2001-01-23");
			YAML_ASSERT(doc["bill-to"].size() == 3);
			YAML_ASSERT(doc["bill-to"]["given"].as<std::string>() == "Chris");
			YAML_ASSERT(doc["bill-to"]["family"].as<std::string>() == "Dumars");
			YAML_ASSERT(doc["bill-to"]["address"].size() == 4);
			YAML_ASSERT(doc["bill-to"]["address"]["lines"].as<std::string>() == "458 Walkman Dr.\nSuite #292\n");
			YAML_ASSERT(doc["bill-to"]["address"]["city"].as<std::string>() == "Royal Oak");
			YAML_ASSERT(doc["bill-to"]["address"]["state"].as<std::string>() == "MI");
			YAML_ASSERT(doc["bill-to"]["address"]["postal"].as<std::string>() == "48046");
			YAML_ASSERT(doc["ship-to"].size() == 3);
			YAML_ASSERT(doc["ship-to"]["given"].as<std::string>() == "Chris");
			YAML_ASSERT(doc["ship-to"]["family"].as<std::string>() == "Dumars");
			YAML_ASSERT(doc["ship-to"]["address"].size() == 4);
			YAML_ASSERT(doc["ship-to"]["address"]["lines"].as<std::string>() == "458 Walkman Dr.\nSuite #292\n");
			YAML_ASSERT(doc["ship-to"]["address"]["city"].as<std::string>() == "Royal Oak");
			YAML_ASSERT(doc["ship-to"]["address"]["state"].as<std::string>() == "MI");
			YAML_ASSERT(doc["ship-to"]["address"]["postal"].as<std::string>() == "48046");
			YAML_ASSERT(doc["product"].size() == 2);
			YAML_ASSERT(doc["product"][0].size() == 4);
			YAML_ASSERT(doc["product"][0]["sku"].as<std::string>() == "BL394D");
			YAML_ASSERT(doc["product"][0]["quantity"].as<int>() == 4);
			YAML_ASSERT(doc["product"][0]["description"].as<std::string>() == "Basketball");
			YAML_ASSERT(doc["product"][0]["price"].as<std::string>() == "450.00");
			YAML_ASSERT(doc["product"][1].size() == 4);
			YAML_ASSERT(doc["product"][1]["sku"].as<std::string>() == "BL4438H");
			YAML_ASSERT(doc["product"][1]["quantity"].as<int>() == 1);
			YAML_ASSERT(doc["product"][1]["description"].as<std::string>() == "Super Hoop");
			YAML_ASSERT(doc["product"][1]["price"].as<std::string>() == "2392.00");
			YAML_ASSERT(doc["tax"].as<std::string>() == "251.42");
			YAML_ASSERT(doc["total"].as<std::string>() == "4443.52");
			YAML_ASSERT(doc["comments"].as<std::string>() == "Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.");
			return true;
		}
382
383
		
		// 2.28
Jesse Beder's avatar
Jesse Beder committed
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
		TEST LogFile() {
			std::vector<YAML::Node> docs = YAML::LoadAll(ex2_28);
			YAML_ASSERT(docs.size() == 3);

			{
				YAML::Node doc = docs[0];
				YAML_ASSERT(doc.size() == 3);
				YAML_ASSERT(doc["Time"].as<std::string>() == "2001-11-23 15:01:42 -5");
				YAML_ASSERT(doc["User"].as<std::string>() == "ed");
				YAML_ASSERT(doc["Warning"].as<std::string>() == "This is an error message for the log file");
			}

			{
				YAML::Node doc = docs[1];
				YAML_ASSERT(doc.size() == 3);
				YAML_ASSERT(doc["Time"].as<std::string>() == "2001-11-23 15:02:31 -5");
				YAML_ASSERT(doc["User"].as<std::string>() == "ed");
				YAML_ASSERT(doc["Warning"].as<std::string>() == "A slightly different error message.");
			}

			{
				YAML::Node doc = docs[2];
				YAML_ASSERT(doc.size() == 4);
				YAML_ASSERT(doc["Date"].as<std::string>() == "2001-11-23 15:03:17 -5");
				YAML_ASSERT(doc["User"].as<std::string>() == "ed");
				YAML_ASSERT(doc["Fatal"].as<std::string>() == "Unknown variable \"bar\"");
				YAML_ASSERT(doc["Stack"].size() == 2);
				YAML_ASSERT(doc["Stack"][0].size() == 3);
				YAML_ASSERT(doc["Stack"][0]["file"].as<std::string>() == "TopClass.py");
				YAML_ASSERT(doc["Stack"][0]["line"].as<std::string>() == "23");
				YAML_ASSERT(doc["Stack"][0]["code"].as<std::string>() == "x = MoreObject(\"345\\n\")\n");
				YAML_ASSERT(doc["Stack"][1].size() == 3);
				YAML_ASSERT(doc["Stack"][1]["file"].as<std::string>() == "MoreClass.py");
				YAML_ASSERT(doc["Stack"][1]["line"].as<std::string>() == "58");
				YAML_ASSERT(doc["Stack"][1]["code"].as<std::string>() == "foo = bar");
			}
			return true;
		}
422
423
424
425
		
		// TODO: 5.1 - 5.2 BOM
		
		// 5.3
Jesse Beder's avatar
Jesse Beder committed
426
		TEST BlockStructureIndicators() {
427
			YAML::Node doc = YAML::Load(ex5_3);
Jesse Beder's avatar
Jesse Beder committed
428
429
430
431
432
433
434
435
436
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["sequence"].size() == 2);
			YAML_ASSERT(doc["sequence"][0].as<std::string>() == "one");
			YAML_ASSERT(doc["sequence"][1].as<std::string>() == "two");
			YAML_ASSERT(doc["mapping"].size() == 2);
			YAML_ASSERT(doc["mapping"]["sky"].as<std::string>() == "blue");
			YAML_ASSERT(doc["mapping"]["sea"].as<std::string>() == "green");
			return true;
		}
437
438
		
		// 5.4
Jesse Beder's avatar
Jesse Beder committed
439
		TEST FlowStructureIndicators() {
440
			YAML::Node doc = YAML::Load(ex5_4);
Jesse Beder's avatar
Jesse Beder committed
441
442
443
444
445
446
447
448
449
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["sequence"].size() == 2);
			YAML_ASSERT(doc["sequence"][0].as<std::string>() == "one");
			YAML_ASSERT(doc["sequence"][1].as<std::string>() == "two");
			YAML_ASSERT(doc["mapping"].size() == 2);
			YAML_ASSERT(doc["mapping"]["sky"].as<std::string>() == "blue");
			YAML_ASSERT(doc["mapping"]["sea"].as<std::string>() == "green");
			return true;
		}
450
451
		
		// 5.5
Jesse Beder's avatar
Jesse Beder committed
452
		TEST CommentIndicator() {
453
			YAML::Node doc = YAML::Load(ex5_5);
454
			YAML_ASSERT(doc.IsNull());
Jesse Beder's avatar
Jesse Beder committed
455
456
			return true;
		}
457
458
		
		// 5.6
Jesse Beder's avatar
Jesse Beder committed
459
		TEST NodePropertyIndicators() {
460
			YAML::Node doc = YAML::Load(ex5_6);
Jesse Beder's avatar
Jesse Beder committed
461
462
463
464
465
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["anchored"].as<std::string>() == "value"); // TODO: assert tag
			YAML_ASSERT(doc["alias"].as<std::string>() == "value");
			return true;
		}
466
467
		
		// 5.7
Jesse Beder's avatar
Jesse Beder committed
468
		TEST BlockScalarIndicators() {
469
			YAML::Node doc = YAML::Load(ex5_7);
Jesse Beder's avatar
Jesse Beder committed
470
471
472
473
474
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["literal"].as<std::string>() == "some\ntext\n");
			YAML_ASSERT(doc["folded"].as<std::string>() == "some text\n");
			return true;
		}
475
476
		
		// 5.8
Jesse Beder's avatar
Jesse Beder committed
477
		TEST QuotedScalarIndicators() {
478
			YAML::Node doc = YAML::Load(ex5_8);
Jesse Beder's avatar
Jesse Beder committed
479
480
481
482
483
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["single"].as<std::string>() == "text");
			YAML_ASSERT(doc["double"].as<std::string>() == "text");
			return true;
		}
484
485
486
487
488
		
		// TODO: 5.9 directive
		// TODO: 5.10 reserved indicator
		
		// 5.11
Jesse Beder's avatar
Jesse Beder committed
489
		TEST LineBreakCharacters() {
490
			YAML::Node doc = YAML::Load(ex5_11);
Jesse Beder's avatar
Jesse Beder committed
491
492
493
			YAML_ASSERT(doc.as<std::string>() == "Line break (no glyph)\nLine break (glyphed)\n");
			return true;
		}
494
495
		
		// 5.12
Jesse Beder's avatar
Jesse Beder committed
496
		TEST TabsAndSpaces() {
497
			YAML::Node doc = YAML::Load(ex5_12);
Jesse Beder's avatar
Jesse Beder committed
498
499
500
501
502
503
504
505
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["quoted"].as<std::string>() == "Quoted\t");
			YAML_ASSERT(doc["block"].as<std::string>() ==
						"void main() {\n"
						"\tprintf(\"Hello, world!\\n\");\n"
						"}");
			return true;
		}
506
507
		
		// 5.13
Jesse Beder's avatar
Jesse Beder committed
508
		TEST EscapedCharacters() {
509
			YAML::Node doc = YAML::Load(ex5_13);
Jesse Beder's avatar
Jesse Beder committed
510
511
512
			YAML_ASSERT(doc.as<std::string>() == "Fun with \x5C \x22 \x07 \x08 \x1B \x0C \x0A \x0D \x09 \x0B " + std::string("\x00", 1) + " \x20 \xA0 \x85 \xe2\x80\xa8 \xe2\x80\xa9 A A A");
			return true;
		}
513
514
		
		// 5.14
Jesse Beder's avatar
Jesse Beder committed
515
516
		TEST InvalidEscapedCharacters() {
			try {
517
				YAML::Load(ex5_14);
Jesse Beder's avatar
Jesse Beder committed
518
519
520
521
522
523
524
			} catch(const YAML::ParserException& e) {
				YAML_ASSERT(e.msg == std::string(YAML::ErrorMsg::INVALID_ESCAPE) + "c");
				return true;
			}
			
			return false;
		}
525
526
		
		// 6.1
527
		TEST IndentationSpaces() {
528
			YAML::Node doc = YAML::Load(ex6_1);
529
530
531
532
533
534
535
536
537
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["Not indented"].size() == 2);
			YAML_ASSERT(doc["Not indented"]["By one space"].as<std::string>() == "By four\n  spaces\n");
			YAML_ASSERT(doc["Not indented"]["Flow style"].size() == 3);
			YAML_ASSERT(doc["Not indented"]["Flow style"][0].as<std::string>() == "By two");
			YAML_ASSERT(doc["Not indented"]["Flow style"][1].as<std::string>() == "Also by two");
			YAML_ASSERT(doc["Not indented"]["Flow style"][2].as<std::string>() == "Still by two");
			return true;
		}
538
539
		
		// 6.2
540
		TEST IndentationIndicators() {
541
			YAML::Node doc = YAML::Load(ex6_2);
542
543
544
545
546
547
548
549
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["a"].size() == 2);
			YAML_ASSERT(doc["a"][0].as<std::string>() == "b");
			YAML_ASSERT(doc["a"][1].size() == 2);
			YAML_ASSERT(doc["a"][1][0].as<std::string>() == "c");
			YAML_ASSERT(doc["a"][1][1].as<std::string>() == "d");
			return true;
		}
550
551
		
		// 6.3
552
		TEST SeparationSpaces() {
553
			YAML::Node doc = YAML::Load(ex6_3);
554
555
556
557
558
559
560
561
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc[0].size() == 1);
			YAML_ASSERT(doc[0]["foo"].as<std::string>() == "bar");
			YAML_ASSERT(doc[1].size() == 2);
			YAML_ASSERT(doc[1][0].as<std::string>() == "baz");
			YAML_ASSERT(doc[1][1].as<std::string>() == "baz");
			return true;
		}
562
563
		
		// 6.4
564
		TEST LinePrefixes() {
565
			YAML::Node doc = YAML::Load(ex6_4);
566
567
568
569
570
571
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["plain"].as<std::string>() == "text lines");
			YAML_ASSERT(doc["quoted"].as<std::string>() == "text lines");
			YAML_ASSERT(doc["block"].as<std::string>() == "text\n \tlines\n");
			return true;
		}
572
573
		
		// 6.5
574
		TEST EmptyLines() {
575
			YAML::Node doc = YAML::Load(ex6_5);
576
577
578
579
580
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["Folding"].as<std::string>() == "Empty line\nas a line feed");
			YAML_ASSERT(doc["Chomping"].as<std::string>() == "Clipped empty lines\n");
			return true;
		}
581
582
		
		// 6.6
583
		TEST LineFolding() {
584
			YAML::Node doc = YAML::Load(ex6_6);
585
586
587
			YAML_ASSERT(doc.as<std::string>() == "trimmed\n\n\nas space");
			return true;
		}
588
589
		
		// 6.7
590
		TEST BlockFolding() {
591
			YAML::Node doc = YAML::Load(ex6_7);
592
593
594
			YAML_ASSERT(doc.as<std::string>() == "foo \n\n\t bar\n\nbaz\n");
			return true;
		}
595
596
		
		// 6.8
597
		TEST FlowFolding() {
598
			YAML::Node doc = YAML::Load(ex6_8);
599
600
601
			YAML_ASSERT(doc.as<std::string>() == " foo\nbar\nbaz ");
			return true;
		}
602
603
		
		// 6.9
604
		TEST SeparatedComment() {
605
			YAML::Node doc = YAML::Load(ex6_9);
606
607
608
609
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["key"].as<std::string>() == "value");
			return true;
		}
610
611
		
		// 6.10
612
		TEST CommentLines() {
613
			YAML::Node doc = YAML::Load(ex6_10);
614
			YAML_ASSERT(doc.IsNull());
615
616
			return true;
		}
617
618
		
		// 6.11
619
		TEST MultiLineComments() {
620
			YAML::Node doc = YAML::Load(ex6_11);
621
622
623
624
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["key"].as<std::string>() == "value");
			return true;
		}
625
626
		
		// 6.12
627
		TEST SeparationSpacesII() {
628
			YAML::Node doc = YAML::Load(ex6_12);
629
630
631
632
633
634
635
636
637
638
639
			
			std::map<std::string, std::string> sammy;
			sammy["first"] = "Sammy";
			sammy["last"] = "Sosa";
			
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc[sammy].size() == 2);
			YAML_ASSERT(doc[sammy]["hr"].as<int>() == 65);
			YAML_ASSERT(doc[sammy]["avg"].as<std::string>() == "0.278");
			return true;
		}
640
641
		
		// 6.13
642
		TEST ReservedDirectives() {
643
			YAML::Node doc = YAML::Load(ex6_13);
644
645
646
			YAML_ASSERT(doc.as<std::string>() == "foo");
			return true;
		}
647
648
		
		// 6.14
649
		TEST YAMLDirective() {
650
			YAML::Node doc = YAML::Load(ex6_14);
651
652
653
			YAML_ASSERT(doc.as<std::string>() == "foo");
			return true;
		}
654
655
		
		// 6.15
656
657
		TEST InvalidRepeatedYAMLDirective() {
			try {
658
				YAML::Load(ex6_15);
659
660
661
662
663
664
665
			} catch(const YAML::ParserException& e) {
				YAML_ASSERT(e.msg == YAML::ErrorMsg::REPEATED_YAML_DIRECTIVE);
				return true;
			}
			
			return "  No exception was thrown";
		}
666
667
		
		// 6.16
Jesse Beder's avatar
Jesse Beder committed
668
		TEST TagDirective() {
669
			YAML::Node doc = YAML::Load(ex6_16);
Jesse Beder's avatar
Jesse Beder committed
670
671
672
673
			YAML_ASSERT(doc.Tag() == "tag:yaml.org,2002:str");
			YAML_ASSERT(doc.as<std::string>() == "foo");
			return true;
		}
674
675
		
		// 6.17
Jesse Beder's avatar
Jesse Beder committed
676
677
		TEST InvalidRepeatedTagDirective() {
			try {
678
				YAML::Load(ex6_17);
Jesse Beder's avatar
Jesse Beder committed
679
680
681
682
683
684
685
686
687
			} catch(const YAML::ParserException& e) {
				if(e.msg == YAML::ErrorMsg::REPEATED_TAG_DIRECTIVE)
					return true;
				
				throw;
			}
			
			return "  No exception was thrown";
		}
688
689
		
		// 6.18
Jesse Beder's avatar
Jesse Beder committed
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
		TEST PrimaryTagHandle() {
			std::vector<YAML::Node> docs = YAML::LoadAll(ex6_18);
			YAML_ASSERT(docs.size() == 2);
			
			{
				YAML::Node doc = docs[0];
				YAML_ASSERT(doc.Tag() == "!foo");
				YAML_ASSERT(doc.as<std::string>() == "bar");
			}

			{
				YAML::Node doc = docs[1];
				YAML_ASSERT(doc.Tag() == "tag:example.com,2000:app/foo");
				YAML_ASSERT(doc.as<std::string>() == "bar");
			}
			return true;
		}
707
708
		
		// 6.19
Jesse Beder's avatar
Jesse Beder committed
709
		TEST SecondaryTagHandle() {
710
			YAML::Node doc = YAML::Load(ex6_19);
Jesse Beder's avatar
Jesse Beder committed
711
712
713
714
			YAML_ASSERT(doc.Tag() == "tag:example.com,2000:app/int");
			YAML_ASSERT(doc.as<std::string>() == "1 - 3");
			return true;
		}
715
716
		
		// 6.20
Jesse Beder's avatar
Jesse Beder committed
717
		TEST TagHandles() {
718
			YAML::Node doc = YAML::Load(ex6_20);
Jesse Beder's avatar
Jesse Beder committed
719
720
721
722
			YAML_ASSERT(doc.Tag() == "tag:example.com,2000:app/foo");
			YAML_ASSERT(doc.as<std::string>() == "bar");
			return true;
		}
723
724
		
		// 6.21
Jesse Beder's avatar
Jesse Beder committed
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
		TEST LocalTagPrefix() {
			std::vector<YAML::Node> docs = YAML::LoadAll(ex6_21);
			YAML_ASSERT(docs.size() == 2);
			
			{
				YAML::Node doc = docs[0];
				YAML_ASSERT(doc.Tag() == "!my-light");
				YAML_ASSERT(doc.as<std::string>() == "fluorescent");
			}

			{
				YAML::Node doc = docs[1];
				YAML_ASSERT(doc.Tag() == "!my-light");
				YAML_ASSERT(doc.as<std::string>() == "green");
			}
			return true;
		}
742
743
		
		// 6.22
Jesse Beder's avatar
Jesse Beder committed
744
		TEST GlobalTagPrefix() {
745
			YAML::Node doc = YAML::Load(ex6_22);
Jesse Beder's avatar
Jesse Beder committed
746
747
748
749
750
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc[0].Tag() == "tag:example.com,2000:app/foo");
			YAML_ASSERT(doc[0].as<std::string>() == "bar");
			return true;
		}
751
752
		
		// 6.23
Jesse Beder's avatar
Jesse Beder committed
753
		TEST NodeProperties() {
754
			YAML::Node doc = YAML::Load(ex6_23);
Jesse Beder's avatar
Jesse Beder committed
755
756
757
758
759
760
761
762
763
764
765
766
767
768
			YAML_ASSERT(doc.size() == 2);
			for(YAML::const_iterator it=doc.begin();it!=doc.end();++it) {
				if(it->first.as<std::string>() == "foo") {
					YAML_ASSERT(it->first.Tag() == "tag:yaml.org,2002:str");
					YAML_ASSERT(it->second.Tag() == "tag:yaml.org,2002:str");
					YAML_ASSERT(it->second.as<std::string>() == "bar");
				} else if(it->first.as<std::string>() == "baz") {
					YAML_ASSERT(it->second.as<std::string>() == "foo");
				} else
					return "  unknown key";
			}
			
			return true;
		}
769
770
		
		// 6.24
Jesse Beder's avatar
Jesse Beder committed
771
		TEST VerbatimTags() {
772
			YAML::Node doc = YAML::Load(ex6_24);
Jesse Beder's avatar
Jesse Beder committed
773
774
775
776
777
778
779
780
781
			YAML_ASSERT(doc.size() == 1);
			for(YAML::const_iterator it=doc.begin();it!=doc.end();++it) {
				YAML_ASSERT(it->first.Tag() == "tag:yaml.org,2002:str");
				YAML_ASSERT(it->first.as<std::string>() == "foo");
				YAML_ASSERT(it->second.Tag() == "!bar");
				YAML_ASSERT(it->second.as<std::string>() == "baz");
			}
			return true;
		}
782
783
		
		// 6.25
Jesse Beder's avatar
Jesse Beder committed
784
		TEST InvalidVerbatimTags() {
785
			YAML::Node doc = YAML::Load(ex6_25);
Jesse Beder's avatar
Jesse Beder committed
786
787
			return "  not implemented yet"; // TODO: check tags (but we probably will say these are valid, I think)
		}
788
789
		
		// 6.26
Jesse Beder's avatar
Jesse Beder committed
790
		TEST TagShorthands() {
791
			YAML::Node doc = YAML::Load(ex6_26);
Jesse Beder's avatar
Jesse Beder committed
792
793
794
795
796
797
798
799
800
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].Tag() == "!local");
			YAML_ASSERT(doc[0].as<std::string>() == "foo");
			YAML_ASSERT(doc[1].Tag() == "tag:yaml.org,2002:str");
			YAML_ASSERT(doc[1].as<std::string>() == "bar");
			YAML_ASSERT(doc[2].Tag() == "tag:example.com,2000:app/tag%21");
			YAML_ASSERT(doc[2].as<std::string>() == "baz");
			return true;
		}
801
802
		
		// 6.27
Jesse Beder's avatar
Jesse Beder committed
803
804
805
		TEST InvalidTagShorthands() {
			bool threw = false;
			try {
806
				YAML::Load(ex6_27a);
Jesse Beder's avatar
Jesse Beder committed
807
808
809
810
811
812
813
814
815
			} catch(const YAML::ParserException& e) {
				threw = true;
				if(e.msg != YAML::ErrorMsg::TAG_WITH_NO_SUFFIX)
					throw;
			}
			
			if(!threw)
				return "  No exception was thrown for a tag with no suffix";
			
816
			YAML::Load(ex6_27b); // TODO: should we reject this one (since !h! is not declared)?
Jesse Beder's avatar
Jesse Beder committed
817
818
			return "  not implemented yet";
		}
819
820
		
		// 6.28
Jesse Beder's avatar
Jesse Beder committed
821
		TEST NonSpecificTags() {
822
			YAML::Node doc = YAML::Load(ex6_28);
Jesse Beder's avatar
Jesse Beder committed
823
824
825
826
827
828
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].as<std::string>() == "12"); // TODO: check tags. How?
			YAML_ASSERT(doc[1].as<int>() == 12);
			YAML_ASSERT(doc[2].as<std::string>() == "12");
			return true;
		}
829
830
		
		// 6.29
831
		TEST NodeAnchors() {
832
			YAML::Node doc = YAML::Load(ex6_29);
833
834
835
836
837
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["First occurrence"].as<std::string>() == "Value");
			YAML_ASSERT(doc["Second occurrence"].as<std::string>() == "Value");
			return true;
		}
838
839
		
		// 7.1
840
		TEST AliasNodes() {
841
			YAML::Node doc = YAML::Load(ex7_1);
842
843
844
845
846
847
848
			YAML_ASSERT(doc.size() == 4);
			YAML_ASSERT(doc["First occurrence"].as<std::string>() == "Foo");
			YAML_ASSERT(doc["Second occurrence"].as<std::string>() == "Foo");
			YAML_ASSERT(doc["Override anchor"].as<std::string>() == "Bar");
			YAML_ASSERT(doc["Reuse anchor"].as<std::string>() == "Bar");
			return true;
		}
849
850
		
		// 7.2
851
		TEST EmptyNodes() {
852
			YAML::Node doc = YAML::Load(ex7_2);
853
854
855
856
857
858
859
860
861
862
863
864
865
			YAML_ASSERT(doc.size() == 2);
			for(YAML::const_iterator it=doc.begin();it!=doc.end();++it) {
				if(it->first.as<std::string>() == "foo") {
					YAML_ASSERT(it->second.Tag() == "tag:yaml.org,2002:str");
					YAML_ASSERT(it->second.as<std::string>() == "");
				} else if(it->first.as<std::string>() == "") {
					YAML_ASSERT(it->first.Tag() == "tag:yaml.org,2002:str");
					YAML_ASSERT(it->second.as<std::string>() == "bar");
				} else
					return "  unexpected key";
			}
			return true;
		}
866
867
		
		// 7.3
868
		TEST CompletelyEmptyNodes() {
869
			YAML::Node doc = YAML::Load(ex7_3);
870
			YAML_ASSERT(doc.size() == 2);
871
			YAML_ASSERT(doc["foo"].IsNull());
872
			YAML_ASSERT(doc[YAML::Null].as<std::string>() == "bar");
873
874
			return true;
		}
875
876
		
		// 7.4
877
		TEST DoubleQuotedImplicitKeys() {
878
			YAML::Node doc = YAML::Load(ex7_4);
879
880
881
882
883
884
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["implicit block key"].size() == 1);
			YAML_ASSERT(doc["implicit block key"][0].size() == 1);
			YAML_ASSERT(doc["implicit block key"][0]["implicit flow key"].as<std::string>() == "value");
			return true;
		}
885
886
		
		// 7.5
887
		TEST DoubleQuotedLineBreaks() {
888
			YAML::Node doc = YAML::Load(ex7_5);
889
890
891
			YAML_ASSERT(doc.as<std::string>() == "folded to a space,\nto a line feed, or \t \tnon-content");
			return true;
		}
892
893
		
		// 7.6
894
		TEST DoubleQuotedLines() {
895
			YAML::Node doc = YAML::Load(ex7_6);
896
897
898
			YAML_ASSERT(doc.as<std::string>() == " 1st non-empty\n2nd non-empty 3rd non-empty ");
			return true;
		}
899
900
		
		// 7.7
901
		TEST SingleQuotedCharacters() {
902
			YAML::Node doc = YAML::Load(ex7_7);
903
904
905
			YAML_ASSERT(doc.as<std::string>() == "here's to \"quotes\"");
			return true;
		}
906
907
		
		// 7.8
908
		TEST SingleQuotedImplicitKeys() {
909
			YAML::Node doc = YAML::Load(ex7_8);
910
911
912
913
914
915
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["implicit block key"].size() == 1);
			YAML_ASSERT(doc["implicit block key"][0].size() == 1);
			YAML_ASSERT(doc["implicit block key"][0]["implicit flow key"].as<std::string>() == "value");
			return true;
		}
916
917
		
		// 7.9
918
		TEST SingleQuotedLines() {
919
			YAML::Node doc = YAML::Load(ex7_9);
920
921
922
			YAML_ASSERT(doc.as<std::string>() == " 1st non-empty\n2nd non-empty 3rd non-empty ");
			return true;
		}
923
924
		
		// 7.10
925
		TEST PlainCharacters() {
926
			YAML::Node doc = YAML::Load(ex7_10);
927
928
929
930
931
932
933
934
935
936
937
938
939
940
			YAML_ASSERT(doc.size() == 6);
			YAML_ASSERT(doc[0].as<std::string>() == "::vector");
			YAML_ASSERT(doc[1].as<std::string>() == ": - ()");
			YAML_ASSERT(doc[2].as<std::string>() == "Up, up, and away!");
			YAML_ASSERT(doc[3].as<int>() == -123);
			YAML_ASSERT(doc[4].as<std::string>() == "http://example.com/foo#bar");
			YAML_ASSERT(doc[5].size() == 5);
			YAML_ASSERT(doc[5][0].as<std::string>() == "::vector");
			YAML_ASSERT(doc[5][1].as<std::string>() == ": - ()");
			YAML_ASSERT(doc[5][2].as<std::string>() == "Up, up, and away!");
			YAML_ASSERT(doc[5][3].as<int>() == -123);
			YAML_ASSERT(doc[5][4].as<std::string>() == "http://example.com/foo#bar");
			return true;
		}
941
942
		
		// 7.11
943
		TEST PlainImplicitKeys() {
944
			YAML::Node doc = YAML::Load(ex7_11);
945
946
947
948
949
950
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["implicit block key"].size() == 1);
			YAML_ASSERT(doc["implicit block key"][0].size() == 1);
			YAML_ASSERT(doc["implicit block key"][0]["implicit flow key"].as<std::string>() == "value");
			return true;
		}
951
952
		
		// 7.12
953
		TEST PlainLines() {
954
			YAML::Node doc = YAML::Load(ex7_12);
955
956
957
			YAML_ASSERT(doc.as<std::string>() == "1st non-empty\n2nd non-empty 3rd non-empty");
			return true;
		}
958
959
		
		// 7.13
960
		TEST FlowSequence() {
961
			YAML::Node doc = YAML::Load(ex7_13);
962
963
964
965
966
967
968
969
970
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc[0].size() == 2);
			YAML_ASSERT(doc[0][0].as<std::string>() == "one");
			YAML_ASSERT(doc[0][1].as<std::string>() == "two");
			YAML_ASSERT(doc[1].size() == 2);
			YAML_ASSERT(doc[1][0].as<std::string>() == "three");
			YAML_ASSERT(doc[1][1].as<std::string>() == "four");
			return true;
		}
971
972
		
		// 7.14
973
		TEST FlowSequenceEntries() {
974
			YAML::Node doc = YAML::Load(ex7_14);
975
976
977
978
979
980
981
982
983
984
			YAML_ASSERT(doc.size() == 5);
			YAML_ASSERT(doc[0].as<std::string>() == "double quoted");
			YAML_ASSERT(doc[1].as<std::string>() == "single quoted");
			YAML_ASSERT(doc[2].as<std::string>() == "plain text");
			YAML_ASSERT(doc[3].size() == 1);
			YAML_ASSERT(doc[3][0].as<std::string>() == "nested");
			YAML_ASSERT(doc[4].size() == 1);
			YAML_ASSERT(doc[4]["single"].as<std::string>() == "pair");
			return true;
		}
985
986
		
		// 7.15
987
		TEST FlowMappings() {
988
			YAML::Node doc = YAML::Load(ex7_15);
989
990
991
992
993
994
995
996
997
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc[0].size() == 2);
			YAML_ASSERT(doc[0]["one"].as<std::string>() == "two");
			YAML_ASSERT(doc[0]["three"].as<std::string>() == "four");
			YAML_ASSERT(doc[1].size() == 2);
			YAML_ASSERT(doc[1]["five"].as<std::string>() == "six");
			YAML_ASSERT(doc[1]["seven"].as<std::string>() == "eight");
			return true;
		}
998
999
		
		// 7.16
1000
		TEST FlowMappingEntries() {
1001
			YAML::Node doc = YAML::Load(ex7_16);
1002
1003
1004
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["explicit"].as<std::string>() == "entry");
			YAML_ASSERT(doc["implicit"].as<std::string>() == "entry");
1005
			YAML_ASSERT(doc[YAML::Null].IsNull());
1006
1007
			return true;
		}
1008
1009
		
		// 7.17
1010
		TEST FlowMappingSeparateValues() {
1011
			YAML::Node doc = YAML::Load(ex7_17);
1012
1013
			YAML_ASSERT(doc.size() == 4);
			YAML_ASSERT(doc["unquoted"].as<std::string>() == "separate");
1014
1015
			YAML_ASSERT(doc["http://foo.com"].IsNull());
			YAML_ASSERT(doc["omitted value"].IsNull());
1016
			YAML_ASSERT(doc[YAML::Null].as<std::string>() == "omitted key");
1017
1018
			return true;
		}
1019
1020
		
		// 7.18
1021
		TEST FlowMappingAdjacentValues() {
1022
			YAML::Node doc = YAML::Load(ex7_18);
1023
1024
1025
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["adjacent"].as<std::string>() == "value");
			YAML_ASSERT(doc["readable"].as<std::string>() == "value");
1026
			YAML_ASSERT(doc["empty"].IsNull());
1027
1028
			return true;
		}
1029
1030
		
		// 7.19
1031
		TEST SinglePairFlowMappings() {
1032
			YAML::Node doc = YAML::Load(ex7_19);
1033
1034
1035
1036
1037
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc[0].size() == 1);
			YAML_ASSERT(doc[0]["foo"].as<std::string>() == "bar");
			return true;
		}
1038
1039
		
		// 7.20
1040
		TEST SinglePairExplicitEntry() {
1041
			YAML::Node doc = YAML::Load(ex7_20);
1042
1043
1044
1045
1046
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc[0].size() == 1);
			YAML_ASSERT(doc[0]["foo bar"].as<std::string>() == "baz");
			return true;
		}
1047
1048
		
		// 7.21
1049
		TEST SinglePairImplicitEntries() {
1050
			YAML::Node doc = YAML::Load(ex7_21);
1051
1052
1053
1054
1055
1056
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].size() == 1);
			YAML_ASSERT(doc[0][0].size() == 1);
			YAML_ASSERT(doc[0][0]["YAML"].as<std::string>() == "separate");
			YAML_ASSERT(doc[1].size() == 1);
			YAML_ASSERT(doc[1][0].size() == 1);
1057
			YAML_ASSERT(doc[1][0][YAML::Null].as<std::string>() == "empty key entry");
1058
1059
1060
1061
1062
1063
1064
1065
			YAML_ASSERT(doc[2].size() == 1);
			YAML_ASSERT(doc[2][0].size() == 1);
			
			std::map<std::string, std::string> key;
			key["JSON"] = "like";
			YAML_ASSERT(doc[2][0][key].as<std::string>() == "adjacent");
			return true;
		}
1066
1067
		
		// 7.22
1068
1069
		TEST InvalidImplicitKeys() {
			try {
1070
				YAML::Load(ex7_22);
1071
1072
1073
1074
1075
1076
1077
1078
			} catch(const YAML::Exception& e) {
				if(e.msg == YAML::ErrorMsg::END_OF_SEQ_FLOW)
					return true;
				
				throw;
			}
			return "  no exception thrown";
		}
1079
1080
		
		// 7.23
1081
		TEST FlowContent() {
1082
			YAML::Node doc = YAML::Load(ex7_23);
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
			YAML_ASSERT(doc.size() == 5);
			YAML_ASSERT(doc[0].size() == 2);
			YAML_ASSERT(doc[0][0].as<std::string>() == "a");
			YAML_ASSERT(doc[0][1].as<std::string>() == "b");
			YAML_ASSERT(doc[1].size() == 1);
			YAML_ASSERT(doc[1]["a"].as<std::string>() == "b");
			YAML_ASSERT(doc[2].as<std::string>() == "a");
			YAML_ASSERT(doc[3].as<char>() == 'b');
			YAML_ASSERT(doc[4].as<std::string>() == "c");
			return true;
		}
1094
1095
		
		// 7.24
1096
		TEST FlowNodes() {
1097
			YAML::Node doc = YAML::Load(ex7_24);
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
			YAML_ASSERT(doc.size() == 5);
			YAML_ASSERT(doc[0].Tag() == "tag:yaml.org,2002:str");
			YAML_ASSERT(doc[0].as<std::string>() == "a");
			YAML_ASSERT(doc[1].as<char>() == 'b');
			YAML_ASSERT(doc[2].as<std::string>() == "c");
			YAML_ASSERT(doc[3].as<std::string>() == "c");
			YAML_ASSERT(doc[4].Tag() == "tag:yaml.org,2002:str");
			YAML_ASSERT(doc[4].as<std::string>() == "");
			return true;
		}
1108

1109
		// 8.1
1110
		TEST BlockScalarHeader() {
1111
			YAML::Node doc = YAML::Load(ex8_1);
1112
1113
1114
1115
1116
1117
1118
			YAML_ASSERT(doc.size() == 4);
			YAML_ASSERT(doc[0].as<std::string>() == "literal\n");
			YAML_ASSERT(doc[1].as<std::string>() == " folded\n");
			YAML_ASSERT(doc[2].as<std::string>() == "keep\n\n");
			YAML_ASSERT(doc[3].as<std::string>() == " strip");
			return true;
		}
1119
1120
		
		// 8.2
1121
		TEST BlockIndentationHeader() {
1122
			YAML::Node doc = YAML::Load(ex8_2);
1123
1124
1125
1126
1127
1128
1129
			YAML_ASSERT(doc.size() == 4);
			YAML_ASSERT(doc[0].as<std::string>() == "detected\n");
			YAML_ASSERT(doc[1].as<std::string>() == "\n\n# detected\n");
			YAML_ASSERT(doc[2].as<std::string>() == " explicit\n");
			YAML_ASSERT(doc[3].as<std::string>() == "\t\ndetected\n");
			return true;
		}
1130
1131
		
		// 8.3
1132
1133
1134
1135
		TEST InvalidBlockScalarIndentationIndicators() {
			{
				bool threw = false;
				try {
1136
					YAML::Load(ex8_3a);
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
				} catch(const YAML::Exception& e) {
					if(e.msg != YAML::ErrorMsg::END_OF_SEQ)
						throw;
					
					threw = true;
				}
				
				if(!threw)
					return "  no exception thrown for less indented auto-detecting indentation for a literal block scalar";
			}
			
			{
				bool threw = false;
				try {
1151
					YAML::Load(ex8_3b);
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
				} catch(const YAML::Exception& e) {
					if(e.msg != YAML::ErrorMsg::END_OF_SEQ)
						throw;
					
					threw = true;
				}
				
				if(!threw)
					return "  no exception thrown for less indented auto-detecting indentation for a folded block scalar";
			}
			
			{
				bool threw = false;
				try {
1166
					YAML::Load(ex8_3c);
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
				} catch(const YAML::Exception& e) {
					if(e.msg != YAML::ErrorMsg::END_OF_SEQ)
						throw;
					
					threw = true;
				}
				
				if(!threw)
					return "  no exception thrown for less indented explicit indentation for a literal block scalar";
			}
			
			return true;
		}
1180
1181
		
		// 8.4
1182
		TEST ChompingFinalLineBreak() {
1183
			YAML::Node doc = YAML::Load(ex8_4);
1184
1185
1186
1187
1188
1189
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["strip"].as<std::string>() == "text");
			YAML_ASSERT(doc["clip"].as<std::string>() == "text\n");
			YAML_ASSERT(doc["keep"].as<std::string>() == "text\n");
			return true;
		}
1190
1191
		
		// 8.5
1192
		TEST ChompingTrailingLines() {
1193
			YAML::Node doc = YAML::Load(ex8_5);
1194
1195
1196
1197
1198
1199
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["strip"].as<std::string>() == "# text");
			YAML_ASSERT(doc["clip"].as<std::string>() == "# text\n");
			YAML_ASSERT(doc["keep"].as<std::string>() == "# text\n"); // Note: I believe this is a bug in the YAML spec - it should be "# text\n\n"
			return true;
		}
1200
1201
		
		// 8.6
1202
		TEST EmptyScalarChomping() {
1203
			YAML::Node doc = YAML::Load(ex8_6);
1204
1205
1206
1207
1208
1209
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["strip"].as<std::string>() == "");
			YAML_ASSERT(doc["clip"].as<std::string>() == "");
			YAML_ASSERT(doc["keep"].as<std::string>() == "\n");
			return true;
		}
1210
1211
		
		// 8.7
1212
		TEST LiteralScalar() {
1213
			YAML::Node doc = YAML::Load(ex8_7);
1214
1215
1216
			YAML_ASSERT(doc.as<std::string>() == "literal\n\ttext\n");
			return true;
		}
1217
1218
		
		// 8.8
1219
		TEST LiteralContent() {
1220
			YAML::Node doc = YAML::Load(ex8_8);
1221
1222
1223
			YAML_ASSERT(doc.as<std::string>() == "\n\nliteral\n \n\ntext\n");
			return true;
		}
1224
1225
		
		// 8.9
1226
		TEST FoldedScalar() {
1227
			YAML::Node doc = YAML::Load(ex8_9);
1228
1229
1230
			YAML_ASSERT(doc.as<std::string>() == "folded text\n");
			return true;
		}
1231
1232
		
		// 8.10
1233
		TEST FoldedLines() {
1234
			YAML::Node doc = YAML::Load(ex8_10);
1235
1236
1237
			YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n  * bullet\n\n  * list\n  * lines\n\nlast line\n");
			return true;
		}
1238
1239
		
		// 8.11
1240
		TEST MoreIndentedLines() {
1241
			YAML::Node doc = YAML::Load(ex8_11);
1242
1243
1244
			YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n  * bullet\n\n  * list\n  * lines\n\nlast line\n");
			return true;
		}
1245
1246
		
		// 8.12
1247
		TEST EmptySeparationLines() {
1248
			YAML::Node doc = YAML::Load(ex8_12);
1249
1250
1251
			YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n  * bullet\n\n  * list\n  * lines\n\nlast line\n");
			return true;
		}
1252
1253
		
		// 8.13
1254
		TEST FinalEmptyLines() {
1255
			YAML::Node doc = YAML::Load(ex8_13);
1256
1257
1258
			YAML_ASSERT(doc.as<std::string>() == "\nfolded line\nnext line\n  * bullet\n\n  * list\n  * lines\n\nlast line\n");
			return true;
		}
1259
1260
		
		// 8.14
1261
		TEST BlockSequence() {
1262
			YAML::Node doc = YAML::Load(ex8_14);
1263
1264
1265
1266
1267
1268
1269
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["block sequence"].size() == 2);
			YAML_ASSERT(doc["block sequence"][0].as<std::string>() == "one");
			YAML_ASSERT(doc["block sequence"][1].size() == 1);
			YAML_ASSERT(doc["block sequence"][1]["two"].as<std::string>() == "three");
			return true;
		}
1270
1271
		
		// 8.15
1272
		TEST BlockSequenceEntryTypes() {
1273
			YAML::Node doc = YAML::Load(ex8_15);
1274
			YAML_ASSERT(doc.size() == 4);
1275
			YAML_ASSERT(doc[0].IsNull());
1276
1277
1278
1279
1280
1281
1282
1283
			YAML_ASSERT(doc[1].as<std::string>() == "block node\n");
			YAML_ASSERT(doc[2].size() == 2);
			YAML_ASSERT(doc[2][0].as<std::string>() == "one");
			YAML_ASSERT(doc[2][1].as<std::string>() == "two");
			YAML_ASSERT(doc[3].size() == 1);
			YAML_ASSERT(doc[3]["one"].as<std::string>() == "two");
			return true;
		}
1284
1285
		
		// 8.16
1286
		TEST BlockMappings() {
1287
			YAML::Node doc = YAML::Load(ex8_16);
1288
1289
1290
1291
1292
			YAML_ASSERT(doc.size() == 1);
			YAML_ASSERT(doc["block mapping"].size() == 1);
			YAML_ASSERT(doc["block mapping"]["key"].as<std::string>() == "value");
			return true;
		}
1293
1294
		
		// 8.17
1295
		TEST ExplicitBlockMappingEntries() {
1296
			YAML::Node doc = YAML::Load(ex8_17);
1297
			YAML_ASSERT(doc.size() == 2);
1298
			YAML_ASSERT(doc["explicit key"].IsNull());
1299
1300
1301
1302
1303
			YAML_ASSERT(doc["block key\n"].size() == 2);
			YAML_ASSERT(doc["block key\n"][0].as<std::string>() == "one");
			YAML_ASSERT(doc["block key\n"][1].as<std::string>() == "two");
			return true;
		}
1304
1305
		
		// 8.18
1306
		TEST ImplicitBlockMappingEntries() {
1307
			YAML::Node doc = YAML::Load(ex8_18);
1308
1309
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc["plain key"].as<std::string>() == "in-line value");
1310
			YAML_ASSERT(doc[YAML::Null].IsNull());
1311
1312
1313
1314
			YAML_ASSERT(doc["quoted key"].size() == 1);
			YAML_ASSERT(doc["quoted key"][0].as<std::string>() == "entry");
			return true;
		}
1315
1316
		
		// 8.19
1317
		TEST CompactBlockMappings() {
1318
			YAML::Node doc = YAML::Load(ex8_19);
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc[0].size() == 1);
			YAML_ASSERT(doc[0]["sun"].as<std::string>() == "yellow");
			YAML_ASSERT(doc[1].size() == 1);
			std::map<std::string, std::string> key;
			key["earth"] = "blue";
			YAML_ASSERT(doc[1][key].size() == 1);
			YAML_ASSERT(doc[1][key]["moon"].as<std::string>() == "white");
			return true;
		}
1329
1330
		
		// 8.20
1331
		TEST BlockNodeTypes() {
1332
			YAML::Node doc = YAML::Load(ex8_20);
1333
1334
1335
1336
1337
1338
1339
			YAML_ASSERT(doc.size() == 3);
			YAML_ASSERT(doc[0].as<std::string>() == "flow in block");
			YAML_ASSERT(doc[1].as<std::string>() == "Block scalar\n");
			YAML_ASSERT(doc[2].size() == 1);
			YAML_ASSERT(doc[2]["foo"].as<std::string>() == "bar");
			return true;
		}
1340
1341
		
		// 8.21
1342
		TEST BlockScalarNodes() {
1343
			YAML::Node doc = YAML::Load(ex8_21);
1344
1345
1346
1347
1348
1349
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["literal"].as<std::string>() == "value"); // Note: I believe this is a bug in the YAML spec - it should be "value\n"
			YAML_ASSERT(doc["folded"].as<std::string>() == "value");
			YAML_ASSERT(doc["folded"].Tag() == "!foo");
			return true;
		}
1350
1351
		
		// 8.22
1352
		TEST BlockCollectionNodes() {
1353
			YAML::Node doc = YAML::Load(ex8_22);
1354
1355
1356
1357
1358
1359
1360
1361
1362
			YAML_ASSERT(doc.size() == 2);
			YAML_ASSERT(doc["sequence"].size() == 2);
			YAML_ASSERT(doc["sequence"][0].as<std::string>() == "entry");
			YAML_ASSERT(doc["sequence"][1].size() == 1);
			YAML_ASSERT(doc["sequence"][1][0].as<std::string>() == "nested");
			YAML_ASSERT(doc["mapping"].size() == 1);
			YAML_ASSERT(doc["mapping"]["foo"].as<std::string>() == "bar");
			return true;
		}
1363
1364
	}
}