tonyair
/
silverstripe-framework
mirror of https://github.com/silverstripe/silverstripe-framework
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

MINOR Removed unnecessary tests from symfony-yaml dependency (which also fixes phpunit binary execution)

This commit is contained in:
Ingo Schommer 2012-03-14 12:02:07 +01:00
parent 37ae36cd58
commit eecca9b73a
21 changed files with 0 additions and 3345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
thirdparty/symfony-yaml/test/fixtures/YtsAnchorAlias.yml vendored
View File

@ -1,31 +0,0 @@
--- %YAML:1.0
test: Simple Alias Example
brief: >
If you need to refer to the same item of data twice,
you can give that item an alias. The alias is a plain
string, starting with an ampersand. The item may then
be referred to by the alias throughout your document
by using an asterisk before the name of the alias.
This is called an anchor.
yaml: |
- &showell Steve
- Clark
- Brian
- Oren
- *showell
php: |
array('Steve', 'Clark', 'Brian', 'Oren', 'Steve')
---
test: Alias of a Mapping
brief: >
An alias can be used on any item of data, including
sequences, mappings, and other complex data types.
yaml: |
- &hello
Meat: pork
Starch: potato
- banana
- *hello
php: |
array(array('Meat'=>'pork', 'Starch'=>'potato'), 'banana', array('Meat'=>'pork', 'Starch'=>'potato'))

178
thirdparty/symfony-yaml/test/fixtures/YtsBasicTests.yml vendored
View File

@ -1,178 +0,0 @@
--- %YAML:1.0
test: Simple Sequence
brief: |
You can specify a list in YAML by placing each
member of the list on a new line with an opening
dash. These lists are called sequences.
yaml: |
- apple
- banana
- carrot
php: |
array('apple', 'banana', 'carrot')
---
test: Nested Sequences
brief: |
You can include a sequence within another
sequence by giving the sequence an empty
dash, followed by an indented list.
yaml: |
-
- foo
- bar
- baz
php: |
array(array('foo', 'bar', 'baz'))
---
test: Mixed Sequences
brief: |
Sequences can contain any YAML data,
including strings and other sequences.
yaml: |
- apple
-
- foo
- bar
- x123
- banana
- carrot
php: |
array('apple', array('foo', 'bar', 'x123'), 'banana', 'carrot')
---
test: Deeply Nested Sequences
brief: |
Sequences can be nested even deeper, with each
level of indentation representing a level of
depth.
yaml: |
-
-
- uno
- dos
php: |
array(array(array('uno', 'dos')))
---
test: Simple Mapping
brief: |
You can add a keyed list (also known as a dictionary or
hash) to your document by placing each member of the
list on a new line, with a colon seperating the key
from its value. In YAML, this type of list is called
a mapping.
yaml: |
foo: whatever
bar: stuff
php: |
array('foo' => 'whatever', 'bar' => 'stuff')
---
test: Sequence in a Mapping
brief: |
A value in a mapping can be a sequence.
yaml: |
foo: whatever
bar:
- uno
- dos
php: |
array('foo' => 'whatever', 'bar' => array('uno', 'dos'))
---
test: Nested Mappings
brief: |
A value in a mapping can be another mapping.
yaml: |
foo: whatever
bar:
fruit: apple
name: steve
sport: baseball
php: |
array(
'foo' => 'whatever',
'bar' => array(
'fruit' => 'apple',
'name' => 'steve',
'sport' => 'baseball'
)
)
---
test: Mixed Mapping
brief: |
A mapping can contain any assortment
of mappings and sequences as values.
yaml: |
foo: whatever
bar:
-
fruit: apple
name: steve
sport: baseball
- more
-
python: rocks
perl: papers
ruby: scissorses
php: |
array(
'foo' => 'whatever',
'bar' => array(
array(
'fruit' => 'apple',
'name' => 'steve',
'sport' => 'baseball'
),
'more',
array(
'python' => 'rocks',
'perl' => 'papers',
'ruby' => 'scissorses'
)
)
)
---
test: Mapping-in-Sequence Shortcut
todo: true
brief: |
If you are adding a mapping to a sequence, you
can place the mapping on the same line as the
dash as a shortcut.
yaml: |
- work on YAML.py:
- work on Store
php: |
array(array('work on YAML.py' => array('work on Store')))
---
test: Sequence-in-Mapping Shortcut
todo: true
brief: |
The dash in a sequence counts as indentation, so
you can add a sequence inside of a mapping without
needing spaces as indentation.
yaml: |
allow:
- 'localhost'
- '%.sourceforge.net'
- '%.freepan.org'
php: |
array('allow' => array('localhost', '%.sourceforge.net', '%.freepan.org'))
---
todo: true
test: Merge key
brief: |
A merge key ('<<') can be used in a mapping to insert other mappings. If
the value associated with the merge key is a mapping, each of its key/value
pairs is inserted into the current mapping.
yaml: |
mapping:
name: Joe
job: Accountant
<<:
age: 38
php: |
array(
'mapping' =>
array(
'name' => 'Joe',
'job' => 'Accountant',
'age' => 38
)
)

52
thirdparty/symfony-yaml/test/fixtures/YtsBlockMapping.yml vendored
View File

@ -1,52 +0,0 @@
---
test: One Element Mapping
brief: |
A mapping with one key/value pair
yaml: |
foo: bar
php: |
array('foo' => 'bar')
---
test: Multi Element Mapping
brief: |
More than one key/value pair
yaml: |
red: baron
white: walls
blue: berries
php: |
array(
'red' => 'baron',
'white' => 'walls',
'blue' => 'berries',
)
---
test: Values aligned
brief: |
Often times human editors of documents will align the values even
though YAML emitters generally don't.
yaml: |
red: baron
white: walls
blue: berries
php: |
array(
'red' => 'baron',
'white' => 'walls',
'blue' => 'berries',
)
---
test: Colons aligned
brief: |
Spaces can come before the ': ' key/value separator.
yaml: |
red : baron
white : walls
blue : berries
php: |
array(
'red' => 'baron',
'white' => 'walls',
'blue' => 'berries',
)

85
thirdparty/symfony-yaml/test/fixtures/YtsDocumentSeparator.yml vendored
View File

@ -1,85 +0,0 @@
--- %YAML:1.0
test: Trailing Document Separator
todo: true
brief: >
You can separate YAML documents
with a string of three dashes.
yaml: |
- foo: 1
bar: 2
---
more: stuff
python: |
[
[ { 'foo': 1, 'bar': 2 } ],
{ 'more': 'stuff' }
]
ruby: |
[ { 'foo' => 1, 'bar' => 2 } ]
---
test: Leading Document Separator
todo: true
brief: >
You can explicity give an opening
document separator to your YAML stream.
yaml: |
---
- foo: 1
bar: 2
---
more: stuff
python: |
[
[ {'foo': 1, 'bar': 2}],
{'more': 'stuff'}
]
ruby: |
[ { 'foo' => 1, 'bar' => 2 } ]
---
test: YAML Header
todo: true
brief: >
The opening separator can contain directives
to the YAML parser, such as the version
number.
yaml: |
--- %YAML:1.0
foo: 1
bar: 2
php: |
array('foo' => 1, 'bar' => 2)
documents: 1
---
test: Red Herring Document Separator
brief: >
Separators included in blocks or strings
are treated as blocks or strings, as the
document separator should have no indentation
preceding it.
yaml: |
foo: |
---
php: |
array('foo' => "---\n")
---
test: Multiple Document Separators in Block
brief: >
This technique allows you to embed other YAML
documents within literal blocks.
yaml: |
foo: |
---
foo: bar
---
yo: baz
bar: |
fooness
php: |
array(
'foo' => "---\nfoo: bar\n---\nyo: baz\n",
'bar' => "fooness\n"
)

26
thirdparty/symfony-yaml/test/fixtures/YtsErrorTests.yml vendored
View File

@ -1,26 +0,0 @@
---
test: Missing value for hash item
todo: true
brief: |
Third item in this hash doesn't have a value
yaml: |
okay: value
also okay: ~
causes error because no value specified
last key: value okay here too
python-error: causes error because no value specified
---
test: Not indenting enough
brief: |
There was a bug in PyYaml where it was off by one
in the indentation check. It was allowing the YAML
below.
# This is actually valid YAML now. Someone should tell showell.
yaml: |
foo:
firstline: 1
secondline: 2
php: |
array('foo' => null, 'firstline' => 1, 'secondline' => 2)

60
thirdparty/symfony-yaml/test/fixtures/YtsFlowCollections.yml vendored
View File

@ -1,60 +0,0 @@
---
test: Simple Inline Array
brief: >
Sequences can be contained on a
single line, using the inline syntax.
Separate each entry with commas and
enclose in square brackets.
yaml: |
seq: [ a, b, c ]
php: |
array('seq' => array('a', 'b', 'c'))
---
test: Simple Inline Hash
brief: >
Mapping can also be contained on
a single line, using the inline
syntax. Each key-value pair is
separated by a colon, with a comma
between each entry in the mapping.
Enclose with curly braces.
yaml: |
hash: { name: Steve, foo: bar }
php: |
array('hash' => array('name' => 'Steve', 'foo' => 'bar'))
---
test: Multi-line Inline Collections
todo: true
brief: >
Both inline sequences and inline mappings
can span multiple lines, provided that you
indent the additional lines.
yaml: |
languages: [ Ruby,
Perl,
Python ]
websites: { YAML: yaml.org,
Ruby: ruby-lang.org,
Python: python.org,
Perl: use.perl.org }
php: |
array(
'languages' => array('Ruby', 'Perl', 'Python'),
'websites' => array(
'YAML' => 'yaml.org',
'Ruby' => 'ruby-lang.org',
'Python' => 'python.org',
'Perl' => 'use.perl.org'
)
)
---
test: Commas in Values (not in the spec!)
todo: true
brief: >
List items in collections are delimited by commas, but
there must be a space after each comma. This allows you
to add numbers without quoting.
yaml: |
attendances: [ 45,123, 70,000, 17,222 ]
php: |
array('attendances' => array(45123, 70000, 17222))

176
thirdparty/symfony-yaml/test/fixtures/YtsFoldedScalars.yml vendored
View File

