scratch

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 65  →  ?path2? @ 66
/vendor/mustangostang/spyc/tests/DumpTest.php
@@ -0,0 +1,196 @@
<?php
 
require_once ("../Spyc.php");
 
class DumpTest extends PHPUnit_Framework_TestCase {
 
private $files_to_test = array();
 
public function setUp() {
$this->files_to_test = array ('../spyc.yaml', 'failing1.yaml', 'indent_1.yaml', 'quotes.yaml');
}
 
public function testShortSyntax() {
$dump = spyc_dump(array ('item1', 'item2', 'item3'));
$awaiting = "- item1\n- item2\n- item3\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDump() {
foreach ($this->files_to_test as $file) {
$yaml = spyc_load(file_get_contents($file));
$dump = Spyc::YAMLDump ($yaml);
$yaml_after_dump = Spyc::YAMLLoad ($dump);
$this->assertEquals ($yaml, $yaml_after_dump);
}
}
 
public function testDumpWithQuotes() {
$Spyc = new Spyc();
$Spyc->setting_dump_force_quotes = true;
foreach ($this->files_to_test as $file) {
$yaml = $Spyc->load(file_get_contents($file));
$dump = $Spyc->dump ($yaml);
$yaml_after_dump = Spyc::YAMLLoad ($dump);
$this->assertEquals ($yaml, $yaml_after_dump);
}
}
 
public function testDumpArrays() {
$dump = Spyc::YAMLDump(array ('item1', 'item2', 'item3'));
$awaiting = "---\n- item1\n- item2\n- item3\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testNull() {
$dump = Spyc::YAMLDump(array('a' => 1, 'b' => null, 'c' => 3));
$awaiting = "---\na: 1\nb: null\nc: 3\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testNext() {
$array = array("aaa", "bbb", "ccc");
#set arrays internal pointer to next element
next($array);
$dump = Spyc::YAMLDump($array);
$awaiting = "---\n- aaa\n- bbb\n- ccc\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpingMixedArrays() {
$array = array();
$array[] = 'Sequence item';
$array['The Key'] = 'Mapped value';
$array[] = array('A sequence','of a sequence');
$array[] = array('first' => 'A sequence','second' => 'of mapped values');
$array['Mapped'] = array('A sequence','which is mapped');
$array['A Note'] = 'What if your text is too long?';
$array['Another Note'] = 'If that is the case, the dumper will probably fold your text by using a block. Kinda like this.';
$array['The trick?'] = 'The trick is that we overrode the default indent, 2, to 4 and the default wordwrap, 40, to 60.';
$array['Old Dog'] = "And if you want\n to preserve line breaks, \ngo ahead!";
$array['key:withcolon'] = "Should support this to";
 
$yaml = Spyc::YAMLDump($array,4,60);
}
 
public function testMixed() {
$dump = Spyc::YAMLDump(array(0 => 1, 'b' => 2, 1 => 3));
$awaiting = "---\n0: 1\nb: 2\n1: 3\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpNumerics() {
$dump = Spyc::YAMLDump(array ('404', '405', '500'));
$awaiting = "---\n- \"404\"\n- \"405\"\n- \"500\"\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpAsterisks() {
$dump = Spyc::YAMLDump(array ('*'));
$awaiting = "---\n- '*'\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpAmpersands() {
$dump = Spyc::YAMLDump(array ('some' => '&foo'));
$awaiting = "---\nsome: '&foo'\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpExclamations() {
$dump = Spyc::YAMLDump(array ('some' => '!foo'));
$awaiting = "---\nsome: '!foo'\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpExclamations2() {
$dump = Spyc::YAMLDump(array ('some' => 'foo!'));
$awaiting = "---\nsome: foo!\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpApostrophes() {
$dump = Spyc::YAMLDump(array ('some' => "'Biz' pimpt bedrijventerreinen"));
$awaiting = "---\nsome: \"'Biz' pimpt bedrijventerreinen\"\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testDumpNumericHashes() {
$dump = Spyc::YAMLDump(array ("titel"=> array("0" => "", 1 => "Dr.", 5 => "Prof.", 6 => "Prof. Dr.")));
$awaiting = "---\ntitel:\n 0: \"\"\n 1: Dr.\n 5: Prof.\n 6: Prof. Dr.\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testEmpty() {
$dump = Spyc::YAMLDump(array("foo" => array()));
$awaiting = "---\nfoo: [ ]\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testHashesInKeys() {
$dump = Spyc::YAMLDump(array ('#color' => '#ffffff'));
$awaiting = "---\n\"#color\": '#ffffff'\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testParagraph() {
$dump = Spyc::YAMLDump(array ('key' => "|\n value"));
$awaiting = "---\nkey: |\n value\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testParagraphTwo() {
$dump = Spyc::YAMLDump(array ('key' => 'Congrats, pimpt bedrijventerreinen pimpt bedrijventerreinen pimpt bedrijventerreinen!'));
$awaiting = "---\nkey: >\n Congrats, pimpt bedrijventerreinen pimpt\n bedrijventerreinen pimpt\n bedrijventerreinen!\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testString() {
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => 'Congrats, pimpt bedrijventerreinen!')));
$awaiting = "---\nkey:\n key_one: Congrats, pimpt bedrijventerreinen!\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testStringLong() {
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => 'Congrats, pimpt bedrijventerreinen pimpt bedrijventerreinen pimpt bedrijventerreinen!')));
$awaiting = "---\nkey:\n key_one: >\n Congrats, pimpt bedrijventerreinen pimpt\n bedrijventerreinen pimpt\n bedrijventerreinen!\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testStringDoubleQuote() {
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => array('key_two' => '"Système d\'e-réservation"'))));
$awaiting = "---\nkey:\n key_one:\n key_two: |\n Système d'e-réservation\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testLongStringDoubleQuote() {
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => array('key_two' => '"Système d\'e-réservation bedrijventerreinen pimpt" bedrijventerreinen!'))));
$awaiting = "---\nkey:\n key_one:\n key_two: |\n \"Système d'e-réservation bedrijventerreinen pimpt\" bedrijventerreinen!\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testStringStartingWithSpace() {
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => " Congrats, pimpt bedrijventerreinen \n pimpt bedrijventerreinen pimpt bedrijventerreinen!")));
$awaiting = "---\nkey:\n key_one: |\n Congrats, pimpt bedrijventerreinen\n pimpt bedrijventerreinen pimpt bedrijventerreinen!\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testPerCentOne() {
$dump = Spyc::YAMLDump(array ('key' => "%name%, pimpts bedrijventerreinen!"));
$awaiting = "---\nkey: '%name%, pimpts bedrijventerreinen!'\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testPerCentAndSimpleQuote() {
$dump = Spyc::YAMLDump(array ('key' => "%name%, pimpt's bedrijventerreinen!"));
$awaiting = "---\nkey: \"%name%, pimpt's bedrijventerreinen!\"\n";
$this->assertEquals ($awaiting, $dump);
}
 
