diff options
Diffstat (limited to 'vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer')
16 files changed, 0 insertions, 2454 deletions
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ArrayToPartsTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ArrayToPartsTransformerTest.php deleted file mode 100644 index bafe5c09..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ArrayToPartsTransformerTest.php +++ /dev/null | |||
@@ -1,149 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | /* | ||
4 | * This file is part of the Symfony package. | ||
5 | * | ||
6 | * (c) Fabien Potencier <fabien.potencier@symfony-project.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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\ArrayToPartsTransformer; | ||
15 | |||
16 | class ArrayToPartsTransformerTest extends \PHPUnit_Framework_TestCase | ||
17 | { | ||
18 | private $transformer; | ||
19 | |||
20 | protected function setUp() | ||
21 | { | ||
22 | $this->transformer = new ArrayToPartsTransformer(array( | ||
23 | 'first' => array('a', 'b', 'c'), | ||
24 | 'second' => array('d', 'e', 'f'), | ||
25 | )); | ||
26 | } | ||
27 | |||
28 | protected function tearDown() | ||
29 | { | ||
30 | $this->transformer = null; | ||
31 | } | ||
32 | |||
33 | public function testTransform() | ||
34 | { | ||
35 | $input = array( | ||
36 | 'a' => '1', | ||
37 | 'b' => '2', | ||
38 | 'c' => '3', | ||
39 | 'd' => '4', | ||
40 | 'e' => '5', | ||
41 | 'f' => '6', | ||
42 | ); | ||
43 | |||
44 | $output = array( | ||
45 | 'first' => array( | ||
46 | 'a' => '1', | ||
47 | 'b' => '2', | ||
48 | 'c' => '3', | ||
49 | ), | ||
50 | 'second' => array( | ||
51 | 'd' => '4', | ||
52 | 'e' => '5', | ||
53 | 'f' => '6', | ||
54 | ), | ||
55 | ); | ||
56 | |||
57 | $this->assertSame($output, $this->transformer->transform($input)); | ||
58 | } | ||
59 | |||
60 | public function testTransformEmpty() | ||
61 | { | ||
62 | $output = array( | ||
63 | 'first' => null, | ||
64 | 'second' => null, | ||
65 | ); | ||
66 | |||
67 | $this->assertSame($output, $this->transformer->transform(null)); | ||
68 | } | ||
69 | |||
70 | /** | ||
71 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
72 | */ | ||
73 | public function testTransformRequiresArray() | ||
74 | { | ||
75 | $this->transformer->transform('12345'); | ||
76 | } | ||
77 | |||
78 | public function testReverseTransform() | ||
79 | { | ||
80 | $input = array( | ||
81 | 'first' => array( | ||
82 | 'a' => '1', | ||
83 | 'b' => '2', | ||
84 | 'c' => '3', | ||
85 | ), | ||
86 | 'second' => array( | ||
87 | 'd' => '4', | ||
88 | 'e' => '5', | ||
89 | 'f' => '6', | ||
90 | ), | ||
91 | ); | ||
92 | |||
93 | $output = array( | ||
94 | 'a' => '1', | ||
95 | 'b' => '2', | ||
96 | 'c' => '3', | ||
97 | 'd' => '4', | ||
98 | 'e' => '5', | ||
99 | 'f' => '6', | ||
100 | ); | ||
101 | |||
102 | $this->assertSame($output, $this->transformer->reverseTransform($input)); | ||
103 | } | ||
104 | |||
105 | public function testReverseTransformCompletelyEmpty() | ||
106 | { | ||
107 | $input = array( | ||
108 | 'first' => '', | ||
109 | 'second' => '', | ||
110 | ); | ||
111 | |||
112 | $this->assertNull($this->transformer->reverseTransform($input)); | ||
113 | } | ||
114 | |||
115 | public function testReverseTransformCompletelyNull() | ||
116 | { | ||
117 | $input = array( | ||
118 | 'first' => null, | ||
119 | 'second' => null, | ||
120 | ); | ||
121 | |||
122 | $this->assertNull($this->transformer->reverseTransform($input)); | ||
123 | } | ||
124 | |||
125 | /** | ||
126 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
127 | */ | ||
128 | public function testReverseTransformPartiallyNull() | ||
129 | { | ||
130 | $input = array( | ||
131 | 'first' => array( | ||
132 | 'a' => '1', | ||
133 | 'b' => '2', | ||
134 | 'c' => '3', | ||
135 | ), | ||
136 | 'second' => null, | ||
137 | ); | ||
138 | |||
139 | $this->transformer->reverseTransform($input); | ||
140 | } | ||
141 | |||
142 | /** | ||
143 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
144 | */ | ||
145 | public function testReverseTransformRequiresArray() | ||
146 | { | ||
147 | $this->transformer->reverseTransform('12345'); | ||
148 | } | ||
149 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/BooleanToStringTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/BooleanToStringTransformerTest.php deleted file mode 100644 index 41f8f956..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/BooleanToStringTransformerTest.php +++ /dev/null | |||
@@ -1,60 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\BooleanToStringTransformer; | ||
15 | |||
16 | class BooleanToStringTransformerTest extends \PHPUnit_Framework_TestCase | ||
17 | { | ||
18 | const TRUE_VALUE = '1'; | ||
19 | |||
20 | protected $transformer; | ||
21 | |||
22 | protected function setUp() | ||
23 | { | ||
24 | $this->transformer = new BooleanToStringTransformer(self::TRUE_VALUE); | ||
25 | } | ||
26 | |||
27 | protected function tearDown() | ||
28 | { | ||
29 | $this->transformer = null; | ||
30 | } | ||
31 | |||
32 | public function testTransform() | ||
33 | { | ||
34 | $this->assertEquals(self::TRUE_VALUE, $this->transformer->transform(true)); | ||
35 | $this->assertNull($this->transformer->transform(false)); | ||
36 | $this->assertNull($this->transformer->transform(null)); | ||
37 | } | ||
38 | |||
39 | public function testTransformExpectsBoolean() | ||
40 | { | ||
41 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
42 | |||
43 | $this->transformer->transform('1'); | ||
44 | } | ||
45 | |||
46 | public function testReverseTransformExpectsString() | ||
47 | { | ||
48 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
49 | |||
50 | $this->transformer->reverseTransform(1); | ||
51 | } | ||
52 | |||
53 | public function testReverseTransform() | ||
54 | { | ||
55 | $this->assertTrue($this->transformer->reverseTransform(self::TRUE_VALUE)); | ||
56 | $this->assertTrue($this->transformer->reverseTransform('foobar')); | ||
57 | $this->assertTrue($this->transformer->reverseTransform('')); | ||
58 | $this->assertFalse($this->transformer->reverseTransform(null)); | ||
59 | } | ||
60 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ChoiceToValueTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ChoiceToValueTransformerTest.php deleted file mode 100644 index bbae0621..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ChoiceToValueTransformerTest.php +++ /dev/null | |||
@@ -1,76 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\ChoiceList\SimpleChoiceList; | ||
15 | use Symfony\Component\Form\Extension\Core\DataTransformer\ChoiceToValueTransformer; | ||
16 | |||
17 | class ChoiceToValueTransformerTest extends \PHPUnit_Framework_TestCase | ||
18 | { | ||
19 | protected $transformer; | ||
20 | |||
21 | protected function setUp() | ||
22 | { | ||
23 | $list = new SimpleChoiceList(array('' => 'A', 0 => 'B', 1 => 'C')); | ||
24 | $this->transformer = new ChoiceToValueTransformer($list); | ||
25 | } | ||
26 | |||
27 | protected function tearDown() | ||
28 | { | ||
29 | $this->transformer = null; | ||
30 | } | ||
31 | |||
32 | public function transformProvider() | ||
33 | { | ||
34 | return array( | ||
35 | // more extensive test set can be found in FormUtilTest | ||
36 | array(0, '0'), | ||
37 | array(false, '0'), | ||
38 | array('', ''), | ||
39 | ); | ||
40 | } | ||
41 | |||
42 | /** | ||
43 | * @dataProvider transformProvider | ||
44 | */ | ||
45 | public function testTransform($in, $out) | ||
46 | { | ||
47 | $this->assertSame($out, $this->transformer->transform($in)); | ||
48 | } | ||
49 | |||
50 | public function reverseTransformProvider() | ||
51 | { | ||
52 | return array( | ||
53 | // values are expected to be valid choice keys already and stay | ||
54 | // the same | ||
55 | array('0', 0), | ||
56 | array('', null), | ||
57 | array(null, null), | ||
58 | ); | ||
59 | } | ||
60 | |||
61 | /** | ||
62 | * @dataProvider reverseTransformProvider | ||
63 | */ | ||
64 | public function testReverseTransform($in, $out) | ||
65 | { | ||
66 | $this->assertSame($out, $this->transformer->reverseTransform($in)); | ||
67 | } | ||
68 | |||
69 | /** | ||
70 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
71 | */ | ||
72 | public function testReverseTransformExpectsScalar() | ||
73 | { | ||
74 | $this->transformer->reverseTransform(array()); | ||
75 | } | ||
76 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ChoicesToValuesTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ChoicesToValuesTransformerTest.php deleted file mode 100644 index 57297193..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ChoicesToValuesTransformerTest.php +++ /dev/null | |||
@@ -1,76 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\ChoiceList\SimpleChoiceList; | ||
15 | |||
16 | use Symfony\Component\Form\Extension\Core\DataTransformer\ChoicesToValuesTransformer; | ||
17 | |||
18 | class ChoicesToValuesTransformerTest extends \PHPUnit_Framework_TestCase | ||
19 | { | ||
20 | protected $transformer; | ||
21 | |||
22 | protected function setUp() | ||
23 | { | ||
24 | $list = new SimpleChoiceList(array(0 => 'A', 1 => 'B', 2 => 'C')); | ||
25 | $this->transformer = new ChoicesToValuesTransformer($list); | ||
26 | } | ||
27 | |||
28 | protected function tearDown() | ||
29 | { | ||
30 | $this->transformer = null; | ||
31 | } | ||
32 | |||
33 | public function testTransform() | ||
34 | { | ||
35 | // Value strategy in SimpleChoiceList is to copy and convert to string | ||
36 | $in = array(0, 1, 2); | ||
37 | $out = array('0', '1', '2'); | ||
38 | |||
39 | $this->assertSame($out, $this->transformer->transform($in)); | ||
40 | } | ||
41 | |||
42 | public function testTransformNull() | ||
43 | { | ||
44 | $this->assertSame(array(), $this->transformer->transform(null)); | ||
45 | } | ||
46 | |||
47 | /** | ||
48 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
49 | */ | ||
50 | public function testTransformExpectsArray() | ||
51 | { | ||
52 | $this->transformer->transform('foobar'); | ||
53 | } | ||
54 | |||
55 | public function testReverseTransform() | ||
56 | { | ||
57 | // values are expected to be valid choices and stay the same | ||
58 | $in = array('0', '1', '2'); | ||
59 | $out = array(0, 1, 2); | ||
60 | |||
61 | $this->assertSame($out, $this->transformer->reverseTransform($in)); | ||
62 | } | ||
63 | |||
64 | public function testReverseTransformNull() | ||
65 | { | ||
66 | $this->assertSame(array(), $this->transformer->reverseTransform(null)); | ||
67 | } | ||
68 | |||
69 | /** | ||
70 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
71 | */ | ||
72 | public function testReverseTransformExpectsArray() | ||
73 | { | ||
74 | $this->transformer->reverseTransform('foobar'); | ||
75 | } | ||
76 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DataTransformerChainTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DataTransformerChainTest.php deleted file mode 100644 index 2ee2f22d..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DataTransformerChainTest.php +++ /dev/null | |||
@@ -1,53 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\DataTransformerChain; | ||
15 | |||
16 | class DataTransformerChainTest extends \PHPUnit_Framework_TestCase | ||
17 | { | ||
18 | public function testTransform() | ||
19 | { | ||
20 | $transformer1 = $this->getMock('Symfony\Component\Form\DataTransformerInterface'); | ||
21 | $transformer1->expects($this->once()) | ||
22 | ->method('transform') | ||
23 | ->with($this->identicalTo('foo')) | ||
24 | ->will($this->returnValue('bar')); | ||
25 | $transformer2 = $this->getMock('Symfony\Component\Form\DataTransformerInterface'); | ||
26 | $transformer2->expects($this->once()) | ||
27 | ->method('transform') | ||
28 | ->with($this->identicalTo('bar')) | ||
29 | ->will($this->returnValue('baz')); | ||
30 | |||
31 | $chain = new DataTransformerChain(array($transformer1, $transformer2)); | ||
32 | |||
33 | $this->assertEquals('baz', $chain->transform('foo')); | ||
34 | } | ||
35 | |||
36 | public function testReverseTransform() | ||
37 | { | ||
38 | $transformer2 = $this->getMock('Symfony\Component\Form\DataTransformerInterface'); | ||
39 | $transformer2->expects($this->once()) | ||
40 | ->method('reverseTransform') | ||
41 | ->with($this->identicalTo('foo')) | ||
42 | ->will($this->returnValue('bar')); | ||
43 | $transformer1 = $this->getMock('Symfony\Component\Form\DataTransformerInterface'); | ||
44 | $transformer1->expects($this->once()) | ||
45 | ->method('reverseTransform') | ||
46 | ->with($this->identicalTo('bar')) | ||
47 | ->will($this->returnValue('baz')); | ||
48 | |||
49 | $chain = new DataTransformerChain(array($transformer1, $transformer2)); | ||
50 | |||
51 | $this->assertEquals('baz', $chain->reverseTransform('foo')); | ||
52 | } | ||
53 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeTestCase.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeTestCase.php deleted file mode 100644 index f7722c49..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeTestCase.php +++ /dev/null | |||
@@ -1,20 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | abstract class DateTimeTestCase extends \PHPUnit_Framework_TestCase | ||
15 | { | ||
16 | public static function assertDateTimeEquals(\DateTime $expected, \DateTime $actual) | ||
17 | { | ||
18 | self::assertEquals($expected->format('c'), $actual->format('c')); | ||
19 | } | ||
20 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToArrayTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToArrayTransformerTest.php deleted file mode 100644 index 4898b88d..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToArrayTransformerTest.php +++ /dev/null | |||
@@ -1,512 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToArrayTransformer; | ||
15 | |||
16 | class DateTimeToArrayTransformerTest extends DateTimeTestCase | ||
17 | { | ||
18 | public function testTransform() | ||
19 | { | ||
20 | $transformer = new DateTimeToArrayTransformer('UTC', 'UTC'); | ||
21 | |||
22 | $input = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
23 | |||
24 | $output = array( | ||
25 | 'year' => '2010', | ||
26 | 'month' => '2', | ||
27 | 'day' => '3', | ||
28 | 'hour' => '4', | ||
29 | 'minute' => '5', | ||
30 | 'second' => '6', | ||
31 | ); | ||
32 | |||
33 | $this->assertSame($output, $transformer->transform($input)); | ||
34 | } | ||
35 | |||
36 | public function testTransformEmpty() | ||
37 | { | ||
38 | $transformer = new DateTimeToArrayTransformer(); | ||
39 | |||
40 | $output = array( | ||
41 | 'year' => '', | ||
42 | 'month' => '', | ||
43 | 'day' => '', | ||
44 | 'hour' => '', | ||
45 | 'minute' => '', | ||
46 | 'second' => '', | ||
47 | ); | ||
48 | |||
49 | $this->assertSame($output, $transformer->transform(null)); | ||
50 | } | ||
51 | |||
52 | public function testTransformEmptyWithFields() | ||
53 | { | ||
54 | $transformer = new DateTimeToArrayTransformer(null, null, array('year', 'minute', 'second')); | ||
55 | |||
56 | $output = array( | ||
57 | 'year' => '', | ||
58 | 'minute' => '', | ||
59 | 'second' => '', | ||
60 | ); | ||
61 | |||
62 | $this->assertSame($output, $transformer->transform(null)); | ||
63 | } | ||
64 | |||
65 | public function testTransformWithFields() | ||
66 | { | ||
67 | $transformer = new DateTimeToArrayTransformer('UTC', 'UTC', array('year', 'month', 'minute', 'second')); | ||
68 | |||
69 | $input = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
70 | |||
71 | $output = array( | ||
72 | 'year' => '2010', | ||
73 | 'month' => '2', | ||
74 | 'minute' => '5', | ||
75 | 'second' => '6', | ||
76 | ); | ||
77 | |||
78 | $this->assertSame($output, $transformer->transform($input)); | ||
79 | } | ||
80 | |||
81 | public function testTransformWithPadding() | ||
82 | { | ||
83 | $transformer = new DateTimeToArrayTransformer('UTC', 'UTC', null, true); | ||
84 | |||
85 | $input = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
86 | |||
87 | $output = array( | ||
88 | 'year' => '2010', | ||
89 | 'month' => '02', | ||
90 | 'day' => '03', | ||
91 | 'hour' => '04', | ||
92 | 'minute' => '05', | ||
93 | 'second' => '06', | ||
94 | ); | ||
95 | |||
96 | $this->assertSame($output, $transformer->transform($input)); | ||
97 | } | ||
98 | |||
99 | public function testTransformDifferentTimezones() | ||
100 | { | ||
101 | $transformer = new DateTimeToArrayTransformer('America/New_York', 'Asia/Hong_Kong'); | ||
102 | |||
103 | $input = new \DateTime('2010-02-03 04:05:06 America/New_York'); | ||
104 | |||
105 | $dateTime = new \DateTime('2010-02-03 04:05:06 America/New_York'); | ||
106 | $dateTime->setTimezone(new \DateTimeZone('Asia/Hong_Kong')); | ||
107 | $output = array( | ||
108 | 'year' => (string) (int) $dateTime->format('Y'), | ||
109 | 'month' => (string) (int) $dateTime->format('m'), | ||
110 | 'day' => (string) (int) $dateTime->format('d'), | ||
111 | 'hour' => (string) (int) $dateTime->format('H'), | ||
112 | 'minute' => (string) (int) $dateTime->format('i'), | ||
113 | 'second' => (string) (int) $dateTime->format('s'), | ||
114 | ); | ||
115 | |||
116 | $this->assertSame($output, $transformer->transform($input)); | ||
117 | } | ||
118 | |||
119 | /** | ||
120 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
121 | */ | ||
122 | public function testTransformRequiresDateTime() | ||
123 | { | ||
124 | $transformer = new DateTimeToArrayTransformer(); | ||
125 | $transformer->reverseTransform('12345'); | ||
126 | } | ||
127 | |||
128 | public function testReverseTransform() | ||
129 | { | ||
130 | $transformer = new DateTimeToArrayTransformer('UTC', 'UTC'); | ||
131 | |||
132 | $input = array( | ||
133 | 'year' => '2010', | ||
134 | 'month' => '2', | ||
135 | 'day' => '3', | ||
136 | 'hour' => '4', | ||
137 | 'minute' => '5', | ||
138 | 'second' => '6', | ||
139 | ); | ||
140 | |||
141 | $output = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
142 | |||
143 | $this->assertDateTimeEquals($output, $transformer->reverseTransform($input)); | ||
144 | } | ||
145 | |||
146 | public function testReverseTransformWithSomeZero() | ||
147 | { | ||
148 | $transformer = new DateTimeToArrayTransformer('UTC', 'UTC'); | ||
149 | |||
150 | $input = array( | ||
151 | 'year' => '2010', | ||
152 | 'month' => '2', | ||
153 | 'day' => '3', | ||
154 | 'hour' => '4', | ||
155 | 'minute' => '0', | ||
156 | 'second' => '0', | ||
157 | ); | ||
158 | |||
159 | $output = new \DateTime('2010-02-03 04:00:00 UTC'); | ||
160 | |||
161 | $this->assertDateTimeEquals($output, $transformer->reverseTransform($input)); | ||
162 | } | ||
163 | |||
164 | public function testReverseTransformCompletelyEmpty() | ||
165 | { | ||
166 | $transformer = new DateTimeToArrayTransformer(); | ||
167 | |||
168 | $input = array( | ||
169 | 'year' => '', | ||
170 | 'month' => '', | ||
171 | 'day' => '', | ||
172 | 'hour' => '', | ||
173 | 'minute' => '', | ||
174 | 'second' => '', | ||
175 | ); | ||
176 | |||
177 | $this->assertNull($transformer->reverseTransform($input)); | ||
178 | } | ||
179 | |||
180 | public function testReverseTransformCompletelyEmptySubsetOfFields() | ||
181 | { | ||
182 | $transformer = new DateTimeToArrayTransformer(null, null, array('year', 'month', 'day')); | ||
183 | |||
184 | $input = array( | ||
185 | 'year' => '', | ||
186 | 'month' => '', | ||
187 | 'day' => '', | ||
188 | ); | ||
189 | |||
190 | $this->assertNull($transformer->reverseTransform($input)); | ||
191 | } | ||
192 | |||
193 | /** | ||
194 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
195 | */ | ||
196 | public function testReverseTransformPartiallyEmptyYear() | ||
197 | { | ||
198 | $transformer = new DateTimeToArrayTransformer(); | ||
199 | $transformer->reverseTransform(array( | ||
200 | 'month' => '2', | ||
201 | 'day' => '3', | ||
202 | 'hour' => '4', | ||
203 | 'minute' => '5', | ||
204 | 'second' => '6', | ||
205 | )); | ||
206 | } | ||
207 | |||
208 | /** | ||
209 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
210 | */ | ||
211 | public function testReverseTransformPartiallyEmptyMonth() | ||
212 | { | ||
213 | $transformer = new DateTimeToArrayTransformer(); | ||
214 | $transformer->reverseTransform(array( | ||
215 | 'year' => '2010', | ||
216 | 'day' => '3', | ||
217 | 'hour' => '4', | ||
218 | 'minute' => '5', | ||
219 | 'second' => '6', | ||
220 | )); | ||
221 | } | ||
222 | |||
223 | /** | ||
224 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
225 | */ | ||
226 | public function testReverseTransformPartiallyEmptyDay() | ||
227 | { | ||
228 | $transformer = new DateTimeToArrayTransformer(); | ||
229 | $transformer->reverseTransform(array( | ||
230 | 'year' => '2010', | ||
231 | 'month' => '2', | ||
232 | 'hour' => '4', | ||
233 | 'minute' => '5', | ||
234 | 'second' => '6', | ||
235 | )); | ||
236 | } | ||
237 | |||
238 | /** | ||
239 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
240 | */ | ||
241 | public function testReverseTransformPartiallyEmptyHour() | ||
242 | { | ||
243 | $transformer = new DateTimeToArrayTransformer(); | ||
244 | $transformer->reverseTransform(array( | ||
245 | 'year' => '2010', | ||
246 | 'month' => '2', | ||
247 | 'day' => '3', | ||
248 | 'minute' => '5', | ||
249 | 'second' => '6', | ||
250 | )); | ||
251 | } | ||
252 | |||
253 | /** | ||
254 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
255 | */ | ||
256 | public function testReverseTransformPartiallyEmptyMinute() | ||
257 | { | ||
258 | $transformer = new DateTimeToArrayTransformer(); | ||
259 | $transformer->reverseTransform(array( | ||
260 | 'year' => '2010', | ||
261 | 'month' => '2', | ||
262 | 'day' => '3', | ||
263 | 'hour' => '4', | ||
264 | 'second' => '6', | ||
265 | )); | ||
266 | } | ||
267 | |||
268 | /** | ||
269 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
270 | */ | ||
271 | public function testReverseTransformPartiallyEmptySecond() | ||
272 | { | ||
273 | $transformer = new DateTimeToArrayTransformer(); | ||
274 | $transformer->reverseTransform(array( | ||
275 | 'year' => '2010', | ||
276 | 'month' => '2', | ||
277 | 'day' => '3', | ||
278 | 'hour' => '4', | ||
279 | 'minute' => '5', | ||
280 | )); | ||
281 | } | ||
282 | |||
283 | public function testReverseTransformNull() | ||
284 | { | ||
285 | $transformer = new DateTimeToArrayTransformer(); | ||
286 | |||
287 | $this->assertNull($transformer->reverseTransform(null)); | ||
288 | } | ||
289 | |||
290 | public function testReverseTransformDifferentTimezones() | ||
291 | { | ||
292 | $transformer = new DateTimeToArrayTransformer('America/New_York', 'Asia/Hong_Kong'); | ||
293 | |||
294 | $input = array( | ||
295 | 'year' => '2010', | ||
296 | 'month' => '2', | ||
297 | 'day' => '3', | ||
298 | 'hour' => '4', | ||
299 | 'minute' => '5', | ||
300 | 'second' => '6', | ||
301 | ); | ||
302 | |||
303 | $output = new \DateTime('2010-02-03 04:05:06 Asia/Hong_Kong'); | ||
304 | $output->setTimezone(new \DateTimeZone('America/New_York')); | ||
305 | |||
306 | $this->assertDateTimeEquals($output, $transformer->reverseTransform($input)); | ||
307 | } | ||
308 | |||
309 | public function testReverseTransformToDifferentTimezone() | ||
310 | { | ||
311 | $transformer = new DateTimeToArrayTransformer('Asia/Hong_Kong', 'UTC'); | ||
312 | |||
313 | $input = array( | ||
314 | 'year' => '2010', | ||
315 | 'month' => '2', | ||
316 | 'day' => '3', | ||
317 | 'hour' => '4', | ||
318 | 'minute' => '5', | ||
319 | 'second' => '6', | ||
320 | ); | ||
321 | |||
322 | $output = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
323 | $output->setTimezone(new \DateTimeZone('Asia/Hong_Kong')); | ||
324 | |||
325 | $this->assertDateTimeEquals($output, $transformer->reverseTransform($input)); | ||
326 | } | ||
327 | |||
328 | /** | ||
329 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
330 | */ | ||
331 | public function testReverseTransformRequiresArray() | ||
332 | { | ||
333 | $transformer = new DateTimeToArrayTransformer(); | ||
334 | $transformer->reverseTransform('12345'); | ||
335 | } | ||
336 | |||
337 | /** | ||
338 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
339 | */ | ||
340 | public function testReverseTransformWithNegativeYear() | ||
341 | { | ||
342 | $transformer = new DateTimeToArrayTransformer(); | ||
343 | $transformer->reverseTransform(array( | ||
344 | 'year' => '-1', | ||
345 | 'month' => '2', | ||
346 | 'day' => '3', | ||
347 | 'hour' => '4', | ||
348 | 'minute' => '5', | ||
349 | 'second' => '6', | ||
350 | )); | ||
351 | } | ||
352 | |||
353 | /** | ||
354 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
355 | */ | ||
356 | public function testReverseTransformWithNegativeMonth() | ||
357 | { | ||
358 | $transformer = new DateTimeToArrayTransformer(); | ||
359 | $transformer->reverseTransform(array( | ||
360 | 'year' => '2010', | ||
361 | 'month' => '-1', | ||
362 | 'day' => '3', | ||
363 | 'hour' => '4', | ||
364 | 'minute' => '5', | ||
365 | 'second' => '6', | ||
366 | )); | ||
367 | } | ||
368 | |||
369 | /** | ||
370 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
371 | */ | ||
372 | public function testReverseTransformWithNegativeDay() | ||
373 | { | ||
374 | $transformer = new DateTimeToArrayTransformer(); | ||
375 | $transformer->reverseTransform(array( | ||
376 | 'year' => '2010', | ||
377 | 'month' => '2', | ||
378 | 'day' => '-1', | ||
379 | 'hour' => '4', | ||
380 | 'minute' => '5', | ||
381 | 'second' => '6', | ||
382 | )); | ||
383 | } | ||
384 | |||
385 | /** | ||
386 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
387 | */ | ||
388 | public function testReverseTransformWithNegativeHour() | ||
389 | { | ||
390 | $transformer = new DateTimeToArrayTransformer(); | ||
391 | $transformer->reverseTransform(array( | ||
392 | 'year' => '2010', | ||
393 | 'month' => '2', | ||
394 | 'day' => '3', | ||
395 | 'hour' => '-1', | ||
396 | 'minute' => '5', | ||
397 | 'second' => '6', | ||
398 | )); | ||
399 | } | ||
400 | |||
401 | /** | ||
402 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
403 | */ | ||
404 | public function testReverseTransformWithNegativeMinute() | ||
405 | { | ||
406 | $transformer = new DateTimeToArrayTransformer(); | ||
407 | $transformer->reverseTransform(array( | ||
408 | 'year' => '2010', | ||
409 | 'month' => '2', | ||
410 | 'day' => '3', | ||
411 | 'hour' => '4', | ||
412 | 'minute' => '-1', | ||
413 | 'second' => '6', | ||
414 | )); | ||
415 | } | ||
416 | |||
417 | /** | ||
418 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
419 | */ | ||
420 | public function testReverseTransformWithNegativeSecond() | ||
421 | { | ||
422 | $transformer = new DateTimeToArrayTransformer(); | ||
423 | $transformer->reverseTransform(array( | ||
424 | 'year' => '2010', | ||
425 | 'month' => '2', | ||
426 | 'day' => '3', | ||
427 | 'hour' => '4', | ||
428 | 'minute' => '5', | ||
429 | 'second' => '-1', | ||
430 | )); | ||
431 | } | ||
432 | |||
433 | /** | ||
434 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
435 | */ | ||
436 | public function testReverseTransformWithInvalidMonth() | ||
437 | { | ||
438 | $transformer = new DateTimeToArrayTransformer(); | ||
439 | $transformer->reverseTransform(array( | ||
440 | 'year' => '2010', | ||
441 | 'month' => '13', | ||
442 | 'day' => '3', | ||
443 | 'hour' => '4', | ||
444 | 'minute' => '5', | ||
445 | 'second' => '6', | ||
446 | )); | ||
447 | } | ||
448 | |||
449 | /** | ||
450 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
451 | */ | ||
452 | public function testReverseTransformWithInvalidDay() | ||
453 | { | ||
454 | $transformer = new DateTimeToArrayTransformer(); | ||
455 | $transformer->reverseTransform(array( | ||
456 | 'year' => '2010', | ||
457 | 'month' => '2', | ||
458 | 'day' => '31', | ||
459 | 'hour' => '4', | ||
460 | 'minute' => '5', | ||
461 | 'second' => '6', | ||
462 | )); | ||
463 | } | ||
464 | |||
465 | /** | ||
466 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
467 | */ | ||
468 | public function testReverseTransformWithStringDay() | ||
469 | { | ||
470 | $transformer = new DateTimeToArrayTransformer(); | ||
471 | $transformer->reverseTransform(array( | ||
472 | 'year' => '2010', | ||
473 | 'month' => '2', | ||
474 | 'day' => 'bazinga', | ||
475 | 'hour' => '4', | ||
476 | 'minute' => '5', | ||
477 | 'second' => '6', | ||
478 | )); | ||
479 | } | ||
480 | |||
481 | /** | ||
482 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
483 | */ | ||
484 | public function testReverseTransformWithStringMonth() | ||
485 | { | ||
486 | $transformer = new DateTimeToArrayTransformer(); | ||
487 | $transformer->reverseTransform(array( | ||
488 | 'year' => '2010', | ||
489 | 'month' => 'bazinga', | ||
490 | 'day' => '31', | ||
491 | 'hour' => '4', | ||
492 | 'minute' => '5', | ||
493 | 'second' => '6', | ||
494 | )); | ||
495 | } | ||
496 | |||
497 | /** | ||
498 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
499 | */ | ||
500 | public function testReverseTransformWithStringYear() | ||
501 | { | ||
502 | $transformer = new DateTimeToArrayTransformer(); | ||
503 | $transformer->reverseTransform(array( | ||
504 | 'year' => 'bazinga', | ||
505 | 'month' => '2', | ||
506 | 'day' => '31', | ||
507 | 'hour' => '4', | ||
508 | 'minute' => '5', | ||
509 | 'second' => '6', | ||
510 | )); | ||
511 | } | ||
512 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToLocalizedStringTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToLocalizedStringTransformerTest.php deleted file mode 100644 index cb50fc36..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToLocalizedStringTransformerTest.php +++ /dev/null | |||
@@ -1,275 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToLocalizedStringTransformer; | ||
15 | use Symfony\Component\Intl\Util\IntlTestHelper; | ||
16 | |||
17 | class DateTimeToLocalizedStringTransformerTest extends DateTimeTestCase | ||
18 | { | ||
19 | protected $dateTime; | ||
20 | protected $dateTimeWithoutSeconds; | ||
21 | |||
22 | protected function setUp() | ||
23 | { | ||
24 | parent::setUp(); | ||
25 | |||
26 | // Since we test against "de_AT", we need the full implementation | ||
27 | IntlTestHelper::requireFullIntl($this); | ||
28 | |||
29 | \Locale::setDefault('de_AT'); | ||
30 | |||
31 | $this->dateTime = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
32 | $this->dateTimeWithoutSeconds = new \DateTime('2010-02-03 04:05:00 UTC'); | ||
33 | } | ||
34 | |||
35 | protected function tearDown() | ||
36 | { | ||
37 | $this->dateTime = null; | ||
38 | $this->dateTimeWithoutSeconds = null; | ||
39 | } | ||
40 | |||
41 | public static function assertEquals($expected, $actual, $message = '', $delta = 0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false) | ||
42 | { | ||
43 | if ($expected instanceof \DateTime && $actual instanceof \DateTime) { | ||
44 | $expected = $expected->format('c'); | ||
45 | $actual = $actual->format('c'); | ||
46 | } | ||
47 | |||
48 | parent::assertEquals($expected, $actual, $message, $delta, $maxDepth, $canonicalize, $ignoreCase); | ||
49 | } | ||
50 | |||
51 | public function dataProvider() | ||
52 | { | ||
53 | return array( | ||
54 | array(\IntlDateFormatter::SHORT, null, null, '03.02.10 04:05', '2010-02-03 04:05:00 UTC'), | ||
55 | array(\IntlDateFormatter::MEDIUM, null, null, '03.02.2010 04:05', '2010-02-03 04:05:00 UTC'), | ||
56 | array(\IntlDateFormatter::LONG, null, null, '03. Februar 2010 04:05', '2010-02-03 04:05:00 UTC'), | ||
57 | array(\IntlDateFormatter::FULL, null, null, 'Mittwoch, 03. Februar 2010 04:05', '2010-02-03 04:05:00 UTC'), | ||
58 | array(\IntlDateFormatter::SHORT, \IntlDateFormatter::NONE, null, '03.02.10', '2010-02-03 00:00:00 UTC'), | ||
59 | array(\IntlDateFormatter::MEDIUM, \IntlDateFormatter::NONE, null, '03.02.2010', '2010-02-03 00:00:00 UTC'), | ||
60 | array(\IntlDateFormatter::LONG, \IntlDateFormatter::NONE, null, '03. Februar 2010', '2010-02-03 00:00:00 UTC'), | ||
61 | array(\IntlDateFormatter::FULL, \IntlDateFormatter::NONE, null, 'Mittwoch, 03. Februar 2010', '2010-02-03 00:00:00 UTC'), | ||
62 | array(null, \IntlDateFormatter::SHORT, null, '03.02.2010 04:05', '2010-02-03 04:05:00 UTC'), | ||
63 | array(null, \IntlDateFormatter::MEDIUM, null, '03.02.2010 04:05:06', '2010-02-03 04:05:06 UTC'), | ||
64 | array(null, \IntlDateFormatter::LONG, null, '03.02.2010 04:05:06 GMT', '2010-02-03 04:05:06 UTC'), | ||
65 | // see below for extra test case for time format FULL | ||
66 | array(\IntlDateFormatter::NONE, \IntlDateFormatter::SHORT, null, '04:05', '1970-01-01 04:05:00 UTC'), | ||
67 | array(\IntlDateFormatter::NONE, \IntlDateFormatter::MEDIUM, null, '04:05:06', '1970-01-01 04:05:06 UTC'), | ||
68 | array(\IntlDateFormatter::NONE, \IntlDateFormatter::LONG, null, '04:05:06 GMT', '1970-01-01 04:05:06 UTC'), | ||
69 | array(null, null, 'yyyy-MM-dd HH:mm:00', '2010-02-03 04:05:00', '2010-02-03 04:05:00 UTC'), | ||
70 | array(null, null, 'yyyy-MM-dd HH:mm', '2010-02-03 04:05', '2010-02-03 04:05:00 UTC'), | ||
71 | array(null, null, 'yyyy-MM-dd HH', '2010-02-03 04', '2010-02-03 04:00:00 UTC'), | ||
72 | array(null, null, 'yyyy-MM-dd', '2010-02-03', '2010-02-03 00:00:00 UTC'), | ||
73 | array(null, null, 'yyyy-MM', '2010-02', '2010-02-01 00:00:00 UTC'), | ||
74 | array(null, null, 'yyyy', '2010', '2010-01-01 00:00:00 UTC'), | ||
75 | array(null, null, 'dd-MM-yyyy', '03-02-2010', '2010-02-03 00:00:00 UTC'), | ||
76 | array(null, null, 'HH:mm:ss', '04:05:06', '1970-01-01 04:05:06 UTC'), | ||
77 | array(null, null, 'HH:mm:00', '04:05:00', '1970-01-01 04:05:00 UTC'), | ||
78 | array(null, null, 'HH:mm', '04:05', '1970-01-01 04:05:00 UTC'), | ||
79 | array(null, null, 'HH', '04', '1970-01-01 04:00:00 UTC'), | ||
80 | ); | ||
81 | } | ||
82 | |||
83 | /** | ||
84 | * @dataProvider dataProvider | ||
85 | */ | ||
86 | public function testTransform($dateFormat, $timeFormat, $pattern, $output, $input) | ||
87 | { | ||
88 | $transformer = new DateTimeToLocalizedStringTransformer( | ||
89 | 'UTC', | ||
90 | 'UTC', | ||
91 | $dateFormat, | ||
92 | $timeFormat, | ||
93 | \IntlDateFormatter::GREGORIAN, | ||
94 | $pattern | ||
95 | ); | ||
96 | |||
97 | $input = new \DateTime($input); | ||
98 | |||
99 | $this->assertEquals($output, $transformer->transform($input)); | ||
100 | } | ||
101 | |||
102 | public function testTransformFullTime() | ||
103 | { | ||
104 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC', null, \IntlDateFormatter::FULL); | ||
105 | |||
106 | $this->assertEquals('03.02.2010 04:05:06 GMT', $transformer->transform($this->dateTime)); | ||
107 | } | ||
108 | |||
109 | public function testTransformToDifferentLocale() | ||
110 | { | ||
111 | \Locale::setDefault('en_US'); | ||
112 | |||
113 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC'); | ||
114 | |||
115 | $this->assertEquals('Feb 3, 2010, 4:05 AM', $transformer->transform($this->dateTime)); | ||
116 | } | ||
117 | |||
118 | public function testTransformEmpty() | ||
119 | { | ||
120 | $transformer = new DateTimeToLocalizedStringTransformer(); | ||
121 | |||
122 | $this->assertSame('', $transformer->transform(null)); | ||
123 | } | ||
124 | |||
125 | public function testTransformWithDifferentTimezones() | ||
126 | { | ||
127 | $transformer = new DateTimeToLocalizedStringTransformer('America/New_York', 'Asia/Hong_Kong'); | ||
128 | |||
129 | $input = new \DateTime('2010-02-03 04:05:06 America/New_York'); | ||
130 | |||
131 | $dateTime = clone $input; | ||
132 | $dateTime->setTimezone(new \DateTimeZone('Asia/Hong_Kong')); | ||
133 | |||
134 | $this->assertEquals($dateTime->format('d.m.Y H:i'), $transformer->transform($input)); | ||
135 | } | ||
136 | |||
137 | public function testTransformWithDifferentPatterns() | ||
138 | { | ||
139 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC', \IntlDateFormatter::FULL, \IntlDateFormatter::FULL, \IntlDateFormatter::GREGORIAN, 'MM*yyyy*dd HH|mm|ss'); | ||
140 | |||
141 | $this->assertEquals('02*2010*03 04|05|06', $transformer->transform($this->dateTime)); | ||
142 | } | ||
143 | |||
144 | /** | ||
145 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
146 | */ | ||
147 | public function testTransformRequiresValidDateTime() | ||
148 | { | ||
149 | $transformer = new DateTimeToLocalizedStringTransformer(); | ||
150 | $transformer->transform('2010-01-01'); | ||
151 | } | ||
152 | |||
153 | public function testTransformWrapsIntlErrors() | ||
154 | { | ||
155 | $transformer = new DateTimeToLocalizedStringTransformer(); | ||
156 | |||
157 | // HOW TO REPRODUCE? | ||
158 | |||
159 | //$this->setExpectedException('Symfony\Component\Form\Extension\Core\DataTransformer\Transdate_formationFailedException'); | ||
160 | |||
161 | //$transformer->transform(1.5); | ||
162 | } | ||
163 | |||
164 | /** | ||
165 | * @dataProvider dataProvider | ||
166 | */ | ||
167 | public function testReverseTransform($dateFormat, $timeFormat, $pattern, $input, $output) | ||
168 | { | ||
169 | $transformer = new DateTimeToLocalizedStringTransformer( | ||
170 | 'UTC', | ||
171 | 'UTC', | ||
172 | $dateFormat, | ||
173 | $timeFormat, | ||
174 | \IntlDateFormatter::GREGORIAN, | ||
175 | $pattern | ||
176 | ); | ||
177 | |||
178 | $output = new \DateTime($output); | ||
179 | |||
180 | $this->assertEquals($output, $transformer->reverseTransform($input)); | ||
181 | } | ||
182 | |||
183 | public function testReverseTransformFullTime() | ||
184 | { | ||
185 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC', null, \IntlDateFormatter::FULL); | ||
186 | |||
187 | $this->assertDateTimeEquals($this->dateTime, $transformer->reverseTransform('03.02.2010 04:05:06 GMT+00:00')); | ||
188 | } | ||
189 | |||
190 | public function testReverseTransformFromDifferentLocale() | ||
191 | { | ||
192 | \Locale::setDefault('en_US'); | ||
193 | |||
194 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC'); | ||
195 | |||
196 | $this->assertDateTimeEquals($this->dateTimeWithoutSeconds, $transformer->reverseTransform('Feb 3, 2010, 04:05 AM')); | ||
197 | } | ||
198 | |||
199 | public function testReverseTransformWithDifferentTimezones() | ||
200 | { | ||
201 | $transformer = new DateTimeToLocalizedStringTransformer('America/New_York', 'Asia/Hong_Kong'); | ||
202 | |||
203 | $dateTime = new \DateTime('2010-02-03 04:05:00 Asia/Hong_Kong'); | ||
204 | $dateTime->setTimezone(new \DateTimeZone('America/New_York')); | ||
205 | |||
206 | $this->assertDateTimeEquals($dateTime, $transformer->reverseTransform('03.02.2010 04:05')); | ||
207 | } | ||
208 | |||
209 | public function testReverseTransformWithDifferentPatterns() | ||
210 | { | ||
211 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC', \IntlDateFormatter::FULL, \IntlDateFormatter::FULL, \IntlDateFormatter::GREGORIAN, 'MM*yyyy*dd HH|mm|ss'); | ||
212 | |||
213 | $this->assertDateTimeEquals($this->dateTime, $transformer->reverseTransform('02*2010*03 04|05|06')); | ||
214 | } | ||
215 | |||
216 | public function testReverseTransformEmpty() | ||
217 | { | ||
218 | $transformer = new DateTimeToLocalizedStringTransformer(); | ||
219 | |||
220 | $this->assertNull($transformer->reverseTransform('')); | ||
221 | } | ||
222 | |||
223 | /** | ||
224 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
225 | */ | ||
226 | public function testReverseTransformRequiresString() | ||
227 | { | ||
228 | $transformer = new DateTimeToLocalizedStringTransformer(); | ||
229 | $transformer->reverseTransform(12345); | ||
230 | } | ||
231 | |||
232 | /** | ||
233 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
234 | */ | ||
235 | public function testReverseTransformWrapsIntlErrors() | ||
236 | { | ||
237 | $transformer = new DateTimeToLocalizedStringTransformer(); | ||
238 | $transformer->reverseTransform('12345'); | ||
239 | } | ||
240 | |||
241 | /** | ||
242 | * @expectedException \Symfony\Component\Form\Exception\UnexpectedTypeException | ||
243 | */ | ||
244 | public function testValidateDateFormatOption() | ||
245 | { | ||
246 | new DateTimeToLocalizedStringTransformer(null, null, 'foobar'); | ||
247 | } | ||
248 | |||
249 | /** | ||
250 | * @expectedException \Symfony\Component\Form\Exception\UnexpectedTypeException | ||
251 | */ | ||
252 | public function testValidateTimeFormatOption() | ||
253 | { | ||
254 | new DateTimeToLocalizedStringTransformer(null, null, null, 'foobar'); | ||
255 | } | ||
256 | |||
257 | /** | ||
258 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
259 | */ | ||
260 | public function testReverseTransformWithNonExistingDate() | ||
261 | { | ||
262 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC', \IntlDateFormatter::SHORT); | ||
263 | |||
264 | $this->assertDateTimeEquals($this->dateTimeWithoutSeconds, $transformer->reverseTransform('31.04.10 04:05')); | ||
265 | } | ||
266 | |||
267 | /** | ||
268 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
269 | */ | ||
270 | public function testReverseTransformOutOfTimestampRange() | ||
271 | { | ||
272 | $transformer = new DateTimeToLocalizedStringTransformer('UTC', 'UTC'); | ||
273 | $transformer->reverseTransform('1789-07-14'); | ||
274 | } | ||
275 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToRfc3339TransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToRfc3339TransformerTest.php deleted file mode 100644 index 98aeb772..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToRfc3339TransformerTest.php +++ /dev/null | |||
@@ -1,132 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToRfc3339Transformer; | ||
15 | |||
16 | class DateTimeToRfc3339TransformerTest extends DateTimeTestCase | ||
17 | { | ||
18 | protected $dateTime; | ||
19 | protected $dateTimeWithoutSeconds; | ||
20 | |||
21 | protected function setUp() | ||
22 | { | ||
23 | parent::setUp(); | ||
24 | |||
25 | $this->dateTime = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
26 | $this->dateTimeWithoutSeconds = new \DateTime('2010-02-03 04:05:00 UTC'); | ||
27 | } | ||
28 | |||
29 | protected function tearDown() | ||
30 | { | ||
31 | $this->dateTime = null; | ||
32 | $this->dateTimeWithoutSeconds = null; | ||
33 | } | ||
34 | |||
35 | public static function assertEquals($expected, $actual, $message = '', $delta = 0, $maxDepth = 10, $canonicalize = FALSE, $ignoreCase = FALSE) | ||
36 | { | ||
37 | if ($expected instanceof \DateTime && $actual instanceof \DateTime) { | ||
38 | $expected = $expected->format('c'); | ||
39 | $actual = $actual->format('c'); | ||
40 | } | ||
41 | |||
42 | parent::assertEquals($expected, $actual, $message, $delta, $maxDepth, $canonicalize, $ignoreCase); | ||
43 | } | ||
44 | |||
45 | public function allProvider() | ||
46 | { | ||
47 | return array( | ||
48 | array('UTC', 'UTC', '2010-02-03 04:05:06 UTC', '2010-02-03T04:05:06Z'), | ||
49 | array('UTC', 'UTC', null, ''), | ||
50 | array('America/New_York', 'Asia/Hong_Kong', '2010-02-03 04:05:06 America/New_York', '2010-02-03T17:05:06+08:00'), | ||
51 | array('America/New_York', 'Asia/Hong_Kong', null, ''), | ||
52 | array('UTC', 'Asia/Hong_Kong', '2010-02-03 04:05:06 UTC', '2010-02-03T12:05:06+08:00'), | ||
53 | array('America/New_York', 'UTC', '2010-02-03 04:05:06 America/New_York', '2010-02-03T09:05:06Z'), | ||
54 | ); | ||
55 | } | ||
56 | |||
57 | public function transformProvider() | ||
58 | { | ||
59 | return $this->allProvider(); | ||
60 | } | ||
61 | |||
62 | public function reverseTransformProvider() | ||
63 | { | ||
64 | return array_merge($this->allProvider(), array( | ||
65 | // format without seconds, as appears in some browsers | ||
66 | array('UTC', 'UTC', '2010-02-03 04:05:00 UTC', '2010-02-03T04:05Z'), | ||
67 | array('America/New_York', 'Asia/Hong_Kong', '2010-02-03 04:05:00 America/New_York', '2010-02-03T17:05+08:00'), | ||
68 | )); | ||
69 | } | ||
70 | |||
71 | /** | ||
72 | * @dataProvider transformProvider | ||
73 | */ | ||
74 | public function testTransform($fromTz, $toTz, $from, $to) | ||
75 | { | ||
76 | $transformer = new DateTimeToRfc3339Transformer($fromTz, $toTz); | ||
77 | |||
78 | $this->assertSame($to, $transformer->transform(null !== $from ? new \DateTime($from) : null)); | ||
79 | } | ||
80 | |||
81 | /** | ||
82 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
83 | */ | ||
84 | public function testTransformRequiresValidDateTime() | ||
85 | { | ||
86 | $transformer = new DateTimeToRfc3339Transformer(); | ||
87 | $transformer->transform('2010-01-01'); | ||
88 | } | ||
89 | |||
90 | /** | ||
91 | * @dataProvider reverseTransformProvider | ||
92 | */ | ||
93 | public function testReverseTransform($toTz, $fromTz, $to, $from) | ||
94 | { | ||
95 | $transformer = new DateTimeToRfc3339Transformer($toTz, $fromTz); | ||
96 | |||
97 | if (null !== $to) { | ||
98 | $this->assertDateTimeEquals(new \DateTime($to), $transformer->reverseTransform($from)); | ||
99 | } else { | ||
100 | $this->assertSame($to, $transformer->reverseTransform($from)); | ||
101 | } | ||
102 | } | ||
103 | |||
104 | /** | ||
105 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
106 | */ | ||
107 | public function testReverseTransformRequiresString() | ||
108 | { | ||
109 | $transformer = new DateTimeToRfc3339Transformer(); | ||
110 | $transformer->reverseTransform(12345); | ||
111 | } | ||
112 | |||
113 | /** | ||
114 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
115 | */ | ||
116 | public function testReverseTransformWithNonExistingDate() | ||
117 | { | ||
118 | $transformer = new DateTimeToRfc3339Transformer('UTC', 'UTC'); | ||
119 | |||
120 | $transformer->reverseTransform('2010-04-31T04:05Z'); | ||
121 | } | ||
122 | |||
123 | /** | ||
124 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
125 | */ | ||
126 | public function testReverseTransformExpectsValidDateString() | ||
127 | { | ||
128 | $transformer = new DateTimeToRfc3339Transformer('UTC', 'UTC'); | ||
129 | |||
130 | $transformer->reverseTransform('2010-2010-2010'); | ||
131 | } | ||
132 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToStringTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToStringTransformerTest.php deleted file mode 100644 index 987df1d8..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToStringTransformerTest.php +++ /dev/null | |||
@@ -1,181 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToStringTransformer; | ||
15 | |||
16 | class DateTimeToStringTransformerTest extends DateTimeTestCase | ||
17 | { | ||
18 | public function dataProvider() | ||
19 | { | ||
20 | $data = array( | ||
21 | array('Y-m-d H:i:s', '2010-02-03 16:05:06', '2010-02-03 16:05:06 UTC'), | ||
22 | array('Y-m-d H:i:00', '2010-02-03 16:05:00', '2010-02-03 16:05:00 UTC'), | ||
23 | array('Y-m-d H:i', '2010-02-03 16:05', '2010-02-03 16:05:00 UTC'), | ||
24 | array('Y-m-d H', '2010-02-03 16', '2010-02-03 16:00:00 UTC'), | ||
25 | array('Y-m-d', '2010-02-03', '2010-02-03 00:00:00 UTC'), | ||
26 | array('Y-m', '2010-12', '2010-12-01 00:00:00 UTC'), | ||
27 | array('Y', '2010', '2010-01-01 00:00:00 UTC'), | ||
28 | array('d-m-Y', '03-02-2010', '2010-02-03 00:00:00 UTC'), | ||
29 | array('H:i:s', '16:05:06', '1970-01-01 16:05:06 UTC'), | ||
30 | array('H:i:00', '16:05:00', '1970-01-01 16:05:00 UTC'), | ||
31 | array('H:i', '16:05', '1970-01-01 16:05:00 UTC'), | ||
32 | array('H', '16', '1970-01-01 16:00:00 UTC'), | ||
33 | |||
34 | // different day representations | ||
35 | array('Y-m-j', '2010-02-3', '2010-02-03 00:00:00 UTC'), | ||
36 | array('z', '33', '1970-02-03 00:00:00 UTC'), | ||
37 | |||
38 | // not bijective | ||
39 | // this will not work as php will use actual date to replace missing info | ||
40 | // and after change of date will lookup for closest Wednesday | ||
41 | // i.e. value: 2010-02, php value: 2010-02-(today i.e. 20), parsed date: 2010-02-24 | ||
42 | //array('Y-m-D', '2010-02-Wed', '2010-02-03 00:00:00 UTC'), | ||
43 | //array('Y-m-l', '2010-02-Wednesday', '2010-02-03 00:00:00 UTC'), | ||
44 | |||
45 | // different month representations | ||
46 | array('Y-n-d', '2010-2-03', '2010-02-03 00:00:00 UTC'), | ||
47 | array('Y-M-d', '2010-Feb-03', '2010-02-03 00:00:00 UTC'), | ||
48 | array('Y-F-d', '2010-February-03', '2010-02-03 00:00:00 UTC'), | ||
49 | |||
50 | // different year representations | ||
51 | array('y-m-d', '10-02-03', '2010-02-03 00:00:00 UTC'), | ||
52 | |||
53 | // different time representations | ||
54 | array('G:i:s', '16:05:06', '1970-01-01 16:05:06 UTC'), | ||
55 | array('g:i:s a', '4:05:06 pm', '1970-01-01 16:05:06 UTC'), | ||
56 | array('h:i:s a', '04:05:06 pm', '1970-01-01 16:05:06 UTC'), | ||
57 | |||
58 | // seconds since unix | ||
59 | array('U', '1265213106', '2010-02-03 16:05:06 UTC'), | ||
60 | ); | ||
61 | |||
62 | // This test will fail < 5.3.9 - see https://bugs.php.net/51994 | ||
63 | if (version_compare(phpversion(), '5.3.9', '>=')) { | ||
64 | $data[] = array('Y-z', '2010-33', '2010-02-03 00:00:00 UTC'); | ||
65 | } | ||
66 | |||
67 | return $data; | ||
68 | } | ||
69 | |||
70 | /** | ||
71 | * @dataProvider dataProvider | ||
72 | */ | ||
73 | public function testTransform($format, $output, $input) | ||
74 | { | ||
75 | $transformer = new DateTimeToStringTransformer('UTC', 'UTC', $format); | ||
76 | |||
77 | $input = new \DateTime($input); | ||
78 | |||
79 | $this->assertEquals($output, $transformer->transform($input)); | ||
80 | } | ||
81 | |||
82 | public function testTransformEmpty() | ||
83 | { | ||
84 | $transformer = new DateTimeToStringTransformer(); | ||
85 | |||
86 | $this->assertSame('', $transformer->transform(null)); | ||
87 | } | ||
88 | |||
89 | public function testTransformWithDifferentTimezones() | ||
90 | { | ||
91 | $transformer = new DateTimeToStringTransformer('Asia/Hong_Kong', 'America/New_York', 'Y-m-d H:i:s'); | ||
92 | |||
93 | $input = new \DateTime('2010-02-03 12:05:06 America/New_York'); | ||
94 | $output = $input->format('Y-m-d H:i:s'); | ||
95 | $input->setTimezone(new \DateTimeZone('Asia/Hong_Kong')); | ||
96 | |||
97 | $this->assertEquals($output, $transformer->transform($input)); | ||
98 | } | ||
99 | |||
100 | public function testTransformExpectsDateTime() | ||
101 | { | ||
102 | $transformer = new DateTimeToStringTransformer(); | ||
103 | |||
104 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
105 | |||
106 | $transformer->transform('1234'); | ||
107 | } | ||
108 | |||
109 | /** | ||
110 | * @dataProvider dataProvider | ||
111 | */ | ||
112 | public function testReverseTransformUsingPipe($format, $input, $output) | ||
113 | { | ||
114 | if (version_compare(phpversion(), '5.3.7', '<')) { | ||
115 | $this->markTestSkipped('Pipe usage requires PHP 5.3.7 or newer.'); | ||
116 | } | ||
117 | |||
118 | $reverseTransformer = new DateTimeToStringTransformer('UTC', 'UTC', $format, true); | ||
119 | |||
120 | $output = new \DateTime($output); | ||
121 | |||
122 | $this->assertDateTimeEquals($output, $reverseTransformer->reverseTransform($input)); | ||
123 | } | ||
124 | |||
125 | /** | ||
126 | * @dataProvider dataProvider | ||
127 | */ | ||
128 | public function testReverseTransformWithoutUsingPipe($format, $input, $output) | ||
129 | { | ||
130 | $reverseTransformer = new DateTimeToStringTransformer('UTC', 'UTC', $format, false); | ||
131 | |||
132 | $output = new \DateTime($output); | ||
133 | |||
134 | $this->assertDateTimeEquals($output, $reverseTransformer->reverseTransform($input)); | ||
135 | } | ||
136 | |||
137 | public function testReverseTransformEmpty() | ||
138 | { | ||
139 | $reverseTransformer = new DateTimeToStringTransformer(); | ||
140 | |||
141 | $this->assertNull($reverseTransformer->reverseTransform('')); | ||
142 | } | ||
143 | |||
144 | public function testReverseTransformWithDifferentTimezones() | ||
145 | { | ||
146 | $reverseTransformer = new DateTimeToStringTransformer('America/New_York', 'Asia/Hong_Kong', 'Y-m-d H:i:s'); | ||
147 | |||
148 | $output = new \DateTime('2010-02-03 16:05:06 Asia/Hong_Kong'); | ||
149 | $input = $output->format('Y-m-d H:i:s'); | ||
150 | $output->setTimeZone(new \DateTimeZone('America/New_York')); | ||
151 | |||
152 | $this->assertDateTimeEquals($output, $reverseTransformer->reverseTransform($input)); | ||
153 | } | ||
154 | |||
155 | public function testReverseTransformExpectsString() | ||
156 | { | ||
157 | $reverseTransformer = new DateTimeToStringTransformer(); | ||
158 | |||
159 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
160 | |||
161 | $reverseTransformer->reverseTransform(1234); | ||
162 | } | ||
163 | |||
164 | public function testReverseTransformExpectsValidDateString() | ||
165 | { | ||
166 | $reverseTransformer = new DateTimeToStringTransformer(); | ||
167 | |||
168 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
169 | |||
170 | $reverseTransformer->reverseTransform('2010-2010-2010'); | ||
171 | } | ||
172 | |||
173 | public function testReverseTransformWithNonExistingDate() | ||
174 | { | ||
175 | $reverseTransformer = new DateTimeToStringTransformer(); | ||
176 | |||
177 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
178 | |||
179 | $reverseTransformer->reverseTransform('2010-04-31'); | ||
180 | } | ||
181 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToTimestampTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToTimestampTransformerTest.php deleted file mode 100644 index b54f0c4c..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/DateTimeToTimestampTransformerTest.php +++ /dev/null | |||
@@ -1,104 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\DateTimeToTimestampTransformer; | ||
15 | |||
16 | class DateTimeToTimestampTransformerTest extends DateTimeTestCase | ||
17 | { | ||
18 | public function testTransform() | ||
19 | { | ||
20 | $transformer = new DateTimeToTimestampTransformer('UTC', 'UTC'); | ||
21 | |||
22 | $input = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
23 | $output = $input->format('U'); | ||
24 | |||
25 | $this->assertEquals($output, $transformer->transform($input)); | ||
26 | } | ||
27 | |||
28 | public function testTransformEmpty() | ||
29 | { | ||
30 | $transformer = new DateTimeToTimestampTransformer(); | ||
31 | |||
32 | $this->assertNull($transformer->transform(null)); | ||
33 | } | ||
34 | |||
35 | public function testTransformWithDifferentTimezones() | ||
36 | { | ||
37 | $transformer = new DateTimeToTimestampTransformer('Asia/Hong_Kong', 'America/New_York'); | ||
38 | |||
39 | $input = new \DateTime('2010-02-03 04:05:06 America/New_York'); | ||
40 | $output = $input->format('U'); | ||
41 | $input->setTimezone(new \DateTimeZone('Asia/Hong_Kong')); | ||
42 | |||
43 | $this->assertEquals($output, $transformer->transform($input)); | ||
44 | } | ||
45 | |||
46 | public function testTransformFromDifferentTimezone() | ||
47 | { | ||
48 | $transformer = new DateTimeToTimestampTransformer('Asia/Hong_Kong', 'UTC'); | ||
49 | |||
50 | $input = new \DateTime('2010-02-03 04:05:06 Asia/Hong_Kong'); | ||
51 | |||
52 | $dateTime = clone $input; | ||
53 | $dateTime->setTimezone(new \DateTimeZone('UTC')); | ||
54 | $output = $dateTime->format('U'); | ||
55 | |||
56 | $this->assertEquals($output, $transformer->transform($input)); | ||
57 | } | ||
58 | |||
59 | public function testTransformExpectsDateTime() | ||
60 | { | ||
61 | $transformer = new DateTimeToTimestampTransformer(); | ||
62 | |||
63 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
64 | |||
65 | $transformer->transform('1234'); | ||
66 | } | ||
67 | |||
68 | public function testReverseTransform() | ||
69 | { | ||
70 | $reverseTransformer = new DateTimeToTimestampTransformer('UTC', 'UTC'); | ||
71 | |||
72 | $output = new \DateTime('2010-02-03 04:05:06 UTC'); | ||
73 | $input = $output->format('U'); | ||
74 | |||
75 | $this->assertDateTimeEquals($output, $reverseTransformer->reverseTransform($input)); | ||
76 | } | ||
77 | |||
78 | public function testReverseTransformEmpty() | ||
79 | { | ||
80 | $reverseTransformer = new DateTimeToTimestampTransformer(); | ||
81 | |||
82 | $this->assertNull($reverseTransformer->reverseTransform(null)); | ||
83 | } | ||
84 | |||
85 | public function testReverseTransformWithDifferentTimezones() | ||
86 | { | ||
87 | $reverseTransformer = new DateTimeToTimestampTransformer('Asia/Hong_Kong', 'America/New_York'); | ||
88 | |||
89 | $output = new \DateTime('2010-02-03 04:05:06 America/New_York'); | ||
90 | $input = $output->format('U'); | ||
91 | $output->setTimezone(new \DateTimeZone('Asia/Hong_Kong')); | ||
92 | |||
93 | $this->assertDateTimeEquals($output, $reverseTransformer->reverseTransform($input)); | ||
94 | } | ||
95 | |||
96 | public function testReverseTransformExpectsValidTimestamp() | ||
97 | { | ||
98 | $reverseTransformer = new DateTimeToTimestampTransformer(); | ||
99 | |||
100 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
101 | |||
102 | $reverseTransformer->reverseTransform('2010-2010-2010'); | ||
103 | } | ||
104 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/IntegerToLocalizedStringTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/IntegerToLocalizedStringTransformerTest.php deleted file mode 100644 index a90fa91b..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/IntegerToLocalizedStringTransformerTest.php +++ /dev/null | |||
@@ -1,115 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\IntegerToLocalizedStringTransformer; | ||
15 | use Symfony\Component\Intl\Util\IntlTestHelper; | ||
16 | |||
17 | class IntegerToLocalizedStringTransformerTest extends \PHPUnit_Framework_TestCase | ||
18 | { | ||
19 | protected function setUp() | ||
20 | { | ||
21 | parent::setUp(); | ||
22 | |||
23 | // Since we test against "de_AT", we need the full implementation | ||
24 | IntlTestHelper::requireFullIntl($this); | ||
25 | |||
26 | \Locale::setDefault('de_AT'); | ||
27 | } | ||
28 | |||
29 | public function testReverseTransform() | ||
30 | { | ||
31 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
32 | |||
33 | $this->assertEquals(1, $transformer->reverseTransform('1')); | ||
34 | $this->assertEquals(1, $transformer->reverseTransform('1,5')); | ||
35 | $this->assertEquals(1234, $transformer->reverseTransform('1234,5')); | ||
36 | $this->assertEquals(12345, $transformer->reverseTransform('12345,912')); | ||
37 | } | ||
38 | |||
39 | public function testReverseTransformEmpty() | ||
40 | { | ||
41 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
42 | |||
43 | $this->assertNull($transformer->reverseTransform('')); | ||
44 | } | ||
45 | |||
46 | public function testReverseTransformWithGrouping() | ||
47 | { | ||
48 | $transformer = new IntegerToLocalizedStringTransformer(null, true); | ||
49 | |||
50 | $this->assertEquals(1234, $transformer->reverseTransform('1.234,5')); | ||
51 | $this->assertEquals(12345, $transformer->reverseTransform('12.345,912')); | ||
52 | $this->assertEquals(1234, $transformer->reverseTransform('1234,5')); | ||
53 | $this->assertEquals(12345, $transformer->reverseTransform('12345,912')); | ||
54 | } | ||
55 | |||
56 | /** | ||
57 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
58 | */ | ||
59 | public function testReverseTransformExpectsString() | ||
60 | { | ||
61 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
62 | |||
63 | $transformer->reverseTransform(1); | ||
64 | } | ||
65 | |||
66 | /** | ||
67 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
68 | */ | ||
69 | public function testReverseTransformExpectsValidNumber() | ||
70 | { | ||
71 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
72 | |||
73 | $transformer->reverseTransform('foo'); | ||
74 | } | ||
75 | |||
76 | /** | ||
77 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
78 | */ | ||
79 | public function testReverseTransformDisallowsNaN() | ||
80 | { | ||
81 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
82 | |||
83 | $transformer->reverseTransform('NaN'); | ||
84 | } | ||
85 | |||
86 | /** | ||
87 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
88 | */ | ||
89 | public function testReverseTransformDisallowsNaN2() | ||
90 | { | ||
91 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
92 | |||
93 | $transformer->reverseTransform('nan'); | ||
94 | } | ||
95 | |||
96 | /** | ||
97 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
98 | */ | ||
99 | public function testReverseTransformDisallowsInfinity() | ||
100 | { | ||
101 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
102 | |||
103 | $transformer->reverseTransform('∞'); | ||
104 | } | ||
105 | |||
106 | /** | ||
107 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
108 | */ | ||
109 | public function testReverseTransformDisallowsNegativeInfinity() | ||
110 | { | ||
111 | $transformer = new IntegerToLocalizedStringTransformer(); | ||
112 | |||
113 | $transformer->reverseTransform('-∞'); | ||
114 | } | ||
115 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/MoneyToLocalizedStringTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/MoneyToLocalizedStringTransformerTest.php deleted file mode 100644 index 8b91fe10..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/MoneyToLocalizedStringTransformerTest.php +++ /dev/null | |||
@@ -1,74 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\MoneyToLocalizedStringTransformer; | ||
15 | use Symfony\Component\Intl\Util\IntlTestHelper; | ||
16 | |||
17 | class MoneyToLocalizedStringTransformerTest extends \PHPUnit_Framework_TestCase | ||
18 | { | ||
19 | protected function setUp() | ||
20 | { | ||
21 | parent::setUp(); | ||
22 | |||
23 | // Since we test against "de_AT", we need the full implementation | ||
24 | IntlTestHelper::requireFullIntl($this); | ||
25 | |||
26 | \Locale::setDefault('de_AT'); | ||
27 | } | ||
28 | |||
29 | public function testTransform() | ||
30 | { | ||
31 | $transformer = new MoneyToLocalizedStringTransformer(null, null, null, 100); | ||
32 | |||
33 | $this->assertEquals('1,23', $transformer->transform(123)); | ||
34 | } | ||
35 | |||
36 | public function testTransformExpectsNumeric() | ||
37 | { | ||
38 | $transformer = new MoneyToLocalizedStringTransformer(null, null, null, 100); | ||
39 | |||
40 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
41 | |||
42 | $transformer->transform('abcd'); | ||
43 | } | ||
44 | |||
45 | public function testTransformEmpty() | ||
46 | { | ||
47 | $transformer = new MoneyToLocalizedStringTransformer(); | ||
48 | |||
49 | $this->assertSame('', $transformer->transform(null)); | ||
50 | } | ||
51 | |||
52 | public function testReverseTransform() | ||
53 | { | ||
54 | $transformer = new MoneyToLocalizedStringTransformer(null, null, null, 100); | ||
55 | |||
56 | $this->assertEquals(123, $transformer->reverseTransform('1,23')); | ||
57 | } | ||
58 | |||
59 | public function testReverseTransformExpectsString() | ||
60 | { | ||
61 | $transformer = new MoneyToLocalizedStringTransformer(null, null, null, 100); | ||
62 | |||
63 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
64 | |||
65 | $transformer->reverseTransform(12345); | ||
66 | } | ||
67 | |||
68 | public function testReverseTransformEmpty() | ||
69 | { | ||
70 | $transformer = new MoneyToLocalizedStringTransformer(); | ||
71 | |||
72 | $this->assertNull($transformer->reverseTransform('')); | ||
73 | } | ||
74 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/NumberToLocalizedStringTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/NumberToLocalizedStringTransformerTest.php deleted file mode 100644 index c58e3f60..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/NumberToLocalizedStringTransformerTest.php +++ /dev/null | |||
@@ -1,393 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\NumberToLocalizedStringTransformer; | ||
15 | use Symfony\Component\Intl\Util\IntlTestHelper; | ||
16 | |||
17 | class NumberToLocalizedStringTransformerTest extends \PHPUnit_Framework_TestCase | ||
18 | { | ||
19 | protected function setUp() | ||
20 | { | ||
21 | parent::setUp(); | ||
22 | |||
23 | // Since we test against "de_AT", we need the full implementation | ||
24 | IntlTestHelper::requireFullIntl($this); | ||
25 | |||
26 | \Locale::setDefault('de_AT'); | ||
27 | } | ||
28 | |||
29 | public function provideTransformations() | ||
30 | { | ||
31 | return array( | ||
32 | array(null, '', 'de_AT'), | ||
33 | array(1, '1', 'de_AT'), | ||
34 | array(1.5, '1,5', 'de_AT'), | ||
35 | array(1234.5, '1234,5', 'de_AT'), | ||
36 | array(12345.912, '12345,912', 'de_AT'), | ||
37 | array(1234.5, '1234,5', 'ru'), | ||
38 | array(1234.5, '1234,5', 'fi'), | ||
39 | ); | ||
40 | } | ||
41 | |||
42 | /** | ||
43 | * @dataProvider provideTransformations | ||
44 | */ | ||
45 | public function testTransform($from, $to, $locale) | ||
46 | { | ||
47 | \Locale::setDefault($locale); | ||
48 | |||
49 | $transformer = new NumberToLocalizedStringTransformer(); | ||
50 | |||
51 | $this->assertSame($to, $transformer->transform($from)); | ||
52 | } | ||
53 | |||
54 | public function provideTransformationsWithGrouping() | ||
55 | { | ||
56 | return array( | ||
57 | array(1234.5, '1.234,5', 'de_AT'), | ||
58 | array(12345.912, '12.345,912', 'de_AT'), | ||
59 | array(1234.5, '1 234,5', 'fr'), | ||
60 | array(1234.5, '1 234,5', 'ru'), | ||
61 | array(1234.5, '1 234,5', 'fi'), | ||
62 | ); | ||
63 | } | ||
64 | |||
65 | /** | ||
66 | * @dataProvider provideTransformationsWithGrouping | ||
67 | */ | ||
68 | public function testTransformWithGrouping($from, $to, $locale) | ||
69 | { | ||
70 | \Locale::setDefault($locale); | ||
71 | |||
72 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
73 | |||
74 | $this->assertSame($to, $transformer->transform($from)); | ||
75 | } | ||
76 | |||
77 | public function testTransformWithPrecision() | ||
78 | { | ||
79 | $transformer = new NumberToLocalizedStringTransformer(2); | ||
80 | |||
81 | $this->assertEquals('1234,50', $transformer->transform(1234.5)); | ||
82 | $this->assertEquals('678,92', $transformer->transform(678.916)); | ||
83 | } | ||
84 | |||
85 | public function testTransformWithRoundingMode() | ||
86 | { | ||
87 | $transformer = new NumberToLocalizedStringTransformer(null, null, NumberToLocalizedStringTransformer::ROUND_DOWN); | ||
88 | $this->assertEquals('1234,547', $transformer->transform(1234.547), '->transform() only applies rounding mode if precision set'); | ||
89 | |||
90 | $transformer = new NumberToLocalizedStringTransformer(2, null, NumberToLocalizedStringTransformer::ROUND_DOWN); | ||
91 | $this->assertEquals('1234,54', $transformer->transform(1234.547), '->transform() rounding-mode works'); | ||
92 | |||
93 | } | ||
94 | |||
95 | /** | ||
96 | * @dataProvider provideTransformations | ||
97 | */ | ||
98 | public function testReverseTransform($to, $from, $locale) | ||
99 | { | ||
100 | \Locale::setDefault($locale); | ||
101 | |||
102 | $transformer = new NumberToLocalizedStringTransformer(); | ||
103 | |||
104 | $this->assertEquals($to, $transformer->reverseTransform($from)); | ||
105 | } | ||
106 | |||
107 | /** | ||
108 | * @dataProvider provideTransformationsWithGrouping | ||
109 | */ | ||
110 | public function testReverseTransformWithGrouping($to, $from, $locale) | ||
111 | { | ||
112 | \Locale::setDefault($locale); | ||
113 | |||
114 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
115 | |||
116 | $this->assertEquals($to, $transformer->reverseTransform($from)); | ||
117 | } | ||
118 | |||
119 | // https://github.com/symfony/symfony/issues/7609 | ||
120 | public function testReverseTransformWithGroupingAndFixedSpaces() | ||
121 | { | ||
122 | if (!extension_loaded('mbstring')) { | ||
123 | $this->markTestSkipped('The "mbstring" extension is required for this test.'); | ||
124 | } | ||
125 | |||
126 | \Locale::setDefault('ru'); | ||
127 | |||
128 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
129 | |||
130 | $this->assertEquals(1234.5, $transformer->reverseTransform("1\xc2\xa0234,5")); | ||
131 | } | ||
132 | |||
133 | public function testReverseTransformWithGroupingButWithoutGroupSeparator() | ||
134 | { | ||
135 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
136 | |||
137 | // omit group separator | ||
138 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234,5')); | ||
139 | $this->assertEquals(12345.912, $transformer->reverseTransform('12345,912')); | ||
140 | } | ||
141 | |||
142 | public function testDecimalSeparatorMayBeDotIfGroupingSeparatorIsNotDot() | ||
143 | { | ||
144 | \Locale::setDefault('fr'); | ||
145 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
146 | |||
147 | // completely valid format | ||
148 | $this->assertEquals(1234.5, $transformer->reverseTransform('1 234,5')); | ||
149 | // accept dots | ||
150 | $this->assertEquals(1234.5, $transformer->reverseTransform('1 234.5')); | ||
151 | // omit group separator | ||
152 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234,5')); | ||
153 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234.5')); | ||
154 | } | ||
155 | |||
156 | /** | ||
157 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
158 | */ | ||
159 | public function testDecimalSeparatorMayNotBeDotIfGroupingSeparatorIsDot() | ||
160 | { | ||
161 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
162 | |||
163 | $transformer->reverseTransform('1.234.5'); | ||
164 | } | ||
165 | |||
166 | /** | ||
167 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
168 | */ | ||
169 | public function testDecimalSeparatorMayNotBeDotIfGroupingSeparatorIsDotWithNoGroupSep() | ||
170 | { | ||
171 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
172 | |||
173 | $transformer->reverseTransform('1234.5'); | ||
174 | } | ||
175 | |||
176 | public function testDecimalSeparatorMayBeDotIfGroupingSeparatorIsDotButNoGroupingUsed() | ||
177 | { | ||
178 | \Locale::setDefault('fr'); | ||
179 | $transformer = new NumberToLocalizedStringTransformer(); | ||
180 | |||
181 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234,5')); | ||
182 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234.5')); | ||
183 | } | ||
184 | |||
185 | public function testDecimalSeparatorMayBeCommaIfGroupingSeparatorIsNotComma() | ||
186 | { | ||
187 | \Locale::setDefault('bg'); | ||
188 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
189 | |||
190 | // completely valid format | ||
191 | $this->assertEquals(1234.5, $transformer->reverseTransform('1 234.5')); | ||
192 | // accept commas | ||
193 | $this->assertEquals(1234.5, $transformer->reverseTransform('1 234,5')); | ||
194 | // omit group separator | ||
195 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234.5')); | ||
196 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234,5')); | ||
197 | } | ||
198 | |||
199 | /** | ||
200 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
201 | */ | ||
202 | public function testDecimalSeparatorMayNotBeCommaIfGroupingSeparatorIsComma() | ||
203 | { | ||
204 | \Locale::setDefault('en'); | ||
205 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
206 | |||
207 | $transformer->reverseTransform('1,234,5'); | ||
208 | } | ||
209 | |||
210 | /** | ||
211 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
212 | */ | ||
213 | public function testDecimalSeparatorMayNotBeCommaIfGroupingSeparatorIsCommaWithNoGroupSep() | ||
214 | { | ||
215 | \Locale::setDefault('en'); | ||
216 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
217 | |||
218 | $transformer->reverseTransform('1234,5'); | ||
219 | } | ||
220 | |||
221 | public function testDecimalSeparatorMayBeCommaIfGroupingSeparatorIsCommaButNoGroupingUsed() | ||
222 | { | ||
223 | \Locale::setDefault('en'); | ||
224 | $transformer = new NumberToLocalizedStringTransformer(); | ||
225 | |||
226 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234,5')); | ||
227 | $this->assertEquals(1234.5, $transformer->reverseTransform('1234.5')); | ||
228 | } | ||
229 | |||
230 | /** | ||
231 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
232 | */ | ||
233 | public function testTransformExpectsNumeric() | ||
234 | { | ||
235 | $transformer = new NumberToLocalizedStringTransformer(); | ||
236 | |||
237 | $transformer->transform('foo'); | ||
238 | } | ||
239 | |||
240 | /** | ||
241 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
242 | */ | ||
243 | public function testReverseTransformExpectsString() | ||
244 | { | ||
245 | $transformer = new NumberToLocalizedStringTransformer(); | ||
246 | |||
247 | $transformer->reverseTransform(1); | ||
248 | } | ||
249 | |||
250 | /** | ||
251 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
252 | */ | ||
253 | public function testReverseTransformExpectsValidNumber() | ||
254 | { | ||
255 | $transformer = new NumberToLocalizedStringTransformer(); | ||
256 | |||
257 | $transformer->reverseTransform('foo'); | ||
258 | } | ||
259 | |||
260 | /** | ||
261 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
262 | * @link https://github.com/symfony/symfony/issues/3161 | ||
263 | */ | ||
264 | public function testReverseTransformDisallowsNaN() | ||
265 | { | ||
266 | $transformer = new NumberToLocalizedStringTransformer(); | ||
267 | |||
268 | $transformer->reverseTransform('NaN'); | ||
269 | } | ||
270 | |||
271 | /** | ||
272 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
273 | */ | ||
274 | public function testReverseTransformDisallowsNaN2() | ||
275 | { | ||
276 | $transformer = new NumberToLocalizedStringTransformer(); | ||
277 | |||
278 | $transformer->reverseTransform('nan'); | ||
279 | } | ||
280 | |||
281 | /** | ||
282 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
283 | */ | ||
284 | public function testReverseTransformDisallowsInfinity() | ||
285 | { | ||
286 | $transformer = new NumberToLocalizedStringTransformer(); | ||
287 | |||
288 | $transformer->reverseTransform('∞'); | ||
289 | } | ||
290 | |||
291 | /** | ||
292 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
293 | */ | ||
294 | public function testReverseTransformDisallowsInfinity2() | ||
295 | { | ||
296 | $transformer = new NumberToLocalizedStringTransformer(); | ||
297 | |||
298 | $transformer->reverseTransform('∞,123'); | ||
299 | } | ||
300 | |||
301 | /** | ||
302 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
303 | */ | ||
304 | public function testReverseTransformDisallowsNegativeInfinity() | ||
305 | { | ||
306 | $transformer = new NumberToLocalizedStringTransformer(); | ||
307 | |||
308 | $transformer->reverseTransform('-∞'); | ||
309 | } | ||
310 | |||
311 | /** | ||
312 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
313 | */ | ||
314 | public function testReverseTransformDisallowsLeadingExtraCharacters() | ||
315 | { | ||
316 | $transformer = new NumberToLocalizedStringTransformer(); | ||
317 | |||
318 | $transformer->reverseTransform('foo123'); | ||
319 | } | ||
320 | |||
321 | /** | ||
322 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
323 | * @expectedExceptionMessage The number contains unrecognized characters: "foo3" | ||
324 | */ | ||
325 | public function testReverseTransformDisallowsCenteredExtraCharacters() | ||
326 | { | ||
327 | $transformer = new NumberToLocalizedStringTransformer(); | ||
328 | |||
329 | $transformer->reverseTransform('12foo3'); | ||
330 | } | ||
331 | |||
332 | /** | ||
333 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
334 | * @expectedExceptionMessage The number contains unrecognized characters: "foo8" | ||
335 | */ | ||
336 | public function testReverseTransformDisallowsCenteredExtraCharactersMultibyte() | ||
337 | { | ||
338 | if (!extension_loaded('mbstring')) { | ||
339 | $this->markTestSkipped('The "mbstring" extension is required for this test.'); | ||
340 | } | ||
341 | |||
342 | \Locale::setDefault('ru'); | ||
343 | |||
344 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
345 | |||
346 | $transformer->reverseTransform("12\xc2\xa0345,67foo8"); | ||
347 | } | ||
348 | |||
349 | /** | ||
350 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
351 | * @expectedExceptionMessage The number contains unrecognized characters: "foo8" | ||
352 | */ | ||
353 | public function testReverseTransformIgnoresTrailingSpacesInExceptionMessage() | ||
354 | { | ||
355 | if (!extension_loaded('mbstring')) { | ||
356 | $this->markTestSkipped('The "mbstring" extension is required for this test.'); | ||
357 | } | ||
358 | |||
359 | \Locale::setDefault('ru'); | ||
360 | |||
361 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
362 | |||
363 | $transformer->reverseTransform("12\xc2\xa0345,67foo8 \xc2\xa0\t"); | ||
364 | } | ||
365 | |||
366 | /** | ||
367 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
368 | * @expectedExceptionMessage The number contains unrecognized characters: "foo" | ||
369 | */ | ||
370 | public function testReverseTransformDisallowsTrailingExtraCharacters() | ||
371 | { | ||
372 | $transformer = new NumberToLocalizedStringTransformer(); | ||
373 | |||
374 | $transformer->reverseTransform('123foo'); | ||
375 | } | ||
376 | |||
377 | /** | ||
378 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
379 | * @expectedExceptionMessage The number contains unrecognized characters: "foo" | ||
380 | */ | ||
381 | public function testReverseTransformDisallowsTrailingExtraCharactersMultibyte() | ||
382 | { | ||
383 | if (!extension_loaded('mbstring')) { | ||
384 | $this->markTestSkipped('The "mbstring" extension is required for this test.'); | ||
385 | } | ||
386 | |||
387 | \Locale::setDefault('ru'); | ||
388 | |||
389 | $transformer = new NumberToLocalizedStringTransformer(null, true); | ||
390 | |||
391 | $transformer->reverseTransform("12\xc2\xa0345,678foo"); | ||
392 | } | ||
393 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/PercentToLocalizedStringTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/PercentToLocalizedStringTransformerTest.php deleted file mode 100644 index 104941c9..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/PercentToLocalizedStringTransformerTest.php +++ /dev/null | |||
@@ -1,114 +0,0 @@ | |||
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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\PercentToLocalizedStringTransformer; | ||
15 | use Symfony\Component\Intl\Util\IntlTestHelper; | ||
16 | |||
17 | class PercentToLocalizedStringTransformerTest extends \PHPUnit_Framework_TestCase | ||
18 | { | ||
19 | protected function setUp() | ||
20 | { | ||
21 | parent::setUp(); | ||
22 | |||
23 | // Since we test against "de_AT", we need the full implementation | ||
24 | IntlTestHelper::requireFullIntl($this); | ||
25 | |||
26 | \Locale::setDefault('de_AT'); | ||
27 | } | ||
28 | |||
29 | public function testTransform() | ||
30 | { | ||
31 | $transformer = new PercentToLocalizedStringTransformer(); | ||
32 | |||
33 | $this->assertEquals('10', $transformer->transform(0.1)); | ||
34 | $this->assertEquals('15', $transformer->transform(0.15)); | ||
35 | $this->assertEquals('12', $transformer->transform(0.1234)); | ||
36 | $this->assertEquals('200', $transformer->transform(2)); | ||
37 | } | ||
38 | |||
39 | public function testTransformEmpty() | ||
40 | { | ||
41 | $transformer = new PercentToLocalizedStringTransformer(); | ||
42 | |||
43 | $this->assertEquals('', $transformer->transform(null)); | ||
44 | } | ||
45 | |||
46 | public function testTransformWithInteger() | ||
47 | { | ||
48 | $transformer = new PercentToLocalizedStringTransformer(null, 'integer'); | ||
49 | |||
50 | $this->assertEquals('0', $transformer->transform(0.1)); | ||
51 | $this->assertEquals('1', $transformer->transform(1)); | ||
52 | $this->assertEquals('15', $transformer->transform(15)); | ||
53 | $this->assertEquals('16', $transformer->transform(15.9)); | ||
54 | } | ||
55 | |||
56 | public function testTransformWithPrecision() | ||
57 | { | ||
58 | $transformer = new PercentToLocalizedStringTransformer(2); | ||
59 | |||
60 | $this->assertEquals('12,34', $transformer->transform(0.1234)); | ||
61 | } | ||
62 | |||
63 | public function testReverseTransform() | ||
64 | { | ||
65 | $transformer = new PercentToLocalizedStringTransformer(); | ||
66 | |||
67 | $this->assertEquals(0.1, $transformer->reverseTransform('10')); | ||
68 | $this->assertEquals(0.15, $transformer->reverseTransform('15')); | ||
69 | $this->assertEquals(0.12, $transformer->reverseTransform('12')); | ||
70 | $this->assertEquals(2, $transformer->reverseTransform('200')); | ||
71 | } | ||
72 | |||
73 | public function testReverseTransformEmpty() | ||
74 | { | ||
75 | $transformer = new PercentToLocalizedStringTransformer(); | ||
76 | |||
77 | $this->assertNull($transformer->reverseTransform('')); | ||
78 | } | ||
79 | |||
80 | public function testReverseTransformWithInteger() | ||
81 | { | ||
82 | $transformer = new PercentToLocalizedStringTransformer(null, 'integer'); | ||
83 | |||
84 | $this->assertEquals(10, $transformer->reverseTransform('10')); | ||
85 | $this->assertEquals(15, $transformer->reverseTransform('15')); | ||
86 | $this->assertEquals(12, $transformer->reverseTransform('12')); | ||
87 | $this->assertEquals(200, $transformer->reverseTransform('200')); | ||
88 | } | ||
89 | |||
90 | public function testReverseTransformWithPrecision() | ||
91 | { | ||
92 | $transformer = new PercentToLocalizedStringTransformer(2); | ||
93 | |||
94 | $this->assertEquals(0.1234, $transformer->reverseTransform('12,34')); | ||
95 | } | ||
96 | |||
97 | public function testTransformExpectsNumeric() | ||
98 | { | ||
99 | $transformer = new PercentToLocalizedStringTransformer(); | ||
100 | |||
101 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
102 | |||
103 | $transformer->transform('foo'); | ||
104 | } | ||
105 | |||
106 | public function testReverseTransformExpectsString() | ||
107 | { | ||
108 | $transformer = new PercentToLocalizedStringTransformer(); | ||
109 | |||
110 | $this->setExpectedException('Symfony\Component\Form\Exception\TransformationFailedException'); | ||
111 | |||
112 | $transformer->reverseTransform(1); | ||
113 | } | ||
114 | } | ||
diff --git a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ValueToDuplicatesTransformerTest.php b/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ValueToDuplicatesTransformerTest.php deleted file mode 100644 index 2c5298da..00000000 --- a/vendor/symfony/form/Symfony/Component/Form/Tests/Extension/Core/DataTransformer/ValueToDuplicatesTransformerTest.php +++ /dev/null | |||
@@ -1,120 +0,0 @@ | |||
1 | <?php | ||
2 | |||
3 | /* | ||
4 | * This file is part of the Symfony package. | ||
5 | * | ||
6 | * (c) Fabien Potencier <fabien.potencier@symfony-project.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\Form\Tests\Extension\Core\DataTransformer; | ||
13 | |||
14 | use Symfony\Component\Form\Extension\Core\DataTransformer\ValueToDuplicatesTransformer; | ||
15 | |||
16 | class ValueToDuplicatesTransformerTest extends \PHPUnit_Framework_TestCase | ||
17 | { | ||
18 | private $transformer; | ||
19 | |||
20 | protected function setUp() | ||
21 | { | ||
22 | $this->transformer = new ValueToDuplicatesTransformer(array('a', 'b', 'c')); | ||
23 | } | ||
24 | |||
25 | protected function tearDown() | ||
26 | { | ||
27 | $this->transformer = null; | ||
28 | } | ||
29 | |||
30 | public function testTransform() | ||
31 | { | ||
32 | $output = array( | ||
33 | 'a' => 'Foo', | ||
34 | 'b' => 'Foo', | ||
35 | 'c' => 'Foo', | ||
36 | ); | ||
37 | |||
38 | $this->assertSame($output, $this->transformer->transform('Foo')); | ||
39 | } | ||
40 | |||
41 | public function testTransformEmpty() | ||
42 | { | ||
43 | $output = array( | ||
44 | 'a' => null, | ||
45 | 'b' => null, | ||
46 | 'c' => null, | ||
47 | ); | ||
48 | |||
49 | $this->assertSame($output, $this->transformer->transform(null)); | ||
50 | } | ||
51 | |||
52 | public function testReverseTransform() | ||
53 | { | ||
54 | $input = array( | ||
55 | 'a' => 'Foo', | ||
56 | 'b' => 'Foo', | ||
57 | 'c' => 'Foo', | ||
58 | ); | ||
59 | |||
60 | $this->assertSame('Foo', $this->transformer->reverseTransform($input)); | ||
61 | } | ||
62 | |||
63 | public function testReverseTransformCompletelyEmpty() | ||
64 | { | ||
65 | $input = array( | ||
66 | 'a' => '', | ||
67 | 'b' => '', | ||
68 | 'c' => '', | ||
69 | ); | ||
70 | |||
71 | $this->assertNull($this->transformer->reverseTransform($input)); | ||
72 | } | ||
73 | |||
74 | public function testReverseTransformCompletelyNull() | ||
75 | { | ||
76 | $input = array( | ||
77 | 'a' => null, | ||
78 | 'b' => null, | ||
79 | 'c' => null, | ||
80 | ); | ||
81 | |||
82 | $this->assertNull($this->transformer->reverseTransform($input)); | ||
83 | } | ||
84 | |||
85 | /** | ||
86 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
87 | */ | ||
88 | public function testReverseTransformPartiallyNull() | ||
89 | { | ||
90 | $input = array( | ||
91 | 'a' => 'Foo', | ||
92 | 'b' => 'Foo', | ||
93 | 'c' => null, | ||
94 | ); | ||
95 | |||
96 | $this->transformer->reverseTransform($input); | ||
97 | } | ||
98 | |||
99 | /** | ||
100 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
101 | */ | ||
102 | public function testReverseTransformDifferences() | ||
103 | { | ||
104 | $input = array( | ||
105 | 'a' => 'Foo', | ||
106 | 'b' => 'Bar', | ||
107 | 'c' => 'Foo', | ||
108 | ); | ||
109 | |||
110 | $this->transformer->reverseTransform($input); | ||
111 | } | ||
112 | |||
113 | /** | ||
114 | * @expectedException \Symfony\Component\Form\Exception\TransformationFailedException | ||
115 | */ | ||
116 | public function testReverseTransformRequiresArray() | ||
117 | { | ||
118 | $this->transformer->reverseTransform('12345'); | ||
119 | } | ||
120 | } | ||