1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
declare( strict_types = 1 ); |
4
|
|
|
|
5
|
|
|
namespace Tests\DataValues\Geo\Formatters; |
6
|
|
|
|
7
|
|
|
use DataValues\Geo\Formatters\LatLongFormatter; |
8
|
|
|
use DataValues\Geo\Parsers\LatLongParser; |
9
|
|
|
use DataValues\Geo\Values\LatLongValue; |
10
|
|
|
use DataValues\StringValue; |
11
|
|
|
use InvalidArgumentException; |
12
|
|
|
use PHPUnit\Framework\TestCase; |
13
|
|
|
use ValueFormatters\FormatterOptions; |
14
|
|
|
|
15
|
|
|
/** |
16
|
|
|
* @covers \DataValues\Geo\Formatters\LatLongFormatter |
17
|
|
|
* |
18
|
|
|
* @group ValueFormatters |
19
|
|
|
* @group DataValueExtensions |
20
|
|
|
* |
21
|
|
|
* @license GPL-2.0-or-later |
22
|
|
|
* @author Jeroen De Dauw < [email protected] > |
23
|
|
|
* @author Addshore |
24
|
|
|
* @author Daniel Kinzler |
25
|
|
|
*/ |
26
|
|
|
class LatLongFormatterTest extends TestCase { |
27
|
|
|
|
28
|
|
|
public function floatNotationProvider() { |
29
|
|
|
return [ |
30
|
|
|
'0, degree' => [ |
31
|
|
|
new LatLongValue( 0, 0 ), |
32
|
|
|
1, |
33
|
|
|
'0, 0' |
34
|
|
|
], |
35
|
|
|
'negative zero' => [ |
36
|
|
|
new LatLongValue( -0.25, 0.25 ), |
37
|
|
|
1, |
38
|
|
|
'0, 0' |
39
|
|
|
], |
40
|
|
|
'signed, minute' => [ |
41
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
42
|
|
|
1 / 60, |
43
|
|
|
'-55.75, 37.25' |
44
|
|
|
], |
45
|
|
|
'signed, degree' => [ |
46
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
47
|
|
|
1, |
48
|
|
|
'-56, 37' |
49
|
|
|
], |
50
|
|
|
'three degrees' => [ |
51
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
52
|
|
|
3, |
53
|
|
|
'-57, 36' |
54
|
|
|
], |
55
|
|
|
'seven degrees' => [ |
56
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
57
|
|
|
7, |
58
|
|
|
'-56, 35' |
59
|
|
|
], |
60
|
|
|
'ten degrees' => [ |
61
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
62
|
|
|
10, |
63
|
|
|
'-60, 40' |
64
|
|
|
], |
65
|
|
|
'rounding degrees down' => [ |
66
|
|
|
new LatLongValue( -14.9, 14.9 ), |
67
|
|
|
10, |
68
|
|
|
'-10, 10' |
69
|
|
|
], |
70
|
|
|
'rounding degrees up' => [ |
71
|
|
|
new LatLongValue( -15, 15 ), |
72
|
|
|
10, |
73
|
|
|
'-20, 20' |
74
|
|
|
], |
75
|
|
|
'rounding fractions down' => [ |
76
|
|
|
new LatLongValue( -0.049, 0.049 ), |
77
|
|
|
0.1, |
78
|
|
|
'0, 0' |
79
|
|
|
], |
80
|
|
|
'rounding fractions up' => [ |
81
|
|
|
new LatLongValue( -0.05, 0.05 ), |
82
|
|
|
0.1, |
83
|
|
|
'-0.1, 0.1' |
84
|
|
|
], |
85
|
|
|
'precision option must support strings' => [ |
86
|
|
|
new LatLongValue( -0.05, 0.05 ), |
87
|
|
|
'0.1', |
88
|
|
|
'-0.1, 0.1' |
89
|
|
|
], |
90
|
|
|
]; |
91
|
|
|
} |
92
|
|
|
|
93
|
|
|
/** |
94
|
|
|
* @param string $format One of the LatLongFormatter::TYPE_… constants |
95
|
|
|
* @param float|int $precision |
96
|
|
|
* |
97
|
|
|
* @return FormatterOptions |
98
|
|
|
*/ |
99
|
|
|
private function makeOptions( $format, $precision ) { |
100
|
|
|
$options = new FormatterOptions(); |
101
|
|
|
$options->setOption( LatLongFormatter::OPT_FORMAT, $format ); |
102
|
|
|
$options->setOption( LatLongFormatter::OPT_DIRECTIONAL, false ); |
103
|
|
|
$options->setOption( LatLongFormatter::OPT_PRECISION, $precision ); |
104
|
|
|
|
105
|
|
|
return $options; |
106
|
|
|
} |
107
|
|
|
|
108
|
|
|
/** |
109
|
|
|
* @dataProvider floatNotationProvider |
110
|
|
|
*/ |
111
|
|
|
public function testFloatNotationFormatting( LatLongValue $latLong, $precision, $expected ) { |
112
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_FLOAT, $precision ); |
113
|
|
|
$this->assertFormatsCorrectly( $latLong, $options, $expected ); |
114
|
|
|
} |
115
|
|
|
|
116
|
|
|
/** |
117
|
|
|
* @dataProvider floatNotationProvider |
118
|
|
|
*/ |
119
|
|
|
public function testFloatNotationRoundTrip( LatLongValue $value, $precision, $expected ) { |
|
|
|
|
120
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_FLOAT, $precision ); |
121
|
|
|
$this->assertRoundTrip( $value, $options ); |
122
|
|
|
} |
123
|
|
|
|
124
|
|
|
public function decimalDegreeNotationProvider() { |
125
|
|
|
return [ |
126
|
|
|
'0, degree' => [ |
127
|
|
|
new LatLongValue( 0, 0 ), |
128
|
|
|
1, |
129
|
|
|
'0°, 0°' |
130
|
|
|
], |
131
|
|
|
'negative zero' => [ |
132
|
|
|
new LatLongValue( -0.25, 0.25 ), |
133
|
|
|
1, |
134
|
|
|
'0°, 0°' |
135
|
|
|
], |
136
|
|
|
'signed, minute' => [ |
137
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
138
|
|
|
1 / 60, |
139
|
|
|
'-55.75°, 37.25°' |
140
|
|
|
], |
141
|
|
|
'signed, degree' => [ |
142
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
143
|
|
|
1, |
144
|
|
|
'-56°, 37°' |
145
|
|
|
], |
146
|
|
|
'three degrees' => [ |
147
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
148
|
|
|
3, |
149
|
|
|
'-57°, 36°' |
150
|
|
|
], |
151
|
|
|
'seven degrees' => [ |
152
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
153
|
|
|
7, |
154
|
|
|
'-56°, 35°' |
155
|
|
|
], |
156
|
|
|
'ten degrees' => [ |
157
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
158
|
|
|
10, |
159
|
|
|
'-60°, 40°' |
160
|
|
|
], |
161
|
|
|
'rounding degrees down' => [ |
162
|
|
|
new LatLongValue( -14.9, 14.9 ), |
163
|
|
|
10, |
164
|
|
|
'-10°, 10°' |
165
|
|
|
], |
166
|
|
|
'rounding degrees up' => [ |
167
|
|
|
new LatLongValue( -15, 15 ), |
168
|
|
|
10, |
169
|
|
|
'-20°, 20°' |
170
|
|
|
], |
171
|
|
|
'rounding fractions down' => [ |
172
|
|
|
new LatLongValue( -0.049, 0.049 ), |
173
|
|
|
0.1, |
174
|
|
|
'0.0°, 0.0°' |
175
|
|
|
], |
176
|
|
|
'rounding fractions up' => [ |
177
|
|
|
new LatLongValue( -0.05, 0.05 ), |
178
|
|
|
0.1, |
179
|
|
|
'-0.1°, 0.1°' |
180
|
|
|
], |
181
|
|
|
'precision option must support strings' => [ |
182
|
|
|
new LatLongValue( -0.05, 0.05 ), |
183
|
|
|
'0.1', |
184
|
|
|
'-0.1°, 0.1°' |
185
|
|
|
], |
186
|
|
|
]; |
187
|
|
|
} |
188
|
|
|
|
189
|
|
|
/** |
190
|
|
|
* @dataProvider decimalDegreeNotationProvider |
191
|
|
|
*/ |
192
|
|
|
public function testDecimalDegreeNotationFormatting( LatLongValue $latLong, $precision, $expected ) { |
193
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_DD, $precision ); |
194
|
|
|
$this->assertFormatsCorrectly( $latLong, $options, $expected ); |
195
|
|
|
} |
196
|
|
|
|
197
|
|
|
/** |
198
|
|
|
* @dataProvider decimalDegreeNotationProvider |
199
|
|
|
*/ |
200
|
|
|
public function testDecimalDegreeNotationRoundTrip( LatLongValue $latLong, $precision, $expected ) { |
|
|
|
|
201
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_DD, $precision ); |
202
|
|
|
$this->assertRoundTrip( $latLong, $options ); |
203
|
|
|
} |
204
|
|
|
|
205
|
|
|
public function decimalMinuteNotationProvider() { |
206
|
|
|
return [ |
207
|
|
|
'0, degree' => [ |
208
|
|
|
new LatLongValue( 0, 0 ), |
209
|
|
|
1, |
210
|
|
|
'0°, 0°' |
211
|
|
|
], |
212
|
|
|
'0, minute' => [ |
213
|
|
|
new LatLongValue( 0, 0 ), |
214
|
|
|
1 / 60, |
215
|
|
|
'0° 0\', 0° 0\'' |
216
|
|
|
], |
217
|
|
|
'0, second' => [ |
218
|
|
|
new LatLongValue( 0, 0 ), |
219
|
|
|
1 / 3600, |
220
|
|
|
'0° 0.00\', 0° 0.00\'' |
221
|
|
|
], |
222
|
|
|
'negative zero' => [ |
223
|
|
|
new LatLongValue( -1 / 128, 1 / 128 ), |
224
|
|
|
1 / 60, |
225
|
|
|
'0° 0\', 0° 0\'' |
226
|
|
|
], |
227
|
|
|
'negative, not zero' => [ |
228
|
|
|
new LatLongValue( -0.25, 0.25 ), |
229
|
|
|
1 / 60, |
230
|
|
|
'-0° 15\', 0° 15\'' |
231
|
|
|
], |
232
|
|
|
'second' => [ |
233
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
234
|
|
|
1 / 3600, |
235
|
|
|
'-55° 45.35\', 37° 15.38\'' |
236
|
|
|
], |
237
|
|
|
'minute' => [ |
238
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
239
|
|
|
1 / 60, |
240
|
|
|
'-55° 45\', 37° 15\'' |
241
|
|
|
], |
242
|
|
|
'ten minutes' => [ |
243
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
244
|
|
|
10 / 60, |
245
|
|
|
'-55° 50\', 37° 20\'' |
246
|
|
|
], |
247
|
|
|
'fifty minutes' => [ |
248
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
249
|
|
|
50 / 60, |
250
|
|
|
'-55° 50\', 37° 30\'' |
251
|
|
|
], |
252
|
|
|
'degree' => [ |
253
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
254
|
|
|
1, |
255
|
|
|
'-56°, 37°' |
256
|
|
|
], |
257
|
|
|
'ten degrees' => [ |
258
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
259
|
|
|
10, |
260
|
|
|
'-60°, 40°' |
261
|
|
|
], |
262
|
|
|
'rounding minutes down' => [ |
263
|
|
|
new LatLongValue( -14.9 / 60, 14.9 / 60 ), |
264
|
|
|
10 / 60, |
265
|
|
|
'-0° 10\', 0° 10\'' |
266
|
|
|
], |
267
|
|
|
'rounding minutes up' => [ |
268
|
|
|
new LatLongValue( -15 / 60, 15 / 60 ), |
269
|
|
|
10 / 60, |
270
|
|
|
'-0° 20\', 0° 20\'' |
271
|
|
|
], |
272
|
|
|
'rounding fractions down' => [ |
273
|
|
|
new LatLongValue( -0.049 / 60, 0.049 / 60 ), |
274
|
|
|
0.1 / 60, |
275
|
|
|
'0° 0.0\', 0° 0.0\'' |
276
|
|
|
], |
277
|
|
|
'rounding fractions up' => [ |
278
|
|
|
new LatLongValue( -0.05 / 60, 0.05 / 60 ), |
279
|
|
|
0.1 / 60, |
280
|
|
|
'-0° 0.1\', 0° 0.1\'' |
281
|
|
|
], |
282
|
|
|
'round to degree when it does not make a difference' => [ |
283
|
|
|
new LatLongValue( 1.5, 2.5 ), |
284
|
|
|
1 - 1 / 60, |
285
|
|
|
'2°, 3°' |
286
|
|
|
], |
287
|
|
|
'round to minutes when it starts making a difference' => [ |
288
|
|
|
new LatLongValue( 1.5, 2.5 ), |
289
|
|
|
1 - 2 / 60, |
290
|
|
|
'1° 56\', 2° 54\'' |
291
|
|
|
], |
292
|
|
|
'precision option must support strings' => [ |
293
|
|
|
new LatLongValue( -0.05, 0.05 ), |
294
|
|
|
'0.1', |
295
|
|
|
'-0° 6\', 0° 6\'' |
296
|
|
|
], |
297
|
|
|
]; |
298
|
|
|
} |
299
|
|
|
|
300
|
|
|
/** |
301
|
|
|
* @dataProvider decimalMinuteNotationProvider |
302
|
|
|
*/ |
303
|
|
|
public function testDecimalMinuteNotationFormatting( LatLongValue $latLong, $precision, $expected ) { |
304
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_DM, $precision ); |
305
|
|
|
$this->assertFormatsCorrectly( $latLong, $options, $expected ); |
306
|
|
|
} |
307
|
|
|
|
308
|
|
|
/** |
309
|
|
|
* @dataProvider decimalMinuteNotationProvider |
310
|
|
|
*/ |
311
|
|
|
public function testDecimalMinuteNotationRoundTrip( LatLongValue $latLong, $precision, $expected ) { |
|
|
|
|
312
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_DM, $precision ); |
313
|
|
|
$this->assertRoundTrip( $latLong, $options ); |
314
|
|
|
} |
315
|
|
|
|
316
|
|
|
public function decimalMinuteSecondNotationProvider() { |
317
|
|
|
return [ |
318
|
|
|
'0, degree' => [ |
319
|
|
|
new LatLongValue( 0, 0 ), |
320
|
|
|
1, |
321
|
|
|
'0°, 0°' |
322
|
|
|
], |
323
|
|
|
'0, minute' => [ |
324
|
|
|
new LatLongValue( 0, 0 ), |
325
|
|
|
1 / 60, |
326
|
|
|
'0° 0\', 0° 0\'' |
327
|
|
|
], |
328
|
|
|
'0, second' => [ |
329
|
|
|
new LatLongValue( 0, 0 ), |
330
|
|
|
1 / 3600, |
331
|
|
|
'0° 0\' 0", 0° 0\' 0"' |
332
|
|
|
], |
333
|
|
|
'negative zero' => [ |
334
|
|
|
new LatLongValue( -1 / 8192, 1 / 8192 ), |
335
|
|
|
1 / 3600, |
336
|
|
|
'0° 0\' 0", 0° 0\' 0"' |
337
|
|
|
], |
338
|
|
|
'negative, not zero' => [ |
339
|
|
|
new LatLongValue( -1 / 4096, 1 / 4096 ), |
340
|
|
|
1 / 7200, |
341
|
|
|
'-0° 0\' 1.0", 0° 0\' 1.0"' |
342
|
|
|
], |
343
|
|
|
'second' => [ |
344
|
|
|
new LatLongValue( -55.755786, 37.25 ), |
345
|
|
|
1 / 3600, |
346
|
|
|
'-55° 45\' 21", 37° 15\' 0"' |
347
|
|
|
], |
348
|
|
|
'second/100' => [ |
349
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
350
|
|
|
1 / 360000, |
351
|
|
|
'-55° 45\' 20.83", 37° 15\' 22.79"' |
352
|
|
|
], |
353
|
|
|
'ten seconds' => [ |
354
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
355
|
|
|
10 / 3600, |
356
|
|
|
'-55° 45\' 20", 37° 15\' 20"' |
357
|
|
|
], |
358
|
|
|
'fifty seconds' => [ |
359
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
360
|
|
|
50 / 3600, |
361
|
|
|
'-55° 45\' 0", 37° 15\' 0"' |
362
|
|
|
], |
363
|
|
|
'minute' => [ |
364
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
365
|
|
|
1 / 60, |
366
|
|
|
'-55° 45\', 37° 15\'' |
367
|
|
|
], |
368
|
|
|
'degree' => [ |
369
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
370
|
|
|
1, |
371
|
|
|
'-56°, 37°' |
372
|
|
|
], |
373
|
|
|
'degree/100, case A' => [ |
374
|
|
|
new LatLongValue( 52.01, 10.01 ), |
375
|
|
|
0.01, |
376
|
|
|
'52° 0\' 36", 10° 0\' 36"' |
377
|
|
|
], |
378
|
|
|
'degree/100, case B' => [ |
379
|
|
|
new LatLongValue( 52.02, 10.02 ), |
380
|
|
|
0.01, |
381
|
|
|
'52° 1\' 12", 10° 1\' 12"' |
382
|
|
|
], |
383
|
|
|
'degree/1000' => [ |
384
|
|
|
new LatLongValue( 52.4, 6.7667 ), |
385
|
|
|
0.001, |
386
|
|
|
'52° 24\' 0", 6° 46\' 1"' |
387
|
|
|
], |
388
|
|
|
'ten degrees' => [ |
389
|
|
|
new LatLongValue( -55.755786, 37.25633 ), |
390
|
|
|
10, |
391
|
|
|
'-60°, 40°' |
392
|
|
|
], |
393
|
|
|
'rounding seconds down' => [ |
394
|
|
|
new LatLongValue( -14.9 / 3600, 14.9 / 3600 ), |
395
|
|
|
10 / 3600, |
396
|
|
|
'-0° 0\' 10", 0° 0\' 10"' |
397
|
|
|
], |
398
|
|
|
'rounding seconds up' => [ |
399
|
|
|
new LatLongValue( -15 / 3600, 15 / 3600 ), |
400
|
|
|
10 / 3600, |
401
|
|
|
'-0° 0\' 20", 0° 0\' 20"' |
402
|
|
|
], |
403
|
|
|
'rounding fractions down' => [ |
404
|
|
|
new LatLongValue( -0.049 / 3600, 0.049 / 3600 ), |
405
|
|
|
0.1 / 3600, |
406
|
|
|
'0° 0\' 0.0", 0° 0\' 0.0"' |
407
|
|
|
], |
408
|
|
|
'rounding fractions up' => [ |
409
|
|
|
new LatLongValue( -0.05 / 3600, 0.05 / 3600 ), |
410
|
|
|
0.1 / 3600, |
411
|
|
|
'-0° 0\' 0.1", 0° 0\' 0.1"' |
412
|
|
|
], |
413
|
|
|
'round to degree when it does not make a difference' => [ |
414
|
|
|
new LatLongValue( 1.5, 2.5 ), |
415
|
|
|
1 - 1 / 60, |
416
|
|
|
'2°, 3°' |
417
|
|
|
], |
418
|
|
|
'round to minutes when it starts making a difference' => [ |
419
|
|
|
new LatLongValue( 1.5, 2.5 ), |
420
|
|
|
1 - 2 / 60, |
421
|
|
|
'1° 56\', 2° 54\'' |
422
|
|
|
], |
423
|
|
|
'round to minutes when it does not make a difference' => [ |
424
|
|
|
new LatLongValue( 1.926, 2.926 ), |
425
|
|
|
1 / 60 - 1 / 3600, |
426
|
|
|
'1° 56\', 2° 56\'' |
427
|
|
|
], |
428
|
|
|
'round to seconds when it starts making a difference' => [ |
429
|
|
|
new LatLongValue( 1.926, 2.926 ), |
430
|
|
|
1 / 60 - 2 / 3600, |
431
|
|
|
'1° 56\' 0", 2° 55\' 56"' |
432
|
|
|
], |
433
|
|
|
'unexpected rounding to 36°, 36°' => [ |
434
|
|
|
new LatLongValue( 36.5867, 37.0458 ), |
435
|
|
|
1.1187604885913, |
436
|
|
|
'37°, 37°' |
437
|
|
|
], |
438
|
|
|
'precision option must support strings' => [ |
439
|
|
|
new LatLongValue( -0.05, 0.05 ), |
440
|
|
|
'0.1', |
441
|
|
|
'-0° 6\', 0° 6\'' |
442
|
|
|
], |
443
|
|
|
'Bug T150085 with 1 second precision' => [ |
444
|
|
|
new LatLongValue( 42.1206, 2.76944 ), |
445
|
|
|
1 / 3600, |
446
|
|
|
'42° 7\' 14", 2° 46\' 10"' |
447
|
|
|
], |
448
|
|
|
'Bug T150085 with 1 minute precision' => [ |
449
|
|
|
new LatLongValue( 42.1206, 2.76944 ), |
450
|
|
|
1 / 60, |
451
|
|
|
'42° 7\', 2° 46\'' |
452
|
|
|
], |
453
|
|
|
'Bug T150085 with ~0.7 minute precision' => [ |
454
|
|
|
new LatLongValue( 42.1206, 2.76944 ), |
455
|
|
|
0.012111004438894, |
456
|
|
|
'42° 7\' 19", 2° 46\' 24"' |
457
|
|
|
], |
458
|
|
|
]; |
459
|
|
|
} |
460
|
|
|
|
461
|
|
|
/** |
462
|
|
|
* @dataProvider decimalMinuteSecondNotationProvider |
463
|
|
|
*/ |
464
|
|
|
public function testDecimalMinuteSecondNotationFormatting( LatLongValue $latLong, $precision, $expected ) { |
465
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_DMS, $precision ); |
466
|
|
|
$this->assertFormatsCorrectly( $latLong, $options, $expected ); |
467
|
|
|
} |
468
|
|
|
|
469
|
|
|
/** |
470
|
|
|
* @dataProvider decimalMinuteSecondNotationProvider |
471
|
|
|
*/ |
472
|
|
|
public function testDecimalMinuteSecondNotationRoundTrip( LatLongValue $latLong, $precision, $expected ) { |
|
|
|
|
473
|
|
|
$options = $this->makeOptions( LatLongFormatter::TYPE_DMS, $precision ); |
474
|
|
|
$this->assertRoundTrip( $latLong, $options ); |
475
|
|
|
} |
476
|
|
|
|
477
|
|
|
/** |
478
|
|
|
* @param LatLongValue $latLong |
479
|
|
|
* @param FormatterOptions $options |
480
|
|
|
* @param string $expected |
481
|
|
|
*/ |
482
|
|
|
private function assertFormatsCorrectly( LatLongValue $latLong, FormatterOptions $options, $expected ) { |
483
|
|
|
$formatter = new LatLongFormatter( $options ); |
484
|
|
|
|
485
|
|
|
$this->assertSame( |
486
|
|
|
$expected, |
487
|
|
|
$formatter->format( $latLong ), |
488
|
|
|
'format()' |
489
|
|
|
); |
490
|
|
|
|
491
|
|
|
$precision = (float)$options->getOption( LatLongFormatter::OPT_PRECISION ); |
492
|
|
|
$this->assertSame( |
493
|
|
|
$expected, |
494
|
|
|
$formatter->formatLatLongValue( $latLong, $precision ), |
495
|
|
|
'formatLatLongValue()' |
496
|
|
|
); |
497
|
|
|
} |
498
|
|
|
|
499
|
|
|
private function assertRoundTrip( LatLongValue $value, FormatterOptions $options ) { |
500
|
|
|
$formatter = new LatLongFormatter( $options ); |
501
|
|
|
$parser = new LatLongParser(); |
502
|
|
|
|
503
|
|
|
$formatted = $formatter->format( $value ); |
504
|
|
|
$parsed = $parser->parse( $formatted ); |
505
|
|
|
|
506
|
|
|
// NOTE: $parsed may be != $coord, because of rounding, so we can't compare directly. |
507
|
|
|
$formattedParsed = $formatter->format( $parsed ); |
508
|
|
|
|
509
|
|
|
$this->assertSame( $formatted, $formattedParsed ); |
510
|
|
|
} |
511
|
|
|
|
512
|
|
|
public function testDirectionalOptionGetsAppliedForDecimalMinutes() { |
513
|
|
|
$coordinates = [ |
514
|
|
|
'55° 0\' N, 37° 0\' E' => [ 55, 37 ], |
515
|
|
|
'55° 30\' N, 37° 30\' W' => [ 55.5, -37.5 ], |
516
|
|
|
'55° 30\' S, 37° 30\' E' => [ -55.5, 37.5 ], |
517
|
|
|
'55° 30\' S, 37° 30\' W' => [ -55.5, -37.5 ], |
518
|
|
|
'0° 0\' N, 0° 0\' E' => [ 0, 0 ], |
519
|
|
|
]; |
520
|
|
|
|
521
|
|
|
$this->assertIsDirectionalFormatMap( $coordinates, LatLongFormatter::TYPE_DM ); |
522
|
|
|
} |
523
|
|
|
|
524
|
|
|
/** |
525
|
|
|
* @param array[] $coordinates |
526
|
|
|
* @param string $format One of the LatLongFormatter::TYPE_… constants |
527
|
|
|
*/ |
528
|
|
|
private function assertIsDirectionalFormatMap( array $coordinates, $format ) { |
529
|
|
|
foreach ( $coordinates as $expected => $arguments ) { |
530
|
|
|
$options = new FormatterOptions(); |
531
|
|
|
$options->setOption( LatLongFormatter::OPT_FORMAT, $format ); |
532
|
|
|
$options->setOption( LatLongFormatter::OPT_DIRECTIONAL, true ); |
533
|
|
|
$options->setOption( LatLongFormatter::OPT_PRECISION, 1 / 60 ); |
534
|
|
|
|
535
|
|
|
$this->assertFormatsCorrectly( |
536
|
|
|
new LatLongValue( $arguments[0], $arguments[1] ), |
537
|
|
|
$options, |
538
|
|
|
$expected |
539
|
|
|
); |
540
|
|
|
} |
541
|
|
|
} |
542
|
|
|
|
543
|
|
|
public function testDirectionalOptionGetsAppliedForFloats() { |
544
|
|
|
$coordinates = [ |
545
|
|
|
'55.75 N, 37.25 W' => [ 55.755786, -37.25633 ], |
546
|
|
|
'55.75 S, 37.25 E' => [ -55.755786, 37.25633 ], |
547
|
|
|
'55 S, 37.25 W' => [ -55, -37.25633 ], |
548
|
|
|
'5.5 N, 37 E' => [ 5.5, 37 ], |
549
|
|
|
'0 N, 0 E' => [ 0, 0 ], |
550
|
|
|
]; |
551
|
|
|
|
552
|
|
|
$this->assertIsDirectionalFormatMap( $coordinates, LatLongFormatter::TYPE_FLOAT ); |
553
|
|
|
} |
554
|
|
|
|
555
|
|
|
private function provideSpacingLevelOptions() { |
556
|
|
|
return [ |
557
|
|
|
'none' => [], |
558
|
|
|
'latlong' => [ LatLongFormatter::OPT_SPACE_LATLONG ], |
559
|
|
|
'direction' => [ LatLongFormatter::OPT_SPACE_DIRECTION ], |
560
|
|
|
'coordparts' => [ LatLongFormatter::OPT_SPACE_COORDPARTS ], |
561
|
|
|
'latlong_direction' => [ |
562
|
|
|
LatLongFormatter::OPT_SPACE_LATLONG, |
563
|
|
|
LatLongFormatter::OPT_SPACE_DIRECTION |
564
|
|
|
], |
565
|
|
|
'all' => [ |
566
|
|
|
LatLongFormatter::OPT_SPACE_LATLONG, |
567
|
|
|
LatLongFormatter::OPT_SPACE_DIRECTION, |
568
|
|
|
LatLongFormatter::OPT_SPACE_COORDPARTS, |
569
|
|
|
], |
570
|
|
|
]; |
571
|
|
|
} |
572
|
|
|
|
573
|
|
|
public function testSpacingOptionGetsAppliedForDecimalMinutes() { |
574
|
|
|
$coordinates = [ |
575
|
|
|
'none' => [ |
576
|
|
|
'55°0\'N,37°0\'E' => [ 55, 37 ], |
577
|
|
|
'55°30\'N,37°30\'W' => [ 55.5, -37.5 ], |
578
|
|
|
'0°0\'N,0°0\'E' => [ 0, 0 ], |
579
|
|
|
], |
580
|
|
|
'latlong' => [ |
581
|
|
|
'55°0\'N, 37°0\'E' => [ 55, 37 ], |
582
|
|
|
'55°30\'N, 37°30\'W' => [ 55.5, -37.5 ], |
583
|
|
|
'0°0\'N, 0°0\'E' => [ 0, 0 ], |
584
|
|
|
], |
585
|
|
|
'direction' => [ |
586
|
|
|
'55°0\' N,37°0\' E' => [ 55, 37 ], |
587
|
|
|
'55°30\' N,37°30\' W' => [ 55.5, -37.5 ], |
588
|
|
|
'0°0\' N,0°0\' E' => [ 0, 0 ], |
589
|
|
|
], |
590
|
|
|
'coordparts' => [ |
591
|
|
|
'55° 0\'N,37° 0\'E' => [ 55, 37 ], |
592
|
|
|
'55° 30\'N,37° 30\'W' => [ 55.5, -37.5 ], |
593
|
|
|
'0° 0\'N,0° 0\'E' => [ 0, 0 ], |
594
|
|
|
], |
595
|
|
|
'latlong_direction' => [ |
596
|
|
|
'55°0\' N, 37°0\' E' => [ 55, 37 ], |
597
|
|
|
'55°30\' N, 37°30\' W' => [ 55.5, -37.5 ], |
598
|
|
|
'0°0\' N, 0°0\' E' => [ 0, 0 ], |
599
|
|
|
], |
600
|
|
|
]; |
601
|
|
|
|
602
|
|
|
$this->assertSpacingCorrect( $coordinates, LatLongFormatter::TYPE_DM ); |
603
|
|
|
} |
604
|
|
|
|
605
|
|
|
/** |
606
|
|
|
* @param array[] $coordSets |
607
|
|
|
* @param string $format One of the LatLongFormatter::TYPE_… constants |
608
|
|
|
*/ |
609
|
|
|
private function assertSpacingCorrect( array $coordSets, $format ) { |
610
|
|
|
$spacingLevelOptions = $this->provideSpacingLevelOptions(); |
611
|
|
|
foreach ( $coordSets as $spacingKey => $coordinates ) { |
612
|
|
|
foreach ( $coordinates as $expected => $arguments ) { |
613
|
|
|
$options = new FormatterOptions(); |
614
|
|
|
$options->setOption( LatLongFormatter::OPT_FORMAT, $format ); |
615
|
|
|
$options->setOption( LatLongFormatter::OPT_DIRECTIONAL, true ); |
616
|
|
|
$options->setOption( LatLongFormatter::OPT_PRECISION, 1 / 60 ); |
617
|
|
|
$options->setOption( LatLongFormatter::OPT_SPACING_LEVEL, $spacingLevelOptions[$spacingKey] ); |
618
|
|
|
|
619
|
|
|
$this->assertFormatsCorrectly( |
620
|
|
|
new LatLongValue( $arguments[0], $arguments[1] ), |
621
|
|
|
$options, |
622
|
|
|
$expected |
623
|
|
|
); |
624
|
|
|
} |
625
|
|
|
} |
626
|
|
|
} |
627
|
|
|
|
628
|
|
|
public function testSpacingOptionGetsAppliedForFloats() { |
629
|
|
|
$coordinates = [ |
630
|
|
|
'none' => [ |
631
|
|
|
'55.75N,37.25W' => [ 55.755786, -37.25633 ], |
632
|
|
|
'0N,0E' => [ 0, 0 ], |
633
|
|
|
], |
634
|
|
|
'latlong' => [ |
635
|
|
|
'55.75N, 37.25W' => [ 55.755786, -37.25633 ], |
636
|
|
|
'0N, 0E' => [ 0, 0 ], |
637
|
|
|
], |
638
|
|
|
'direction' => [ |
639
|
|
|
'55.75 N,37.25 W' => [ 55.755786, -37.25633 ], |
640
|
|
|
'0 N,0 E' => [ 0, 0 ], |
641
|
|
|
], |
642
|
|
|
'coordparts' => [ |
643
|
|
|
'55.75N,37.25W' => [ 55.755786, -37.25633 ], |
644
|
|
|
'0N,0E' => [ 0, 0 ], |
645
|
|
|
], |
646
|
|
|
'latlong_direction' => [ |
647
|
|
|
'55.75 N, 37.25 W' => [ 55.755786, -37.25633 ], |
648
|
|
|
'0 N, 0 E' => [ 0, 0 ], |
649
|
|
|
], |
650
|
|
|
'all' => [ |
651
|
|
|
'55.75 N, 37.25 W' => [ 55.755786, -37.25633 ], |
652
|
|
|
'0 N, 0 E' => [ 0, 0 ], |
653
|
|
|
], |
654
|
|
|
]; |
655
|
|
|
|
656
|
|
|
$this->assertSpacingCorrect( $coordinates, LatLongFormatter::TYPE_FLOAT ); |
657
|
|
|
} |
658
|
|
|
|
659
|
|
|
public function testWrongType() { |
660
|
|
|
$formatter = new LatLongFormatter( new FormatterOptions() ); |
661
|
|
|
|
662
|
|
|
$this->expectException( InvalidArgumentException::class ); |
663
|
|
|
$formatter->format( new StringValue( 'Evil' ) ); |
|
|
|
|
664
|
|
|
} |
665
|
|
|
|
666
|
|
|
public function testGivenInvalidFormattingOption_formatThrowsException() { |
667
|
|
|
$options = new FormatterOptions(); |
668
|
|
|
$options->setOption( LatLongFormatter::OPT_FORMAT, 'not a format' ); |
669
|
|
|
$formatter = new LatLongFormatter( $options ); |
670
|
|
|
|
671
|
|
|
$this->expectException( InvalidArgumentException::class ); |
672
|
|
|
$formatter->format( new LatLongValue( 0, 0 ) ); |
673
|
|
|
} |
674
|
|
|
|
675
|
|
|
/** |
676
|
|
|
* @dataProvider invalidPrecisionProvider |
677
|
|
|
*/ |
678
|
|
|
public function testFormatWithInvalidPrecision_fallsBackToDefaultPrecision( $precision ) { |
679
|
|
|
$options = new FormatterOptions(); |
680
|
|
|
$options->setOption( LatLongFormatter::OPT_PRECISION, $precision ); |
681
|
|
|
$formatter = new LatLongFormatter( $options ); |
682
|
|
|
|
683
|
|
|
$formatted = $formatter->format( new LatLongValue( 1.2, 3.4 ) ); |
684
|
|
|
$this->assertSame( '1.2, 3.4', $formatted ); |
685
|
|
|
} |
686
|
|
|
|
687
|
|
|
/** |
688
|
|
|
* @dataProvider invalidPrecisionProvider |
689
|
|
|
*/ |
690
|
|
|
public function testFormatLatLongValueWithInvalidPrecision_fallsBackToDefaultPrecision( $precision ) { |
691
|
|
|
$formatter = new LatLongFormatter( new FormatterOptions() ); |
692
|
|
|
|
693
|
|
|
$formatted = $formatter->formatLatLongValue( new LatLongValue( 1.2, 3.4 ), $precision ); |
694
|
|
|
$this->assertSame( '1.2, 3.4', $formatted ); |
695
|
|
|
} |
696
|
|
|
|
697
|
|
|
public function invalidPrecisionProvider() { |
698
|
|
|
return [ |
699
|
|
|
[ 0 ], |
700
|
|
|
[ -1 ], |
701
|
|
|
[ NAN ], |
702
|
|
|
[ INF ], |
703
|
|
|
]; |
704
|
|
|
} |
705
|
|
|
|
706
|
|
|
public function testRoundingWithDefaultPrecisionWhenFormattingAsFloat() { |
707
|
|
|
$this->assertSame( |
708
|
|
|
'52.144444444444, -0.46666666666667', |
709
|
|
|
( new LatLongFormatter() )->format( new LatLongValue( 52.1445,-0.466722 ) ) |
710
|
|
|
); |
711
|
|
|
} |
712
|
|
|
|
713
|
|
|
public function testRoundingWithDefaultPrecisionWhenFormattingAsDecimalDegrees() { |
714
|
|
|
$this->assertSame( |
715
|
|
|
'52.1361°, -0.4219°', |
716
|
|
|
$this->newDecimalDegreeFormatter()->format( new LatLongValue( 52.136,-0.422 ) ) |
717
|
|
|
); |
718
|
|
|
} |
719
|
|
|
|
720
|
|
|
private function newDecimalDegreeFormatter() { |
721
|
|
|
return ( new LatLongFormatter( new FormatterOptions( [ |
722
|
|
|
LatLongFormatter::OPT_FORMAT => LatLongFormatter::TYPE_DD |
723
|
|
|
] ) ) ); |
724
|
|
|
} |
725
|
|
|
|
726
|
|
|
} |
727
|
|
|
|
This check looks from parameters that have been defined for a function or method, but which are not used in the method body.