@ -1,176 +0,0 @@
--- %YAML:1.0
test: Single ending newline
brief: >
A pipe character, followed by an indented
block of text is treated as a literal
block, in which newlines are preserved
throughout the block, including the final
newline.
yaml: |
---
this: |
Foo
Bar
php: |
array('this' => "Foo\nBar\n")
---
test: The '+' indicator
brief: >
The '+' indicator says to keep newlines at the end of text
blocks.
yaml: |
normal: |
extra new lines not kept
preserving: |+
extra new lines are kept
dummy: value
php: |
array(
'normal' => "extra new lines not kept\n",
'preserving' => "extra new lines are kept\n\n\n",
'dummy' => 'value'
)
---
test: Three trailing newlines in literals
brief: >
To give you more control over how space
is preserved in text blocks, YAML has
the keep '+' and chomp '-' indicators.
The keep indicator will preserve all
ending newlines, while the chomp indicator
will strip all ending newlines.
yaml: |
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 four newlines.
same as "kept" above: "This has four newlines.\n\n\n\n"
php: |
array(
'clipped' => "This has one newline.\n",
'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 four newlines.\n\n\n\n",
'same as "kept" above' => "This has four newlines.\n\n\n\n"
)
---
test: Extra trailing newlines with spaces
todo: true
brief: >
Normally, only a single newline is kept
from the end of a literal block, unless the
keep '+' character is used in combination
with the pipe. The following example
will preserve all ending whitespace
since the last line of both literal blocks
contains spaces which extend past the indentation
level.
yaml: |
---
this: |
Foo
kept: |+
Foo
php: |
array('this' => "Foo\n\n \n",
'kept' => "Foo\n\n \n" )
---
test: Folded Block in a Sequence
brief: >
A greater-then character, followed by an indented
block of text is treated as a folded block, in
which lines of text separated by a single newline
are concatenated as a single line.
yaml: |
---
- apple
- banana
- >
can't you see
the beauty of yaml?
hmm
- dog
php: |
array(
'apple',
'banana',
"can't you see the beauty of yaml? hmm\n",
'dog'
)
---
test: Folded Block as a Mapping Value
brief: >
Both literal and folded blocks can be
used in collections, as values in a
sequence or a mapping.
yaml: |
---
quote: >
Mark McGwire's
year was crippled
by a knee injury.
source: espn
php: |
array(
'quote' => "Mark McGwire's year was crippled by a knee injury.\n",
'source' => 'espn'
)
---
test: Three trailing newlines in folded blocks
brief: >
The keep and chomp indicators can also
be applied to folded blocks.
yaml: |
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 four newlines.
same as "kept" above: "This has four newlines.\n\n\n\n"
php: |
array(
'clipped' => "This has one newline.\n",
'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 four newlines.\n\n\n\n",
'same as "kept" above' => "This has four newlines.\n\n\n\n"
)

45
thirdparty/symfony-yaml/test/fixtures/YtsNullsAndEmpties.yml vendored
View File

@ -1,45 +0,0 @@
--- %YAML:1.0
test: Empty Sequence
brief: >
You can represent the empty sequence
with an empty inline sequence.
yaml: |
empty: []
php: |
array('empty' => array())
---
test: Empty Mapping
brief: >
You can represent the empty mapping
with an empty inline mapping.
yaml: |
empty: {}
php: |
array('empty' => array())
---
test: Empty Sequence as Entire Document
yaml: |
[]
php: |
array()
---
test: Empty Mapping as Entire Document
yaml: |
{}
php: |
array()
---
test: Null as Document
yaml: |
~
php: |
null
---
test: Empty String
brief: >
You can represent an empty string
with a pair of quotes.
yaml: |
''
php: |
''

1695
thirdparty/symfony-yaml/test/fixtures/YtsSpecificationExamples.yml vendored
View File