public function testPerCentAndDoubleQuote() {
$dump = Spyc::YAMLDump(array ('key' => '%name%, pimpt\'s "bed"rijventerreinen!'));
$awaiting = "---\nkey: |\n %name%, pimpt's \"bed\"rijventerreinen!\n";
$this->assertEquals ($awaiting, $dump);
}
 
}
/vendor/mustangostang/spyc/tests/IndentTest.php
@@ -0,0 +1,70 @@
<?php
 
require_once ("../Spyc.php");
 
class IndentTest extends PHPUnit_Framework_TestCase {
 
protected $Y;
 
protected function setUp() {
$this->Y = Spyc::YAMLLoad("indent_1.yaml");
}
 
public function testIndent_1() {
$this->assertEquals (array ('child_1' => 2, 'child_2' => 0, 'child_3' => 1), $this->Y['root']);
}
 
public function testIndent_2() {
$this->assertEquals (array ('child_1' => 1, 'child_2' => 2), $this->Y['root2']);
}
 
public function testIndent_3() {
$this->assertEquals (array (array ('resolutions' => array (1024 => 768, 1920 => 1200), 'producer' => 'Nec')), $this->Y['display']);
}
 
public function testIndent_4() {
$this->assertEquals (array (
array ('resolutions' => array (1024 => 768)),
array ('resolutions' => array (1920 => 1200)),
), $this->Y['displays']);
}
 
public function testIndent_5() {
$this->assertEquals (array (array (
'row' => 0,
'col' => 0,
'headsets_affected' => array (
array (
'ports' => array (0),
'side' => 'left',
)
),
'switch_function' => array (
'ics_ptt' => true
)
)), $this->Y['nested_hashes_and_seqs']);
}
 
public function testIndent_6() {
$this->assertEquals (array (
'h' => array (
array ('a' => 'b', 'a1' => 'b1'),
array ('c' => 'd')
)
), $this->Y['easier_nest']);
}
 
public function testIndent_space() {
$this->assertEquals ("By four\n spaces", $this->Y['one_space']);
}
 
public function testListAndComment() {
$this->assertEquals (array ('one', 'two', 'three'), $this->Y['list_and_comment']);
}
 
public function testAnchorAndAlias() {
$this->assertEquals (array ('database' => 'rails_dev', 'adapter' => 'mysql', 'host' => 'localhost'), $this->Y['development']);
$this->assertEquals (array (1 => 'abc'), $this->Y['zzz']);
}
 
}
/vendor/mustangostang/spyc/tests/LoadTest.php
@@ -0,0 +1,19 @@
<?php
 
