diff options
author | Nicolas LÅ“uillet <nicolas.loeuillet@gmail.com> | 2013-08-03 19:26:54 +0200 |
---|---|---|
committer | Nicolas LÅ“uillet <nicolas.loeuillet@gmail.com> | 2013-08-03 19:26:54 +0200 |
commit | 4f5b44bd3bd490309eb2ba7b44df4769816ba729 (patch) | |
tree | 6cefe170dfe0a5a361cb1e2d1fc4d580a3316d02 /vendor/symfony/options-resolver/Symfony/Component/OptionsResolver/Tests/OptionsResolverTest.php | |
parent | 2b840e0cfb63a453bea67a98541f3df9c273c5f5 (diff) | |
download | wallabag-4f5b44bd3bd490309eb2ba7b44df4769816ba729.tar.gz wallabag-4f5b44bd3bd490309eb2ba7b44df4769816ba729.tar.zst wallabag-4f5b44bd3bd490309eb2ba7b44df4769816ba729.zip |
twig implementation
Diffstat (limited to 'vendor/symfony/options-resolver/Symfony/Component/OptionsResolver/Tests/OptionsResolverTest.php')
-rw-r--r-- | vendor/symfony/options-resolver/Symfony/Component/OptionsResolver/Tests/OptionsResolverTest.php | 681 |
1 files changed, 681 insertions, 0 deletions
diff --git a/vendor/symfony/options-resolver/Symfony/Component/OptionsResolver/Tests/OptionsResolverTest.php b/vendor/symfony/options-resolver/Symfony/Component/OptionsResolver/Tests/OptionsResolverTest.php new file mode 100644 index 00000000..d50cd3fc --- /dev/null +++ b/vendor/symfony/options-resolver/Symfony/Component/OptionsResolver/Tests/OptionsResolverTest.php | |||
@@ -0,0 +1,681 @@ | |||
1 | <?php | ||
2 | |||
3 | /* | ||
4 | * This file is part of the Symfony package. | ||
5 | * | ||
6 | * (c) Fabien Potencier <fabien@symfony.com> | ||
7 | * | ||
8 | * For the full copyright and license information, please view the LICENSE | ||
9 | * file that was distributed with this source code. | ||
10 | */ | ||
11 | |||
12 | namespace Symfony\Component\OptionsResolver\Tests; | ||
13 | |||
14 | use Symfony\Component\OptionsResolver\OptionsResolver; | ||
15 | use Symfony\Component\OptionsResolver\Options; | ||
16 | |||
17 | class OptionsResolverTest extends \PHPUnit_Framework_TestCase | ||
18 | { | ||
19 | /** | ||
20 | * @var OptionsResolver | ||
21 | */ | ||
22 | private $resolver; | ||
23 | |||
24 | protected function setUp() | ||
25 | { | ||
26 | $this->resolver = new OptionsResolver(); | ||
27 | } | ||
28 | |||
29 | public function testResolve() | ||
30 | { | ||
31 | $this->resolver->setDefaults(array( | ||
32 | 'one' => '1', | ||
33 | 'two' => '2', | ||
34 | )); | ||
35 | |||
36 | $options = array( | ||
37 | 'two' => '20', | ||
38 | ); | ||
39 | |||
40 | $this->assertEquals(array( | ||
41 | 'one' => '1', | ||
42 | 'two' => '20', | ||
43 | ), $this->resolver->resolve($options)); | ||
44 | } | ||
45 | |||
46 | public function testResolveLazy() | ||
47 | { | ||
48 | $this->resolver->setDefaults(array( | ||
49 | 'one' => '1', | ||
50 | 'two' => function (Options $options) { | ||
51 | return '20'; | ||
52 | }, | ||
53 | )); | ||
54 | |||
55 | $this->assertEquals(array( | ||
56 | 'one' => '1', | ||
57 | 'two' => '20', | ||
58 | ), $this->resolver->resolve(array())); | ||
59 | } | ||
60 | |||
61 | public function testResolveLazyDependencyOnOptional() | ||
62 | { | ||
63 | $this->resolver->setDefaults(array( | ||
64 | 'one' => '1', | ||
65 | 'two' => function (Options $options) { | ||
66 | return $options['one'].'2'; | ||
67 | }, | ||
68 | )); | ||
69 | |||
70 | $options = array( | ||
71 | 'one' => '10', | ||
72 | ); | ||
73 | |||
74 | $this->assertEquals(array( | ||
75 | 'one' => '10', | ||
76 | 'two' => '102', | ||
77 | ), $this->resolver->resolve($options)); | ||
78 | } | ||
79 | |||
80 | public function testResolveLazyDependencyOnMissingOptionalWithoutDefault() | ||
81 | { | ||
82 | $test = $this; | ||
83 | |||
84 | $this->resolver->setOptional(array( | ||
85 | 'one', | ||
86 | )); | ||
87 | |||
88 | $this->resolver->setDefaults(array( | ||
89 | 'two' => function (Options $options) use ($test) { | ||
90 | /* @var \PHPUnit_Framework_TestCase $test */ | ||
91 | $test->assertFalse(isset($options['one'])); | ||
92 | |||
93 | return '2'; | ||
94 | }, | ||
95 | )); | ||
96 | |||
97 | $options = array( | ||
98 | ); | ||
99 | |||
100 | $this->assertEquals(array( | ||
101 | 'two' => '2', | ||
102 | ), $this->resolver->resolve($options)); | ||
103 | } | ||
104 | |||
105 | public function testResolveLazyDependencyOnOptionalWithoutDefault() | ||
106 | { | ||
107 | $test = $this; | ||
108 | |||
109 | $this->resolver->setOptional(array( | ||
110 | 'one', | ||
111 | )); | ||
112 | |||
113 | $this->resolver->setDefaults(array( | ||
114 | 'two' => function (Options $options) use ($test) { | ||
115 | /* @var \PHPUnit_Framework_TestCase $test */ | ||
116 | $test->assertTrue(isset($options['one'])); | ||
117 | |||
118 | return $options['one'].'2'; | ||
119 | }, | ||
120 | )); | ||
121 | |||
122 | $options = array( | ||
123 | 'one' => '10', | ||
124 | ); | ||
125 | |||
126 | $this->assertEquals(array( | ||
127 | 'one' => '10', | ||
128 | 'two' => '102', | ||
129 | ), $this->resolver->resolve($options)); | ||
130 | } | ||
131 | |||
132 | public function testResolveLazyDependencyOnRequired() | ||
133 | { | ||
134 | $this->resolver->setRequired(array( | ||
135 | 'one', | ||
136 | )); | ||
137 | $this->resolver->setDefaults(array( | ||
138 | 'two' => function (Options $options) { | ||
139 | return $options['one'].'2'; | ||
140 | }, | ||
141 | )); | ||
142 | |||
143 | $options = array( | ||
144 | 'one' => '10', | ||
145 | ); | ||
146 | |||
147 | $this->assertEquals(array( | ||
148 | 'one' => '10', | ||
149 | 'two' => '102', | ||
150 | ), $this->resolver->resolve($options)); | ||
151 | } | ||
152 | |||
153 | public function testResolveLazyReplaceDefaults() | ||
154 | { | ||
155 | $test = $this; | ||
156 | |||
157 | $this->resolver->setDefaults(array( | ||
158 | 'one' => function (Options $options) use ($test) { | ||
159 | /* @var \PHPUnit_Framework_TestCase $test */ | ||
160 | $test->fail('Previous closure should not be executed'); | ||
161 | }, | ||
162 | )); | ||
163 | |||
164 | $this->resolver->replaceDefaults(array( | ||
165 | 'one' => function (Options $options, $previousValue) { | ||
166 | return '1'; | ||
167 | }, | ||
168 | )); | ||
169 | |||
170 | $this->assertEquals(array( | ||
171 | 'one' => '1', | ||
172 | ), $this->resolver->resolve(array())); | ||
173 | } | ||
174 | |||
175 | /** | ||
176 | * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException | ||
177 | */ | ||
178 | public function testResolveFailsIfNonExistingOption() | ||
179 | { | ||
180 | $this->resolver->setDefaults(array( | ||
181 | 'one' => '1', | ||
182 | )); | ||
183 | |||
184 | $this->resolver->setRequired(array( | ||
185 | 'two', | ||
186 | )); | ||
187 | |||
188 | $this->resolver->setOptional(array( | ||
189 | 'three', | ||
190 | )); | ||
191 | |||
192 | $this->resolver->resolve(array( | ||
193 | 'foo' => 'bar', | ||
194 | )); | ||
195 | } | ||
196 | |||
197 | /** | ||
198 | * @expectedException \Symfony\Component\OptionsResolver\Exception\MissingOptionsException | ||
199 | */ | ||
200 | public function testResolveFailsIfMissingRequiredOption() | ||
201 | { | ||
202 | $this->resolver->setRequired(array( | ||
203 | 'one', | ||
204 | )); | ||
205 | |||
206 | $this->resolver->setDefaults(array( | ||
207 | 'two' => '2', | ||
208 | )); | ||
209 | |||
210 | $this->resolver->resolve(array( | ||
211 | 'two' => '20', | ||
212 | )); | ||
213 | } | ||
214 | |||
215 | public function testResolveSucceedsIfOptionValueAllowed() | ||
216 | { | ||
217 | $this->resolver->setDefaults(array( | ||
218 | 'one' => '1', | ||
219 | )); | ||
220 | |||
221 | $this->resolver->setAllowedValues(array( | ||
222 | 'one' => array('1', 'one'), | ||
223 | )); | ||
224 | |||
225 | $options = array( | ||
226 | 'one' => 'one', | ||
227 | ); | ||
228 | |||
229 | $this->assertEquals(array( | ||
230 | 'one' => 'one', | ||
231 | ), $this->resolver->resolve($options)); | ||
232 | } | ||
233 | |||
234 | public function testResolveSucceedsIfOptionValueAllowed2() | ||
235 | { | ||
236 | $this->resolver->setDefaults(array( | ||
237 | 'one' => '1', | ||
238 | 'two' => '2', | ||
239 | )); | ||
240 | |||
241 | $this->resolver->setAllowedValues(array( | ||
242 | 'one' => '1', | ||
243 | 'two' => '2', | ||
244 | )); | ||
245 | $this->resolver->addAllowedValues(array( | ||
246 | 'one' => 'one', | ||
247 | 'two' => 'two', | ||
248 | )); | ||
249 | |||
250 | $options = array( | ||
251 | 'one' => '1', | ||
252 | 'two' => 'two', | ||
253 | ); | ||
254 | |||
255 | $this->assertEquals(array( | ||
256 | 'one' => '1', | ||
257 | 'two' => 'two', | ||
258 | ), $this->resolver->resolve($options)); | ||
259 | } | ||
260 | |||
261 | public function testResolveSucceedsIfOptionalWithAllowedValuesNotSet() | ||
262 | { | ||
263 | $this->resolver->setRequired(array( | ||
264 | 'one', | ||
265 | )); | ||
266 | |||
267 | $this->resolver->setOptional(array( | ||
268 | 'two', | ||
269 | )); | ||
270 | |||
271 | $this->resolver->setAllowedValues(array( | ||
272 | 'one' => array('1', 'one'), | ||
273 | 'two' => array('2', 'two'), | ||
274 | )); | ||
275 | |||
276 | $options = array( | ||
277 | 'one' => '1', | ||
278 | ); | ||
279 | |||
280 | $this->assertEquals(array( | ||
281 | 'one' => '1', | ||
282 | ), $this->resolver->resolve($options)); | ||
283 | } | ||
284 | |||
285 | /** | ||
286 | * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException | ||
287 | */ | ||
288 | public function testResolveFailsIfOptionValueNotAllowed() | ||
289 | { | ||
290 | $this->resolver->setDefaults(array( | ||
291 | 'one' => '1', | ||
292 | )); | ||
293 | |||
294 | $this->resolver->setAllowedValues(array( | ||
295 | 'one' => array('1', 'one'), | ||
296 | )); | ||
297 | |||
298 | $this->resolver->resolve(array( | ||
299 | 'one' => '2', | ||
300 | )); | ||
301 | } | ||
302 | |||
303 | public function testResolveSucceedsIfOptionTypeAllowed() | ||
304 | { | ||
305 | $this->resolver->setDefaults(array( | ||
306 | 'one' => '1', | ||
307 | )); | ||
308 | |||
309 | $this->resolver->setAllowedTypes(array( | ||
310 | 'one' => 'string', | ||
311 | )); | ||
312 | |||
313 | $options = array( | ||
314 | 'one' => 'one', | ||
315 | ); | ||
316 | |||
317 | $this->assertEquals(array( | ||
318 | 'one' => 'one', | ||
319 | ), $this->resolver->resolve($options)); | ||
320 | } | ||
321 | |||
322 | public function testResolveSucceedsIfOptionTypeAllowedPassArray() | ||
323 | { | ||
324 | $this->resolver->setDefaults(array( | ||
325 | 'one' => '1', | ||
326 | )); | ||
327 | |||
328 | $this->resolver->setAllowedTypes(array( | ||
329 | 'one' => array('string', 'bool'), | ||
330 | )); | ||
331 | |||
332 | $options = array( | ||
333 | 'one' => true, | ||
334 | ); | ||
335 | |||
336 | $this->assertEquals(array( | ||
337 | 'one' => true, | ||
338 | ), $this->resolver->resolve($options)); | ||
339 | } | ||
340 | |||
341 | public function testResolveSucceedsIfOptionTypeAllowedPassObject() | ||
342 | { | ||
343 | $this->resolver->setDefaults(array( | ||
344 | 'one' => '1', | ||
345 | )); | ||
346 | |||
347 | $this->resolver->setAllowedTypes(array( | ||
348 | 'one' => 'object', | ||
349 | )); | ||
350 | |||
351 | $object = new \stdClass(); | ||
352 | $options = array( | ||
353 | 'one' => $object, | ||
354 | ); | ||
355 | |||
356 | $this->assertEquals(array( | ||
357 | 'one' => $object, | ||
358 | ), $this->resolver->resolve($options)); | ||
359 | } | ||
360 | |||
361 | public function testResolveSucceedsIfOptionTypeAllowedPassClass() | ||
362 | { | ||
363 | $this->resolver->setDefaults(array( | ||
364 | 'one' => '1', | ||
365 | )); | ||
366 | |||
367 | $this->resolver->setAllowedTypes(array( | ||
368 | 'one' => '\stdClass', | ||
369 | )); | ||
370 | |||
371 | $object = new \stdClass(); | ||
372 | $options = array( | ||
373 | 'one' => $object, | ||
374 | ); | ||
375 | |||
376 | $this->assertEquals(array( | ||
377 | 'one' => $object, | ||
378 | ), $this->resolver->resolve($options)); | ||
379 | } | ||
380 | |||
381 | public function testResolveSucceedsIfOptionTypeAllowedAddTypes() | ||
382 | { | ||
383 | $this->resolver->setDefaults(array( | ||
384 | 'one' => '1', | ||
385 | 'two' => '2', | ||
386 | )); | ||
387 | |||
388 | $this->resolver->setAllowedTypes(array( | ||
389 | 'one' => 'string', | ||
390 | 'two' => 'bool', | ||
391 | )); | ||
392 | $this->resolver->addAllowedTypes(array( | ||
393 | 'one' => 'float', | ||
394 | 'two' => 'integer', | ||
395 | )); | ||
396 | |||
397 | $options = array( | ||
398 | 'one' => 1.23, | ||
399 | 'two' => false, | ||
400 | ); | ||
401 | |||
402 | $this->assertEquals(array( | ||
403 | 'one' => 1.23, | ||
404 | 'two' => false, | ||
405 | ), $this->resolver->resolve($options)); | ||
406 | } | ||
407 | |||
408 | public function testResolveSucceedsIfOptionalWithTypeAndWithoutValue() | ||
409 | { | ||
410 | $this->resolver->setOptional(array( | ||
411 | 'one', | ||
412 | 'two', | ||
413 | )); | ||
414 | |||
415 | $this->resolver->setAllowedTypes(array( | ||
416 | 'one' => 'string', | ||
417 | 'two' => 'int', | ||
418 | )); | ||
419 | |||
420 | $options = array( | ||
421 | 'two' => 1, | ||
422 | ); | ||
423 | |||
424 | $this->assertEquals(array( | ||
425 | 'two' => 1, | ||
426 | ), $this->resolver->resolve($options)); | ||
427 | } | ||
428 | |||
429 | /** | ||
430 | * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException | ||
431 | */ | ||
432 | public function testResolveFailsIfOptionTypeNotAllowed() | ||
433 | { | ||
434 | $this->resolver->setDefaults(array( | ||
435 | 'one' => '1', | ||
436 | )); | ||
437 | |||
438 | $this->resolver->setAllowedTypes(array( | ||
439 | 'one' => array('string', 'bool'), | ||
440 | )); | ||
441 | |||
442 | $this->resolver->resolve(array( | ||
443 | 'one' => 1.23, | ||
444 | )); | ||
445 | } | ||
446 | |||
447 | /** | ||
448 | * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException | ||
449 | */ | ||
450 | public function testResolveFailsIfOptionTypeNotAllowedMultipleOptions() | ||
451 | { | ||
452 | $this->resolver->setDefaults(array( | ||
453 | 'one' => '1', | ||
454 | 'two' => '2', | ||
455 | )); | ||
456 | |||
457 | $this->resolver->setAllowedTypes(array( | ||
458 | 'one' => 'string', | ||
459 | 'two' => 'bool', | ||
460 | )); | ||
461 | |||
462 | $this->resolver->resolve(array( | ||
463 | 'one' => 'foo', | ||
464 | 'two' => 1.23, | ||
465 | )); | ||
466 | } | ||
467 | |||
468 | /** | ||
469 | * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException | ||
470 | */ | ||
471 | public function testResolveFailsIfOptionTypeNotAllowedAddTypes() | ||
472 | { | ||
473 | $this->resolver->setDefaults(array( | ||
474 | 'one' => '1', | ||
475 | )); | ||
476 | |||
477 | $this->resolver->setAllowedTypes(array( | ||
478 | 'one' => 'string', | ||
479 | )); | ||
480 | $this->resolver->addAllowedTypes(array( | ||
481 | 'one' => 'bool', | ||
482 | )); | ||
483 | |||
484 | $this->resolver->resolve(array( | ||
485 | 'one' => 1.23, | ||
486 | )); | ||
487 | } | ||
488 | |||
489 | /** | ||
490 | * @expectedException \Symfony\Component\OptionsResolver\Exception\OptionDefinitionException | ||
491 | */ | ||
492 | public function testSetRequiredFailsIfDefaultIsPassed() | ||
493 | { | ||
494 | $this->resolver->setRequired(array( | ||
495 | 'one' => '1', | ||
496 | )); | ||
497 | } | ||
498 | |||
499 | /** | ||
500 | * @expectedException \Symfony\Component\OptionsResolver\Exception\OptionDefinitionException | ||
501 | */ | ||
502 | public function testSetOptionalFailsIfDefaultIsPassed() | ||
503 | { | ||
504 | $this->resolver->setOptional(array( | ||
505 | 'one' => '1', | ||
506 | )); | ||
507 | } | ||
508 | |||
509 | public function testFluidInterface() | ||
510 | { | ||
511 | $this->resolver->setDefaults(array('one' => '1')) | ||
512 | ->replaceDefaults(array('one' => '2')) | ||
513 | ->setAllowedValues(array('one' => array('1', '2'))) | ||
514 | ->addAllowedValues(array('one' => array('3'))) | ||
515 | ->setRequired(array('two')) | ||
516 | ->setOptional(array('three')); | ||
517 | |||
518 | $options = array( | ||
519 | 'two' => '2', | ||
520 | ); | ||
521 | |||
522 | $this->assertEquals(array( | ||
523 | 'one' => '2', | ||
524 | 'two' => '2', | ||
525 | ), $this->resolver->resolve($options)); | ||
526 | } | ||
527 | |||
528 | public function testKnownIfDefaultWasSet() | ||
529 | { | ||
530 | $this->assertFalse($this->resolver->isKnown('foo')); | ||
531 | |||
532 | $this->resolver->setDefaults(array( | ||
533 | 'foo' => 'bar', | ||
534 | )); | ||
535 | |||
536 | $this->assertTrue($this->resolver->isKnown('foo')); | ||
537 | } | ||
538 | |||
539 | public function testKnownIfRequired() | ||
540 | { | ||
541 | $this->assertFalse($this->resolver->isKnown('foo')); | ||
542 | |||
543 | $this->resolver->setRequired(array( | ||
544 | 'foo', | ||
545 | )); | ||
546 | |||
547 | $this->assertTrue($this->resolver->isKnown('foo')); | ||
548 | } | ||
549 | |||
550 | public function testKnownIfOptional() | ||
551 | { | ||
552 | $this->assertFalse($this->resolver->isKnown('foo')); | ||
553 | |||
554 | $this->resolver->setOptional(array( | ||
555 | 'foo', | ||
556 | )); | ||
557 | |||
558 | $this->assertTrue($this->resolver->isKnown('foo')); | ||
559 | } | ||
560 | |||
561 | public function testRequiredIfRequired() | ||
562 | { | ||
563 | $this->assertFalse($this->resolver->isRequired('foo')); | ||
564 | |||
565 | $this->resolver->setRequired(array( | ||
566 | 'foo', | ||
567 | )); | ||
568 | |||
569 | $this->assertTrue($this->resolver->isRequired('foo')); | ||
570 | } | ||
571 | |||
572 | public function testNotRequiredIfRequiredAndDefaultValue() | ||
573 | { | ||
574 | $this->assertFalse($this->resolver->isRequired('foo')); | ||
575 | |||
576 | $this->resolver->setRequired(array( | ||
577 | 'foo', | ||
578 | )); | ||
579 | $this->resolver->setDefaults(array( | ||
580 | 'foo' => 'bar', | ||
581 | )); | ||
582 | |||
583 | $this->assertFalse($this->resolver->isRequired('foo')); | ||
584 | } | ||
585 | |||
586 | public function testNormalizersTransformFinalOptions() | ||
587 | { | ||
588 | $this->resolver->setDefaults(array( | ||
589 | 'foo' => 'bar', | ||
590 | 'bam' => 'baz', | ||
591 | )); | ||
592 | $this->resolver->setNormalizers(array( | ||
593 | 'foo' => function (Options $options, $value) { | ||
594 | return $options['bam'].'['.$value.']'; | ||
595 | }, | ||
596 | )); | ||
597 | |||
598 | $expected = array( | ||
599 | 'foo' => 'baz[bar]', | ||
600 | 'bam' => 'baz', | ||
601 | ); | ||
602 | |||
603 | $this->assertEquals($expected, $this->resolver->resolve(array())); | ||
604 | |||
605 | $expected = array( | ||
606 | 'foo' => 'boo[custom]', | ||
607 | 'bam' => 'boo', | ||
608 | ); | ||
609 | |||
610 | $this->assertEquals($expected, $this->resolver->resolve(array( | ||
611 | 'foo' => 'custom', | ||
612 | 'bam' => 'boo', | ||
613 | ))); | ||
614 | } | ||
615 | |||
616 | public function testResolveWithoutOptionSucceedsIfRequiredAndDefaultValue() | ||
617 | { | ||
618 | $this->resolver->setRequired(array( | ||
619 | 'foo', | ||
620 | )); | ||
621 | $this->resolver->setDefaults(array( | ||
622 | 'foo' => 'bar', | ||
623 | )); | ||
624 | |||
625 | $this->assertEquals(array( | ||
626 | 'foo' => 'bar' | ||
627 | ), $this->resolver->resolve(array())); | ||
628 | } | ||
629 | |||
630 | public function testResolveWithoutOptionSucceedsIfDefaultValueAndRequired() | ||
631 | { | ||
632 | $this->resolver->setDefaults(array( | ||
633 | 'foo' => 'bar', | ||
634 | )); | ||
635 | $this->resolver->setRequired(array( | ||
636 | 'foo', | ||
637 | )); | ||
638 | |||
639 | $this->assertEquals(array( | ||
640 | 'foo' => 'bar' | ||
641 | ), $this->resolver->resolve(array())); | ||
642 | } | ||
643 | |||
644 | public function testResolveSucceedsIfOptionRequiredAndValueAllowed() | ||
645 | { | ||
646 | $this->resolver->setRequired(array( | ||
647 | 'one', 'two', | ||
648 | )); | ||
649 | $this->resolver->setAllowedValues(array( | ||
650 | 'two' => array('2'), | ||
651 | )); | ||
652 | |||
653 | $options = array( | ||
654 | 'one' => '1', | ||
655 | 'two' => '2' | ||
656 | ); | ||
657 | |||
658 | $this->assertEquals($options, $this->resolver->resolve($options)); | ||
659 | } | ||
660 | |||
661 | public function testClone() | ||
662 | { | ||
663 | $this->resolver->setDefaults(array('one' => '1')); | ||
664 | |||
665 | $clone = clone $this->resolver; | ||
666 | |||
667 | // Changes after cloning don't affect each other | ||
668 | $this->resolver->setDefaults(array('two' => '2')); | ||
669 | $clone->setDefaults(array('three' => '3')); | ||
670 | |||
671 | $this->assertEquals(array( | ||
672 | 'one' => '1', | ||
673 | 'two' => '2', | ||
674 | ), $this->resolver->resolve()); | ||
675 | |||
676 | $this->assertEquals(array( | ||
677 | 'one' => '1', | ||
678 | 'three' => '3', | ||
679 | ), $clone->resolve()); | ||
680 | } | ||
681 | } | ||