@ -1,1695 +0,0 @@
--- %YAML:1.0
test: Sequence of scalars
spec: 2.1
yaml: |
- Mark McGwire
- Sammy Sosa
- Ken Griffey
php: |
array('Mark McGwire', 'Sammy Sosa', 'Ken Griffey')
---
test: Mapping of scalars to scalars
spec: 2.2
yaml: |
hr: 65
avg: 0.278
rbi: 147
php: |
array('hr' => 65, 'avg' => 0.278, 'rbi' => 147)
---
test: Mapping of scalars to sequences
spec: 2.3
yaml: |
american:
- Boston Red Sox
- Detroit Tigers
- New York Yankees
national:
- New York Mets
- Chicago Cubs
- Atlanta Braves
php: |
array('american' =>
array( 'Boston Red Sox', 'Detroit Tigers',
'New York Yankees' ),
'national' =>
array( 'New York Mets', 'Chicago Cubs',
'Atlanta Braves' )
)
---
test: Sequence of mappings
spec: 2.4
yaml: |
-
name: Mark McGwire
hr: 65
avg: 0.278
-
name: Sammy Sosa
hr: 63
avg: 0.288
php: |
array(
array('name' => 'Mark McGwire', 'hr' => 65, 'avg' => 0.278),
array('name' => 'Sammy Sosa', 'hr' => 63, 'avg' => 0.288)
)
---
test: Legacy A5
todo: true
spec: legacy_A5
yaml: |
?
- New York Yankees
- Atlanta Braves
:
- 2001-07-02
- 2001-08-12
- 2001-08-14
?
- Detroit Tigers
- Chicago Cubs
:
- 2001-07-23
perl-busted: >
YAML.pm will be able to emulate this behavior soon. In this regard
it may be somewhat more correct than Python's native behaviour which
can only use tuples as mapping keys. PyYAML will also need to figure
out some clever way to roundtrip structured keys.
python: |
[
{
('New York Yankees', 'Atlanta Braves'):
[yaml.timestamp('2001-07-02'),
yaml.timestamp('2001-08-12'),
yaml.timestamp('2001-08-14')],
('Detroit Tigers', 'Chicago Cubs'):
[yaml.timestamp('2001-07-23')]
}
]
ruby: |
{
[ 'New York Yankees', 'Atlanta Braves' ] =>
[ Date.new( 2001, 7, 2 ), Date.new( 2001, 8, 12 ), Date.new( 2001, 8, 14 ) ],
[ 'Detroit Tigers', 'Chicago Cubs' ] =>
[ Date.new( 2001, 7, 23 ) ]
}
syck: |
struct test_node seq1[] = {
{ T_STR, 0, "New York Yankees" },
{ T_STR, 0, "Atlanta Braves" },
end_node
};
struct test_node seq2[] = {
{ T_STR, 0, "2001-07-02" },
{ T_STR, 0, "2001-08-12" },
{ T_STR, 0, "2001-08-14" },
end_node
};
struct test_node seq3[] = {
{ T_STR, 0, "Detroit Tigers" },
{ T_STR, 0, "Chicago Cubs" },
end_node
};
struct test_node seq4[] = {
{ T_STR, 0, "2001-07-23" },
end_node
};
struct test_node map[] = {
{ T_SEQ, 0, 0, seq1 },
{ T_SEQ, 0, 0, seq2 },
{ T_SEQ, 0, 0, seq3 },
{ T_SEQ, 0, 0, seq4 },
end_node
};
struct test_node stream[] = {
{ T_MAP, 0, 0, map },
end_node
};
---
test: Sequence of sequences
spec: 2.5
yaml: |
- [ name , hr , avg ]
- [ Mark McGwire , 65 , 0.278 ]
- [ Sammy Sosa , 63 , 0.288 ]
php: |
array(
array( 'name', 'hr', 'avg' ),
array( 'Mark McGwire', 65, 0.278 ),
array( 'Sammy Sosa', 63, 0.288 )
)
---
test: Mapping of mappings
todo: true
spec: 2.6
yaml: |
Mark McGwire: {hr: 65, avg: 0.278}
Sammy Sosa: {
hr: 63,
avg: 0.288
}
php: |
array(
'Mark McGwire' =>
array( 'hr' => 65, 'avg' => 0.278 ),
'Sammy Sosa' =>
array( 'hr' => 63, 'avg' => 0.288 )
)
---
test: Two documents in a stream each with a leading comment
todo: true
spec: 2.7
yaml: |
# Ranking of 1998 home runs
---
- Mark McGwire
- Sammy Sosa
- Ken Griffey
# Team ranking
---
- Chicago Cubs
- St Louis Cardinals
ruby: |
y = YAML::Stream.new
y.add( [ 'Mark McGwire', 'Sammy Sosa', 'Ken Griffey' ] )
y.add( [ 'Chicago Cubs', 'St Louis Cardinals' ] )
documents: 2
---
test: Play by play feed from a game
todo: true
spec: 2.8
yaml: |
---
time: 20:03:20
player: Sammy Sosa
action: strike (miss)
...
---
time: 20:03:47
player: Sammy Sosa
action: grand slam
...
perl: |
[ 'Mark McGwire', 'Sammy Sosa', 'Ken Griffey' ]
documents: 2
---
test: Single document with two comments
spec: 2.9
yaml: |
hr: # 1998 hr ranking
- Mark McGwire
- Sammy Sosa
rbi:
# 1998 rbi ranking
- Sammy Sosa
- Ken Griffey
php: |
array(
'hr' => array( 'Mark McGwire', 'Sammy Sosa' ),
'rbi' => array( 'Sammy Sosa', 'Ken Griffey' )
)
---
test: Node for Sammy Sosa appears twice in this document
spec: 2.10
yaml: |
---
hr:
- Mark McGwire
# Following node labeled SS
- &SS Sammy Sosa
rbi:
- *SS # Subsequent occurance
- Ken Griffey
php: |
array(
'hr' =>
array('Mark McGwire', 'Sammy Sosa'),
'rbi' =>
array('Sammy Sosa', 'Ken Griffey')
)
---
test: Mapping between sequences
todo: true
spec: 2.11
yaml: |
? # PLAY SCHEDULE
- Detroit Tigers
- Chicago Cubs
:
- 2001-07-23
? [ New York Yankees,
Atlanta Braves ]
: [ 2001-07-02, 2001-08-12,
2001-08-14 ]
ruby: |
{
[ 'Detroit Tigers', 'Chicago Cubs' ] => [ Date.new( 2001, 7, 23 ) ],
[ 'New York Yankees', 'Atlanta Braves' ] => [ Date.new( 2001, 7, 2 ), Date.new( 2001, 8, 12 ), Date.new( 2001, 8, 14 ) ]
}
syck: |
struct test_node seq1[] = {
{ T_STR, 0, "New York Yankees" },
{ T_STR, 0, "Atlanta Braves" },
end_node
};
struct test_node seq2[] = {
{ T_STR, 0, "2001-07-02" },
{ T_STR, 0, "2001-08-12" },
{ T_STR, 0, "2001-08-14" },
end_node
};
struct test_node seq3[] = {
{ T_STR, 0, "Detroit Tigers" },
{ T_STR, 0, "Chicago Cubs" },
end_node
};
struct test_node seq4[] = {
{ T_STR, 0, "2001-07-23" },
end_node
};
struct test_node map[] = {
{ T_SEQ, 0, 0, seq3 },
{ T_SEQ, 0, 0, seq4 },
{ T_SEQ, 0, 0, seq1 },
{ T_SEQ, 0, 0, seq2 },
end_node
};
struct test_node stream[] = {
{ T_MAP, 0, 0, map },
end_node
};
---
test: Sequence key shortcut
spec: 2.12
yaml: |
---
# products purchased
- item : Super Hoop
quantity: 1
- item : Basketball
quantity: 4
- item : Big Shoes
quantity: 1
php: |
array (
array (
'item' => 'Super Hoop',
'quantity' => 1,
),
array (
'item' => 'Basketball',
'quantity' => 4,
),
array (
'item' => 'Big Shoes',
'quantity' => 1,
)
)
perl: |
[
{ item => 'Super Hoop', quantity => 1 },
{ item => 'Basketball', quantity => 4 },
{ item => 'Big Shoes', quantity => 1 }
]
ruby: |
[
{ 'item' => 'Super Hoop', 'quantity' => 1 },
{ 'item' => 'Basketball', 'quantity' => 4 },
{ 'item' => 'Big Shoes', 'quantity' => 1 }
]
python: |
[
{ 'item': 'Super Hoop', 'quantity': 1 },
{ 'item': 'Basketball', 'quantity': 4 },
{ 'item': 'Big Shoes', 'quantity': 1 }
]
syck: |
struct test_node map1[] = {
{ T_STR, 0, "item" },
{ T_STR, 0, "Super Hoop" },
{ T_STR, 0, "quantity" },
{ T_STR, 0, "1" },
end_node
};
struct test_node map2[] = {
{ T_STR, 0, "item" },
{ T_STR, 0, "Basketball" },
{ T_STR, 0, "quantity" },
{ T_STR, 0, "4" },
end_node
};
struct test_node map3[] = {
{ T_STR, 0, "item" },
{ T_STR, 0, "Big Shoes" },
{ T_STR, 0, "quantity" },
{ T_STR, 0, "1" },
end_node
};
struct test_node seq[] = {
{ T_MAP, 0, 0, map1 },
{ T_MAP, 0, 0, map2 },
{ T_MAP, 0, 0, map3 },
end_node
};
struct test_node stream[] = {
{ T_SEQ, 0, 0, seq },
end_node
};
---
test: Literal perserves newlines
todo: true
spec: 2.13
yaml: |
# ASCII Art
--- |
\//||\/||
// || ||_
perl: |
"\\//||\\/||\n// || ||_\n"
ruby: |
"\\//||\\/||\n// || ||_\n"
python: |
[
flushLeft(
"""
\//||\/||
// || ||_
"""
)
]
syck: |
struct test_node stream[] = {
{ T_STR, 0, "\\//||\\/||\n// || ||_\n" },
end_node
};
---
test: Folded treats newlines as a space
todo: true
spec: 2.14
yaml: |
---
Mark McGwire's
year was crippled
by a knee injury.
perl: |
"Mark McGwire's year was crippled by a knee injury."
ruby: |
"Mark McGwire's year was crippled by a knee injury."
python: |
[ "Mark McGwire's year was crippled by a knee injury." ]
syck: |
struct test_node stream[] = {
{ T_STR, 0, "Mark McGwire's year was crippled by a knee injury." },
end_node
};
---
test: Newlines preserved for indented and blank lines
todo: true
spec: 2.15
yaml: |
--- >
Sammy Sosa completed another
fine season with great stats.
63 Home Runs
0.288 Batting Average
What a year!
perl: |
"Sammy Sosa completed another fine season with great stats.\n\n 63 Home Runs\n 0.288 Batting Average\n\nWhat a year!\n"
ruby: |
"Sammy Sosa completed another fine season with great stats.\n\n 63 Home Runs\n 0.288 Batting Average\n\nWhat a year!\n"
python: |
[
flushLeft(
"""
Sammy Sosa completed another fine season with great stats.
63 Home Runs
0.288 Batting Average
What a year!
"""
)
]
syck: |
struct test_node stream[] = {
{ T_STR, 0, "Sammy Sosa completed another fine season with great stats.\n\n 63 Home Runs\n 0.288 Batting Average\n\nWhat a year!\n" },
end_node
};
---
test: Indentation determines scope
spec: 2.16
yaml: |
name: Mark McGwire
accomplishment: >
Mark set a major league
home run record in 1998.
stats: |
65 Home Runs
0.278 Batting Average
php: |
array(
'name' => 'Mark McGwire',
'accomplishment' => "Mark set a major league home run record in 1998.\n",
'stats' => "65 Home Runs\n0.278 Batting Average\n"
)
---
test: Quoted scalars
todo: true
spec: 2.17
yaml: |
unicode: "Sosa did fine.\u263A"
control: "\b1998\t1999\t2000\n"
hexesc: "\x0D\x0A is \r\n"
single: '"Howdy!" he cried.'
quoted: ' # not a ''comment''.'
tie-fighter: '|\-*-/|'
ruby: |
{
"tie-fighter" => "|\\-*-/|",
"control"=>"\0101998\t1999\t2000\n",
"unicode"=>"Sosa did fine." + ["263A".hex ].pack('U*'),
"quoted"=>" # not a 'comment'.",
"single"=>"\"Howdy!\" he cried.",
"hexesc"=>"\r\n is \r\n"
}
---
test: Multiline flow scalars
todo: true
spec: 2.18
yaml: |
plain:
This unquoted scalar
spans many lines.
quoted: "So does this
quoted scalar.\n"
ruby: |
{
'plain' => 'This unquoted scalar spans many lines.',
'quoted' => "So does this quoted scalar.\n"
}
---
test: Integers
spec: 2.19
yaml: |
canonical: 12345
decimal: +12,345
octal: 014
hexadecimal: 0xC
php: |
array(
'canonical' => 12345,
'decimal' => 12345,
'octal' => 014,
'hexadecimal' => 0xC
)
---
# FIX: spec shows parens around -inf and NaN
test: Floating point
spec: 2.20
yaml: |
canonical: 1.23015e+3
exponential: 12.3015e+02
fixed: 1,230.15
negative infinity: -.inf
not a number: .NaN
php: |
array(
'canonical' => 1230.15,
'exponential' => 1230.15,
'fixed' => 1230.15,
'negative infinity' => log(0),
'not a number' => -log(0),
)
---
test: Miscellaneous
spec: 2.21
yaml: |
null: ~
true: y
false: n
string: '12345'
php: |
array(
'' => null,
1 => true,
0 => false,
'string' => '12345'
)
---
test: Timestamps
todo: true
spec: 2.22
yaml: |
canonical: 2001-12-15T02:59:43.1Z
iso8601: 2001-12-14t21:59:43.10-05:00
spaced: 2001-12-14 21:59:43.10 -05:00
date: 2002-12-14 # Time is noon UTC
php: |
array(
'canonical' => YAML::mktime( 2001, 12, 15, 2, 59, 43, 0.10 ),
'iso8601' => YAML::mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" ),
'spaced' => YAML::mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" ),
'date' => Date.new( 2002, 12, 14 )
)
---
test: legacy Timestamps test
todo: true
spec: legacy D4
yaml: |
canonical: 2001-12-15T02:59:43.00Z
iso8601: 2001-02-28t21:59:43.00-05:00
spaced: 2001-12-14 21:59:43.00 -05:00
date: 2002-12-14
php: |
array(
'canonical' => Time::utc( 2001, 12, 15, 2, 59, 43, 0 ),
'iso8601' => YAML::mktime( 2001, 2, 28, 21, 59, 43, 0, "-05:00" ),
'spaced' => YAML::mktime( 2001, 12, 14, 21, 59, 43, 0, "-05:00" ),
'date' => Date.new( 2002, 12, 14 )
)
---
test: Various explicit families
todo: true
spec: 2.23
yaml: |
not-date: !str 2002-04-28
picture: !binary |
R0lGODlhDAAMAIQAAP//9/X
17unp5WZmZgAAAOfn515eXv
Pz7Y6OjuDg4J+fn5OTk6enp
56enmleECcgggoBADs=
application specific tag: !!something |
The semantics of the tag
above may be different for
different documents.
ruby-setup: |
YAML.add_private_type( "something" ) do |type, val|
"SOMETHING: #{val}"
end
ruby: |
{
'not-date' => '2002-04-28',
'picture' => "GIF89a\f\000\f\000\204\000\000\377\377\367\365\365\356\351\351\345fff\000\000\000\347\347\347^^^\363\363\355\216\216\216\340\340\340\237\237\237\223\223\223\247\247\247\236\236\236i^\020' \202\n\001\000;",
'application specific tag' => "SOMETHING: The semantics of the tag\nabove may be different for\ndifferent documents.\n"
}
---
test: Application specific family
todo: true
spec: 2.24
yaml: |
# Establish a tag prefix
--- !clarkevans.com,2002/graph/^shape
# Use the prefix: shorthand for
# !clarkevans.com,2002/graph/circle
- !^circle
center: &ORIGIN {x: 73, 'y': 129}
radius: 7
- !^line # !clarkevans.com,2002/graph/line
start: *ORIGIN
finish: { x: 89, 'y': 102 }
- !^label
start: *ORIGIN
color: 0xFFEEBB
value: Pretty vector drawing.
ruby-setup: |
YAML.add_domain_type( "clarkevans.com,2002", 'graph/shape' ) { |type, val|
if Array === val
val << "Shape Container"
val
else
raise YAML::Error, "Invalid graph of class #{ val.class }: " + val.inspect
end
}
one_shape_proc = Proc.new { |type, val|
scheme, domain, type = type.split( /:/, 3 )
if val.is_a? ::Hash
val['TYPE'] = "Shape: #{type}"
val
else
raise YAML::Error, "Invalid graph of class #{ val.class }: " + val.inspect
end
}
YAML.add_domain_type( "clarkevans.com,2002", 'graph/circle', &one_shape_proc )
YAML.add_domain_type( "clarkevans.com,2002", 'graph/line', &one_shape_proc )
YAML.add_domain_type( "clarkevans.com,2002", 'graph/label', &one_shape_proc )
ruby: |
[
{
"radius" => 7,
"center"=>
{
"x" => 73,
"y" => 129
},
"TYPE" => "Shape: graph/circle"
}, {
"finish" =>
{
"x" => 89,
"y" => 102
},
"TYPE" => "Shape: graph/line",
"start" =>
{
"x" => 73,
"y" => 129
}
}, {
"TYPE" => "Shape: graph/label",
"value" => "Pretty vector drawing.",
"start" =>
{
"x" => 73,
"y" => 129
},
"color" => 16772795
},
"Shape Container"
]
# ---
# test: Unordered set
# spec: 2.25
# yaml: |
# # sets are represented as a
# # mapping where each key is
# # associated with the empty string
# --- !set
# ? Mark McGwire
# ? Sammy Sosa
# ? Ken Griff
---
test: Ordered mappings
todo: true
spec: 2.26
yaml: |
# ordered maps are represented as
# a sequence of mappings, with
# each mapping having one key
--- !omap
- Mark McGwire: 65
- Sammy Sosa: 63
- Ken Griffy: 58
ruby: |
YAML::Omap[
'Mark McGwire', 65,
'Sammy Sosa', 63,
'Ken Griffy', 58
]
---
test: Invoice
dump_skip: true
spec: 2.27
yaml: |
--- !clarkevans.com,2002/^invoice
invoice: 34843
date : 2001-01-23
bill-to: &id001
given : Chris
family : Dumars
address:
lines: |
458 Walkman Dr.
Suite #292
city : Royal Oak
state : MI
postal : 48046
ship-to: *id001
product:
-
sku : BL394D
quantity : 4
description : Basketball
price : 450.00
-
sku : BL4438H
quantity : 1
description : Super Hoop
price : 2392.00
tax : 251.42
total: 4443.52
comments: >
Late afternoon is best.
Backup contact is Nancy
Billsmer @ 338-4338.
php: |
array(
'invoice' => 34843, 'date' => mktime(0, 0, 0, 1, 23, 2001),
'bill-to' =>
array( 'given' => 'Chris', 'family' => 'Dumars', 'address' => array( 'lines' => "458 Walkman Dr.\nSuite #292\n", 'city' => 'Royal Oak', 'state' => 'MI', 'postal' => 48046 ) )
, 'ship-to' =>
array( 'given' => 'Chris', 'family' => 'Dumars', 'address' => array( 'lines' => "458 Walkman Dr.\nSuite #292\n", 'city' => 'Royal Oak', 'state' => 'MI', 'postal' => 48046 ) )
, 'product' =>
array(
array( 'sku' => 'BL394D', 'quantity' => 4, 'description' => 'Basketball', 'price' => 450.00 ),
array( 'sku' => 'BL4438H', 'quantity' => 1, 'description' => 'Super Hoop', 'price' => 2392.00 )
),
'tax' => 251.42, 'total' => 4443.52,
'comments' => "Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.\n"
)
---
test: Log file
todo: true
spec: 2.28
yaml: |
---
Time: 2001-11-23 15:01:42 -05:00
User: ed
Warning: >
This is an error message
for the log file
---
Time: 2001-11-23 15:02:31 -05:00
User: ed
Warning: >
A slightly different error
message.
---
Date: 2001-11-23 15:03:17 -05:00
User: ed
Fatal: >
Unknown variable "bar"
Stack:
- file: TopClass.py
line: 23
code: |
x = MoreObject("345\n")
- file: MoreClass.py
line: 58
code: |-
foo = bar
ruby: |
y = YAML::Stream.new
y.add( { 'Time' => YAML::mktime( 2001, 11, 23, 15, 01, 42, 00, "-05:00" ),
'User' => 'ed', 'Warning' => "This is an error message for the log file\n" } )
y.add( { 'Time' => YAML::mktime( 2001, 11, 23, 15, 02, 31, 00, "-05:00" ),
'User' => 'ed', 'Warning' => "A slightly different error message.\n" } )
y.add( { 'Date' => YAML::mktime( 2001, 11, 23, 15, 03, 17, 00, "-05:00" ),
'User' => 'ed', 'Fatal' => "Unknown variable \"bar\"\n",
'Stack' => [
{ 'file' => 'TopClass.py', 'line' => 23, 'code' => "x = MoreObject(\"345\\n\")\n" },
{ 'file' => 'MoreClass.py', 'line' => 58, 'code' => "foo = bar" } ] } )
documents: 3
---
test: Throwaway comments
yaml: |
### These are four throwaway comment ###
### lines (the second line is empty). ###
this: | # Comments may trail lines.
contains three lines of text.
The third one starts with a
# character. This isn't a comment.
# These are three throwaway comment
# lines (the first line is empty).
php: |
array(
'this' => "contains three lines of text.\nThe third one starts with a\n# character. This isn't a comment.\n"
)
---
test: Document with a single value
todo: true
yaml: |
--- >
This YAML stream contains a single text value.
The next stream is a log file - a sequence of
log entries. Adding an entry to the log is a
simple matter of appending it at the end.
ruby: |
"This YAML stream contains a single text value. The next stream is a log file - a sequence of log entries. Adding an entry to the log is a simple matter of appending it at the end.\n"
---
test: Document stream
todo: true
yaml: |
---
at: 2001-08-12 09:25:00.00 Z
type: GET
HTTP: '1.0'
url: '/index.html'
---
at: 2001-08-12 09:25:10.00 Z
type: GET
HTTP: '1.0'
url: '/toc.html'
ruby: |
y = YAML::Stream.new
y.add( {
'at' => Time::utc( 2001, 8, 12, 9, 25, 00 ),
'type' => 'GET',
'HTTP' => '1.0',
'url' => '/index.html'
} )
y.add( {
'at' => Time::utc( 2001, 8, 12, 9, 25, 10 ),
'type' => 'GET',
'HTTP' => '1.0',
'url' => '/toc.html'
} )
documents: 2
---
test: Top level mapping
yaml: |
# This stream is an example of a top-level mapping.
invoice : 34843
date : 2001-01-23
total : 4443.52
php: |
array(
'invoice' => 34843,
'date' => mktime(0, 0, 0, 1, 23, 2001),
'total' => 4443.52
)
---
test: Single-line documents
todo: true
yaml: |
# The following is a sequence of three documents.
# The first contains an empty mapping, the second
# an empty sequence, and the last an empty string.
--- {}
--- [ ]
--- ''
ruby: |
y = YAML::Stream.new
y.add( {} )
y.add( [] )
y.add( '' )
documents: 3
---
test: Document with pause
todo: true
yaml: |
# A communication channel based on a YAML stream.
---
sent at: 2002-06-06 11:46:25.10 Z
payload: Whatever
# Receiver can process this as soon as the following is sent:
...
# Even if the next message is sent long after:
---
sent at: 2002-06-06 12:05:53.47 Z
payload: Whatever
...
ruby: |
y = YAML::Stream.new
y.add(
{ 'sent at' => YAML::mktime( 2002, 6, 6, 11, 46, 25, 0.10 ),
'payload' => 'Whatever' }
)
y.add(
{ "payload" => "Whatever", "sent at" => YAML::mktime( 2002, 6, 6, 12, 5, 53, 0.47 ) }
)
documents: 2
---
test: Explicit typing
yaml: |
integer: 12
also int: ! "12"
string: !str 12
php: |
array( 'integer' => 12, 'also int' => 12, 'string' => '12' )
---
test: Private types
todo: true
yaml: |
# Both examples below make use of the 'x-private:ball'
# type family URI, but with different semantics.
---
pool: !!ball
number: 8
color: black
---
bearing: !!ball
material: steel
ruby: |
y = YAML::Stream.new
y.add( { 'pool' =>
YAML::PrivateType.new( 'ball',
{ 'number' => 8, 'color' => 'black' } ) }
)
y.add( { 'bearing' =>
YAML::PrivateType.new( 'ball',
{ 'material' => 'steel' } ) }
)
documents: 2
---
test: Type family under yaml.org
yaml: |
# The URI is 'tag:yaml.org,2002:str'
- !str a Unicode string
php: |
array( 'a Unicode string' )
---
test: Type family under perl.yaml.org
todo: true
yaml: |
# The URI is 'tag:perl.yaml.org,2002:Text::Tabs'
- !perl/Text::Tabs {}
ruby: |
[ YAML::DomainType.new( 'perl.yaml.org,2002', 'Text::Tabs', {} ) ]
---
test: Type family under clarkevans.com
todo: true
yaml: |
# The URI is 'tag:clarkevans.com,2003-02:timesheet'
- !clarkevans.com,2003-02/timesheet {}
ruby: |
[ YAML::DomainType.new( 'clarkevans.com,2003-02', 'timesheet', {} ) ]
---
test: URI Escaping
todo: true
yaml: |
same:
- !domain.tld,2002/type\x30 value
- !domain.tld,2002/type0 value
different: # As far as the YAML parser is concerned
- !domain.tld,2002/type%30 value
- !domain.tld,2002/type0 value
ruby-setup: |
YAML.add_domain_type( "domain.tld,2002", "type0" ) { |type, val|
"ONE: #{val}"
}
YAML.add_domain_type( "domain.tld,2002", "type%30" ) { |type, val|
"TWO: #{val}"
}
ruby: |
{ 'same' => [ 'ONE: value', 'ONE: value' ], 'different' => [ 'TWO: value', 'ONE: value' ] }
---
test: URI Prefixing
todo: true
yaml: |
# 'tag:domain.tld,2002:invoice' is some type family.
invoice: !domain.tld,2002/^invoice
# 'seq' is shorthand for 'tag:yaml.org,2002:seq'.
# This does not effect '^customer' below
# because it is does not specify a prefix.
customers: !seq
# '^customer' is shorthand for the full
# notation 'tag:domain.tld,2002:customer'.
- !^customer
given : Chris
family : Dumars
ruby-setup: |
YAML.add_domain_type( "domain.tld,2002", /(invoice|customer)/ ) { |type, val|
if val.is_a? ::Hash
scheme, domain, type = type.split( /:/, 3 )
val['type'] = "domain #{type}"
val
else
raise YAML::Error, "Not a Hash in domain.tld/invoice: " + val.inspect
end
}
ruby: |
{ "invoice"=> { "customers"=> [ { "given"=>"Chris", "type"=>"domain customer", "family"=>"Dumars" } ], "type"=>"domain invoice" } }
---
test: Overriding anchors
yaml: |
anchor : &A001 This scalar has an anchor.
override : &A001 >
The alias node below is a
repeated use of this value.
alias : *A001
php: |
array( 'anchor' => 'This scalar has an anchor.',
'override' => "The alias node below is a repeated use of this value.\n",
'alias' => "The alias node below is a repeated use of this value.\n" )
---
test: Flow and block formatting
todo: true
yaml: |
empty: []
flow: [ one, two, three # May span lines,
, four, # indentation is
five ] # mostly ignored.
block:
- First item in top sequence
-
- Subordinate sequence entry
- >
A folded sequence entry
- Sixth item in top sequence
ruby: |
{ 'empty' => [], 'flow' => [ 'one', 'two', 'three', 'four', 'five' ],
'block' => [ 'First item in top sequence', [ 'Subordinate sequence entry' ],
"A folded sequence entry\n", 'Sixth item in top sequence' ] }
---
test: Complete mapping test
todo: true
yaml: |
empty: {}
flow: { one: 1, two: 2 }
spanning: { one: 1,
two: 2 }
block:
first : First entry
second:
key: Subordinate mapping
third:
- Subordinate sequence
- { }
- Previous mapping is empty.
- A key: value pair in a sequence.
A second: key:value pair.
- The previous entry is equal to the following one.
-
A key: value pair in a sequence.
A second: key:value pair.
!float 12 : This key is a float.
? >
?
: This key had to be protected.
"\a" : This key had to be escaped.
? >
This is a
multi-line
folded key
: Whose value is
also multi-line.
? this also works as a key
: with a value at the next line.
?
- This key
- is a sequence
:
- With a sequence value.
?
This: key
is a: mapping
:
with a: mapping value.
ruby: |
{ 'empty' => {}, 'flow' => { 'one' => 1, 'two' => 2 },
'spanning' => { 'one' => 1, 'two' => 2 },
'block' => { 'first' => 'First entry', 'second' =>
{ 'key' => 'Subordinate mapping' }, 'third' =>
[ 'Subordinate sequence', {}, 'Previous mapping is empty.',
{ 'A key' => 'value pair in a sequence.', 'A second' => 'key:value pair.' },
'The previous entry is equal to the following one.',
{ 'A key' => 'value pair in a sequence.', 'A second' => 'key:value pair.' } ],
12.0 => 'This key is a float.', "?\n" => 'This key had to be protected.',
"\a" => 'This key had to be escaped.',
"This is a multi-line folded key\n" => "Whose value is also multi-line.",
'this also works as a key' => 'with a value at the next line.',
[ 'This key', 'is a sequence' ] => [ 'With a sequence value.' ] } }
# Couldn't recreate map exactly, so we'll do a detailed check to be sure it's entact
obj_y['block'].keys.each { |k|
if Hash === k
v = obj_y['block'][k]
if k['This'] == 'key' and k['is a'] == 'mapping' and v['with a'] == 'mapping value.'
obj_r['block'][k] = v
end
end
}
---
test: Literal explicit indentation
yaml: |
# Explicit indentation must
# be given in all the three
# following cases.
leading spaces: |2
This value starts with four spaces.
leading line break: |2
This value starts with a line break.
leading comment indicator: |2
# first line starts with a
# character.
# Explicit indentation may
# also be given when it is
# not required.
redundant: |2
This value is indented 2 spaces.
php: |
array(
'leading spaces' => " This value starts with four spaces.\n",
'leading line break' => "\nThis value starts with a line break.\n",
'leading comment indicator' => "# first line starts with a\n# character.\n",
'redundant' => "This value is indented 2 spaces.\n"
)
---
test: Chomping and keep modifiers
yaml: |
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 two newlines.
same as "kept" above: "This has two newlines.\n\n"
php: |
array(
'clipped' => "This has one newline.\n",
'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 two newlines.\n\n",
'same as "kept" above' => "This has two newlines.\n\n"
)
---
test: Literal combinations
todo: true
yaml: |
empty: |
literal: |
The \ ' " characters may be
freely used. Leading white
space is significant.
Line breaks are significant.
Thus this value contains one
empty line and ends with a
single line break, but does
not start with one.
is equal to: "The \\ ' \" characters may \
be\nfreely used. Leading white\n space \
is significant.\n\nLine breaks are \
significant.\nThus this value contains \
one\nempty line and ends with a\nsingle \
line break, but does\nnot start with one.\n"
# Comments may follow a block
# scalar value. They must be
# less indented.
# Modifiers may be combined in any order.
indented and chomped: |2-
This has no newline.
also written as: |-2
This has no newline.
both are equal to: " This has no newline."
php: |
array(
'empty' => '',
'literal' => "The \\ ' \" characters may be\nfreely used. Leading white\n space " +
"is significant.\n\nLine breaks are significant.\nThus this value contains one\n" +
"empty line and ends with a\nsingle line break, but does\nnot start with one.\n",
'is equal to' => "The \\ ' \" characters may be\nfreely used. Leading white\n space " +
"is significant.\n\nLine breaks are significant.\nThus this value contains one\n" +
"empty line and ends with a\nsingle line break, but does\nnot start with one.\n",
'indented and chomped' => ' This has no newline.',
'also written as' => ' This has no newline.',
'both are equal to' => ' This has no newline.'
)
---
test: Folded combinations
todo: true
yaml: |
empty: >
one paragraph: >
Line feeds are converted
to spaces, so this value
contains no line breaks
except for the final one.
multiple paragraphs: >2
An empty line, either
at the start or in
the value:
Is interpreted as a
line break. Thus this
value contains three
line breaks.
indented text: >
This is a folded
paragraph followed
by a list:
* first entry
* second entry
Followed by another
folded paragraph,
another list:
* first entry
* second entry
And a final folded
paragraph.
above is equal to: |
This is a folded paragraph followed by a list:
* first entry
* second entry
Followed by another folded paragraph, another list:
* first entry
* second entry
And a final folded paragraph.
# Explicit comments may follow
# but must be less indented.
php: |
array(
'empty' => '',
'one paragraph' => 'Line feeds are converted to spaces, so this value'.
" contains no line breaks except for the final one.\n",
'multiple paragraphs' => "\nAn empty line, either at the start or in the value:\n".
"Is interpreted as a line break. Thus this value contains three line breaks.\n",
'indented text' => "This is a folded paragraph followed by a list:\n".
" * first entry\n * second entry\nFollowed by another folded paragraph, ".
"another list:\n\n * first entry\n\n * second entry\n\nAnd a final folded paragraph.\n",
'above is equal to' => "This is a folded paragraph followed by a list:\n".
" * first entry\n * second entry\nFollowed by another folded paragraph, ".
"another list:\n\n * first entry\n\n * second entry\n\nAnd a final folded paragraph.\n"
)
---
test: Single quotes
todo: true
yaml: |
empty: ''
second: '! : \ etc. can be used freely.'
third: 'a single quote '' must be escaped.'
span: 'this contains
six spaces
and one
line break'
is same as: "this contains six spaces\nand one line break"
php: |
array(
'empty' => '',
'second' => '! : \\ etc. can be used freely.',
'third' => "a single quote ' must be escaped.",
'span' => "this contains six spaces\nand one line break",
'is same as' => "this contains six spaces\nand one line break"
)
---
test: Double quotes
todo: true
yaml: |
empty: ""
second: "! : etc. can be used freely."
third: "a \" or a \\ must be escaped."
fourth: "this value ends with an LF.\n"
span: "this contains
four \
spaces"
is equal to: "this contains four spaces"
php: |
array(
'empty' => '',
'second' => '! : etc. can be used freely.',
'third' => 'a " or a \\ must be escaped.',
'fourth' => "this value ends with an LF.\n",
'span' => "this contains four spaces",
'is equal to' => "this contains four spaces"
)
---
test: Unquoted strings
todo: true
yaml: |
first: There is no unquoted empty string.
second: 12 ## This is an integer.
third: !str 12 ## This is a string.
span: this contains
six spaces
and one
line break
indicators: this has no comments.
#:foo and bar# are
both text.
flow: [ can span
lines, # comment
like
this ]
note: { one-line keys: but multi-line values }
php: |
array(
'first' => 'There is no unquoted empty string.',
'second' => 12,
'third' => '12',
'span' => "this contains six spaces\nand one line break",
'indicators' => "this has no comments. #:foo and bar# are both text.",
'flow' => [ 'can span lines', 'like this' ],
'note' => { 'one-line keys' => 'but multi-line values' }
)
---
test: Spanning sequences
todo: true
yaml: |
# The following are equal seqs
# with different identities.
flow: [ one, two ]
spanning: [ one,
two ]
block:
- one
- two
php: |
array(
'flow' => [ 'one', 'two' ],
'spanning' => [ 'one', 'two' ],
'block' => [ 'one', 'two' ]
)
---
test: Flow mappings
yaml: |
# The following are equal maps
# with different identities.
flow: { one: 1, two: 2 }
block:
one: 1
two: 2
php: |
array(
'flow' => array( 'one' => 1, 'two' => 2 ),
'block' => array( 'one' => 1, 'two' => 2 )
)
---
test: Representations of 12
todo: true
yaml: |
- 12 # An integer
# The following scalars
# are loaded to the
# string value '1' '2'.
- !str 12
- '12'
- "12"
- "\
1\
2\
"
# Strings containing paths and regexps can be unquoted:
- /foo/bar
- d:/foo/bar
- foo/bar
- /a.*b/
php: |
array( 12, '12', '12', '12', '12', '/foo/bar', 'd:/foo/bar', 'foo/bar', '/a.*b/' )
---
test: "Null"
todo: true
yaml: |
canonical: ~
english: null
# This sequence has five
# entries, two with values.
sparse:
- ~
- 2nd entry
- Null
- 4th entry
-
four: This mapping has five keys,
only two with values.
php: |
array (
'canonical' => null,
'english' => null,
'sparse' => array( null, '2nd entry', null, '4th entry', null ]),
'four' => 'This mapping has five keys, only two with values.'
)
---
test: Omap
todo: true
yaml: |
# Explicitly typed dictionary.
Bestiary: !omap
- aardvark: African pig-like ant eater. Ugly.
- anteater: South-American ant eater. Two species.
- anaconda: South-American constrictor snake. Scary.
# Etc.
ruby: |
{
'Bestiary' => YAML::Omap[
'aardvark', 'African pig-like ant eater. Ugly.',
'anteater', 'South-American ant eater. Two species.',
'anaconda', 'South-American constrictor snake. Scary.'
]
}
---
test: Pairs
todo: true
yaml: |
# Explicitly typed pairs.
tasks: !pairs
- meeting: with team.
- meeting: with boss.
- break: lunch.
- meeting: with client.
ruby: |
{
'tasks' => YAML::Pairs[
'meeting', 'with team.',
'meeting', 'with boss.',
'break', 'lunch.',
'meeting', 'with client.'
]
}
---
test: Set
todo: true
yaml: |
# Explicitly typed set.
baseball players: !set
Mark McGwire:
Sammy Sosa:
Ken Griffey:
ruby: |
{
'baseball players' => YAML::Set[
'Mark McGwire', nil,
'Sammy Sosa', nil,
'Ken Griffey', nil
]
}
---
test: Boolean
yaml: |
false: used as key
logical: true
answer: no
php: |
array(
false => 'used as key',
'logical' => true,
'answer' => false
)
---
test: Integer
yaml: |
canonical: 12345
decimal: +12,345
octal: 014
hexadecimal: 0xC
php: |
array(
'canonical' => 12345,
'decimal' => 12345,
'octal' => 12,
'hexadecimal' => 12
)
---
test: Float
yaml: |
canonical: 1.23015e+3
exponential: 12.3015e+02
fixed: 1,230.15
negative infinity: -.inf
not a number: .NaN
php: |
array(
'canonical' => 1230.15,
'exponential' => 1230.15,
'fixed' => 1230.15,
'negative infinity' => log(0),
'not a number' => -log(0)
)
---
test: Timestamp
todo: true
yaml: |
canonical: 2001-12-15T02:59:43.1Z
valid iso8601: 2001-12-14t21:59:43.10-05:00
space separated: 2001-12-14 21:59:43.10 -05:00
date (noon UTC): 2002-12-14
ruby: |
array(
'canonical' => YAML::mktime( 2001, 12, 15, 2, 59, 43, 0.10 ),
'valid iso8601' => YAML::mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" ),
'space separated' => YAML::mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" ),
'date (noon UTC)' => Date.new( 2002, 12, 14 )
)
---
test: Binary
todo: true
yaml: |
canonical: !binary "\
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\
OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
base64: !binary |
R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
description: >
The binary value above is a tiny arrow
encoded as a gif image.
ruby-setup: |
arrow_gif = "GIF89a\f\000\f\000\204\000\000\377\377\367\365\365\356\351\351\345fff\000\000\000\347\347\347^^^\363\363\355\216\216\216\340\340\340\237\237\237\223\223\223\247\247\247\236\236\236iiiccc\243\243\243\204\204\204\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371\377\376\371!\376\016Made with GIMP\000,\000\000\000\000\f\000\f\000\000\005, \216\2010\236\343@\024\350i\020\304\321\212\010\034\317\200M$z\357\3770\205p\270\2601f\r\e\316\001\303\001\036\020' \202\n\001\000;"
ruby: |
{
'canonical' => arrow_gif,
'base64' => arrow_gif,
'description' => "The binary value above is a tiny arrow encoded as a gif image.\n"
}
---
test: Merge key
todo: true
yaml: |
---
- &CENTER { x: 1, y: 2 }
- &LEFT { x: 0, y: 2 }
- &BIG { r: 10 }
- &SMALL { r: 1 }
# All the following maps are equal:
- # Explicit keys
x: 1
y: 2
r: 10
label: center/big
- # Merge one map
<< : *CENTER
r: 10
label: center/big
- # Merge multiple maps
<< : [ *CENTER, *BIG ]
label: center/big
- # Override
<< : [ *BIG, *LEFT, *SMALL ]
x: 1
label: center/big
ruby-setup: |
center = { 'x' => 1, 'y' => 2 }
left = { 'x' => 0, 'y' => 2 }
big = { 'r' => 10 }
small = { 'r' => 1 }
node1 = { 'x' => 1, 'y' => 2, 'r' => 10, 'label' => 'center/big' }
node2 = center.dup
node2.update( { 'r' => 10, 'label' => 'center/big' } )
node3 = big.dup
node3.update( center )
node3.update( { 'label' => 'center/big' } )
node4 = small.dup
node4.update( left )
node4.update( big )
node4.update( { 'x' => 1, 'label' => 'center/big' } )
ruby: |
[
center, left, big, small, node1, node2, node3, node4
]
---
test: Default key
todo: true
yaml: |
--- # Old schema
link with:
- library1.dll
- library2.dll
--- # New schema
link with:
- = : library1.dll
version: 1.2
- = : library2.dll
version: 2.3
ruby: |
y = YAML::Stream.new
y.add( { 'link with' => [ 'library1.dll', 'library2.dll' ] } )
obj_h = Hash[ 'version' => 1.2 ]
obj_h.default = 'library1.dll'
obj_h2 = Hash[ 'version' => 2.3 ]
obj_h2.default = 'library2.dll'
y.add( { 'link with' => [ obj_h, obj_h2 ] } )
documents: 2
---
test: Special keys
todo: true
yaml: |
"!": These three keys
"&": had to be quoted
"=": and are normal strings.
# NOTE: the following node should NOT be serialized this way.
encoded node :
!special '!' : '!type'
!special|canonical '&' : 12
= : value
# The proper way to serialize the above node is as follows:
node : !!type &12 value
ruby: |
{ '!' => 'These three keys', '&' => 'had to be quoted',
'=' => 'and are normal strings.',
'encoded node' => YAML::PrivateType.new( 'type', 'value' ),
'node' => YAML::PrivateType.new( 'type', 'value' ) }