require_once ("../Spyc.php");
 
class LoadTest extends PHPUnit_Framework_TestCase {
public function testQuotes() {
$test_values = array(
"adjacent '''' \"\"\"\" quotes.",
"adjacent '''' quotes.",
"adjacent \"\"\"\" quotes.",
);
foreach($test_values as $value) {
$yaml = array($value);
$dump = Spyc::YAMLDump ($yaml);
$yaml_loaded = Spyc::YAMLLoad ($dump);
$this->assertEquals ($yaml, $yaml_loaded);
}
}
}
/vendor/mustangostang/spyc/tests/ParseTest.php
@@ -0,0 +1,401 @@
<?php
 
require_once ("../Spyc.php");
 
class ParseTest extends PHPUnit_Framework_TestCase {
 
protected $yaml;
 
protected function setUp() {
$this->yaml = spyc_load_file('../spyc.yaml');
}
 
public function testMergeHashKeys() {
$Expected = array (
array ('step' => array('instrument' => 'Lasik 2000', 'pulseEnergy' => 5.4, 'pulseDuration' => 12, 'repetition' => 1000, 'spotSize' => '1mm')),
array ('step' => array('instrument' => 'Lasik 2000', 'pulseEnergy' => 5.4, 'pulseDuration' => 12, 'repetition' => 1000, 'spotSize' => '2mm')),
);
$Actual = spyc_load_file ('indent_1.yaml');
$this->assertEquals ($Expected, $Actual['steps']);
}
 
public function testDeathMasks() {
$Expected = array ('sad' => 2, 'magnificent' => 4);
$Actual = spyc_load_file ('indent_1.yaml');
$this->assertEquals ($Expected, $Actual['death masks are']);
}
 
public function testDevDb() {
$Expected = array ('adapter' => 'mysql', 'host' => 'localhost', 'database' => 'rails_dev');
$Actual = spyc_load_file ('indent_1.yaml');
$this->assertEquals ($Expected, $Actual['development']);
}
 
public function testNumericKey() {
$this->assertEquals ("Ooo, a numeric key!", $this->yaml[1040]);
}
 
public function testMappingsString() {
$this->assertEquals ("Anyone's name, really.", $this->yaml['String']);
}
 
public function testMappingsInt() {
$this->assertSame (13, $this->yaml['Int']);
}
 
public function testMappingsHex() {
$this->assertSame (243, $this->yaml['Hex']);
$this->assertSame ('f0xf3', $this->yaml['BadHex']);
}
 
public function testMappingsBooleanTrue() {
$this->assertSame (true, $this->yaml['True']);
}
 
public function testMappingsBooleanFalse() {
$this->assertSame (false, $this->yaml['False']);
}
 
public function testMappingsZero() {
$this->assertSame (0, $this->yaml['Zero']);
}
 
public function testMappingsNull() {
$this->assertSame (null, $this->yaml['Null']);
}
 
public function testMappingsNotNull() {
$this->assertSame ('null', $this->yaml['NotNull']);
}
 
public function testMappingsFloat() {
$this->assertSame (5.34, $this->yaml['Float']);
}
 
public function testMappingsNegative() {
$this->assertSame (-90, $this->yaml['Negative']);
}
 
public function testMappingsSmallFloat() {
$this->assertSame (0.7, $this->yaml['SmallFloat']);
}
 
public function testNewline() {
$this->assertSame ('\n', $this->yaml['NewLine']);
}
 
public function testQuotedNewline() {
$this->assertSame ("\n", $this->yaml['QuotedNewLine']);
}
 
public function testSeq0() {
$this->assertEquals ("PHP Class", $this->yaml[0]);
}
 
public function testSeq1() {
$this->assertEquals ("Basic YAML Loader", $this->yaml[1]);
}
 
public function testSeq2() {
$this->assertEquals ("Very Basic YAML Dumper", $this->yaml[2]);
}
 
public function testSeq3() {
$this->assertEquals (array("YAML is so easy to learn.",
"Your config files will never be the same."), $this->yaml[3]);
}
 
public function testSeqMap() {
$this->assertEquals (array("cpu" => "1.5ghz", "ram" => "1 gig",
"os" => "os x 10.4.1"), $this->yaml[4]);
}
 
public function testMappedSequence() {
$this->assertEquals (array("yaml.org", "php.net"), $this->yaml['domains']);
}
 
public function testAnotherSequence() {
$this->assertEquals (array("program" => "Adium", "platform" => "OS X",
"type" => "Chat Client"), $this->yaml[5]);
}
 
public function testFoldedBlock() {
$this->assertEquals ("There isn't any time for your tricks!\nDo you understand?", $this->yaml['no time']);
}
 
public function testLiteralAsMapped() {
$this->assertEquals ("There is nothing but time\nfor your tricks.", $this->yaml['some time']);
}
 
public function testCrazy() {
$this->assertEquals (array( array("name" => "spartan", "notes" =>
array( "Needs to be backed up",
"Needs to be normalized" ),
"type" => "mysql" )), $this->yaml['databases']);
}
 
public function testColons() {
$this->assertEquals ("like", $this->yaml["if: you'd"]);
}
 
public function testInline() {
$this->assertEquals (array("One", "Two", "Three", "Four"), $this->yaml[6]);
}
 
public function testNestedInline() {
$this->assertEquals (array("One", array("Two", "And", "Three"), "Four", "Five"), $this->yaml[7]);
}
 
public function testNestedNestedInline() {
$this->assertEquals (array( "This", array("Is", "Getting", array("Ridiculous", "Guys")),
"Seriously", array("Show", "Mercy")), $this->yaml[8]);
}
 
public function testInlineMappings() {
$this->assertEquals (array("name" => "chris", "age" => "young", "brand" => "lucky strike"), $this->yaml[9]);
}
 
public function testNestedInlineMappings() {
$this->assertEquals (array("name" => "mark", "age" => "older than chris",
"brand" => array("marlboro", "lucky strike")), $this->yaml[10]);
}
 
public function testReferences() {
$this->assertEquals (array('Perl', 'Python', 'PHP', 'Ruby'), $this->yaml['dynamic languages']);
}
 
public function testReferences2() {
$this->assertEquals (array('C/C++', 'Java'), $this->yaml['compiled languages']);
}
 
public function testReferences3() {
$this->assertEquals (array(
array('Perl', 'Python', 'PHP', 'Ruby'),
array('C/C++', 'Java')
), $this->yaml['all languages']);
}
 
public function testEscapedQuotes() {
$this->assertEquals ("you know, this shouldn't work. but it does.", $this->yaml[11]);
}
 
public function testEscapedQuotes_2() {
$this->assertEquals ( "that's my value.", $this->yaml[12]);
}
 
public function testEscapedQuotes_3() {
$this->assertEquals ("again, that's my value.", $this->yaml[13]);
}
 
public function testQuotes() {
$this->assertEquals ("here's to \"quotes\", boss.", $this->yaml[14]);
}
 
public function testQuoteSequence() {
$this->assertEquals ( array( 'name' => "Foo, Bar's", 'age' => 20), $this->yaml[15]);
}
 
public function testShortSequence() {
$this->assertEquals (array( 0 => "a", 1 => array (0 => 1, 1 => 2), 2 => "b"), $this->yaml[16]);
}
 
public function testQuotedNewlines() {
$this->assertEquals ("First line\nSecond line\nThird line", $this->yaml[17]);
}
 
public function testHash_1() {
$this->assertEquals ("Hash", $this->yaml['hash_1']);
}
 
public function testHash_2() {
$this->assertEquals ('Hash #and a comment', $this->yaml['hash_2']);
}
 
public function testHash_3() {
$this->assertEquals ('Hash (#) can appear in key too', $this->yaml['hash#3']);
}
 
public function testEndloop() {
$this->assertEquals ("Does this line in the end indeed make Spyc go to an infinite loop?", $this->yaml['endloop']);
}
 
public function testReallyLargeNumber() {
$this->assertEquals ('115792089237316195423570985008687907853269984665640564039457584007913129639936', $this->yaml['a_really_large_number']);
}
 
public function testFloatWithZeros() {
$this->assertSame ('1.0', $this->yaml['float_test']);
}
 
public function testFloatWithQuotes() {
$this->assertSame ('1.0', $this->yaml['float_test_with_quotes']);
}
 
public function testFloatInverse() {
$this->assertEquals ('001', $this->yaml['float_inverse_test']);
}
 
public function testIntArray() {
$this->assertEquals (array (1, 2, 3), $this->yaml['int array']);
}
 
public function testArrayOnSeveralLines() {
$this->assertEquals (array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19), $this->yaml['array on several lines']);
}
 
