============================================================

@@ Host gila.activestate.com
@@ Platform Linux-2.4.21-297-default-i686
@@ CWD /home/andreask/workbench/tcllib-head/tcllib
@@ Shell /home/andreask/TDK/bin/tclsh
@@ Tcl 8.4.15
@@ MatchTests *
@@ SkipFiles l.*.test
@@ MatchFiles *.test
@@ Start 1211482309
@@ Module yaml
@@ Testsuite modules/yaml/rb.test
0.2.2
---- loadtest-1 start

==== loadtest-1 Simple Sequence FAILED
==== Contents of test case:

        set data {
---
- apple 
- banana 
- carrot 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Nested Sequences FAILED
==== Contents of test case:

        set data {
---
- 
 - foo 
 - bar 
 - baz 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 9)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Mixed Sequences FAILED
==== Contents of test case:

        set data {
---
- apple 
- 
 - foo 
 - bar 
 - x123 
- banana 
- carrot 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 12)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Deeply Nested Sequences FAILED
==== Contents of test case:

        set data {
---
- 
 - 
  - uno 
  - dos 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 9)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Simple Mapping FAILED
==== Contents of test case:

        set data {
---
foo: whatever 
bar: stuff 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 7)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Sequence in a Mapping FAILED
==== Contents of test case:

        set data {
---
foo: whatever 
bar: 
 - uno 
 - dos 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 9)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Nested Mappings FAILED
==== Contents of test case:

        set data {
---
foo: whatever 
bar: 
 fruit: apple 
 name: steve 
 sport: baseball 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 10)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Mixed Mapping FAILED
==== Contents of test case:

        set data {
---
foo: whatever 
bar: 
 - 
   fruit: apple 
   name: steve 
   sport: baseball 
 - more 
 - 
   python: rocks 
   perl: papers 
   ruby: scissorses 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 16)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Mapping-in-Sequence Shortcut FAILED
==== Contents of test case:

        set data {
---
- work on YAML.py: 
   - work on Store
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 7)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Sequence-in-Mapping Shortcut FAILED
==== Contents of test case:

        set data {
---
allow:
- 'localhost'
- '%.sourceforge.net'
- '%.freepan.org'
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 9)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Merge key FAILED
==== Contents of test case:

        set data {
---
mapping:
  name: Joe
  job: Accountant
  <<:
    age: 38
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 10)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Simple Inline Array FAILED
==== Contents of test case:

        set data {
---  
seq: [ a, b, c ] 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 6)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Simple Inline Hash FAILED
==== Contents of test case:

        set data {
---  
hash: { name: Steve, foo: bar }
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 6)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Multi-line Inline Collections FAILED
==== Contents of test case:

        set data {
---  
languages: [ Ruby, 
             Perl, 
             Python ] 
websites: { YAML: yaml.org, 
            Ruby: ruby-lang.org, 
            Python: python.org, 
            Perl: use.perl.org }
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 12)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Commas in Values FAILED
==== Contents of test case:

        set data {
---  
attendances: [ 45,123, 70,000, 17,222 ]
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 6)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Strings FAILED
==== Contents of test case:

        set data {
--- String
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 5)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 String characters FAILED
==== Contents of test case:

        set data {
---
- What's Yaml? 
- It's for writing data structures in plain text. 
- And? 
- And what? That's not good enough for you? 
- No, I mean, "And what about Yaml?" 
- Oh, oh yeah. Uh.. Yaml for Ruby. 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 11)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Indicators in Strings FAILED
==== Contents of test case:

        set data {
---  
the colon followed by space is an indicator: but is a string:right here 
same for the pound sign: here we have it#in a string 
the comma can, honestly, be used in most cases: [ but not in, inline collections ]
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Forcing Strings FAILED
==== Contents of test case:

        set data {
---  
date string: !!str 2001-08-01 
number string: !!str 192 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 7)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Single-quoted Strings FAILED
==== Contents of test case:

        set data {
---  
all my favorite symbols: '#:!/%.)' 
a few i hate: '&(*' 
why do i hate them?: 'it''s very hard to explain' 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Double-quoted Strings FAILED
==== Contents of test case:

        set data {
---  
i know where i want my line breaks: "one here\nand another here\n" 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 6)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Multi-line Quoted Strings FAILED
==== Contents of test case:

        set data {
---  
i want a long string: "so i'm going to
  let it go on and on to other lines
  until i end it with a quote."
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Plain scalars FAILED
==== Contents of test case:

        set data {
---  
- My little toe is broken in two places;
- I'm crazy to have skied this way;
- I'm not the craziest he's seen, since there was always the German guy
  who skied for 3 hours on a broken shin bone (just below the kneecap);
- Nevertheless, second place is respectable, and he doesn't
  recommend going for the record;
- He's going to put my foot in plaster for a month;
- This would impair my skiing ability somewhat for the
  duration, as can be imagined.
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 14)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Null FAILED
==== Contents of test case:

        set data {
---  
name: Mr. Show 
hosted by: Bob and David 
date of next season: ~ 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Boolean FAILED
==== Contents of test case:

        set data {
---  
Is Gus a Liar?: true
Do I rely on Gus for Sustenance?: false 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 7)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Integers FAILED
==== Contents of test case:

        set data {
---  
zero: 0 
simple: 12 
one-thousand: 1,000 
negative one-thousand: -1,000 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 9)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Integers as Map Keys FAILED
==== Contents of test case:

        set data {
---  
1: one 
2: two 
3: three 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-1 start

==== loadtest-1 Floats FAILED
==== Contents of test case:

        set data {
---  
a simple float: 2.00 
larger float: 1,000.09 
scientific notation: 1.00009e+3 
}
        yaml::load $data
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $data"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

@+
@|bad switch "-format": must be -base or -gmt
@|    while executing
@|"clock scan "2001-12-14 21:59:43 -05:00" -format {%Y-%m-%d %k:%M:%S %Z}"
@|    (in namespace eval "::loadtest" script line 310)
@|    invoked from within
@|"namespace eval loadtest {
@|    test loadtest-1 "Simple Sequence" -body {
@|        set data {
@|---
@|- apple 
@|- banana 
@|- carrot 
@|}
@|        yaml::load $data..."
@|    (file "/home/andreask/workbench/tcllib-head/tcllib/modules/yaml/rb.test" line 15)
@|    invoked from within
@|"source [pSet file]"
@-
@@ Testsuite modules/yaml/yaml.test
0.2.2
---- loadtest-1 start

==== loadtest-1 test of ::yaml::load 1 sequence of sequences FAILED
==== Contents of test case:

        set sequences {
---
-
  - Mark McGwire^---
  - Sammy Sosa
-
  - Sammy Sosa
  - Ken Griffey
}

        yaml::load $sequences
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $sequences"
    ("uplevel" body line 12)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-1 FAILED

---- loadtest-2 start

==== loadtest-2 test of ::yaml::load 2 FAILED
==== Contents of test case:

        set mappings {
---
bill-to:
    given  : Chris
    family : Dumars
hello-to:
    given  : Arnold Berry
    family : Son
}
        yaml::load $mappings
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $mappings"
    ("uplevel" body line 11)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-2 FAILED

---- loadtest-3 start

==== loadtest-3 test of ::yaml::load 3 FAILED
==== Contents of test case:

        set map_seqs {
---
hr: # 1998 hr ranking
  - Mark McGwire
  - Sammy Sosa
rbi:
  # 1998 rbi ranking
  - Sammy Sosa
  - Ken Griffey
}
        yaml::load $map_seqs
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $map_seqs"
    ("uplevel" body line 12)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-3 FAILED

---- loadtest-4 start

==== loadtest-4 test of ::yaml::load 4 FAILED
==== Contents of test case:

        set seq_maps {
---
-
  name: Mark McGwire
  hr:   65
  avg:  0.278
-
  name: Sammy Sosa
  hr:   63
  avg:  0.288
}
        yaml::load $seq_maps
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $seq_maps"
    ("uplevel" body line 13)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-4 FAILED

---- loadtest-5 start

==== loadtest-5 test of ::yaml::load 5 inline sequences FAILED
==== Contents of test case:

        set inline_seq_seqs {
---
- [name        , hr, avg  ]
- [Mark McGwire, 65, 0.278]
- [Sammy Sosa  , 63, 0.288]
}
        yaml::load $inline_seq_seqs
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $inline_seq_seqs"
    ("uplevel" body line 8)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-5 FAILED

---- loadtest-6 start

==== loadtest-6 test of ::yaml::load 6 inline mappings FAILED
==== Contents of test case:

        set inline_map_maps {
---
Mark McGwire: {hr: 65, avg: 0.278}
Sammy Sosa: { hr: 63, avg: 0.288}
}
        yaml::load $inline_map_maps
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $inline_map_maps"
    ("uplevel" body line 7)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-6 FAILED

---- loadtest-7 start

==== loadtest-7 test of ::yaml::load 7 boolean FAILED
==== Contents of test case:

        set boolean {
---
india:
    pork   : yes
    beef   : n
    oil    : off
    polytheism : true
arabia:
    pork   : no
    beef   : y
    oil    : on
    polytheism : false
}
        yaml::load $boolean
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $boolean"
    ("uplevel" body line 15)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-7 FAILED

---- loadtest-8 start

==== loadtest-8 test of ::yaml::load 8 - Literal Block Scalar FAILED
==== Contents of test case:

        set literal {
---
clipped: | # comment
    This has one newline.
  # comment


same as "clipped" above: "This has one newline.\n" # comment

stripped: |- # comment
    This has no newline.



same as "stripped" above: "This has no newline." # comment
kept: |+
    This has four newlines.



same as "kept" above: "This has four newlines.\n\n\n\n"
}
        yaml::load $literal
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $literal"
    ("uplevel" body line 24)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-8 FAILED

---- loadtest-9 start

==== loadtest-9 test of ::yaml::load 9 - Folding Block Scalar FAILED
==== Contents of test case:

        set folding {
---
clipped: >
    This
    has one newline.



same as "clipped" above: "This has one newline.\n" 

stripped: >-
    This
    has
    no newline.



same as "stripped" above: "This has no newline."

kept: >+
    This
    has
    no newline.



same as "kept" above: "This has four newlines.\n\n\n\n"}
        yaml::load $folding
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $folding"
    ("uplevel" body line 29)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-9 FAILED

---- loadtest-10 start

==== loadtest-10 test of ::yaml::load 10 - Folded Block as a Mapping Value FAILED
==== Contents of test case:

        set foldedmap {
---
quote: >
    Mark McGwire's
    year was crippled
    by a knee injury.
source: espn
}
        yaml::load $foldedmap
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $foldedmap"
    ("uplevel" body line 10)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-10 FAILED

---- loadtest-11 start

==== loadtest-11 test of ::yaml::load 11 - Alias Node FAILED
==== Contents of test case:

        set alias {
---
- &showell Steve
- Clark 
- Brian 
- Oren 
- *showell 
}
        yaml::load $alias
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $alias"
    ("uplevel" body line 10)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-11 FAILED

---- loadtest-12 start

==== loadtest-12 test of ::yaml::load 12 - Alias Node FAILED
==== Contents of test case:

        set alias2 {
---
- &hello 
    Meat: pork 
    Starch: potato 
- banana 
- *hello 
}
        yaml::load $alias2
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $alias2"
    ("uplevel" body line 10)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-12 FAILED

---- loadtest-13 start

==== loadtest-13 test of ::yaml::load 13 - Flow Alias Node FAILED
==== Contents of test case:

        set alias3 {
---
- &hello 
    { Meat: &meat pork,
      Starch: potato }
- banana 
- *hello 
- &bye
    [ The last man, children, *meat ]
- habana 
- *bye
}
        yaml::load $alias3
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $alias3"
    ("uplevel" body line 14)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-13 FAILED

---- loadtest-14 start

==== loadtest-14 test of ::yaml::load 14 - Plane Characters FAILED
==== Contents of test case:

    set plane_characters {
---
# Outside flow collection:
- ::std::vector
- Up, up and away!
- -123
# Inside flow collection:
- [ ::std::vector,
  "Up, up and away!",
  -123 ]
}
        yaml::load $plane_characters
    
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
---- errorInfo: ambiguous option "-": must be -exact, -glob, -regexp, or --
    while executing
"switch $ch {
            " " {
                incr data(current)
                continue
            }
            "\n" {
                set data(c..."
    (procedure "_skipSpaces" line 7)
    invoked from within
"_skipSpaces 1"
    (procedure "_parseBlockNode" line 10)
    invoked from within
"_parseBlockNode"
    (procedure "yaml::load" line 8)
    invoked from within
"yaml::load $plane_characters"
    ("uplevel" body line 13)
    invoked from within
"uplevel 1 $script"
---- errorCode: NONE
==== loadtest-14 FAILED

---- loadtest-15 start

==== loadtest-15 test of ::yaml::load 15 error FAILED
==== Contents of test case:

        set error1 {
---
- [name        , \{hr: avg \[\hr: avg\} \] ]
}
        set code [catch {yaml::load $error1} msg]
        concat $code $msg
    
---- Result was:
1 ambiguous option "-": must be -exact, -glob, -regexp, or --
---- Result should have been (exact matching):
1 line(3): There is a flow-mapping end '\}' not in flow-mapping {k: v, ...}.
==== loadtest-15 FAILED

---- loadtest-16 start

==== loadtest-16 test of ::yaml::load 16 error FAILED
==== Contents of test case:

        set error2 {
---
- [name        , \[hr: avg \{\hr: avg\] \} ]
}
        set code [catch {yaml::load $error2} msg]
        concat $code $msg
    
---- Result was:
1 ambiguous option "-": must be -exact, -glob, -regexp, or --
---- Result should have been (exact matching):
1 line(3): There is a flow-sequence end '\]' not in flow-sequence [v, ...].
==== loadtest-16 FAILED

---- loadtest-17 start

==== loadtest-17 test of ::yaml::load 17 error FAILED
==== Contents of test case:

        set error3 {
---
- Clark 
- @Brian 
}
        set code [catch {yaml::load $error3} msg]
        concat $code $msg
    
---- Result was:
1 ambiguous option "-": must be -exact, -glob, -regexp, or --
---- Result should have been (exact matching):
1 line(4): Reserved indicators {@} can't start a plain scalar.
==== loadtest-17 FAILED

---- loadtest-18 start

==== loadtest-18 test of ::yaml::load 18 error FAILED
==== Contents of test case:

        set error4 {
---
- Clark 
- `Brian 
}
        set code [catch {yaml::load $error4} msg]
        concat $code $msg
    
---- Result was:
1 ambiguous option "-": must be -exact, -glob, -regexp, or --
---- Result should have been (exact matching):
1 line(4): Reserved indicators {`} can't start a plain scalar.
==== loadtest-18 FAILED

---- loadtest-19 start

==== loadtest-19 test of ::yaml::load 19 error FAILED
==== Contents of test case:

        set error5 {
---
- Clark 
- 	Brian 
}
        set code [catch {yaml::load $error5} msg]
        concat $code $msg
    
---- Result was:
1 ambiguous option "-": must be -exact, -glob, -regexp, or --
---- Result should have been (exact matching):
1 line(4): Tabs can be used only in comments, and in quoted "..." '...'.
==== loadtest-19 FAILED

---- loadtest-20 start

==== loadtest-20 test of ::yaml::load 20 error FAILED
==== Contents of test case:

        set error6 {
---
- *a
- Brian 
- @a Geoge
}
        set code [catch {yaml::load $error6} msg]
        concat $code $msg
    
---- Result was:
1 ambiguous option "-": must be -exact, -glob, -regexp, or --
---- Result should have been (exact matching):
1 line(4): Could not find the anchor-name(current-version, "after refering" is not supported)
==== loadtest-20 FAILED

---- loadtest-21 start

==== loadtest-21 test of ::yaml::load 21 error FAILED
==== Contents of test case:

        set error7 {
---
- "Clark 
[45munmatched open quote in list[0m
Passed       0 of      0
Skipped      0 of      0
Failed       0 of      0
#Errors [45m     1[0m