244
thirdparty/symfony-yaml/test/fixtures/YtsTypeTransfers.yml vendored
View File

@ -1,244 +0,0 @@
--- %YAML:1.0
test: Strings
brief: >
Any group of characters beginning with an
alphabetic or numeric character is a string,
unless it belongs to one of the groups below
(such as an Integer or Time).
yaml: |
String
php: |
'String'
---
test: String characters
brief: >
A string can contain any alphabetic or
numeric character, along with many
punctuation characters, including the
period, dash, space, quotes, exclamation, and
question mark.
yaml: |
- 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.
php: |
array(
"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."
)
---
test: Indicators in Strings
brief: >
Be careful using indicators in strings. In particular,
the comma, colon, and pound sign must be used carefully.
yaml: |
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 ]
php: |
array(
'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' => array('but not in', 'inline collections')
)
---
test: Forcing Strings
brief: >
Any YAML type can be forced into a string using the
explicit !str method.
yaml: |
date string: !str 2001-08-01
number string: !str 192
php: |
array(
'date string' => '2001-08-01',
'number string' => '192'
)
---
test: Single-quoted Strings
brief: >
You can also enclose your strings within single quotes,
which allows use of slashes, colons, and other indicators
freely. Inside single quotes, you can represent a single
quote in your string by using two single quotes next to
each other.
yaml: |
all my favorite symbols: '#:!/%.)'
a few i hate: '&(*'
why do i hate them?: 'it''s very hard to explain'
entities: '&pound; me'
php: |
array(
'all my favorite symbols' => '#:!/%.)',
'a few i hate' => '&(*',
'why do i hate them?' => 'it\'s very hard to explain',
'entities' => '&pound; me'
)
---
test: Double-quoted Strings
brief: >
Enclosing strings in double quotes allows you
to use escapings to represent ASCII and
Unicode characters.
yaml: |
i know where i want my line breaks: "one here\nand another here\n"
php: |
array(
'i know where i want my line breaks' => "one here\nand another here\n"
)
---
test: Multi-line Quoted Strings
todo: true
brief: >
Both single- and double-quoted strings may be
carried on to new lines in your YAML document.
They must be indented a step and indentation
is interpreted as a single space.
yaml: |
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."
php: |
array('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."
)
---
test: Plain scalars
todo: true
brief: >
Unquoted strings may also span multiple lines, if they
are free of YAML space indicators and indented.
yaml: |
- 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.
php: |
array(
"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."
)
---
test: 'Null'
brief: >
You can use the tilde '~' character for a null value.
yaml: |
name: Mr. Show
hosted by: Bob and David
date of next season: ~
php: |
array(
'name' => 'Mr. Show',
'hosted by' => 'Bob and David',
'date of next season' => null
)
---
test: Boolean
brief: >
You can use 'true' and 'false' for boolean values.
yaml: |
Is Gus a Liar?: true
Do I rely on Gus for Sustenance?: false
php: |
array(
'Is Gus a Liar?' => true,
'Do I rely on Gus for Sustenance?' => false
)
---
test: Integers
dump_skip: true
brief: >
An integer is a series of numbers, optionally
starting with a positive or negative sign. Integers
may also contain commas for readability.
yaml: |
zero: 0
simple: 12
one-thousand: 1,000
negative one-thousand: -1,000
php: |
array(
'zero' => 0,
'simple' => 12,
'one-thousand' => 1000,
'negative one-thousand' => -1000
)
---
test: Integers as Map Keys
brief: >
An integer can be used a dictionary key.
yaml: |
1: one
2: two
3: three
php: |
array(
1 => 'one',
2 => 'two',
3 => 'three'
)
---
test: Floats
dump_skip: true
brief: >
Floats are represented by numbers with decimals,
allowing for scientific notation, as well as
positive and negative infinity and "not a number."
yaml: |
a simple float: 2.00
larger float: 1,000.09
scientific notation: 1.00009e+3
php: |
array(
'a simple float' => 2.0,
'larger float' => 1000.09,
'scientific notation' => 1000.09
)
---
test: Time
todo: true
brief: >
You can represent timestamps by using
ISO8601 format, or a variation which
allows spaces between the date, time and
time zone.
yaml: |
iso8601: 2001-12-14t21:59:43.10-05:00
space seperated: 2001-12-14 21:59:43.10 -05:00
php: |
array(
'iso8601' => mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" ),
'space seperated' => mktime( 2001, 12, 14, 21, 59, 43, 0.10, "-05:00" )
)
---
test: Date
todo: true
brief: >
A date can be represented by its year,
month and day in ISO8601 order.
yaml: |
1976-07-31
php: |
date( 1976, 7, 31 )