public function testArrayWithCommas() {
$this->assertEquals(array (0, 1), $this->yaml['array with commas']);
}
 
public function testmoreLessKey() {
$this->assertEquals ('<value>', $this->yaml['morelesskey']);
}
 
public function testArrayOfZero() {
$this->assertSame (array(0), $this->yaml['array_of_zero']);
}
 
public function testSophisticatedArrayOfZero() {
$this->assertSame (array('rx' => array ('tx' => array (0))), $this->yaml['sophisticated_array_of_zero']);
}
 
public function testSwitches() {
$this->assertEquals (array (array ('row' => 0, 'col' => 0, 'func' => array ('tx' => array(0, 1)))), $this->yaml['switches']);
}
 
public function testEmptySequence() {
$this->assertSame (array(), $this->yaml['empty_sequence']);
}
 
public function testEmptyHash() {
$this->assertSame (array(), $this->yaml['empty_hash']);
}
 
public function testEmptykey() {
$this->assertSame (array('' => array ('key' => 'value')), $this->yaml['empty_key']);
}
 
public function testMultilines() {
$this->assertSame (array(array('type' => 'SomeItem', 'values' => array ('blah', 'blah', 'blah', 'blah'), 'ints' => array(2, 54, 12, 2143))), $this->yaml['multiline_items']);
}
 
