Attachment "yaml-testsuite-failures.log" to
ticket [1969847fff]
added by
andreas_kupries
2008-05-23 02:18:17.
============================================================
@@ 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