16
thirdparty/symfony-yaml/test/fixtures/index.yml vendored
View File

@ -1,16 +0,0 @@
- sfComments
- sfCompact
- sfTests
- sfObjects
- sfMergeKey
- sfQuotes
- YtsAnchorAlias
- YtsBasicTests
- YtsBlockMapping
- YtsDocumentSeparator
- YtsErrorTests
- YtsFlowCollections
- YtsFoldedScalars
- YtsNullsAndEmpties
- YtsSpecificationExamples
- YtsTypeTransfers

51
thirdparty/symfony-yaml/test/fixtures/sfComments.yml vendored
View File

@ -1,51 +0,0 @@
--- %YAML:1.0
test: Comments at the end of a line
brief: >
Comments at the end of a line
yaml: |
ex1: "foo # bar"
ex2: "foo # bar" # comment
ex3: 'foo # bar' # comment
ex4: foo # comment
php: |
array('ex1' => 'foo # bar', 'ex2' => 'foo # bar', 'ex3' => 'foo # bar', 'ex4' => 'foo')
---
test: Comments in the middle
brief: >
Comments in the middle
yaml: |
foo:
# some comment
# some comment
bar: foo
# some comment
# some comment
php: |
array('foo' => array('bar' => 'foo'))
---
test: Comments on a hash line
brief: >
Comments on a hash line
yaml: |
foo: # a comment
foo: bar # a comment
php: |
array('foo' => array('foo' => 'bar'))
---
test: 'Value starting with a #'
brief: >
'Value starting with a #'
yaml: |
foo: '#bar'
php: |
array('foo' => '#bar')
---
test: Document starting with a comment and a separator
brief: >
Commenting before document start is allowed
yaml: |
# document comment
---
foo: bar # a comment
php: |
array('foo' => 'bar')