public function testManyNewlines() {
$this->assertSame ('A quick
fox
 
 
jumped
over
 
 
 
 
 
a lazy
 
 
 
dog', $this->yaml['many_lines']);
}
 
public function testWerte() {
$this->assertSame (array ('1' => 'nummer 1', '0' => 'Stunde 0'), $this->yaml['werte']);
}
 
/* public function testNoIndent() {
$this->assertSame (array(
array ('record1'=>'value1'),
array ('record2'=>'value2')
)
, $this->yaml['noindent_records']);
} */
 
public function testColonsInKeys() {
$this->assertSame (array (1000), $this->yaml['a:1']);
}
 
public function testColonsInKeys2() {
$this->assertSame (array (2000), $this->yaml['a:2']);
}
 
public function testUnquotedColonsInKeys() {
$this->assertSame (array (3000), $this->yaml['a:3']);
}
 
public function testComplicatedKeyWithColon() {
$this->assertSame(array("a:b:''test'" => 'value'), $this->yaml['complex_unquoted_key']);
}
 
public function testKeysInMappedValueException() {
$this->setExpectedException('Exception');
Spyc::YAMLLoad('x: y: z:');
}
 
public function testKeysInValueException() {
$this->setExpectedException('Exception');
Spyc::YAMLLoad('x: y: z');
}
 
public function testSpecialCharacters() {
$this->assertSame ('[{]]{{]]', $this->yaml['special_characters']);
}
 
public function testAngleQuotes() {
$Quotes = Spyc::YAMLLoad('quotes.yaml');
$this->assertEquals (array ('html_tags' => array ('<br>', '<p>'), 'html_content' => array ('<p>hello world</p>', 'hello<br>world'), 'text_content' => array ('hello world')),
$Quotes);
}
 
public function testFailingColons() {
$Failing = Spyc::YAMLLoad('failing1.yaml');
$this->assertSame (array ('MyObject' => array ('Prop1' => array ('key1:val1'))),
$Failing);
}
 
public function testQuotesWithComments() {
$Expected = 'bar';
$Actual = spyc_load_file ('comments.yaml');
$this->assertEquals ($Expected, $Actual['foo']);
}
 
public function testArrayWithComments() {
$Expected = array ('x', 'y', 'z');
$Actual = spyc_load_file ('comments.yaml');
$this->assertEquals ($Expected, $Actual['arr']);
}
 
public function testAfterArrayWithKittens() {
$Expected = 'kittens';
$Actual = spyc_load_file ('comments.yaml');
$this->assertEquals ($Expected, $Actual['bar']);
}
 
// Plain characters http://www.yaml.org/spec/1.2/spec.html#id2789510
public function testKai() {
$Expected = array('-example' => 'value');
$Actual = spyc_load_file ('indent_1.yaml');
$this->assertEquals ($Expected, $Actual['kai']);
}
 
public function testKaiList() {
$Expected = array ('-item', '-item', '-item');
$Actual = spyc_load_file ('indent_1.yaml');
$this->assertEquals ($Expected, $Actual['kai_list_of_items']);
}
 
public function testDifferentQuoteTypes() {
$expected = array ('Something', "", "", "Something else");
$this->assertSame ($expected, $this->yaml['invoice']);
}
 
public function testDifferentQuoteTypes2() {
$expected = array ('Something', "Nothing", "Anything", "Thing");
$this->assertSame ($expected, $this->yaml['quotes']);
}
 
// Separation spaces http://www.yaml.org/spec/1.2/spec.html#id2778394
public function testMultipleArrays() {
$expected = array(array(array('x')));
$this->assertSame($expected, Spyc::YAMLLoad("- - - x"));
}
}
/vendor/mustangostang/spyc/tests/RoundTripTest.php
@@ -0,0 +1,78 @@
<?php
 
