src/vendor/yaml-rust/tests/spec_test.rs.inc

   1 #[test]
   2 fn test_ex2_1_seq_scalars() {
   3     let mut v = str_to_test_events(EX2_1).into_iter();
   4     assert_next!(v, TestEvent::OnDocumentStart);
   5     assert_next!(v, TestEvent::OnSequenceStart);
   6     assert_next!(v, TestEvent::OnScalar);
   7     assert_next!(v, TestEvent::OnScalar);
   8     assert_next!(v, TestEvent::OnScalar);
   9     assert_next!(v, TestEvent::OnSequenceEnd);
  10     assert_next!(v, TestEvent::OnDocumentEnd);
  11 }
  12
  13 #[test]
  14 fn test_ex2_2_mapping_scalars_to_scalars() {
  15     let mut v = str_to_test_events(EX2_2).into_iter();
  16     assert_next!(v, TestEvent::OnDocumentStart);
  17     assert_next!(v, TestEvent::OnMapStart);
  18     assert_next!(v, TestEvent::OnScalar);
  19     assert_next!(v, TestEvent::OnScalar);
  20     assert_next!(v, TestEvent::OnScalar);
  21     assert_next!(v, TestEvent::OnScalar);
  22     assert_next!(v, TestEvent::OnScalar);
  23     assert_next!(v, TestEvent::OnScalar);
  24     assert_next!(v, TestEvent::OnMapEnd);
  25     assert_next!(v, TestEvent::OnDocumentEnd);
  26 }
  27
  28 #[test]
  29 fn test_ex2_3_mapping_scalars_to_sequences() {
  30     let mut v = str_to_test_events(EX2_3).into_iter();
  31     assert_next!(v, TestEvent::OnDocumentStart);
  32     assert_next!(v, TestEvent::OnMapStart);
  33     assert_next!(v, TestEvent::OnScalar);
  34     assert_next!(v, TestEvent::OnSequenceStart);
  35     assert_next!(v, TestEvent::OnScalar);
  36     assert_next!(v, TestEvent::OnScalar);
  37     assert_next!(v, TestEvent::OnScalar);
  38     assert_next!(v, TestEvent::OnSequenceEnd);
  39     assert_next!(v, TestEvent::OnScalar);
  40     assert_next!(v, TestEvent::OnSequenceStart);
  41     assert_next!(v, TestEvent::OnScalar);
  42     assert_next!(v, TestEvent::OnScalar);
  43     assert_next!(v, TestEvent::OnScalar);
  44     assert_next!(v, TestEvent::OnSequenceEnd);
  45     assert_next!(v, TestEvent::OnMapEnd);
  46     assert_next!(v, TestEvent::OnDocumentEnd);
  47 }
  48
  49 #[test]
  50 fn test_ex2_4_sequence_of_mappings() {
  51     let mut v = str_to_test_events(EX2_4).into_iter();
  52     assert_next!(v, TestEvent::OnDocumentStart);
  53     assert_next!(v, TestEvent::OnSequenceStart);
  54     assert_next!(v, TestEvent::OnMapStart);
  55     assert_next!(v, TestEvent::OnScalar);
  56     assert_next!(v, TestEvent::OnScalar);
  57     assert_next!(v, TestEvent::OnScalar);
  58     assert_next!(v, TestEvent::OnScalar);
  59     assert_next!(v, TestEvent::OnScalar);
  60     assert_next!(v, TestEvent::OnScalar);
  61     assert_next!(v, TestEvent::OnMapEnd);
  62     assert_next!(v, TestEvent::OnMapStart);
  63     assert_next!(v, TestEvent::OnScalar);
  64     assert_next!(v, TestEvent::OnScalar);
  65     assert_next!(v, TestEvent::OnScalar);
  66     assert_next!(v, TestEvent::OnScalar);
  67     assert_next!(v, TestEvent::OnScalar);
  68     assert_next!(v, TestEvent::OnScalar);
  69     assert_next!(v, TestEvent::OnMapEnd);
  70     assert_next!(v, TestEvent::OnSequenceEnd);
  71     assert_next!(v, TestEvent::OnDocumentEnd);
  72 }
  73
  74 #[test]
  75 fn test_ex2_5_sequence_of_sequences() {
  76     let mut v = str_to_test_events(EX2_5).into_iter();
  77     assert_next!(v, TestEvent::OnDocumentStart);
  78     assert_next!(v, TestEvent::OnSequenceStart);
  79     assert_next!(v, TestEvent::OnSequenceStart);
  80     assert_next!(v, TestEvent::OnScalar);
  81     assert_next!(v, TestEvent::OnScalar);
  82     assert_next!(v, TestEvent::OnScalar);
  83     assert_next!(v, TestEvent::OnSequenceEnd);
  84     assert_next!(v, TestEvent::OnSequenceStart);
  85     assert_next!(v, TestEvent::OnScalar);
  86     assert_next!(v, TestEvent::OnScalar);
  87     assert_next!(v, TestEvent::OnScalar);
  88     assert_next!(v, TestEvent::OnSequenceEnd);
  89     assert_next!(v, TestEvent::OnSequenceStart);
  90     assert_next!(v, TestEvent::OnScalar);
  91     assert_next!(v, TestEvent::OnScalar);
  92     assert_next!(v, TestEvent::OnScalar);
  93     assert_next!(v, TestEvent::OnSequenceEnd);
  94     assert_next!(v, TestEvent::OnSequenceEnd);
  95     assert_next!(v, TestEvent::OnDocumentEnd);
  96 }
  97
  98 #[test]
  99 fn test_ex2_6_mapping_of_mappings() {
 100     let mut v = str_to_test_events(EX2_6).into_iter();
 101     assert_next!(v, TestEvent::OnDocumentStart);
 102     assert_next!(v, TestEvent::OnMapStart);
 103     assert_next!(v, TestEvent::OnScalar);
 104     assert_next!(v, TestEvent::OnMapStart);
 105     assert_next!(v, TestEvent::OnScalar);
 106     assert_next!(v, TestEvent::OnScalar);
 107     assert_next!(v, TestEvent::OnScalar);
 108     assert_next!(v, TestEvent::OnScalar);
 109     assert_next!(v, TestEvent::OnMapEnd);
 110     assert_next!(v, TestEvent::OnScalar);
 111     assert_next!(v, TestEvent::OnMapStart);
 112     assert_next!(v, TestEvent::OnScalar);
 113     assert_next!(v, TestEvent::OnScalar);
 114     assert_next!(v, TestEvent::OnScalar);
 115     assert_next!(v, TestEvent::OnScalar);
 116     assert_next!(v, TestEvent::OnMapEnd);
 117     assert_next!(v, TestEvent::OnMapEnd);
 118     assert_next!(v, TestEvent::OnDocumentEnd);
 119 }
 120
 121 #[test]
 122 fn test_ex2_7_two_documents_in_a_stream() {
 123     let mut v = str_to_test_events(EX2_7).into_iter();
 124     assert_next!(v, TestEvent::OnDocumentStart);
 125     assert_next!(v, TestEvent::OnSequenceStart);
 126     assert_next!(v, TestEvent::OnScalar);
 127     assert_next!(v, TestEvent::OnScalar);
 128     assert_next!(v, TestEvent::OnScalar);
 129     assert_next!(v, TestEvent::OnSequenceEnd);
 130     assert_next!(v, TestEvent::OnDocumentEnd);
 131     assert_next!(v, TestEvent::OnDocumentStart);
 132     assert_next!(v, TestEvent::OnSequenceStart);
 133     assert_next!(v, TestEvent::OnScalar);
 134     assert_next!(v, TestEvent::OnScalar);
 135     assert_next!(v, TestEvent::OnSequenceEnd);
 136     assert_next!(v, TestEvent::OnDocumentEnd);
 137 }
 138
 139 #[test]
 140 fn test_ex2_8_play_by_play_feed() {
 141     let mut v = str_to_test_events(EX2_8).into_iter();
 142     assert_next!(v, TestEvent::OnDocumentStart);
 143     assert_next!(v, TestEvent::OnMapStart);
 144     assert_next!(v, TestEvent::OnScalar);
 145     assert_next!(v, TestEvent::OnScalar);
 146     assert_next!(v, TestEvent::OnScalar);
 147     assert_next!(v, TestEvent::OnScalar);
 148     assert_next!(v, TestEvent::OnScalar);
 149     assert_next!(v, TestEvent::OnScalar);
 150     assert_next!(v, TestEvent::OnMapEnd);
 151     assert_next!(v, TestEvent::OnDocumentEnd);
 152     assert_next!(v, TestEvent::OnDocumentStart);
 153     assert_next!(v, TestEvent::OnMapStart);
 154     assert_next!(v, TestEvent::OnScalar);
 155     assert_next!(v, TestEvent::OnScalar);
 156     assert_next!(v, TestEvent::OnScalar);
 157     assert_next!(v, TestEvent::OnScalar);
 158     assert_next!(v, TestEvent::OnScalar);
 159     assert_next!(v, TestEvent::OnScalar);
 160     assert_next!(v, TestEvent::OnMapEnd);
 161     assert_next!(v, TestEvent::OnDocumentEnd);
 162 }
 163
 164 #[test]
 165 fn test_ex2_9_single_document_with_two_comments() {
 166     let mut v = str_to_test_events(EX2_9).into_iter();
 167     assert_next!(v, TestEvent::OnDocumentStart);
 168     assert_next!(v, TestEvent::OnMapStart);
 169     assert_next!(v, TestEvent::OnScalar);
 170     assert_next!(v, TestEvent::OnSequenceStart);
 171     assert_next!(v, TestEvent::OnScalar);
 172     assert_next!(v, TestEvent::OnScalar);
 173     assert_next!(v, TestEvent::OnSequenceEnd);
 174     assert_next!(v, TestEvent::OnScalar);
 175     assert_next!(v, TestEvent::OnSequenceStart);
 176     assert_next!(v, TestEvent::OnScalar);
 177     assert_next!(v, TestEvent::OnScalar);
 178     assert_next!(v, TestEvent::OnSequenceEnd);
 179     assert_next!(v, TestEvent::OnMapEnd);
 180     assert_next!(v, TestEvent::OnDocumentEnd);
 181 }
 182
 183 #[test]
 184 fn test_ex2_10_simple_anchor() {
 185     let mut v = str_to_test_events(EX2_10).into_iter();
 186     assert_next!(v, TestEvent::OnDocumentStart);
 187     assert_next!(v, TestEvent::OnMapStart);
 188     assert_next!(v, TestEvent::OnScalar);
 189     assert_next!(v, TestEvent::OnSequenceStart);
 190     assert_next!(v, TestEvent::OnScalar);
 191     assert_next!(v, TestEvent::OnScalar);
 192     assert_next!(v, TestEvent::OnSequenceEnd);
 193     assert_next!(v, TestEvent::OnScalar);
 194     assert_next!(v, TestEvent::OnSequenceStart);
 195     assert_next!(v, TestEvent::OnAlias);
 196     assert_next!(v, TestEvent::OnScalar);
 197     assert_next!(v, TestEvent::OnSequenceEnd);
 198     assert_next!(v, TestEvent::OnMapEnd);
 199     assert_next!(v, TestEvent::OnDocumentEnd);
 200 }
 201
 202 #[test]
 203 fn test_ex2_11_mapping_between_sequences() {
 204     let mut v = str_to_test_events(EX2_11).into_iter();
 205     assert_next!(v, TestEvent::OnDocumentStart);
 206     assert_next!(v, TestEvent::OnMapStart);
 207     assert_next!(v, TestEvent::OnSequenceStart);
 208     assert_next!(v, TestEvent::OnScalar);
 209     assert_next!(v, TestEvent::OnScalar);
 210     assert_next!(v, TestEvent::OnSequenceEnd);
 211     assert_next!(v, TestEvent::OnSequenceStart);
 212     assert_next!(v, TestEvent::OnScalar);
 213     assert_next!(v, TestEvent::OnSequenceEnd);
 214     assert_next!(v, TestEvent::OnSequenceStart);
 215     assert_next!(v, TestEvent::OnScalar);
 216     assert_next!(v, TestEvent::OnScalar);
 217     assert_next!(v, TestEvent::OnSequenceEnd);
 218     assert_next!(v, TestEvent::OnSequenceStart);
 219     assert_next!(v, TestEvent::OnScalar);
 220     assert_next!(v, TestEvent::OnScalar);
 221     assert_next!(v, TestEvent::OnScalar);
 222     assert_next!(v, TestEvent::OnSequenceEnd);
 223     assert_next!(v, TestEvent::OnMapEnd);
 224     assert_next!(v, TestEvent::OnDocumentEnd);
 225 }
 226
 227 #[test]
 228 fn test_ex2_12_compact_nested_mapping() {
 229     let mut v = str_to_test_events(EX2_12).into_iter();
 230     assert_next!(v, TestEvent::OnDocumentStart);
 231     assert_next!(v, TestEvent::OnSequenceStart);
 232     assert_next!(v, TestEvent::OnMapStart);
 233     assert_next!(v, TestEvent::OnScalar);
 234     assert_next!(v, TestEvent::OnScalar);
 235     assert_next!(v, TestEvent::OnScalar);
 236     assert_next!(v, TestEvent::OnScalar);
 237     assert_next!(v, TestEvent::OnMapEnd);
 238     assert_next!(v, TestEvent::OnMapStart);
 239     assert_next!(v, TestEvent::OnScalar);
 240     assert_next!(v, TestEvent::OnScalar);
 241     assert_next!(v, TestEvent::OnScalar);
 242     assert_next!(v, TestEvent::OnScalar);
 243     assert_next!(v, TestEvent::OnMapEnd);
 244     assert_next!(v, TestEvent::OnMapStart);
 245     assert_next!(v, TestEvent::OnScalar);
 246     assert_next!(v, TestEvent::OnScalar);
 247     assert_next!(v, TestEvent::OnScalar);
 248     assert_next!(v, TestEvent::OnScalar);
 249     assert_next!(v, TestEvent::OnMapEnd);
 250     assert_next!(v, TestEvent::OnSequenceEnd);
 251     assert_next!(v, TestEvent::OnDocumentEnd);
 252 }
 253
 254 #[test]
 255 fn test_ex2_13_in_literals_newlines_are_preserved() {
 256     let mut v = str_to_test_events(EX2_13).into_iter();
 257     assert_next!(v, TestEvent::OnDocumentStart);
 258     assert_next!(v, TestEvent::OnScalar);
 259     assert_next!(v, TestEvent::OnDocumentEnd);
 260 }
 261
 262 #[test]
 263 fn test_ex2_14_in_folded_scalars_newlines_become_spaces() {
 264     let mut v = str_to_test_events(EX2_14).into_iter();
 265     assert_next!(v, TestEvent::OnDocumentStart);
 266     assert_next!(v, TestEvent::OnScalar);
 267     assert_next!(v, TestEvent::OnDocumentEnd);
 268 }
 269
 270 #[test]
 271 fn test_ex2_15_folded_newlines_are_preserved_for_more_indented_and_blank_lines() {
 272     let mut v = str_to_test_events(EX2_15).into_iter();
 273     assert_next!(v, TestEvent::OnDocumentStart);
 274     assert_next!(v, TestEvent::OnScalar);
 275     assert_next!(v, TestEvent::OnDocumentEnd);
 276 }
 277
 278 #[test]
 279 fn test_ex2_16_indentation_determines_scope() {
 280     let mut v = str_to_test_events(EX2_16).into_iter();
 281     assert_next!(v, TestEvent::OnDocumentStart);
 282     assert_next!(v, TestEvent::OnMapStart);
 283     assert_next!(v, TestEvent::OnScalar);
 284     assert_next!(v, TestEvent::OnScalar);
 285     assert_next!(v, TestEvent::OnScalar);
 286     assert_next!(v, TestEvent::OnScalar);
 287     assert_next!(v, TestEvent::OnScalar);
 288     assert_next!(v, TestEvent::OnScalar);
 289     assert_next!(v, TestEvent::OnMapEnd);
 290     assert_next!(v, TestEvent::OnDocumentEnd);
 291 }
 292
 293 #[test]
 294 fn test_ex2_17_quoted_scalars() {
 295     let mut v = str_to_test_events(EX2_17).into_iter();
 296     assert_next!(v, TestEvent::OnDocumentStart);
 297     assert_next!(v, TestEvent::OnMapStart);
 298     assert_next!(v, TestEvent::OnScalar);
 299     assert_next!(v, TestEvent::OnScalar);
 300     assert_next!(v, TestEvent::OnScalar);
 301     assert_next!(v, TestEvent::OnScalar);
 302     assert_next!(v, TestEvent::OnScalar);
 303     assert_next!(v, TestEvent::OnScalar);
 304     assert_next!(v, TestEvent::OnScalar);
 305     assert_next!(v, TestEvent::OnScalar);
 306     assert_next!(v, TestEvent::OnScalar);
 307     assert_next!(v, TestEvent::OnScalar);
 308     assert_next!(v, TestEvent::OnScalar);
 309     assert_next!(v, TestEvent::OnScalar);
 310     assert_next!(v, TestEvent::OnMapEnd);
 311     assert_next!(v, TestEvent::OnDocumentEnd);
 312 }
 313
 314 #[test]
 315 fn test_ex2_18_multi_line_flow_scalars() {
 316     let mut v = str_to_test_events(EX2_18).into_iter();
 317     assert_next!(v, TestEvent::OnDocumentStart);
 318     assert_next!(v, TestEvent::OnMapStart);
 319     assert_next!(v, TestEvent::OnScalar);
 320     assert_next!(v, TestEvent::OnScalar);
 321     assert_next!(v, TestEvent::OnScalar);
 322     assert_next!(v, TestEvent::OnScalar);
 323     assert_next!(v, TestEvent::OnMapEnd);
 324     assert_next!(v, TestEvent::OnDocumentEnd);
 325 }
 326
 327 #[test]
 328 fn test_ex2_23_various_explicit_tags() {
 329     let mut v = str_to_test_events(EX2_23).into_iter();
 330     assert_next!(v, TestEvent::OnDocumentStart);
 331     assert_next!(v, TestEvent::OnMapStart);
 332     assert_next!(v, TestEvent::OnScalar);
 333     assert_next!(v, TestEvent::OnScalar);
 334     assert_next!(v, TestEvent::OnScalar);
 335     assert_next!(v, TestEvent::OnScalar);
 336     assert_next!(v, TestEvent::OnScalar);
 337     assert_next!(v, TestEvent::OnScalar);
 338     assert_next!(v, TestEvent::OnMapEnd);
 339     assert_next!(v, TestEvent::OnDocumentEnd);
 340 }
 341
 342 #[test]
 343 fn test_ex2_24_global_tags() {
 344     let mut v = str_to_test_events(EX2_24).into_iter();
 345     assert_next!(v, TestEvent::OnDocumentStart);
 346     assert_next!(v, TestEvent::OnSequenceStart);
 347     assert_next!(v, TestEvent::OnMapStart);
 348     assert_next!(v, TestEvent::OnScalar);
 349     assert_next!(v, TestEvent::OnMapStart);
 350     assert_next!(v, TestEvent::OnScalar);
 351     assert_next!(v, TestEvent::OnScalar);
 352     assert_next!(v, TestEvent::OnScalar);
 353     assert_next!(v, TestEvent::OnScalar);
 354     assert_next!(v, TestEvent::OnMapEnd);
 355     assert_next!(v, TestEvent::OnScalar);
 356     assert_next!(v, TestEvent::OnScalar);
 357     assert_next!(v, TestEvent::OnMapEnd);
 358     assert_next!(v, TestEvent::OnMapStart);
 359     assert_next!(v, TestEvent::OnScalar);
 360     assert_next!(v, TestEvent::OnAlias);
 361     assert_next!(v, TestEvent::OnScalar);
 362     assert_next!(v, TestEvent::OnMapStart);
 363     assert_next!(v, TestEvent::OnScalar);
 364     assert_next!(v, TestEvent::OnScalar);
 365     assert_next!(v, TestEvent::OnScalar);
 366     assert_next!(v, TestEvent::OnScalar);
 367     assert_next!(v, TestEvent::OnMapEnd);
 368     assert_next!(v, TestEvent::OnMapEnd);
 369     assert_next!(v, TestEvent::OnMapStart);
 370     assert_next!(v, TestEvent::OnScalar);
 371     assert_next!(v, TestEvent::OnAlias);
 372     assert_next!(v, TestEvent::OnScalar);
 373     assert_next!(v, TestEvent::OnScalar);
 374     assert_next!(v, TestEvent::OnScalar);
 375     assert_next!(v, TestEvent::OnScalar);
 376     assert_next!(v, TestEvent::OnMapEnd);
 377     assert_next!(v, TestEvent::OnSequenceEnd);
 378     assert_next!(v, TestEvent::OnDocumentEnd);
 379 }
 380
 381 #[test]
 382 fn test_ex2_25_unordered_sets() {
 383     let mut v = str_to_test_events(EX2_25).into_iter();
 384     assert_next!(v, TestEvent::OnDocumentStart);
 385     assert_next!(v, TestEvent::OnMapStart);
 386     assert_next!(v, TestEvent::OnScalar);
 387     assert_next!(v, TestEvent::OnNull);
 388     assert_next!(v, TestEvent::OnScalar);
 389     assert_next!(v, TestEvent::OnNull);
 390     assert_next!(v, TestEvent::OnScalar);
 391     assert_next!(v, TestEvent::OnNull);
 392     assert_next!(v, TestEvent::OnMapEnd);
 393     assert_next!(v, TestEvent::OnDocumentEnd);
 394 }
 395
 396 #[test]
 397 fn test_ex2_26_ordered_mappings() {
 398     let mut v = str_to_test_events(EX2_26).into_iter();
 399     assert_next!(v, TestEvent::OnDocumentStart);
 400     assert_next!(v, TestEvent::OnSequenceStart);
 401     assert_next!(v, TestEvent::OnMapStart);
 402     assert_next!(v, TestEvent::OnScalar);
 403     assert_next!(v, TestEvent::OnScalar);
 404     assert_next!(v, TestEvent::OnMapEnd);
 405     assert_next!(v, TestEvent::OnMapStart);
 406     assert_next!(v, TestEvent::OnScalar);
 407     assert_next!(v, TestEvent::OnScalar);
 408     assert_next!(v, TestEvent::OnMapEnd);
 409     assert_next!(v, TestEvent::OnMapStart);
 410     assert_next!(v, TestEvent::OnScalar);
 411     assert_next!(v, TestEvent::OnScalar);
 412     assert_next!(v, TestEvent::OnMapEnd);
 413     assert_next!(v, TestEvent::OnSequenceEnd);
 414     assert_next!(v, TestEvent::OnDocumentEnd);
 415 }
 416
 417 #[test]
 418 fn test_ex2_27_invoice() {
 419     let mut v = str_to_test_events(EX2_27).into_iter();
 420     assert_next!(v, TestEvent::OnDocumentStart);
 421     assert_next!(v, TestEvent::OnMapStart);
 422     assert_next!(v, TestEvent::OnScalar);
 423     assert_next!(v, TestEvent::OnScalar);
 424     assert_next!(v, TestEvent::OnScalar);
 425     assert_next!(v, TestEvent::OnScalar);
 426     assert_next!(v, TestEvent::OnScalar);
 427     assert_next!(v, TestEvent::OnMapStart);
 428     assert_next!(v, TestEvent::OnScalar);
 429     assert_next!(v, TestEvent::OnScalar);
 430     assert_next!(v, TestEvent::OnScalar);
 431     assert_next!(v, TestEvent::OnScalar);
 432     assert_next!(v, TestEvent::OnScalar);
 433     assert_next!(v, TestEvent::OnMapStart);
 434     assert_next!(v, TestEvent::OnScalar);
 435     assert_next!(v, TestEvent::OnScalar);
 436     assert_next!(v, TestEvent::OnScalar);
 437     assert_next!(v, TestEvent::OnScalar);
 438     assert_next!(v, TestEvent::OnScalar);
 439     assert_next!(v, TestEvent::OnScalar);
 440     assert_next!(v, TestEvent::OnScalar);
 441     assert_next!(v, TestEvent::OnScalar);
 442     assert_next!(v, TestEvent::OnMapEnd);
 443     assert_next!(v, TestEvent::OnMapEnd);
 444     assert_next!(v, TestEvent::OnScalar);
 445     assert_next!(v, TestEvent::OnAlias);
 446     assert_next!(v, TestEvent::OnScalar);
 447     assert_next!(v, TestEvent::OnSequenceStart);
 448     assert_next!(v, TestEvent::OnMapStart);
 449     assert_next!(v, TestEvent::OnScalar);
 450     assert_next!(v, TestEvent::OnScalar);
 451     assert_next!(v, TestEvent::OnScalar);
 452     assert_next!(v, TestEvent::OnScalar);
 453     assert_next!(v, TestEvent::OnScalar);
 454     assert_next!(v, TestEvent::OnScalar);
 455     assert_next!(v, TestEvent::OnScalar);
 456     assert_next!(v, TestEvent::OnScalar);
 457     assert_next!(v, TestEvent::OnMapEnd);
 458     assert_next!(v, TestEvent::OnMapStart);
 459     assert_next!(v, TestEvent::OnScalar);
 460     assert_next!(v, TestEvent::OnScalar);
 461     assert_next!(v, TestEvent::OnScalar);
 462     assert_next!(v, TestEvent::OnScalar);
 463     assert_next!(v, TestEvent::OnScalar);
 464     assert_next!(v, TestEvent::OnScalar);
 465     assert_next!(v, TestEvent::OnScalar);
 466     assert_next!(v, TestEvent::OnScalar);
 467     assert_next!(v, TestEvent::OnMapEnd);
 468     assert_next!(v, TestEvent::OnSequenceEnd);
 469     assert_next!(v, TestEvent::OnScalar);
 470     assert_next!(v, TestEvent::OnScalar);
 471     assert_next!(v, TestEvent::OnScalar);
 472     assert_next!(v, TestEvent::OnScalar);
 473     assert_next!(v, TestEvent::OnScalar);
 474     assert_next!(v, TestEvent::OnScalar);
 475     assert_next!(v, TestEvent::OnMapEnd);
 476     assert_next!(v, TestEvent::OnDocumentEnd);
 477 }
 478
 479 #[test]
 480 fn test_ex2_28_log_file() {
 481     let mut v = str_to_test_events(EX2_28).into_iter();
 482     assert_next!(v, TestEvent::OnDocumentStart);
 483     assert_next!(v, TestEvent::OnMapStart);
 484     assert_next!(v, TestEvent::OnScalar);
 485     assert_next!(v, TestEvent::OnScalar);
 486     assert_next!(v, TestEvent::OnScalar);
 487     assert_next!(v, TestEvent::OnScalar);
 488     assert_next!(v, TestEvent::OnScalar);
 489     assert_next!(v, TestEvent::OnScalar);
 490     assert_next!(v, TestEvent::OnMapEnd);
 491     assert_next!(v, TestEvent::OnDocumentEnd);
 492     assert_next!(v, TestEvent::OnDocumentStart);
 493     assert_next!(v, TestEvent::OnMapStart);
 494     assert_next!(v, TestEvent::OnScalar);
 495     assert_next!(v, TestEvent::OnScalar);
 496     assert_next!(v, TestEvent::OnScalar);
 497     assert_next!(v, TestEvent::OnScalar);
 498     assert_next!(v, TestEvent::OnScalar);
 499     assert_next!(v, TestEvent::OnScalar);
 500     assert_next!(v, TestEvent::OnMapEnd);
 501     assert_next!(v, TestEvent::OnDocumentEnd);
 502     assert_next!(v, TestEvent::OnDocumentStart);
 503     assert_next!(v, TestEvent::OnMapStart);
 504     assert_next!(v, TestEvent::OnScalar);
 505     assert_next!(v, TestEvent::OnScalar);
 506     assert_next!(v, TestEvent::OnScalar);
 507     assert_next!(v, TestEvent::OnScalar);
 508     assert_next!(v, TestEvent::OnScalar);
 509     assert_next!(v, TestEvent::OnScalar);
 510     assert_next!(v, TestEvent::OnScalar);
 511     assert_next!(v, TestEvent::OnSequenceStart);
 512     assert_next!(v, TestEvent::OnMapStart);
 513     assert_next!(v, TestEvent::OnScalar);
 514     assert_next!(v, TestEvent::OnScalar);
 515     assert_next!(v, TestEvent::OnScalar);
 516     assert_next!(v, TestEvent::OnScalar);
 517     assert_next!(v, TestEvent::OnScalar);
 518     assert_next!(v, TestEvent::OnScalar);
 519     assert_next!(v, TestEvent::OnMapEnd);
 520     assert_next!(v, TestEvent::OnMapStart);
 521     assert_next!(v, TestEvent::OnScalar);
 522     assert_next!(v, TestEvent::OnScalar);
 523     assert_next!(v, TestEvent::OnScalar);
 524     assert_next!(v, TestEvent::OnScalar);
 525     assert_next!(v, TestEvent::OnScalar);
 526     assert_next!(v, TestEvent::OnScalar);
 527     assert_next!(v, TestEvent::OnMapEnd);
 528     assert_next!(v, TestEvent::OnSequenceEnd);
 529     assert_next!(v, TestEvent::OnMapEnd);
 530     assert_next!(v, TestEvent::OnDocumentEnd);
 531 }
 532
 533 #[test]
 534 fn test_ex5_3_block_structure_indicators() {
 535     let mut v = str_to_test_events(EX5_3).into_iter();
 536     assert_next!(v, TestEvent::OnDocumentStart);
 537     assert_next!(v, TestEvent::OnMapStart);
 538     assert_next!(v, TestEvent::OnScalar);
 539     assert_next!(v, TestEvent::OnSequenceStart);
 540     assert_next!(v, TestEvent::OnScalar);
 541     assert_next!(v, TestEvent::OnScalar);
 542     assert_next!(v, TestEvent::OnSequenceEnd);
 543     assert_next!(v, TestEvent::OnScalar);
 544     assert_next!(v, TestEvent::OnMapStart);
 545     assert_next!(v, TestEvent::OnScalar);
 546     assert_next!(v, TestEvent::OnScalar);
 547     assert_next!(v, TestEvent::OnScalar);
 548     assert_next!(v, TestEvent::OnScalar);
 549     assert_next!(v, TestEvent::OnMapEnd);
 550     assert_next!(v, TestEvent::OnMapEnd);
 551     assert_next!(v, TestEvent::OnDocumentEnd);
 552 }
 553
 554 #[test]
 555 fn test_ex5_4_flow_structure_indicators() {
 556     let mut v = str_to_test_events(EX5_4).into_iter();
 557     assert_next!(v, TestEvent::OnDocumentStart);
 558     assert_next!(v, TestEvent::OnMapStart);
 559     assert_next!(v, TestEvent::OnScalar);
 560     assert_next!(v, TestEvent::OnSequenceStart);
 561     assert_next!(v, TestEvent::OnScalar);
 562     assert_next!(v, TestEvent::OnScalar);
 563     assert_next!(v, TestEvent::OnSequenceEnd);
 564     assert_next!(v, TestEvent::OnScalar);
 565     assert_next!(v, TestEvent::OnMapStart);
 566     assert_next!(v, TestEvent::OnScalar);
 567     assert_next!(v, TestEvent::OnScalar);
 568     assert_next!(v, TestEvent::OnScalar);
 569     assert_next!(v, TestEvent::OnScalar);
 570     assert_next!(v, TestEvent::OnMapEnd);
 571     assert_next!(v, TestEvent::OnMapEnd);
 572     assert_next!(v, TestEvent::OnDocumentEnd);
 573 }
 574
 575 #[test]
 576 fn test_ex5_6_node_property_indicators() {
 577     let mut v = str_to_test_events(EX5_6).into_iter();
 578     assert_next!(v, TestEvent::OnDocumentStart);
 579     assert_next!(v, TestEvent::OnMapStart);
 580     assert_next!(v, TestEvent::OnScalar);
 581     assert_next!(v, TestEvent::OnScalar);
 582     assert_next!(v, TestEvent::OnScalar);
 583     assert_next!(v, TestEvent::OnAlias);
 584     assert_next!(v, TestEvent::OnMapEnd);
 585     assert_next!(v, TestEvent::OnDocumentEnd);
 586 }
 587
 588 #[test]
 589 fn test_ex5_7_block_scalar_indicators() {
 590     let mut v = str_to_test_events(EX5_7).into_iter();
 591     assert_next!(v, TestEvent::OnDocumentStart);
 592     assert_next!(v, TestEvent::OnMapStart);
 593     assert_next!(v, TestEvent::OnScalar);
 594     assert_next!(v, TestEvent::OnScalar);
 595     assert_next!(v, TestEvent::OnScalar);
 596     assert_next!(v, TestEvent::OnScalar);
 597     assert_next!(v, TestEvent::OnMapEnd);
 598     assert_next!(v, TestEvent::OnDocumentEnd);
 599 }
 600
 601 #[test]
 602 fn test_ex5_8_quoted_scalar_indicators() {
 603     let mut v = str_to_test_events(EX5_8).into_iter();
 604     assert_next!(v, TestEvent::OnDocumentStart);
 605     assert_next!(v, TestEvent::OnMapStart);
 606     assert_next!(v, TestEvent::OnScalar);
 607     assert_next!(v, TestEvent::OnScalar);
 608     assert_next!(v, TestEvent::OnScalar);
 609     assert_next!(v, TestEvent::OnScalar);
 610     assert_next!(v, TestEvent::OnMapEnd);
 611     assert_next!(v, TestEvent::OnDocumentEnd);
 612 }
 613
 614 #[test]
 615 fn test_ex5_11_line_break_characters() {
 616     let mut v = str_to_test_events(EX5_11).into_iter();
 617     assert_next!(v, TestEvent::OnDocumentStart);
 618     assert_next!(v, TestEvent::OnScalar);
 619     assert_next!(v, TestEvent::OnDocumentEnd);
 620 }
 621
 622 #[test]
 623 fn test_ex5_12_tabs_and_spaces() {
 624     let mut v = str_to_test_events(EX5_12).into_iter();
 625     assert_next!(v, TestEvent::OnDocumentStart);
 626     assert_next!(v, TestEvent::OnMapStart);
 627     assert_next!(v, TestEvent::OnScalar);
 628     assert_next!(v, TestEvent::OnScalar);
 629     assert_next!(v, TestEvent::OnScalar);
 630     assert_next!(v, TestEvent::OnScalar);
 631     assert_next!(v, TestEvent::OnMapEnd);
 632     assert_next!(v, TestEvent::OnDocumentEnd);
 633 }
 634
 635 #[test]
 636 fn test_ex5_13_escaped_characters() {
 637     let mut v = str_to_test_events(EX5_13).into_iter();
 638     assert_next!(v, TestEvent::OnDocumentStart);
 639     assert_next!(v, TestEvent::OnScalar);
 640     assert_next!(v, TestEvent::OnDocumentEnd);
 641 }
 642
 643 #[test]
 644 fn test_ex6_1_indentation_spaces() {
 645     let mut v = str_to_test_events(EX6_1).into_iter();
 646     assert_next!(v, TestEvent::OnDocumentStart);
 647     assert_next!(v, TestEvent::OnMapStart);
 648     assert_next!(v, TestEvent::OnScalar);
 649     assert_next!(v, TestEvent::OnMapStart);
 650     assert_next!(v, TestEvent::OnScalar);
 651     assert_next!(v, TestEvent::OnScalar);
 652     assert_next!(v, TestEvent::OnScalar);
 653     assert_next!(v, TestEvent::OnSequenceStart);
 654     assert_next!(v, TestEvent::OnScalar);
 655     assert_next!(v, TestEvent::OnScalar);
 656     assert_next!(v, TestEvent::OnScalar);
 657     assert_next!(v, TestEvent::OnSequenceEnd);
 658     assert_next!(v, TestEvent::OnMapEnd);
 659     assert_next!(v, TestEvent::OnMapEnd);
 660     assert_next!(v, TestEvent::OnDocumentEnd);
 661 }
 662
 663 #[test]
 664 fn test_ex6_2_indentation_indicators() {
 665     let mut v = str_to_test_events(EX6_2).into_iter();
 666     assert_next!(v, TestEvent::OnDocumentStart);
 667     assert_next!(v, TestEvent::OnMapStart);
 668     assert_next!(v, TestEvent::OnScalar);
 669     assert_next!(v, TestEvent::OnSequenceStart);
 670     assert_next!(v, TestEvent::OnScalar);
 671     assert_next!(v, TestEvent::OnSequenceStart);
 672     assert_next!(v, TestEvent::OnScalar);
 673     assert_next!(v, TestEvent::OnScalar);
 674     assert_next!(v, TestEvent::OnSequenceEnd);
 675     assert_next!(v, TestEvent::OnSequenceEnd);
 676     assert_next!(v, TestEvent::OnMapEnd);
 677     assert_next!(v, TestEvent::OnDocumentEnd);
 678 }
 679
 680 #[test]
 681 fn test_ex6_3_separation_spaces() {
 682     let mut v = str_to_test_events(EX6_3).into_iter();
 683     assert_next!(v, TestEvent::OnDocumentStart);
 684     assert_next!(v, TestEvent::OnSequenceStart);
 685     assert_next!(v, TestEvent::OnMapStart);
 686     assert_next!(v, TestEvent::OnScalar);
 687     assert_next!(v, TestEvent::OnScalar);
 688     assert_next!(v, TestEvent::OnMapEnd);
 689     assert_next!(v, TestEvent::OnSequenceStart);
 690     assert_next!(v, TestEvent::OnScalar);
 691     assert_next!(v, TestEvent::OnScalar);
 692     assert_next!(v, TestEvent::OnSequenceEnd);
 693     assert_next!(v, TestEvent::OnSequenceEnd);
 694     assert_next!(v, TestEvent::OnDocumentEnd);
 695 }
 696
 697 #[test]
 698 fn test_ex6_4_line_prefixes() {
 699     let mut v = str_to_test_events(EX6_4).into_iter();
 700     assert_next!(v, TestEvent::OnDocumentStart);
 701     assert_next!(v, TestEvent::OnMapStart);
 702     assert_next!(v, TestEvent::OnScalar);
 703     assert_next!(v, TestEvent::OnScalar);
 704     assert_next!(v, TestEvent::OnScalar);
 705     assert_next!(v, TestEvent::OnScalar);
 706     assert_next!(v, TestEvent::OnScalar);
 707     assert_next!(v, TestEvent::OnScalar);
 708     assert_next!(v, TestEvent::OnMapEnd);
 709     assert_next!(v, TestEvent::OnDocumentEnd);
 710 }
 711
 712 #[test]
 713 fn test_ex6_5_empty_lines() {
 714     let mut v = str_to_test_events(EX6_5).into_iter();
 715     assert_next!(v, TestEvent::OnDocumentStart);
 716     assert_next!(v, TestEvent::OnMapStart);
 717     assert_next!(v, TestEvent::OnScalar);
 718     assert_next!(v, TestEvent::OnScalar);
 719     assert_next!(v, TestEvent::OnScalar);
 720     assert_next!(v, TestEvent::OnScalar);
 721     assert_next!(v, TestEvent::OnMapEnd);
 722     assert_next!(v, TestEvent::OnDocumentEnd);
 723 }
 724
 725 #[test]
 726 fn test_ex6_6_line_folding() {
 727     let mut v = str_to_test_events(EX6_6).into_iter();
 728     assert_next!(v, TestEvent::OnDocumentStart);
 729     assert_next!(v, TestEvent::OnScalar);
 730     assert_next!(v, TestEvent::OnDocumentEnd);
 731 }
 732
 733 #[test]
 734 fn test_ex6_7_block_folding() {
 735     let mut v = str_to_test_events(EX6_7).into_iter();
 736     assert_next!(v, TestEvent::OnDocumentStart);
 737     assert_next!(v, TestEvent::OnScalar);
 738     assert_next!(v, TestEvent::OnDocumentEnd);
 739 }
 740
 741 #[test]
 742 fn test_ex6_8_flow_folding() {
 743     let mut v = str_to_test_events(EX6_8).into_iter();
 744     assert_next!(v, TestEvent::OnDocumentStart);
 745     assert_next!(v, TestEvent::OnScalar);
 746     assert_next!(v, TestEvent::OnDocumentEnd);
 747 }
 748
 749 #[test]
 750 fn test_ex6_9_separated_comment() {
 751     let mut v = str_to_test_events(EX6_9).into_iter();
 752     assert_next!(v, TestEvent::OnDocumentStart);
 753     assert_next!(v, TestEvent::OnMapStart);
 754     assert_next!(v, TestEvent::OnScalar);
 755     assert_next!(v, TestEvent::OnScalar);
 756     assert_next!(v, TestEvent::OnMapEnd);
 757     assert_next!(v, TestEvent::OnDocumentEnd);
 758 }
 759
 760 #[test]
 761 fn test_ex6_12_separation_spaces_ii() {
 762     let mut v = str_to_test_events(EX6_12).into_iter();
 763     assert_next!(v, TestEvent::OnDocumentStart);
 764     assert_next!(v, TestEvent::OnMapStart);
 765     assert_next!(v, TestEvent::OnMapStart);
 766     assert_next!(v, TestEvent::OnScalar);
 767     assert_next!(v, TestEvent::OnScalar);
 768     assert_next!(v, TestEvent::OnScalar);
 769     assert_next!(v, TestEvent::OnScalar);
 770     assert_next!(v, TestEvent::OnMapEnd);
 771     assert_next!(v, TestEvent::OnMapStart);
 772     assert_next!(v, TestEvent::OnScalar);
 773     assert_next!(v, TestEvent::OnScalar);
 774     assert_next!(v, TestEvent::OnScalar);
 775     assert_next!(v, TestEvent::OnScalar);
 776     assert_next!(v, TestEvent::OnMapEnd);
 777     assert_next!(v, TestEvent::OnMapEnd);
 778     assert_next!(v, TestEvent::OnDocumentEnd);
 779 }
 780
 781 #[test]
 782 fn test_ex6_13_reserved_directives() {
 783     let mut v = str_to_test_events(EX6_13).into_iter();
 784     assert_next!(v, TestEvent::OnDocumentStart);
 785     assert_next!(v, TestEvent::OnScalar);
 786     assert_next!(v, TestEvent::OnDocumentEnd);
 787 }
 788
 789 #[test]
 790 fn test_ex6_14_yaml_directive() {
 791     let mut v = str_to_test_events(EX6_14).into_iter();
 792     assert_next!(v, TestEvent::OnDocumentStart);
 793     assert_next!(v, TestEvent::OnScalar);
 794     assert_next!(v, TestEvent::OnDocumentEnd);
 795 }
 796
 797 #[test]
 798 fn test_ex6_16_tag_directive() {
 799     let mut v = str_to_test_events(EX6_16).into_iter();
 800     assert_next!(v, TestEvent::OnDocumentStart);
 801     assert_next!(v, TestEvent::OnScalar);
 802     assert_next!(v, TestEvent::OnDocumentEnd);
 803 }
 804
 805 #[test]
 806 fn test_ex6_18_primary_tag_handle() {
 807     let mut v = str_to_test_events(EX6_18).into_iter();
 808     assert_next!(v, TestEvent::OnDocumentStart);
 809     assert_next!(v, TestEvent::OnScalar);
 810     assert_next!(v, TestEvent::OnDocumentEnd);
 811     assert_next!(v, TestEvent::OnDocumentStart);
 812     assert_next!(v, TestEvent::OnScalar);
 813     assert_next!(v, TestEvent::OnDocumentEnd);
 814 }
 815
 816 #[test]
 817 fn test_ex6_19_secondary_tag_handle() {
 818     let mut v = str_to_test_events(EX6_19).into_iter();
 819     assert_next!(v, TestEvent::OnDocumentStart);
 820     assert_next!(v, TestEvent::OnScalar);
 821     assert_next!(v, TestEvent::OnDocumentEnd);
 822 }
 823
 824 #[test]
 825 fn test_ex6_20_tag_handles() {
 826     let mut v = str_to_test_events(EX6_20).into_iter();
 827     assert_next!(v, TestEvent::OnDocumentStart);
 828     assert_next!(v, TestEvent::OnScalar);
 829     assert_next!(v, TestEvent::OnDocumentEnd);
 830 }
 831
 832 #[test]
 833 fn test_ex6_21_local_tag_prefix() {
 834     let mut v = str_to_test_events(EX6_21).into_iter();
 835     assert_next!(v, TestEvent::OnDocumentStart);
 836     assert_next!(v, TestEvent::OnScalar);
 837     assert_next!(v, TestEvent::OnDocumentEnd);
 838     assert_next!(v, TestEvent::OnDocumentStart);
 839     assert_next!(v, TestEvent::OnScalar);
 840     assert_next!(v, TestEvent::OnDocumentEnd);
 841 }
 842
 843 #[test]
 844 fn test_ex6_22_global_tag_prefix() {
 845     let mut v = str_to_test_events(EX6_22).into_iter();
 846     assert_next!(v, TestEvent::OnDocumentStart);
 847     assert_next!(v, TestEvent::OnSequenceStart);
 848     assert_next!(v, TestEvent::OnScalar);
 849     assert_next!(v, TestEvent::OnSequenceEnd);
 850     assert_next!(v, TestEvent::OnDocumentEnd);
 851 }
 852
 853 #[test]
 854 fn test_ex6_23_node_properties() {
 855     let mut v = str_to_test_events(EX6_23).into_iter();
 856     assert_next!(v, TestEvent::OnDocumentStart);
 857     assert_next!(v, TestEvent::OnMapStart);
 858     assert_next!(v, TestEvent::OnScalar);
 859     assert_next!(v, TestEvent::OnScalar);
 860     assert_next!(v, TestEvent::OnScalar);
 861     assert_next!(v, TestEvent::OnAlias);
 862     assert_next!(v, TestEvent::OnMapEnd);
 863     assert_next!(v, TestEvent::OnDocumentEnd);
 864 }
 865
 866 #[test]
 867 fn test_ex6_24_verbatim_tags() {
 868     let mut v = str_to_test_events(EX6_24).into_iter();
 869     assert_next!(v, TestEvent::OnDocumentStart);
 870     assert_next!(v, TestEvent::OnMapStart);
 871     assert_next!(v, TestEvent::OnScalar);
 872     assert_next!(v, TestEvent::OnScalar);
 873     assert_next!(v, TestEvent::OnMapEnd);
 874     assert_next!(v, TestEvent::OnDocumentEnd);
 875 }
 876
 877 #[test]
 878 fn test_ex6_26_tag_shorthands() {
 879     let mut v = str_to_test_events(EX6_26).into_iter();
 880     assert_next!(v, TestEvent::OnDocumentStart);
 881     assert_next!(v, TestEvent::OnSequenceStart);
 882     assert_next!(v, TestEvent::OnScalar);
 883     assert_next!(v, TestEvent::OnScalar);
 884     assert_next!(v, TestEvent::OnScalar);
 885     assert_next!(v, TestEvent::OnSequenceEnd);
 886     assert_next!(v, TestEvent::OnDocumentEnd);
 887 }
 888
 889 #[test]
 890 fn test_ex6_28_non_specific_tags() {
 891     let mut v = str_to_test_events(EX6_28).into_iter();
 892     assert_next!(v, TestEvent::OnDocumentStart);
 893     assert_next!(v, TestEvent::OnSequenceStart);
 894     assert_next!(v, TestEvent::OnScalar);
 895     assert_next!(v, TestEvent::OnScalar);
 896     assert_next!(v, TestEvent::OnScalar);
 897     assert_next!(v, TestEvent::OnSequenceEnd);
 898     assert_next!(v, TestEvent::OnDocumentEnd);
 899 }
 900
 901 #[test]
 902 fn test_ex6_29_node_anchors() {
 903     let mut v = str_to_test_events(EX6_29).into_iter();
 904     assert_next!(v, TestEvent::OnDocumentStart);
 905     assert_next!(v, TestEvent::OnMapStart);
 906     assert_next!(v, TestEvent::OnScalar);
 907     assert_next!(v, TestEvent::OnScalar);
 908     assert_next!(v, TestEvent::OnScalar);
 909     assert_next!(v, TestEvent::OnAlias);
 910     assert_next!(v, TestEvent::OnMapEnd);
 911     assert_next!(v, TestEvent::OnDocumentEnd);
 912 }
 913
 914 #[test]
 915 fn test_ex7_1_alias_nodes() {
 916     let mut v = str_to_test_events(EX7_1).into_iter();
 917     assert_next!(v, TestEvent::OnDocumentStart);
 918     assert_next!(v, TestEvent::OnMapStart);
 919     assert_next!(v, TestEvent::OnScalar);
 920     assert_next!(v, TestEvent::OnScalar);
 921     assert_next!(v, TestEvent::OnScalar);
 922     assert_next!(v, TestEvent::OnAlias);
 923     assert_next!(v, TestEvent::OnScalar);
 924     assert_next!(v, TestEvent::OnScalar);
 925     assert_next!(v, TestEvent::OnScalar);
 926     assert_next!(v, TestEvent::OnAlias);
 927     assert_next!(v, TestEvent::OnMapEnd);
 928     assert_next!(v, TestEvent::OnDocumentEnd);
 929 }
 930
 931 #[allow(dead_code)]
 932 fn test_ex7_2_empty_nodes() {
 933     let mut v = str_to_test_events(EX7_2).into_iter();
 934     assert_next!(v, TestEvent::OnDocumentStart);
 935     assert_next!(v, TestEvent::OnMapStart);
 936     assert_next!(v, TestEvent::OnScalar);
 937     assert_next!(v, TestEvent::OnScalar);
 938     assert_next!(v, TestEvent::OnScalar);
 939     assert_next!(v, TestEvent::OnScalar);
 940     assert_next!(v, TestEvent::OnMapEnd);
 941     assert_next!(v, TestEvent::OnDocumentEnd);
 942 }
 943
 944 #[test]
 945 fn test_ex7_3_completely_empty_nodes() {
 946     let mut v = str_to_test_events(EX7_3).into_iter();
 947     assert_next!(v, TestEvent::OnDocumentStart);
 948     assert_next!(v, TestEvent::OnMapStart);
 949     assert_next!(v, TestEvent::OnScalar);
 950     assert_next!(v, TestEvent::OnNull);
 951     assert_next!(v, TestEvent::OnNull);
 952     assert_next!(v, TestEvent::OnScalar);
 953     assert_next!(v, TestEvent::OnMapEnd);
 954     assert_next!(v, TestEvent::OnDocumentEnd);
 955 }
 956
 957 #[test]
 958 fn test_ex7_4_double_quoted_implicit_keys() {
 959     let mut v = str_to_test_events(EX7_4).into_iter();
 960     assert_next!(v, TestEvent::OnDocumentStart);
 961     assert_next!(v, TestEvent::OnMapStart);
 962     assert_next!(v, TestEvent::OnScalar);
 963     assert_next!(v, TestEvent::OnSequenceStart);
 964     assert_next!(v, TestEvent::OnMapStart);
 965     assert_next!(v, TestEvent::OnScalar);
 966     assert_next!(v, TestEvent::OnScalar);
 967     assert_next!(v, TestEvent::OnMapEnd);
 968     assert_next!(v, TestEvent::OnSequenceEnd);
 969     assert_next!(v, TestEvent::OnMapEnd);
 970     assert_next!(v, TestEvent::OnDocumentEnd);
 971 }
 972
 973 #[test]
 974 fn test_ex7_5_double_quoted_line_breaks() {
 975     let mut v = str_to_test_events(EX7_5).into_iter();
 976     assert_next!(v, TestEvent::OnDocumentStart);
 977     assert_next!(v, TestEvent::OnScalar);
 978     assert_next!(v, TestEvent::OnDocumentEnd);
 979 }
 980
 981 #[test]
 982 fn test_ex7_6_double_quoted_lines() {
 983     let mut v = str_to_test_events(EX7_6).into_iter();
 984     assert_next!(v, TestEvent::OnDocumentStart);
 985     assert_next!(v, TestEvent::OnScalar);
 986     assert_next!(v, TestEvent::OnDocumentEnd);
 987 }
 988
 989 #[test]
 990 fn test_ex7_7_single_quoted_characters() {
 991     let mut v = str_to_test_events(EX7_7).into_iter();
 992     assert_next!(v, TestEvent::OnDocumentStart);
 993     assert_next!(v, TestEvent::OnScalar);
 994     assert_next!(v, TestEvent::OnDocumentEnd);
 995 }
 996
 997 #[test]
 998 fn test_ex7_8_single_quoted_implicit_keys() {
 999     let mut v = str_to_test_events(EX7_8).into_iter();
1000     assert_next!(v, TestEvent::OnDocumentStart);
1001     assert_next!(v, TestEvent::OnMapStart);
1002     assert_next!(v, TestEvent::OnScalar);
1003     assert_next!(v, TestEvent::OnSequenceStart);
1004     assert_next!(v, TestEvent::OnMapStart);
1005     assert_next!(v, TestEvent::OnScalar);
1006     assert_next!(v, TestEvent::OnScalar);
1007     assert_next!(v, TestEvent::OnMapEnd);
1008     assert_next!(v, TestEvent::OnSequenceEnd);
1009     assert_next!(v, TestEvent::OnMapEnd);
1010     assert_next!(v, TestEvent::OnDocumentEnd);
1011 }
1012
1013 #[test]
1014 fn test_ex7_9_single_quoted_lines() {
1015     let mut v = str_to_test_events(EX7_9).into_iter();
1016     assert_next!(v, TestEvent::OnDocumentStart);
1017     assert_next!(v, TestEvent::OnScalar);
1018     assert_next!(v, TestEvent::OnDocumentEnd);
1019 }
1020
1021 #[allow(dead_code)]
1022 fn test_ex7_10_plain_characters() {
1023     let mut v = str_to_test_events(EX7_10).into_iter();
1024     assert_next!(v, TestEvent::OnDocumentStart);
1025     assert_next!(v, TestEvent::OnSequenceStart);
1026     assert_next!(v, TestEvent::OnScalar);
1027     assert_next!(v, TestEvent::OnScalar);
1028     assert_next!(v, TestEvent::OnScalar);
1029     assert_next!(v, TestEvent::OnScalar);
1030     assert_next!(v, TestEvent::OnScalar);
1031     assert_next!(v, TestEvent::OnSequenceStart);
1032     assert_next!(v, TestEvent::OnScalar);
1033     assert_next!(v, TestEvent::OnScalar);
1034     assert_next!(v, TestEvent::OnScalar);
1035     assert_next!(v, TestEvent::OnScalar);
1036     assert_next!(v, TestEvent::OnScalar);
1037     assert_next!(v, TestEvent::OnSequenceEnd);
1038     assert_next!(v, TestEvent::OnSequenceEnd);
1039     assert_next!(v, TestEvent::OnDocumentEnd);
1040 }
1041
1042 #[test]
1043 fn test_ex7_11_plain_implicit_keys() {
1044     let mut v = str_to_test_events(EX7_11).into_iter();
1045     assert_next!(v, TestEvent::OnDocumentStart);
1046     assert_next!(v, TestEvent::OnMapStart);
1047     assert_next!(v, TestEvent::OnScalar);
1048     assert_next!(v, TestEvent::OnSequenceStart);
1049     assert_next!(v, TestEvent::OnMapStart);
1050     assert_next!(v, TestEvent::OnScalar);
1051     assert_next!(v, TestEvent::OnScalar);
1052     assert_next!(v, TestEvent::OnMapEnd);
1053     assert_next!(v, TestEvent::OnSequenceEnd);
1054     assert_next!(v, TestEvent::OnMapEnd);
1055     assert_next!(v, TestEvent::OnDocumentEnd);
1056 }
1057
1058 #[test]
1059 fn test_ex7_12_plain_lines() {
1060     let mut v = str_to_test_events(EX7_12).into_iter();
1061     assert_next!(v, TestEvent::OnDocumentStart);
1062     assert_next!(v, TestEvent::OnScalar);
1063     assert_next!(v, TestEvent::OnDocumentEnd);
1064 }
1065
1066 #[test]
1067 fn test_ex7_13_flow_sequence() {
1068     let mut v = str_to_test_events(EX7_13).into_iter();
1069     assert_next!(v, TestEvent::OnDocumentStart);
1070     assert_next!(v, TestEvent::OnSequenceStart);
1071     assert_next!(v, TestEvent::OnSequenceStart);
1072     assert_next!(v, TestEvent::OnScalar);
1073     assert_next!(v, TestEvent::OnScalar);
1074     assert_next!(v, TestEvent::OnSequenceEnd);
1075     assert_next!(v, TestEvent::OnSequenceStart);
1076     assert_next!(v, TestEvent::OnScalar);
1077     assert_next!(v, TestEvent::OnScalar);
1078     assert_next!(v, TestEvent::OnSequenceEnd);
1079     assert_next!(v, TestEvent::OnSequenceEnd);
1080     assert_next!(v, TestEvent::OnDocumentEnd);
1081 }
1082
1083 #[test]
1084 fn test_ex7_14_flow_sequence_entries() {
1085     let mut v = str_to_test_events(EX7_14).into_iter();
1086     assert_next!(v, TestEvent::OnDocumentStart);
1087     assert_next!(v, TestEvent::OnSequenceStart);
1088     assert_next!(v, TestEvent::OnScalar);
1089     assert_next!(v, TestEvent::OnScalar);
1090     assert_next!(v, TestEvent::OnScalar);
1091     assert_next!(v, TestEvent::OnSequenceStart);
1092     assert_next!(v, TestEvent::OnScalar);
1093     assert_next!(v, TestEvent::OnSequenceEnd);
1094     assert_next!(v, TestEvent::OnMapStart);
1095     assert_next!(v, TestEvent::OnScalar);
1096     assert_next!(v, TestEvent::OnScalar);
1097     assert_next!(v, TestEvent::OnMapEnd);
1098     assert_next!(v, TestEvent::OnSequenceEnd);
1099     assert_next!(v, TestEvent::OnDocumentEnd);
1100 }
1101
1102 #[test]
1103 fn test_ex7_15_flow_mappings() {
1104     let mut v = str_to_test_events(EX7_15).into_iter();
1105     assert_next!(v, TestEvent::OnDocumentStart);
1106     assert_next!(v, TestEvent::OnSequenceStart);
1107     assert_next!(v, TestEvent::OnMapStart);
1108     assert_next!(v, TestEvent::OnScalar);
1109     assert_next!(v, TestEvent::OnScalar);
1110     assert_next!(v, TestEvent::OnScalar);
1111     assert_next!(v, TestEvent::OnScalar);
1112     assert_next!(v, TestEvent::OnMapEnd);
1113     assert_next!(v, TestEvent::OnMapStart);
1114     assert_next!(v, TestEvent::OnScalar);
1115     assert_next!(v, TestEvent::OnScalar);
1116     assert_next!(v, TestEvent::OnScalar);
1117     assert_next!(v, TestEvent::OnScalar);
1118     assert_next!(v, TestEvent::OnMapEnd);
1119     assert_next!(v, TestEvent::OnSequenceEnd);
1120     assert_next!(v, TestEvent::OnDocumentEnd);
1121 }
1122
1123 #[test]
1124 fn test_ex7_16_flow_mapping_entries() {
1125     let mut v = str_to_test_events(EX7_16).into_iter();
1126     assert_next!(v, TestEvent::OnDocumentStart);
1127     assert_next!(v, TestEvent::OnMapStart);
1128     assert_next!(v, TestEvent::OnScalar);
1129     assert_next!(v, TestEvent::OnScalar);
1130     assert_next!(v, TestEvent::OnScalar);
1131     assert_next!(v, TestEvent::OnScalar);
1132     assert_next!(v, TestEvent::OnNull);
1133     assert_next!(v, TestEvent::OnNull);
1134     assert_next!(v, TestEvent::OnMapEnd);
1135     assert_next!(v, TestEvent::OnDocumentEnd);
1136 }
1137
1138 #[allow(dead_code)]
1139 fn test_ex7_17_flow_mapping_separate_values() {
1140     let mut v = str_to_test_events(EX7_17).into_iter();
1141     assert_next!(v, TestEvent::OnDocumentStart);
1142     assert_next!(v, TestEvent::OnMapStart);
1143     assert_next!(v, TestEvent::OnScalar);
1144     assert_next!(v, TestEvent::OnScalar);
1145     assert_next!(v, TestEvent::OnScalar);
1146     assert_next!(v, TestEvent::OnNull);
1147     assert_next!(v, TestEvent::OnScalar);
1148     assert_next!(v, TestEvent::OnNull);
1149     assert_next!(v, TestEvent::OnNull);
1150     assert_next!(v, TestEvent::OnScalar);
1151     assert_next!(v, TestEvent::OnMapEnd);
1152     assert_next!(v, TestEvent::OnDocumentEnd);
1153 }
1154
1155 #[test]
1156 fn test_ex7_18_flow_mapping_adjacent_values() {
1157     let mut v = str_to_test_events(EX7_18).into_iter();
1158     assert_next!(v, TestEvent::OnDocumentStart);
1159     assert_next!(v, TestEvent::OnMapStart);
1160     assert_next!(v, TestEvent::OnScalar);
1161     assert_next!(v, TestEvent::OnScalar);
1162     assert_next!(v, TestEvent::OnScalar);
1163     assert_next!(v, TestEvent::OnScalar);
1164     assert_next!(v, TestEvent::OnScalar);
1165     assert_next!(v, TestEvent::OnNull);
1166     assert_next!(v, TestEvent::OnMapEnd);
1167     assert_next!(v, TestEvent::OnDocumentEnd);
1168 }
1169
1170 #[test]
1171 fn test_ex7_19_single_pair_flow_mappings() {
1172     let mut v = str_to_test_events(EX7_19).into_iter();
1173     assert_next!(v, TestEvent::OnDocumentStart);
1174     assert_next!(v, TestEvent::OnSequenceStart);
1175     assert_next!(v, TestEvent::OnMapStart);
1176     assert_next!(v, TestEvent::OnScalar);
1177     assert_next!(v, TestEvent::OnScalar);
1178     assert_next!(v, TestEvent::OnMapEnd);
1179     assert_next!(v, TestEvent::OnSequenceEnd);
1180     assert_next!(v, TestEvent::OnDocumentEnd);
1181 }
1182
1183 #[test]
1184 fn test_ex7_20_single_pair_explicit_entry() {
1185     let mut v = str_to_test_events(EX7_20).into_iter();
1186     assert_next!(v, TestEvent::OnDocumentStart);
1187     assert_next!(v, TestEvent::OnSequenceStart);
1188     assert_next!(v, TestEvent::OnMapStart);
1189     assert_next!(v, TestEvent::OnScalar);
1190     assert_next!(v, TestEvent::OnScalar);
1191     assert_next!(v, TestEvent::OnMapEnd);
1192     assert_next!(v, TestEvent::OnSequenceEnd);
1193     assert_next!(v, TestEvent::OnDocumentEnd);
1194 }
1195
1196 #[allow(dead_code)]
1197 fn test_ex7_21_single_pair_implicit_entries() {
1198     let mut v = str_to_test_events(EX7_21).into_iter();
1199     assert_next!(v, TestEvent::OnDocumentStart);
1200     assert_next!(v, TestEvent::OnSequenceStart);
1201     assert_next!(v, TestEvent::OnSequenceStart);
1202     assert_next!(v, TestEvent::OnMapStart);
1203     assert_next!(v, TestEvent::OnScalar);
1204     assert_next!(v, TestEvent::OnScalar);
1205     assert_next!(v, TestEvent::OnMapEnd);
1206     assert_next!(v, TestEvent::OnSequenceEnd);
1207     assert_next!(v, TestEvent::OnSequenceStart);
1208     assert_next!(v, TestEvent::OnMapStart);
1209     assert_next!(v, TestEvent::OnNull);
1210     assert_next!(v, TestEvent::OnScalar);
1211     assert_next!(v, TestEvent::OnMapEnd);
1212     assert_next!(v, TestEvent::OnSequenceEnd);
1213     assert_next!(v, TestEvent::OnSequenceStart);
1214     assert_next!(v, TestEvent::OnMapStart);
1215     assert_next!(v, TestEvent::OnMapStart);
1216     assert_next!(v, TestEvent::OnScalar);
1217     assert_next!(v, TestEvent::OnScalar);
1218     assert_next!(v, TestEvent::OnMapEnd);
1219     assert_next!(v, TestEvent::OnScalar);
1220     assert_next!(v, TestEvent::OnMapEnd);
1221     assert_next!(v, TestEvent::OnSequenceEnd);
1222     assert_next!(v, TestEvent::OnSequenceEnd);
1223     assert_next!(v, TestEvent::OnDocumentEnd);
1224 }
1225
1226 #[test]
1227 fn test_ex7_23_flow_content() {
1228     let mut v = str_to_test_events(EX7_23).into_iter();
1229     assert_next!(v, TestEvent::OnDocumentStart);
1230     assert_next!(v, TestEvent::OnSequenceStart);
1231     assert_next!(v, TestEvent::OnSequenceStart);
1232     assert_next!(v, TestEvent::OnScalar);
1233     assert_next!(v, TestEvent::OnScalar);
1234     assert_next!(v, TestEvent::OnSequenceEnd);
1235     assert_next!(v, TestEvent::OnMapStart);
1236     assert_next!(v, TestEvent::OnScalar);
1237     assert_next!(v, TestEvent::OnScalar);
1238     assert_next!(v, TestEvent::OnMapEnd);
1239     assert_next!(v, TestEvent::OnScalar);
1240     assert_next!(v, TestEvent::OnScalar);
1241     assert_next!(v, TestEvent::OnScalar);
1242     assert_next!(v, TestEvent::OnSequenceEnd);
1243     assert_next!(v, TestEvent::OnDocumentEnd);
1244 }
1245
1246 #[test]
1247 fn test_ex7_24_flow_nodes() {
1248     let mut v = str_to_test_events(EX7_24).into_iter();
1249     assert_next!(v, TestEvent::OnDocumentStart);
1250     assert_next!(v, TestEvent::OnSequenceStart);
1251     assert_next!(v, TestEvent::OnScalar);
1252     assert_next!(v, TestEvent::OnScalar);
1253     assert_next!(v, TestEvent::OnScalar);
1254     assert_next!(v, TestEvent::OnAlias);
1255     assert_next!(v, TestEvent::OnScalar);
1256     assert_next!(v, TestEvent::OnSequenceEnd);
1257     assert_next!(v, TestEvent::OnDocumentEnd);
1258 }
1259
1260 #[test]
1261 fn test_ex8_1_block_scalar_header() {
1262     let mut v = str_to_test_events(EX8_1).into_iter();
1263     assert_next!(v, TestEvent::OnDocumentStart);
1264     assert_next!(v, TestEvent::OnSequenceStart);
1265     assert_next!(v, TestEvent::OnScalar);
1266     assert_next!(v, TestEvent::OnScalar);
1267     assert_next!(v, TestEvent::OnScalar);
1268     assert_next!(v, TestEvent::OnScalar);
1269     assert_next!(v, TestEvent::OnSequenceEnd);
1270     assert_next!(v, TestEvent::OnDocumentEnd);
1271 }
1272
1273 #[allow(dead_code)]
1274 fn test_ex8_2_block_indentation_header() {
1275     let mut v = str_to_test_events(EX8_2).into_iter();
1276     assert_next!(v, TestEvent::OnDocumentStart);
1277     assert_next!(v, TestEvent::OnSequenceStart);
1278     assert_next!(v, TestEvent::OnScalar);
1279     assert_next!(v, TestEvent::OnScalar);
1280     assert_next!(v, TestEvent::OnScalar);
1281     assert_next!(v, TestEvent::OnScalar);
1282     assert_next!(v, TestEvent::OnSequenceEnd);
1283     assert_next!(v, TestEvent::OnDocumentEnd);
1284 }
1285
1286 #[test]
1287 fn test_ex8_4_chomping_final_line_break() {
1288     let mut v = str_to_test_events(EX8_4).into_iter();
1289     assert_next!(v, TestEvent::OnDocumentStart);
1290     assert_next!(v, TestEvent::OnMapStart);
1291     assert_next!(v, TestEvent::OnScalar);
1292     assert_next!(v, TestEvent::OnScalar);
1293     assert_next!(v, TestEvent::OnScalar);
1294     assert_next!(v, TestEvent::OnScalar);
1295     assert_next!(v, TestEvent::OnScalar);
1296     assert_next!(v, TestEvent::OnScalar);
1297     assert_next!(v, TestEvent::OnMapEnd);
1298     assert_next!(v, TestEvent::OnDocumentEnd);
1299 }
1300
1301 #[test]
1302 fn test_ex8_6_empty_scalar_chomping() {
1303     let mut v = str_to_test_events(EX8_6).into_iter();
1304     assert_next!(v, TestEvent::OnDocumentStart);
1305     assert_next!(v, TestEvent::OnMapStart);
1306     assert_next!(v, TestEvent::OnScalar);
1307     assert_next!(v, TestEvent::OnScalar);
1308     assert_next!(v, TestEvent::OnScalar);
1309     assert_next!(v, TestEvent::OnScalar);
1310     assert_next!(v, TestEvent::OnScalar);
1311     assert_next!(v, TestEvent::OnScalar);
1312     assert_next!(v, TestEvent::OnMapEnd);
1313     assert_next!(v, TestEvent::OnDocumentEnd);
1314 }
1315
1316 #[test]
1317 fn test_ex8_7_literal_scalar() {
1318     let mut v = str_to_test_events(EX8_7).into_iter();
1319     assert_next!(v, TestEvent::OnDocumentStart);
1320     assert_next!(v, TestEvent::OnScalar);
1321     assert_next!(v, TestEvent::OnDocumentEnd);
1322 }
1323
1324 #[test]
1325 fn test_ex8_8_literal_content() {
1326     let mut v = str_to_test_events(EX8_8).into_iter();
1327     assert_next!(v, TestEvent::OnDocumentStart);
1328     assert_next!(v, TestEvent::OnScalar);
1329     assert_next!(v, TestEvent::OnDocumentEnd);
1330 }
1331
1332 #[test]
1333 fn test_ex8_9_folded_scalar() {
1334     let mut v = str_to_test_events(EX8_9).into_iter();
1335     assert_next!(v, TestEvent::OnDocumentStart);
1336     assert_next!(v, TestEvent::OnScalar);
1337     assert_next!(v, TestEvent::OnDocumentEnd);
1338 }
1339
1340 #[test]
1341 fn test_ex8_10_folded_lines() {
1342     let mut v = str_to_test_events(EX8_10).into_iter();
1343     assert_next!(v, TestEvent::OnDocumentStart);
1344     assert_next!(v, TestEvent::OnScalar);
1345     assert_next!(v, TestEvent::OnDocumentEnd);
1346 }
1347
1348 #[test]
1349 fn test_ex8_11_more_indented_lines() {
1350     let mut v = str_to_test_events(EX8_11).into_iter();
1351     assert_next!(v, TestEvent::OnDocumentStart);
1352     assert_next!(v, TestEvent::OnScalar);
1353     assert_next!(v, TestEvent::OnDocumentEnd);
1354 }
1355
1356 #[test]
1357 fn test_ex8_12_empty_separation_lines() {
1358     let mut v = str_to_test_events(EX8_12).into_iter();
1359     assert_next!(v, TestEvent::OnDocumentStart);
1360     assert_next!(v, TestEvent::OnScalar);
1361     assert_next!(v, TestEvent::OnDocumentEnd);
1362 }
1363
1364 #[test]
1365 fn test_ex8_13_final_empty_lines() {
1366     let mut v = str_to_test_events(EX8_13).into_iter();
1367     assert_next!(v, TestEvent::OnDocumentStart);
1368     assert_next!(v, TestEvent::OnScalar);
1369     assert_next!(v, TestEvent::OnDocumentEnd);
1370 }
1371
1372 #[test]
1373 fn test_ex8_14_block_sequence() {
1374     let mut v = str_to_test_events(EX8_14).into_iter();
1375     assert_next!(v, TestEvent::OnDocumentStart);
1376     assert_next!(v, TestEvent::OnMapStart);
1377     assert_next!(v, TestEvent::OnScalar);
1378     assert_next!(v, TestEvent::OnSequenceStart);
1379     assert_next!(v, TestEvent::OnScalar);
1380     assert_next!(v, TestEvent::OnMapStart);
1381     assert_next!(v, TestEvent::OnScalar);
1382     assert_next!(v, TestEvent::OnScalar);
1383     assert_next!(v, TestEvent::OnMapEnd);
1384     assert_next!(v, TestEvent::OnSequenceEnd);
1385     assert_next!(v, TestEvent::OnMapEnd);
1386     assert_next!(v, TestEvent::OnDocumentEnd);
1387 }
1388
1389 #[test]
1390 fn test_ex8_15_block_sequence_entry_types() {
1391     let mut v = str_to_test_events(EX8_15).into_iter();
1392     assert_next!(v, TestEvent::OnDocumentStart);
1393     assert_next!(v, TestEvent::OnSequenceStart);
1394     assert_next!(v, TestEvent::OnNull);
1395     assert_next!(v, TestEvent::OnScalar);
1396     assert_next!(v, TestEvent::OnSequenceStart);
1397     assert_next!(v, TestEvent::OnScalar);
1398     assert_next!(v, TestEvent::OnScalar);
1399     assert_next!(v, TestEvent::OnSequenceEnd);
1400     assert_next!(v, TestEvent::OnMapStart);
1401     assert_next!(v, TestEvent::OnScalar);
1402     assert_next!(v, TestEvent::OnScalar);
1403     assert_next!(v, TestEvent::OnMapEnd);
1404     assert_next!(v, TestEvent::OnSequenceEnd);
1405     assert_next!(v, TestEvent::OnDocumentEnd);
1406 }
1407
1408 #[test]
1409 fn test_ex8_16_block_mappings() {
1410     let mut v = str_to_test_events(EX8_16).into_iter();
1411     assert_next!(v, TestEvent::OnDocumentStart);
1412     assert_next!(v, TestEvent::OnMapStart);
1413     assert_next!(v, TestEvent::OnScalar);
1414     assert_next!(v, TestEvent::OnMapStart);
1415     assert_next!(v, TestEvent::OnScalar);
1416     assert_next!(v, TestEvent::OnScalar);
1417     assert_next!(v, TestEvent::OnMapEnd);
1418     assert_next!(v, TestEvent::OnMapEnd);
1419     assert_next!(v, TestEvent::OnDocumentEnd);
1420 }
1421
1422 #[test]
1423 fn test_ex8_17_explicit_block_mapping_entries() {
1424     let mut v = str_to_test_events(EX8_17).into_iter();
1425     assert_next!(v, TestEvent::OnDocumentStart);
1426     assert_next!(v, TestEvent::OnMapStart);
1427     assert_next!(v, TestEvent::OnScalar);
1428     assert_next!(v, TestEvent::OnNull);
1429     assert_next!(v, TestEvent::OnScalar);
1430     assert_next!(v, TestEvent::OnSequenceStart);
1431     assert_next!(v, TestEvent::OnScalar);
1432     assert_next!(v, TestEvent::OnScalar);
1433     assert_next!(v, TestEvent::OnSequenceEnd);
1434     assert_next!(v, TestEvent::OnMapEnd);
1435     assert_next!(v, TestEvent::OnDocumentEnd);
1436 }
1437
1438 #[test]
1439 fn test_ex8_18_implicit_block_mapping_entries() {
1440     let mut v = str_to_test_events(EX8_18).into_iter();
1441     assert_next!(v, TestEvent::OnDocumentStart);
1442     assert_next!(v, TestEvent::OnMapStart);
1443     assert_next!(v, TestEvent::OnScalar);
1444     assert_next!(v, TestEvent::OnScalar);
1445     assert_next!(v, TestEvent::OnNull);
1446     assert_next!(v, TestEvent::OnNull);
1447     assert_next!(v, TestEvent::OnScalar);
1448     assert_next!(v, TestEvent::OnSequenceStart);
1449     assert_next!(v, TestEvent::OnScalar);
1450     assert_next!(v, TestEvent::OnSequenceEnd);
1451     assert_next!(v, TestEvent::OnMapEnd);
1452     assert_next!(v, TestEvent::OnDocumentEnd);
1453 }
1454
1455 #[test]
1456 fn test_ex8_19_compact_block_mappings() {
1457     let mut v = str_to_test_events(EX8_19).into_iter();
1458     assert_next!(v, TestEvent::OnDocumentStart);
1459     assert_next!(v, TestEvent::OnSequenceStart);
1460     assert_next!(v, TestEvent::OnMapStart);
1461     assert_next!(v, TestEvent::OnScalar);
1462     assert_next!(v, TestEvent::OnScalar);
1463     assert_next!(v, TestEvent::OnMapEnd);
1464     assert_next!(v, TestEvent::OnMapStart);
1465     assert_next!(v, TestEvent::OnMapStart);
1466     assert_next!(v, TestEvent::OnScalar);
1467     assert_next!(v, TestEvent::OnScalar);
1468     assert_next!(v, TestEvent::OnMapEnd);
1469     assert_next!(v, TestEvent::OnMapStart);
1470     assert_next!(v, TestEvent::OnScalar);
1471     assert_next!(v, TestEvent::OnScalar);
1472     assert_next!(v, TestEvent::OnMapEnd);
1473     assert_next!(v, TestEvent::OnMapEnd);
1474     assert_next!(v, TestEvent::OnSequenceEnd);
1475     assert_next!(v, TestEvent::OnDocumentEnd);
1476 }
1477
1478 #[test]
1479 fn test_ex8_20_block_node_types() {
1480     let mut v = str_to_test_events(EX8_20).into_iter();
1481     assert_next!(v, TestEvent::OnDocumentStart);
1482     assert_next!(v, TestEvent::OnSequenceStart);
1483     assert_next!(v, TestEvent::OnScalar);
1484     assert_next!(v, TestEvent::OnScalar);
1485     assert_next!(v, TestEvent::OnMapStart);
1486     assert_next!(v, TestEvent::OnScalar);
1487     assert_next!(v, TestEvent::OnScalar);
1488     assert_next!(v, TestEvent::OnMapEnd);
1489     assert_next!(v, TestEvent::OnSequenceEnd);
1490     assert_next!(v, TestEvent::OnDocumentEnd);
1491 }
1492
1493 #[test]
1494 fn test_ex8_22_block_collection_nodes() {
1495     let mut v = str_to_test_events(EX8_22).into_iter();
1496     assert_next!(v, TestEvent::OnDocumentStart);
1497     assert_next!(v, TestEvent::OnMapStart);
1498     assert_next!(v, TestEvent::OnScalar);
1499     assert_next!(v, TestEvent::OnSequenceStart);
1500     assert_next!(v, TestEvent::OnScalar);
1501     assert_next!(v, TestEvent::OnSequenceStart);
1502     assert_next!(v, TestEvent::OnScalar);
1503     assert_next!(v, TestEvent::OnSequenceEnd);
1504     assert_next!(v, TestEvent::OnSequenceEnd);
1505     assert_next!(v, TestEvent::OnScalar);
1506     assert_next!(v, TestEvent::OnMapStart);
1507     assert_next!(v, TestEvent::OnScalar);
1508     assert_next!(v, TestEvent::OnScalar);
1509     assert_next!(v, TestEvent::OnMapEnd);
1510     assert_next!(v, TestEvent::OnMapEnd);
1511     assert_next!(v, TestEvent::OnDocumentEnd);
1512 }
1513