53
thirdparty/symfony-yaml/test/fixtures/sfCompact.yml vendored
View File

@ -1,53 +0,0 @@
--- %YAML:1.0
test: Compact notation
brief: |
Compact notation for sets of mappings with single element
yaml: |
---
# products purchased
- item : Super Hoop
- item : Basketball
quantity: 1
- item:
name: Big Shoes
nick: Biggies
quantity: 1
php: |
array (
array (
'item' => 'Super Hoop',
),
array (
'item' => 'Basketball',
'quantity' => 1,
),
array (
'item' => array(
'name' => 'Big Shoes',
'nick' => 'Biggies'
),
'quantity' => 1
)
)
---
test: Compact notation combined with inline notation
brief: |
Combinations of compact and inline notation are allowed
yaml: |
---
items:
- { item: Super Hoop, quantity: 1 }
- [ Basketball, Big Shoes ]
php: |
array (
'items' => array (
array (
'item' => 'Super Hoop',
'quantity' => 1,
),
array (
'Basketball',
'Big Shoes'
)
)
)

27
thirdparty/symfony-yaml/test/fixtures/sfMergeKey.yml vendored
View File

@ -1,27 +0,0 @@
--- %YAML:1.0
test: Simple In Place Substitution
brief: >
If you want to reuse an entire alias, only overwriting what is different
you can use a << in place substitution. This is not part of the official
YAML spec, but a widely implemented extension. See the following URL for
details: http://yaml.org/type/merge.html
yaml: |
foo: &foo
a: Steve
b: Clark
c: Brian
bar: &bar
<<: *foo
x: Oren
foo2: &foo2
a: Ballmer
ding: &dong [ fi, fei, fo, fam]
check:
<<:
- *foo
- *dong
isit: tested
head:
<<: [ *foo , *dong , *foo2 ]
php: |
array('foo' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian'), 'bar' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian', 'x' => 'Oren'), 'foo2' => array('a' => 'Ballmer'), 'ding' => array('fi', 'fei', 'fo', 'fam'), 'check' => array('a' => 'Steve', 'b' => 'Clark', 'c' => 'Brian', 'fi', 'fei', 'fo', 'fam', 'isit' => 'tested'), 'head' => array('a' => 'Ballmer', 'b' => 'Clark', 'c' => 'Brian', 'fi', 'fei', 'fo', 'fam'))