require_once ("../Spyc.php");
 
function roundTrip($a) { return Spyc::YAMLLoad(Spyc::YAMLDump(array('x' => $a))); }
 
 
class RoundTripTest extends PHPUnit_Framework_TestCase {
 
protected function setUp() {
}
 
public function testNull() {
$this->assertEquals (array ('x' => null), roundTrip (null));
}
 
public function testY() {
$this->assertEquals (array ('x' => 'y'), roundTrip ('y'));
}
public function testExclam() {
$this->assertEquals (array ('x' => '!yeah'), roundTrip ('!yeah'));
}
 
public function test5() {
$this->assertEquals (array ('x' => '5'), roundTrip ('5'));
}
 
public function testSpaces() {
$this->assertEquals (array ('x' => 'x '), roundTrip ('x '));
}
public function testApostrophes() {
$this->assertEquals (array ('x' => "'biz'"), roundTrip ("'biz'"));
}
 
public function testNewLines() {
$this->assertEquals (array ('x' => "\n"), roundTrip ("\n"));
}
 
public function testHashes() {
$this->assertEquals (array ('x' => array ("#color" => '#fff')), roundTrip (array ("#color" => '#fff')));
}
 
public function testPreserveString() {
$result1 = roundTrip ('0');
$result2 = roundTrip ('true');
$this->assertTrue (is_string ($result1['x']));
$this->assertTrue (is_string ($result2['x']));
}
 
public function testPreserveBool() {
$result = roundTrip (true);
$this->assertTrue (is_bool ($result['x']));
}
 
public function testPreserveInteger() {
$result = roundTrip (0);
$this->assertTrue (is_int ($result['x']));
}
 
public function testWordWrap() {
$this->assertEquals (array ('x' => "aaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), roundTrip ("aaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
}
 
public function testABCD() {
$this->assertEquals (array ('a', 'b', 'c', 'd'), Spyc::YAMLLoad(Spyc::YAMLDump(array('a', 'b', 'c', 'd'))));
}
public function testABCD2() {
$a = array('a', 'b', 'c', 'd'); // Create a simple list
$b = Spyc::YAMLDump($a); // Dump the list as YAML
$c = Spyc::YAMLLoad($b); // Load the dumped YAML
$d = Spyc::YAMLDump($c); // Re-dump the data
$this->assertSame($b, $d);
}
}
/vendor/mustangostang/spyc/tests/comments.yaml
@@ -0,0 +1,3 @@
foo: 'bar' #Comment
arr: ['x', 'y', 'z'] # Comment here
bar: kittens
/vendor/mustangostang/spyc/tests/failing1.yaml
@@ -0,0 +1,2 @@
MyObject:
Prop1: {key1:val1}
/vendor/mustangostang/spyc/tests/indent_1.yaml
@@ -0,0 +1,70 @@
root:
child_1: 2
 
child_2: 0
child_3: 1
 
root2:
child_1: 1
# A comment
child_2: 2
 
displays:
- resolutions:
1024: 768
- resolutions:
1920: 1200
 
display:
- resolutions:
1024: 768
1920: 1200
producer: "Nec"
 
nested_hashes_and_seqs:
- { row: 0, col: 0, headsets_affected: [{ports: [0], side: left}], switch_function: {ics_ptt: true} }
 
easier_nest: { h: [{a: b, a1: b1}, {c: d}] }
 
one_space: |
By four
spaces
 
steps:
- step: &id001
instrument: Lasik 2000
pulseEnergy: 5.4
pulseDuration: 12
repetition: 1000
spotSize: 1mm
- step:
<<: *id001
spotSize: 2mm
 
death masks are:
sad: 2
<<: {magnificent: 4}
 
login: &login
adapter: mysql
host: localhost
 
development:
database: rails_dev
<<: *login
 
"key": "value:"
colon_only: ":"
 
list_and_comment: [one, two, three] # comment
kai:
-example: value
kai_list_of_items:
- -item
- '-item'
-item
 
&foo bar:
1: "abc"
 
zzz: *foo
/vendor/mustangostang/spyc/tests/quotes.yaml
@@ -0,0 +1,8 @@
html_tags:
- <br>
- <p>
html_content:
- <p>hello world</p>
- hello<br>world
text_content:
- hello world