11
thirdparty/symfony-yaml/test/fixtures/sfObjects.yml vendored
View File

@ -1,11 +0,0 @@
--- %YAML:1.0
test: Objects
brief: >
Comments at the end of a line
yaml: |
ex1: "foo # bar"
ex2: "foo # bar" # comment
ex3: 'foo # bar' # comment
ex4: foo # comment
php: |
array('ex1' => 'foo # bar', 'ex2' => 'foo # bar', 'ex3' => 'foo # bar', 'ex4' => 'foo')

33
thirdparty/symfony-yaml/test/fixtures/sfQuotes.yml vendored
View File

@ -1,33 +0,0 @@
--- %YAML:1.0
test: Some characters at the beginning of a string must be escaped
brief: >
Some characters at the beginning of a string must be escaped
yaml: |
foo: | bar
php: |
array('foo' => '| bar')
---
test: A key can be a quoted string
brief: >
A key can be a quoted string
yaml: |
"foo1": bar
'foo2': bar
"foo \" bar": bar
'foo '' bar': bar
'foo3: ': bar
"foo4: ": bar
foo5: { "foo \" bar: ": bar, 'foo '' bar: ': bar }
php: |
array(
'foo1' => 'bar',
'foo2' => 'bar',
'foo " bar' => 'bar',
'foo \' bar' => 'bar',
'foo3: ' => 'bar',
'foo4: ' => 'bar',
'foo5' => array(
'foo " bar: ' => 'bar',
'foo \' bar: ' => 'bar',
),
)

145
thirdparty/symfony-yaml/test/fixtures/sfTests.yml vendored
View File

@ -1,145 +0,0 @@
--- %YAML:1.0
test: Multiple quoted string on one line
brief: >
Multiple quoted string on one line
yaml: |
stripped_title: { name: "foo bar", help: "bar foo" }
php: |
array('stripped_title' => array('name' => 'foo bar', 'help' => 'bar foo'))
---
test: Empty sequence
yaml: |
foo: [ ]
php: |
array('foo' => array())
---
test: Empty value
yaml: |
foo:
php: |
array('foo' => null)
---
test: Inline string parsing
brief: >
Inline string parsing
yaml: |
test: ['complex: string', 'another [string]']
php: |
array('test' => array('complex: string', 'another [string]'))
---
test: Boolean
brief: >
Boolean
yaml: |
- false
- -
- off
- no
- true
- +
- on
- yes
- null
- ~
- 'false'
- '-'
- 'off'
- 'no'
- 'true'
- '+'
- 'on'
- 'yes'
- 'null'
- '~'
php: |
array(
false,
false,
false,
false,
true,
true,
true,
true,
null,
null,
'false',
'-',
'off',
'no',
'true',
'+',
'on',
'yes',
'null',
'~',
)
---
test: Empty lines in folded blocks
brief: >
Empty lines in folded blocks
yaml: |
foo:
bar: |
foo
bar
php: |
array('foo' => array('bar' => "foo\n\n\n \nbar\n"))
---
test: IP addresses
brief: >
IP addresses
yaml: |
foo: 10.0.0.2
php: |
array('foo' => '10.0.0.2')
---
test: A sequence with an embedded mapping
brief: >
A sequence with an embedded mapping
yaml: |
- foo
- bar: { bar: foo }
php: |
array('foo', array('bar' => array('bar' => 'foo')))
---
test: A sequence with an unordered array
brief: >
A sequence with an unordered array
yaml: |
1: foo
0: bar
php: |
array(1 => 'foo', 0 => 'bar')
---
test: Octal
brief: as in spec example 2.19, octal value is converted
yaml: |
foo: 0123
php: |
array('foo' => 83)
---
test: Octal strings
brief: Octal notation in a string must remain a string
yaml: |
foo: "0123"
php: |
array('foo' => '0123')
---
test: Octal strings
brief: Octal notation in a string must remain a string
yaml: |
foo: '0123'
php: |
array('foo' => '0123')
---
test: Octal strings
brief: Octal notation in a string must remain a string
yaml: |
foo: |
0123
php: |
array('foo' => "0123\n")

27
thirdparty/symfony-yaml/test/prove.php vendored
View File

@ -1,27 +0,0 @@
<?php
/*
* This file is part of the symfony package.
* (c) Fabien Potencier <fabien.potencier@symfony-project.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
require_once(dirname(__FILE__).'/lime/lime.php');
$h = new lime_harness(array(
'force_colors' => isset($argv) && in_array('--color', $argv),
'verbose' => isset($argv) && in_array('--verbose', $argv),
));
$h->base_dir = realpath(dirname(__FILE__));
foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator(dirname(__FILE__)), RecursiveIteratorIterator::LEAVES_ONLY) as $file)
{
if (preg_match('/Test\.php$/', $file))
{
$h->register($file->getRealPath());
}
}
exit($h->run() ? 0 : 1);

152
thirdparty/symfony-yaml/test/sfYamlDumperTest.php vendored
View File

@ -1,152 +0,0 @@
<?php
/*
* This file is part of the symfony package.
* (c) Fabien Potencier <fabien.potencier@symfony-project.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
require_once(dirname(__FILE__).'/lime/lime.php');
require_once(dirname(__FILE__).'/../lib/sfYaml.php');
require_once(dirname(__FILE__).'/../lib/sfYamlParser.php');
require_once(dirname(__FILE__).'/../lib/sfYamlDumper.php');
sfYaml::setSpecVersion('1.1');
$t = new lime_test(152);
$parser = new sfYamlParser();
$dumper = new sfYamlDumper();
$path = dirname(__FILE__).'/fixtures';
$files = $parser->parse(file_get_contents($path.'/index.yml'));
foreach ($files as $file)
{
$t->diag($file);
$yamls = file_get_contents($path.'/'.$file.'.yml');
// split YAMLs documents
foreach (preg_split('/^---( %YAML\:1\.0)?/m', $yamls) as $yaml)
{
if (!$yaml)
{
continue;
}
$test = $parser->parse($yaml);
if (isset($test['dump_skip']) && $test['dump_skip'])
{
continue;
}
else if (isset($test['todo']) && $test['todo'])
{
$t->todo($test['test']);
}
else
{
$expected = eval('return '.trim($test['php']).';');
$t->is_deeply($parser->parse($dumper->dump($expected, 10)), $expected, $test['test']);
}
}
}
// inline level
$array = array(
'' => 'bar',
'foo' => '#bar',
'foo\'bar' => array(),
'bar' => array(1, 'foo'),
'foobar' => array(
'foo' => 'bar',
'bar' => array(1, 'foo'),
'foobar' => array(
'foo' => 'bar',
'bar' => array(1, 'foo'),
),
),
);
$expected = <<<EOF
{ '': bar, foo: '#bar', 'foo''bar': { }, bar: [1, foo], foobar: { foo: bar, bar: [1, foo], foobar: { foo: bar, bar: [1, foo] } } }
EOF;
$t->is($dumper->dump($array, -10), $expected, '->dump() takes an inline level argument');
$t->is($dumper->dump($array, 0), $expected, '->dump() takes an inline level argument');
$expected = <<<EOF
'': bar
foo: '#bar'
'foo''bar': { }
bar: [1, foo]
foobar: { foo: bar, bar: [1, foo], foobar: { foo: bar, bar: [1, foo] } }
EOF;
$t->is($dumper->dump($array, 1), $expected, '->dump() takes an inline level argument');
$expected = <<<EOF
'': bar
foo: '#bar'
'foo''bar': { }
bar:
- 1
- foo
foobar:
foo: bar
bar: [1, foo]
foobar: { foo: bar, bar: [1, foo] }
EOF;
$t->is($dumper->dump($array, 2), $expected, '->dump() takes an inline level argument');
$expected = <<<EOF
'': bar
foo: '#bar'
'foo''bar': { }
bar:
- 1
- foo
foobar:
foo: bar
bar:
- 1
- foo
foobar:
foo: bar
bar: [1, foo]
EOF;
$t->is($dumper->dump($array, 3), $expected, '->dump() takes an inline level argument');
$expected = <<<EOF
'': bar
foo: '#bar'
'foo''bar': { }
bar:
- 1
- foo
foobar:
foo: bar
bar:
- 1
- foo
foobar:
foo: bar
bar:
- 1
- foo
EOF;
$t->is($dumper->dump($array, 4), $expected, '->dump() takes an inline level argument');
$t->is($dumper->dump($array, 10), $expected, '->dump() takes an inline level argument');
// objects
$t->diag('Objects support');
class A
{
public $a = 'foo';
}
$a = array('foo' => new A(), 'bar' => 1);
$t->is($dumper->dump($a), '{ foo: !!php/object:O:1:"A":1:{s:1:"a";s:3:"foo";}, bar: 1 }', '->dump() is able to dump objects');

147
thirdparty/symfony-yaml/test/sfYamlInlineTest.php vendored
View File

@ -1,147 +0,0 @@
<?php
/*
* This file is part of the symfony package.
* (c) Fabien Potencier <fabien.potencier@symfony-project.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
require_once(dirname(__FILE__).'/lime/lime.php');
require_once(dirname(__FILE__).'/../lib/sfYaml.php');
require_once(dirname(__FILE__).'/../lib/sfYamlInline.php');
sfYaml::setSpecVersion('1.1');
$t = new lime_test(124);
// ::load()
$t->diag('::load()');
$testsForLoad = array(
'' => '',
'null' => null,
'false' => false,
'true' => true,
'12' => 12,
'"quoted string"' => 'quoted string',
"'quoted string'" => 'quoted string',
'12.30e+02' => 12.30e+02,
'0x4D2' => 0x4D2,
'02333' => 02333,
'.Inf' => -log(0),
'-.Inf' => log(0),
'123456789123456789' => '123456789123456789',
'"foo\r\nbar"' => "foo\r\nbar",
"'foo#bar'" => 'foo#bar',
"'foo # bar'" => 'foo # bar',
"'#cfcfcf'" => '#cfcfcf',
'2007-10-30' => mktime(0, 0, 0, 10, 30, 2007),
'2007-10-30T02:59:43Z' => gmmktime(2, 59, 43, 10, 30, 2007),
'2007-10-30 02:59:43 Z' => gmmktime(2, 59, 43, 10, 30, 2007),
'"a \\"string\\" with \'quoted strings inside\'"' => 'a "string" with \'quoted strings inside\'',
"'a \"string\" with ''quoted strings inside'''" => 'a "string" with \'quoted strings inside\'',
// sequences
// urls are no key value mapping. see #3609. Valid yaml "key: value" mappings require a space after the colon
'[foo, http://urls.are/no/mappings, false, null, 12]' => array('foo', 'http://urls.are/no/mappings', false, null, 12),
'[ foo , bar , false , null , 12 ]' => array('foo', 'bar', false, null, 12),
'[\'foo,bar\', \'foo bar\']' => array('foo,bar', 'foo bar'),
// mappings
'{foo:bar,bar:foo,false:false,null:null,integer:12}' => array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12),
'{ foo : bar, bar : foo, false : false, null : null, integer : 12 }' => array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12),
'{foo: \'bar\', bar: \'foo: bar\'}' => array('foo' => 'bar', 'bar' => 'foo: bar'),
'{\'foo\': \'bar\', "bar": \'foo: bar\'}' => array('foo' => 'bar', 'bar' => 'foo: bar'),
'{\'foo\'\'\': \'bar\', "bar\"": \'foo: bar\'}' => array('foo\'' => 'bar', "bar\"" => 'foo: bar'),
'{\'foo: \': \'bar\', "bar: ": \'foo: bar\'}' => array('foo: ' => 'bar', "bar: " => 'foo: bar'),
// nested sequences and mappings
'[foo, [bar, foo]]' => array('foo', array('bar', 'foo')),
'[foo, {bar: foo}]' => array('foo', array('bar' => 'foo')),
'{ foo: {bar: foo} }' => array('foo' => array('bar' => 'foo')),
'{ foo: [bar, foo] }' => array('foo' => array('bar', 'foo')),
'[ foo, [ bar, foo ] ]' => array('foo', array('bar', 'foo')),
'[{ foo: {bar: foo} }]' => array(array('foo' => array('bar' => 'foo'))),
'[foo, [bar, [foo, [bar, foo]], foo]]' => array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo')),
'[foo, {bar: foo, foo: [foo, {bar: foo}]}, [foo, {bar: foo}]]' => array('foo', array('bar' => 'foo', 'foo' => array('foo', array('bar' => 'foo'))), array('foo', array('bar' => 'foo'))),
'[foo, bar: { foo: bar }]' => array('foo', '1' => array('bar' => array('foo' => 'bar'))),
);
foreach ($testsForLoad as $yaml => $value)
{
$t->is_deeply(sfYamlInline::load($yaml), $value, sprintf('::load() converts an inline YAML to a PHP structure (%s)', $yaml));
}
$testsForDump = array(
'null' => null,
'false' => false,
'true' => true,
'12' => 12,
"'quoted string'" => 'quoted string',
'12.30e+02' => 12.30e+02,
'1234' => 0x4D2,
'1243' => 02333,
'.Inf' => -log(0),
'-.Inf' => log(0),
'"foo\r\nbar"' => "foo\r\nbar",
"'foo#bar'" => 'foo#bar',
"'foo # bar'" => 'foo # bar',
"'#cfcfcf'" => '#cfcfcf',
"'a \"string\" with ''quoted strings inside'''" => 'a "string" with \'quoted strings inside\'',
// sequences
'[foo, bar, false, null, 12]' => array('foo', 'bar', false, null, 12),
'[\'foo,bar\', \'foo bar\']' => array('foo,bar', 'foo bar'),
// mappings
'{ foo: bar, bar: foo, \'false\': false, \'null\': null, integer: 12 }' => array('foo' => 'bar', 'bar' => 'foo', 'false' => false, 'null' => null, 'integer' => 12),
'{ foo: bar, bar: \'foo: bar\' }' => array('foo' => 'bar', 'bar' => 'foo: bar'),
// nested sequences and mappings
'[foo, [bar, foo]]' => array('foo', array('bar', 'foo')),
'[foo, [bar, [foo, [bar, foo]], foo]]' => array('foo', array('bar', array('foo', array('bar', 'foo')), 'foo')),
'{ foo: { bar: foo } }' => array('foo' => array('bar' => 'foo')),
'[foo, { bar: foo }]' => array('foo', array('bar' => 'foo')),
'[foo, { bar: foo, foo: [foo, { bar: foo }] }, [foo, { bar: foo }]]' => array('foo', array('bar' => 'foo', 'foo' => array('foo', array('bar' => 'foo'))), array('foo', array('bar' => 'foo'))),
);
// ::dump()
$t->diag('::dump()');
foreach ($testsForDump as $yaml => $value)
{
$t->is(sfYamlInline::dump($value), $yaml, sprintf('::dump() converts a PHP structure to an inline YAML (%s)', $yaml));
}
foreach ($testsForLoad as $yaml => $value)
{
if ($value == 1230)
{
continue;
}
$t->is_deeply(sfYamlInline::load(sfYamlInline::dump($value)), $value, 'check consistency');
}
foreach ($testsForDump as $yaml => $value)
{
if ($value == 1230)
{
continue;
}
$t->is_deeply(sfYamlInline::load(sfYamlInline::dump($value)), $value, 'check consistency');
}

91
thirdparty/symfony-yaml/test/sfYamlParserTest.php vendored
View File

@ -1,91 +0,0 @@
<?php
/*
* This file is part of the symfony package.
* (c) Fabien Potencier <fabien.potencier@symfony-project.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
require_once(dirname(__FILE__).'/lime/lime.php');
require_once(dirname(__FILE__).'/../lib/sfYaml.php');
require_once(dirname(__FILE__).'/../lib/sfYamlParser.php');
sfYaml::setSpecVersion('1.1');
$t = new lime_test(153);
$parser = new sfYamlParser();
$path = dirname(__FILE__).'/fixtures';
$files = $parser->parse(file_get_contents($path.'/index.yml'));
foreach ($files as $file)
{
$t->diag($file);
$yamls = file_get_contents($path.'/'.$file.'.yml');
// split YAMLs documents
foreach (preg_split('/^---( %YAML\:1\.0)?/m', $yamls) as $yaml)
{
if (!$yaml)
{
continue;
}
$test = $parser->parse($yaml);
if (isset($test['todo']) && $test['todo'])
{
$t->todo($test['test']);
}
else
{
$expected = var_export(eval('return '.trim($test['php']).';'), true);
$t->is(var_export($parser->parse($test['yaml']), true), $expected, $test['test']);
}
}
}
// test tabs in YAML
$yamls = array(
"foo:\n bar",
"foo:\n bar",
"foo:\n bar",
"foo:\n bar",
);
foreach ($yamls as $yaml)
{
try
{
$content = $parser->parse($yaml);
$t->fail('YAML files must not contain tabs');
}
catch (InvalidArgumentException $e)
{
$t->pass('YAML files must not contain tabs');
}
}
$yaml = <<<EOF
--- %YAML:1.0
foo
...
EOF;
$t->is('foo', $parser->parse($yaml));
// objects
$t->diag('Objects support');
class A
{
public $a = 'foo';
}
$a = array('foo' => new A(), 'bar' => 1);
$t->is($parser->parse(<<<EOF
foo: !!php/object:O:1:"A":1:{s:1:"a";s:3:"foo";}
bar: 1
EOF
), $a, '->parse() is able to dump objects');