Mercurial > hg > orthanc-stone

comparison OrthancStone/UnitTestsSources/GenericToolboxTests.cpp @ 1877:a2955abe4c2e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
skeleton for the RenderingPlugin
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 12 Jan 2022 08:23:38 +0100
parents UnitTestsSources/GenericToolboxTests.cpp@7053b8a0aaec
children 187a261d7ae2
comparison
equal deleted inserted replaced
1876:b1f510e601d2 1877:a2955abe4c2e
1 /**
2 * Stone of Orthanc
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2022 Osimis S.A., Belgium
6 * Copyright (C) 2021-2022 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
7 *
8 * This program is free software: you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation, either version 3 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
21 **/
22
23
24 #include "../Sources/Toolbox/GenericToolbox.h"
25
26 #include <boost/date_time/posix_time/posix_time.hpp>
27 #include <boost/lexical_cast.hpp>
28 #include <boost/enable_shared_from_this.hpp>
29
30 #include <gtest/gtest.h>
31 #include <stdint.h>
32 #include <cmath>
33
34 #if __cplusplus >= 201103L // Is C++11?
35 # include <cinttypes> // For PRId64
36 #else
37 # define PRId64 "ld"
38 #endif
39
40 TEST(GenericToolbox, TestLegitDoubleString)
41 {
42 using OrthancStone::GenericToolbox::LegitDoubleString;
43
44 EXPECT_TRUE(LegitDoubleString("12.34"));
45 EXPECT_TRUE(LegitDoubleString("1234"));
46 EXPECT_TRUE(LegitDoubleString(".1234"));
47 EXPECT_TRUE(LegitDoubleString("1234."));
48 EXPECT_TRUE(LegitDoubleString("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011234"));
49 EXPECT_TRUE(LegitDoubleString("000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000000000011234"));
50 EXPECT_TRUE(LegitDoubleString("0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000112.34"));
51 EXPECT_TRUE(LegitDoubleString("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011234."));
52 EXPECT_TRUE(LegitDoubleString("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001123456"));
53 EXPECT_TRUE(LegitDoubleString("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001123456000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011234000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000112345000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011234000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011234565664565623456"));
54 EXPECT_TRUE(LegitDoubleString("1234."));
55 EXPECT_TRUE(LegitDoubleString(".0123"));
56 EXPECT_TRUE(LegitDoubleString(".123"));
57 EXPECT_TRUE(LegitDoubleString(".5"));
58 EXPECT_TRUE(LegitDoubleString("."));
59 EXPECT_TRUE(LegitDoubleString(""));
60 EXPECT_TRUE(LegitDoubleString("0."));
61 EXPECT_TRUE(LegitDoubleString(".0"));
62
63 EXPECT_TRUE(LegitDoubleString("1e-15"));
64 EXPECT_TRUE(LegitDoubleString("1E-15"));
65 EXPECT_TRUE(LegitDoubleString("0.31E-15"));
66 EXPECT_TRUE(LegitDoubleString(".0031E-15"));
67 EXPECT_TRUE(LegitDoubleString("1e-15"));
68 EXPECT_TRUE(LegitDoubleString("1E015"));
69 EXPECT_TRUE(LegitDoubleString("0.31E015"));
70
71
72 EXPECT_FALSE(LegitDoubleString(".5f"));
73 EXPECT_FALSE(LegitDoubleString("\n.0031E015"));
74 EXPECT_FALSE(LegitDoubleString(".05f"));
75 EXPECT_FALSE(LegitDoubleString(" 1 2 "));
76 EXPECT_FALSE(LegitDoubleString(" 0.12\t"));
77 EXPECT_FALSE(LegitDoubleString(" 0.12"));
78 EXPECT_TRUE(LegitDoubleString("0.12\t"));
79 EXPECT_TRUE(LegitDoubleString("12\t"));
80 EXPECT_FALSE(LegitDoubleString(".01 23"));
81 EXPECT_FALSE(LegitDoubleString(". 123"));
82 EXPECT_TRUE(LegitDoubleString(".5 "));
83 EXPECT_FALSE(LegitDoubleString(" ."));
84 EXPECT_FALSE(LegitDoubleString("\n0."));
85 }
86
87 TEST(GenericToolbox, TestLegitIntegerString)
88 {
89 using OrthancStone::GenericToolbox::LegitIntegerString;
90
91 EXPECT_TRUE(LegitIntegerString("1234"));
92 EXPECT_TRUE(LegitIntegerString("234"));
93 EXPECT_TRUE(LegitIntegerString("01234"));
94 EXPECT_TRUE(LegitIntegerString("12340"));
95 EXPECT_TRUE(LegitIntegerString("0000000000000011234"));
96 EXPECT_TRUE(LegitIntegerString("00000000000000011234"));
97 EXPECT_TRUE(LegitIntegerString("00000000000011234"));
98 EXPECT_TRUE(LegitIntegerString("112340000000000010"));
99 EXPECT_TRUE(LegitIntegerString("0000000000001123456"));
100 EXPECT_TRUE(LegitIntegerString("000000000000112345604565665623456"));
101 EXPECT_TRUE(LegitIntegerString(""));
102 EXPECT_TRUE(LegitIntegerString("0"));
103 EXPECT_TRUE(LegitIntegerString("00000"));
104
105 EXPECT_FALSE(LegitIntegerString(".5f"));
106 EXPECT_FALSE(LegitIntegerString("1e-15"));
107 EXPECT_FALSE(LegitIntegerString("1E-15"));
108 EXPECT_FALSE(LegitIntegerString("0.31E-15"));
109 EXPECT_FALSE(LegitIntegerString(".0031E-15"));
110 EXPECT_FALSE(LegitIntegerString("1e-15"));
111 EXPECT_FALSE(LegitIntegerString("1E015"));
112 EXPECT_FALSE(LegitIntegerString("0.31E015"));
113 EXPECT_FALSE(LegitIntegerString("\n.0031E015"));
114 EXPECT_FALSE(LegitIntegerString(".05f"));
115 EXPECT_FALSE(LegitIntegerString(" 1 2 "));
116 EXPECT_FALSE(LegitIntegerString(" 0.12\t"));
117 EXPECT_FALSE(LegitIntegerString(" 0.12"));
118 EXPECT_FALSE(LegitIntegerString("0.12\t"));
119 EXPECT_FALSE(LegitIntegerString("12\t"));
120 EXPECT_FALSE(LegitIntegerString(".01 23"));
121 EXPECT_FALSE(LegitIntegerString(". 123"));
122 EXPECT_FALSE(LegitIntegerString(".5 "));
123 EXPECT_FALSE(LegitIntegerString(" ."));
124 EXPECT_FALSE(LegitIntegerString("\n0."));
125 }
126
127
128 /**
129 * The very long "TestStringToDouble" was split in 4 parts. Otherwise,
130 * while running in WebAssembly (at least in "Debug" CMAKE_BUILD_TYPE
131 * with Emscripten 2.0.0), one get error "failed to asynchronously
132 * prepare wasm: CompileError: WebAssembly.instantiate(): Compiling
133 * function [...] failed: local count too large". This is because the
134 * function is too long.
135 **/
136 TEST(GenericToolbox, TestStringToDouble1)
137 {
138 using OrthancStone::GenericToolbox::StringToDouble;
139
140 const double TOLERANCE = 0.00000000000001;
141 double r = 0.0;
142
143 {
144 bool ok = StringToDouble(r, "0.0001");
145 EXPECT_TRUE(ok);
146 EXPECT_NEAR(0.0001, r, TOLERANCE);
147 }
148
149 {
150 bool ok = StringToDouble(r, "0.0001");
151 EXPECT_TRUE(ok);
152 EXPECT_NEAR(0.0001, r, TOLERANCE);
153 }
154
155 {
156 bool ok = StringToDouble(r, "-0.50217817069333900000");
157 EXPECT_TRUE(ok);
158 EXPECT_NEAR(-0.50217817069333900000, r, TOLERANCE);
159 }
160
161 {
162 bool ok = StringToDouble(r, "5.96770274105399000000");
163 EXPECT_TRUE(ok);
164 EXPECT_NEAR(5.96770274105399000000, r, TOLERANCE);
165 }
166
167 {
168 bool ok = StringToDouble(r, "-1.49521088758962000000");
169 EXPECT_TRUE(ok);
170 EXPECT_NEAR(-1.49521088758962000000, r, TOLERANCE);
171 }
172
173 {
174 bool ok = StringToDouble(r, "-2.06201839227379000000");
175 EXPECT_TRUE(ok);
176 EXPECT_NEAR(-2.06201839227379000000, r, TOLERANCE);
177 }
178
179 {
180 bool ok = StringToDouble(r, "5.33360671999703000000");
181 EXPECT_TRUE(ok);
182 EXPECT_NEAR(5.33360671999703000000, r, TOLERANCE);
183 }
184
185 {
186 bool ok = StringToDouble(r, "-1.07639304839166000000");
187 EXPECT_TRUE(ok);
188 EXPECT_NEAR(-1.07639304839166000000, r, TOLERANCE);
189 }
190
191 {
192 bool ok = StringToDouble(r, "0.19287806240687400000");
193 EXPECT_TRUE(ok);
194 EXPECT_NEAR(0.19287806240687400000, r, TOLERANCE);
195 }
196
197 {
198 bool ok = StringToDouble(r, "2.44207082838626000000");
199 EXPECT_TRUE(ok);
200 EXPECT_NEAR(2.44207082838626000000, r, TOLERANCE);
201 }
202
203 {
204 bool ok = StringToDouble(r, "-0.84619708036551800000");
205 EXPECT_TRUE(ok);
206 EXPECT_NEAR(-0.84619708036551800000, r, TOLERANCE);
207 }
208
209 {
210 bool ok = StringToDouble(r, "-1.58091726580509000000");
211 EXPECT_TRUE(ok);
212 EXPECT_NEAR(-1.58091726580509000000, r, TOLERANCE);
213 }
214
215 {
216 bool ok = StringToDouble(r, "1.18073661859763000000");
217 EXPECT_TRUE(ok);
218 EXPECT_NEAR(1.18073661859763000000, r, TOLERANCE);
219 }
220
221 {
222 bool ok = StringToDouble(r, "1.33045549786387000000");
223 EXPECT_TRUE(ok);
224 EXPECT_NEAR(1.33045549786387000000, r, TOLERANCE);
225 }
226
227 {
228 bool ok = StringToDouble(r, "-3.00272400249168000000");
229 EXPECT_TRUE(ok);
230 EXPECT_NEAR(-3.00272400249168000000, r, TOLERANCE);
231 }
232
233 {
234 bool ok = StringToDouble(r, "4.95337715877137000000");
235 EXPECT_TRUE(ok);
236 EXPECT_NEAR(4.95337715877137000000, r, TOLERANCE);
237 }
238
239 {
240 bool ok = StringToDouble(r, "8.95930523708542000000");
241 EXPECT_TRUE(ok);
242 EXPECT_NEAR(8.95930523708542000000, r, TOLERANCE);
243 }
244
245 {
246 bool ok = StringToDouble(r, "-3.78847681371515000000");
247 EXPECT_TRUE(ok);
248 EXPECT_NEAR(-3.78847681371515000000, r, TOLERANCE);
249 }
250
251 {
252 bool ok = StringToDouble(r, "-3.23601540702684000000");
253 EXPECT_TRUE(ok);
254 EXPECT_NEAR(-3.23601540702684000000, r, TOLERANCE);
255 }
256
257 {
258 bool ok = StringToDouble(r, "3.40676557671367000000");
259 EXPECT_TRUE(ok);
260 EXPECT_NEAR(3.40676557671367000000, r, TOLERANCE);
261 }
262
263 {
264 bool ok = StringToDouble(r, "-0.36110595246212700000");
265 EXPECT_TRUE(ok);
266 EXPECT_NEAR(-0.36110595246212700000, r, TOLERANCE);
267 }
268
269 {
270 bool ok = StringToDouble(r, "-1.10430292945232000000");
271 EXPECT_TRUE(ok);
272 EXPECT_NEAR(-1.10430292945232000000, r, TOLERANCE);
273 }
274
275 {
276 bool ok = StringToDouble(r, "-0.34892053003478100000");
277 EXPECT_TRUE(ok);
278 EXPECT_NEAR(-0.34892053003478100000, r, TOLERANCE);
279 }
280
281 {
282 bool ok = StringToDouble(r, "-3.86871791690589000000");
283 EXPECT_TRUE(ok);
284 EXPECT_NEAR(-3.86871791690589000000, r, TOLERANCE);
285 }
286
287 {
288 bool ok = StringToDouble(r, "-0.23477571361979100000");
289 EXPECT_TRUE(ok);
290 EXPECT_NEAR(-0.23477571361979100000, r, TOLERANCE);
291 }
292
293 {
294 bool ok = StringToDouble(r, "4.17723077954105000000");
295 EXPECT_TRUE(ok);
296 EXPECT_NEAR(4.17723077954105000000, r, TOLERANCE);
297 }
298
299 {
300 bool ok = StringToDouble(r, "-5.55533339430731000000");
301 EXPECT_TRUE(ok);
302 EXPECT_NEAR(-5.55533339430731000000, r, TOLERANCE);
303 }
304
305 {
306 bool ok = StringToDouble(r, "1.39193581722996000000");
307 EXPECT_TRUE(ok);
308 EXPECT_NEAR(1.39193581722996000000, r, TOLERANCE);
309 }
310
311 {
312 bool ok = StringToDouble(r, "-1.98290538242799000000");
313 EXPECT_TRUE(ok);
314 EXPECT_NEAR(-1.98290538242799000000, r, TOLERANCE);
315 }
316
317 {
318 bool ok = StringToDouble(r, "-1.39701448187652000000");
319 EXPECT_TRUE(ok);
320 EXPECT_NEAR(-1.39701448187652000000, r, TOLERANCE);
321 }
322
323 {
324 bool ok = StringToDouble(r, "-2.97546141973594000000");
325 EXPECT_TRUE(ok);
326 EXPECT_NEAR(-2.97546141973594000000, r, TOLERANCE);
327 }
328
329 {
330 bool ok = StringToDouble(r, "1.33870401451186000000");
331 EXPECT_TRUE(ok);
332 EXPECT_NEAR(1.33870401451186000000, r, TOLERANCE);
333 }
334
335 {
336 bool ok = StringToDouble(r, "2.15061799435527000000");
337 EXPECT_TRUE(ok);
338 EXPECT_NEAR(2.15061799435527000000, r, TOLERANCE);
339 }
340
341 {
342 bool ok = StringToDouble(r, "2.78705704115137000000");
343 EXPECT_TRUE(ok);
344 EXPECT_NEAR(2.78705704115137000000, r, TOLERANCE);
345 }
346
347 {
348 bool ok = StringToDouble(r, "1.56210637202493000000");
349 EXPECT_TRUE(ok);
350 EXPECT_NEAR(1.56210637202493000000, r, TOLERANCE);
351 }
352
353 {
354 bool ok = StringToDouble(r, "-8.86139731673717000000");
355 EXPECT_TRUE(ok);
356 EXPECT_NEAR(-8.86139731673717000000, r, TOLERANCE);
357 }
358
359 {
360 bool ok = StringToDouble(r, "3.63169336137189000000");
361 EXPECT_TRUE(ok);
362 EXPECT_NEAR(3.63169336137189000000, r, TOLERANCE);
363 }
364
365 {
366 bool ok = StringToDouble(r, "-2.93978481744645000000");
367 EXPECT_TRUE(ok);
368 EXPECT_NEAR(-2.93978481744645000000, r, TOLERANCE);
369 }
370
371 {
372 bool ok = StringToDouble(r, "-3.49952444717512000000");
373 EXPECT_TRUE(ok);
374 EXPECT_NEAR(-3.49952444717512000000, r, TOLERANCE);
375 }
376
377 {
378 bool ok = StringToDouble(r, "-1.32659301981935000000");
379 EXPECT_TRUE(ok);
380 EXPECT_NEAR(-1.32659301981935000000, r, TOLERANCE);
381 }
382
383 {
384 bool ok = StringToDouble(r, "2.59514994228045000000");
385 EXPECT_TRUE(ok);
386 EXPECT_NEAR(2.59514994228045000000, r, TOLERANCE);
387 }
388
389 {
390 bool ok = StringToDouble(r, "-3.66422938111626000000");
391 EXPECT_TRUE(ok);
392 EXPECT_NEAR(-3.66422938111626000000, r, TOLERANCE);
393 }
394
395 {
396 bool ok = StringToDouble(r, "-2.70431239624531000000");
397 EXPECT_TRUE(ok);
398 EXPECT_NEAR(-2.70431239624531000000, r, TOLERANCE);
399 }
400
401 {
402 bool ok = StringToDouble(r, "1.22698147029468000000");
403 EXPECT_TRUE(ok);
404 EXPECT_NEAR(1.22698147029468000000, r, TOLERANCE);
405 }
406
407 {
408 bool ok = StringToDouble(r, "-0.90761005965631200000");
409 EXPECT_TRUE(ok);
410 EXPECT_NEAR(-0.90761005965631200000, r, TOLERANCE);
411 }
412
413 {
414 bool ok = StringToDouble(r, "-5.43368952065867000000");
415 EXPECT_TRUE(ok);
416 EXPECT_NEAR(-5.43368952065867000000, r, TOLERANCE);
417 }
418
419 {
420 bool ok = StringToDouble(r, "2.79510450171595000000");
421 EXPECT_TRUE(ok);
422 EXPECT_NEAR(2.79510450171595000000, r, TOLERANCE);
423 }
424
425 {
426 bool ok = StringToDouble(r, "-2.94081596072268000000");
427 EXPECT_TRUE(ok);
428 EXPECT_NEAR(-2.94081596072268000000, r, TOLERANCE);
429 }
430
431 {
432 bool ok = StringToDouble(r, "0.42019476309409300000");
433 EXPECT_TRUE(ok);
434 EXPECT_NEAR(0.42019476309409300000, r, TOLERANCE);
435 }
436
437 {
438 bool ok = StringToDouble(r, "-3.70663631642677000000");
439 EXPECT_TRUE(ok);
440 EXPECT_NEAR(-3.70663631642677000000, r, TOLERANCE);
441 }
442
443 {
444 bool ok = StringToDouble(r, "-0.06601188243267550000");
445 EXPECT_TRUE(ok);
446 EXPECT_NEAR(-0.06601188243267550000, r, TOLERANCE);
447 }
448
449 {
450 bool ok = StringToDouble(r, "0.79928310771909400000");
451 EXPECT_TRUE(ok);
452 EXPECT_NEAR(0.79928310771909400000, r, TOLERANCE);
453 }
454
455 {
456 bool ok = StringToDouble(r, "1.65577800860582000000");
457 EXPECT_TRUE(ok);
458 EXPECT_NEAR(1.65577800860582000000, r, TOLERANCE);
459 }
460
461 {
462 bool ok = StringToDouble(r, "2.62187216187698000000");
463 EXPECT_TRUE(ok);
464 EXPECT_NEAR(2.62187216187698000000, r, TOLERANCE);
465 }
466
467 {
468 bool ok = StringToDouble(r, "0.95596656702613300000");
469 EXPECT_TRUE(ok);
470 EXPECT_NEAR(0.95596656702613300000, r, TOLERANCE);
471 }
472
473 {
474 bool ok = StringToDouble(r, "-4.14349841191783000000");
475 EXPECT_TRUE(ok);
476 EXPECT_NEAR(-4.14349841191783000000, r, TOLERANCE);
477 }
478
479 {
480 bool ok = StringToDouble(r, "-2.23732575725115000000");
481 EXPECT_TRUE(ok);
482 EXPECT_NEAR(-2.23732575725115000000, r, TOLERANCE);
483 }
484
485 {
486 bool ok = StringToDouble(r, "4.02522229405373000000");
487 EXPECT_TRUE(ok);
488 EXPECT_NEAR(4.02522229405373000000, r, TOLERANCE);
489 }
490
491 {
492 bool ok = StringToDouble(r, "-0.43364697172459700000");
493 EXPECT_TRUE(ok);
494 EXPECT_NEAR(-0.43364697172459700000, r, TOLERANCE);
495 }
496
497 {
498 bool ok = StringToDouble(r, "1.39612114240613000000");
499 EXPECT_TRUE(ok);
500 EXPECT_NEAR(1.39612114240613000000, r, TOLERANCE);
501 }
502
503 {
504 bool ok = StringToDouble(r, "-0.87981321512563200000");
505 EXPECT_TRUE(ok);
506 EXPECT_NEAR(-0.87981321512563200000, r, TOLERANCE);
507 }
508
509 {
510 bool ok = StringToDouble(r, "0.47459557296809400000");
511 EXPECT_TRUE(ok);
512 EXPECT_NEAR(0.47459557296809400000, r, TOLERANCE);
513 }
514
515 {
516 bool ok = StringToDouble(r, "1.10534326849558000000");
517 EXPECT_TRUE(ok);
518 EXPECT_NEAR(1.10534326849558000000, r, TOLERANCE);
519 }
520
521 {
522 bool ok = StringToDouble(r, "-1.48420825457170000000");
523 EXPECT_TRUE(ok);
524 EXPECT_NEAR(-1.48420825457170000000, r, TOLERANCE);
525 }
526
527 {
528 bool ok = StringToDouble(r, "-0.98994851457562000000");
529 EXPECT_TRUE(ok);
530 EXPECT_NEAR(-0.98994851457562000000, r, TOLERANCE);
531 }
532
533 {
534 bool ok = StringToDouble(r, "-0.18550683277018200000");
535 EXPECT_TRUE(ok);
536 EXPECT_NEAR(-0.18550683277018200000, r, TOLERANCE);
537 }
538
539 {
540 bool ok = StringToDouble(r, "0.79951199056989300000");
541 EXPECT_TRUE(ok);
542 EXPECT_NEAR(0.79951199056989300000, r, TOLERANCE);
543 }
544
545 {
546 bool ok = StringToDouble(r, "-2.92573951347502000000");
547 EXPECT_TRUE(ok);
548 EXPECT_NEAR(-2.92573951347502000000, r, TOLERANCE);
549 }
550
551 {
552 bool ok = StringToDouble(r, "2.46138476058529000000");
553 EXPECT_TRUE(ok);
554 EXPECT_NEAR(2.46138476058529000000, r, TOLERANCE);
555 }
556
557 {
558 bool ok = StringToDouble(r, "2.34518431607109000000");
559 EXPECT_TRUE(ok);
560 EXPECT_NEAR(2.34518431607109000000, r, TOLERANCE);
561 }
562
563 {
564 bool ok = StringToDouble(r, "1.33372656820168000000");
565 EXPECT_TRUE(ok);
566 EXPECT_NEAR(1.33372656820168000000, r, TOLERANCE);
567 }
568
569 {
570 bool ok = StringToDouble(r, "-0.16931283159188600000");
571 EXPECT_TRUE(ok);
572 EXPECT_NEAR(-0.16931283159188600000, r, TOLERANCE);
573 }
574
575 {
576 bool ok = StringToDouble(r, "-4.97223922802124000000");
577 EXPECT_TRUE(ok);
578 EXPECT_NEAR(-4.97223922802124000000, r, TOLERANCE);
579 }
580
581 {
582 bool ok = StringToDouble(r, "2.48394627491386000000");
583 EXPECT_TRUE(ok);
584 EXPECT_NEAR(2.48394627491386000000, r, TOLERANCE);
585 }
586
587 {
588 bool ok = StringToDouble(r, "0.88861737945960600000");
589 EXPECT_TRUE(ok);
590 EXPECT_NEAR(0.88861737945960600000, r, TOLERANCE);
591 }
592
593 {
594 bool ok = StringToDouble(r, "-2.85676190081840000000");
595 EXPECT_TRUE(ok);
596 EXPECT_NEAR(-2.85676190081840000000, r, TOLERANCE);
597 }
598
599 {
600 bool ok = StringToDouble(r, "1.54459170417494000000");
601 EXPECT_TRUE(ok);
602 EXPECT_NEAR(1.54459170417494000000, r, TOLERANCE);
603 }
604
605 {
606 bool ok = StringToDouble(r, "0.16447870264995300000");
607 EXPECT_TRUE(ok);
608 EXPECT_NEAR(0.16447870264995300000, r, TOLERANCE);
609 }
610
611 {
612 bool ok = StringToDouble(r, "-2.35795535411029000000");
613 EXPECT_TRUE(ok);
614 EXPECT_NEAR(-2.35795535411029000000, r, TOLERANCE);
615 }
616
617 {
618 bool ok = StringToDouble(r, "0.29431172135530300000");
619 EXPECT_TRUE(ok);
620 EXPECT_NEAR(0.29431172135530300000, r, TOLERANCE);
621 }
622
623 {
624 bool ok = StringToDouble(r, "-2.96558311276619000000");
625 EXPECT_TRUE(ok);
626 EXPECT_NEAR(-2.96558311276619000000, r, TOLERANCE);
627 }
628
629 {
630 bool ok = StringToDouble(r, "2.81681460880669000000");
631 EXPECT_TRUE(ok);
632 EXPECT_NEAR(2.81681460880669000000, r, TOLERANCE);
633 }
634
635 {
636 bool ok = StringToDouble(r, "-4.20509941503951000000");
637 EXPECT_TRUE(ok);
638 EXPECT_NEAR(-4.20509941503951000000, r, TOLERANCE);
639 }
640
641 {
642 bool ok = StringToDouble(r, "1.72765905661257000000");
643 EXPECT_TRUE(ok);
644 EXPECT_NEAR(1.72765905661257000000, r, TOLERANCE);
645 }
646
647 {
648 bool ok = StringToDouble(r, "0.48788237089759900000");
649 EXPECT_TRUE(ok);
650 EXPECT_NEAR(0.48788237089759900000, r, TOLERANCE);
651 }
652
653 {
654 bool ok = StringToDouble(r, "-1.24947907141902000000");
655 EXPECT_TRUE(ok);
656 EXPECT_NEAR(-1.24947907141902000000, r, TOLERANCE);
657 }
658
659 {
660 bool ok = StringToDouble(r, "1.59005387432649000000");
661 EXPECT_TRUE(ok);
662 EXPECT_NEAR(1.59005387432649000000, r, TOLERANCE);
663 }
664
665 {
666 bool ok = StringToDouble(r, "1.30370570926522000000");
667 EXPECT_TRUE(ok);
668 EXPECT_NEAR(1.30370570926522000000, r, TOLERANCE);
669 }
670
671 {
672 bool ok = StringToDouble(r, "1.73638792046556000000");
673 EXPECT_TRUE(ok);
674 EXPECT_NEAR(1.73638792046556000000, r, TOLERANCE);
675 }
676
677 {
678 bool ok = StringToDouble(r, "-0.87789934199453800000");
679 EXPECT_TRUE(ok);
680 EXPECT_NEAR(-0.87789934199453800000, r, TOLERANCE);
681 }
682
683 {
684 bool ok = StringToDouble(r, "-2.51989255137937000000");
685 EXPECT_TRUE(ok);
686 EXPECT_NEAR(-2.51989255137937000000, r, TOLERANCE);
687 }
688
689 {
690 bool ok = StringToDouble(r, "-1.76305470679095000000");
691 EXPECT_TRUE(ok);
692 EXPECT_NEAR(-1.76305470679095000000, r, TOLERANCE);
693 }
694
695 {
696 bool ok = StringToDouble(r, "1.86920962997342000000");
697 EXPECT_TRUE(ok);
698 EXPECT_NEAR(1.86920962997342000000, r, TOLERANCE);
699 }
700
701 {
702 bool ok = StringToDouble(r, "2.91313411328065000000");
703 EXPECT_TRUE(ok);
704 EXPECT_NEAR(2.91313411328065000000, r, TOLERANCE);
705 }
706
707 {
708 bool ok = StringToDouble(r, "-1.73463683758381000000");
709 EXPECT_TRUE(ok);
710 EXPECT_NEAR(-1.73463683758381000000, r, TOLERANCE);
711 }
712
713 {
714 bool ok = StringToDouble(r, "-0.84273889473222500000");
715 EXPECT_TRUE(ok);
716 EXPECT_NEAR(-0.84273889473222500000, r, TOLERANCE);
717 }
718
719 {
720 bool ok = StringToDouble(r, "-0.87403925546477700000");
721 EXPECT_TRUE(ok);
722 EXPECT_NEAR(-0.87403925546477700000, r, TOLERANCE);
723 }
724
725 {
726 bool ok = StringToDouble(r, "-4.36964126011414000000");
727 EXPECT_TRUE(ok);
728 EXPECT_NEAR(-4.36964126011414000000, r, TOLERANCE);
729 }
730
731 {
732 bool ok = StringToDouble(r, "2.02726746648694000000");
733 EXPECT_TRUE(ok);
734 EXPECT_NEAR(2.02726746648694000000, r, TOLERANCE);
735 }
736
737 {
738 bool ok = StringToDouble(r, "2.50557053097483000000");
739 EXPECT_TRUE(ok);
740 EXPECT_NEAR(2.50557053097483000000, r, TOLERANCE);
741 }
742
743 {
744 bool ok = StringToDouble(r, "-1.56453106035648000000");
745 EXPECT_TRUE(ok);
746 EXPECT_NEAR(-1.56453106035648000000, r, TOLERANCE);
747 }
748
749 {
750 bool ok = StringToDouble(r, "1.61890516636808000000");
751 EXPECT_TRUE(ok);
752 EXPECT_NEAR(1.61890516636808000000, r, TOLERANCE);
753 }
754
755 {
756 bool ok = StringToDouble(r, "-3.37767835277405000000");
757 EXPECT_TRUE(ok);
758 EXPECT_NEAR(-3.37767835277405000000, r, TOLERANCE);
759 }
760
761 {
762 bool ok = StringToDouble(r, "0.90511255527429100000");
763 EXPECT_TRUE(ok);
764 EXPECT_NEAR(0.90511255527429100000, r, TOLERANCE);
765 }
766
767 {
768 bool ok = StringToDouble(r, "2.05929345122920000000");
769 EXPECT_TRUE(ok);
770 EXPECT_NEAR(2.05929345122920000000, r, TOLERANCE);
771 }
772
773 {
774 bool ok = StringToDouble(r, "1.21311454144036000000");
775 EXPECT_TRUE(ok);
776 EXPECT_NEAR(1.21311454144036000000, r, TOLERANCE);
777 }
778
779 {
780 bool ok = StringToDouble(r, "-7.79062987304713000000");
781 EXPECT_TRUE(ok);
782 EXPECT_NEAR(-7.79062987304713000000, r, TOLERANCE);
783 }
784
785 {
786 bool ok = StringToDouble(r, "5.21365525338096000000");
787 EXPECT_TRUE(ok);
788 EXPECT_NEAR(5.21365525338096000000, r, TOLERANCE);
789 }
790
791 {
792 bool ok = StringToDouble(r, "4.28348152906416000000");
793 EXPECT_TRUE(ok);
794 EXPECT_NEAR(4.28348152906416000000, r, TOLERANCE);
795 }
796
797 {
798 bool ok = StringToDouble(r, "1.06610409505261000000");
799 EXPECT_TRUE(ok);
800 EXPECT_NEAR(1.06610409505261000000, r, TOLERANCE);
801 }
802
803 {
804 bool ok = StringToDouble(r, "-0.35302095923550200000");
805 EXPECT_TRUE(ok);
806 EXPECT_NEAR(-0.35302095923550200000, r, TOLERANCE);
807 }
808
809 {
810 bool ok = StringToDouble(r, "2.90818370281786000000");
811 EXPECT_TRUE(ok);
812 EXPECT_NEAR(2.90818370281786000000, r, TOLERANCE);
813 }
814
815 {
816 bool ok = StringToDouble(r, "5.32125632829404000000");
817 EXPECT_TRUE(ok);
818 EXPECT_NEAR(5.32125632829404000000, r, TOLERANCE);
819 }
820
821 {
822 bool ok = StringToDouble(r, "-0.19461589112926800000");
823 EXPECT_TRUE(ok);
824 EXPECT_NEAR(-0.19461589112926800000, r, TOLERANCE);
825 }
826
827 {
828 bool ok = StringToDouble(r, "-0.13206147532649300000");
829 EXPECT_TRUE(ok);
830 EXPECT_NEAR(-0.13206147532649300000, r, TOLERANCE);
831 }
832
833 {
834 bool ok = StringToDouble(r, "2.90445975568758000000");
835 EXPECT_TRUE(ok);
836 EXPECT_NEAR(2.90445975568758000000, r, TOLERANCE);
837 }
838
839 {
840 bool ok = StringToDouble(r, "2.09055301456874000000");
841 EXPECT_TRUE(ok);
842 EXPECT_NEAR(2.09055301456874000000, r, TOLERANCE);
843 }
844
845 {
846 bool ok = StringToDouble(r, "-0.94747584830211900000");
847 EXPECT_TRUE(ok);
848 EXPECT_NEAR(-0.94747584830211900000, r, TOLERANCE);
849 }
850
851 {
852 bool ok = StringToDouble(r, "-1.87479371073786000000");
853 EXPECT_TRUE(ok);
854 EXPECT_NEAR(-1.87479371073786000000, r, TOLERANCE);
855 }
856
857 {
858 bool ok = StringToDouble(r, "-5.77693922561847000000");
859 EXPECT_TRUE(ok);
860 EXPECT_NEAR(-5.77693922561847000000, r, TOLERANCE);
861 }
862
863 {
864 bool ok = StringToDouble(r, "1.43857452366099000000");
865 EXPECT_TRUE(ok);
866 EXPECT_NEAR(1.43857452366099000000, r, TOLERANCE);
867 }
868
869 {
870 bool ok = StringToDouble(r, "1.32571155407419000000");
871 EXPECT_TRUE(ok);
872 EXPECT_NEAR(1.32571155407419000000, r, TOLERANCE);
873 }
874
875 {
876 bool ok = StringToDouble(r, "0.02598140411007480000");
877 EXPECT_TRUE(ok);
878 EXPECT_NEAR(0.02598140411007480000, r, TOLERANCE);
879 }
880
881 {
882 bool ok = StringToDouble(r, "1.63213858956142000000");
883 EXPECT_TRUE(ok);
884 EXPECT_NEAR(1.63213858956142000000, r, TOLERANCE);
885 }
886
887 {
888 bool ok = StringToDouble(r, "2.87199046737281000000");
889 EXPECT_TRUE(ok);
890 EXPECT_NEAR(2.87199046737281000000, r, TOLERANCE);
891 }
892
893 {
894 bool ok = StringToDouble(r, "-1.51485641768478000000");
895 EXPECT_TRUE(ok);
896 EXPECT_NEAR(-1.51485641768478000000, r, TOLERANCE);
897 }
898
899 {
900 bool ok = StringToDouble(r, "0.64286402800302700000");
901 EXPECT_TRUE(ok);
902 EXPECT_NEAR(0.64286402800302700000, r, TOLERANCE);
903 }
904
905 {
906 bool ok = StringToDouble(r, "2.47677130142230000000");
907 EXPECT_TRUE(ok);
908 EXPECT_NEAR(2.47677130142230000000, r, TOLERANCE);
909 }
910
911 {
912 bool ok = StringToDouble(r, "2.39498987162520000000");
913 EXPECT_TRUE(ok);
914 EXPECT_NEAR(2.39498987162520000000, r, TOLERANCE);
915 }
916
917 {
918 bool ok = StringToDouble(r, "0.97846593865349600000");
919 EXPECT_TRUE(ok);
920 EXPECT_NEAR(0.97846593865349600000, r, TOLERANCE);
921 }
922
923 {
924 bool ok = StringToDouble(r, "3.38696988049949000000");
925 EXPECT_TRUE(ok);
926 EXPECT_NEAR(3.38696988049949000000, r, TOLERANCE);
927 }
928
929 {
930 bool ok = StringToDouble(r, "0.99716557343840900000");
931 EXPECT_TRUE(ok);
932 EXPECT_NEAR(0.99716557343840900000, r, TOLERANCE);
933 }
934
935 {
936 bool ok = StringToDouble(r, "-0.26983285318203300000");
937 EXPECT_TRUE(ok);
938 EXPECT_NEAR(-0.26983285318203300000, r, TOLERANCE);
939 }
940
941 {
942 bool ok = StringToDouble(r, "0.02818282704670500000");
943 EXPECT_TRUE(ok);
944 EXPECT_NEAR(0.02818282704670500000, r, TOLERANCE);
945 }
946
947 {
948 bool ok = StringToDouble(r, "-3.33995460770471000000");
949 EXPECT_TRUE(ok);
950 EXPECT_NEAR(-3.33995460770471000000, r, TOLERANCE);
951 }
952
953 {
954 bool ok = StringToDouble(r, "-1.90961343273142000000");
955 EXPECT_TRUE(ok);
956 EXPECT_NEAR(-1.90961343273142000000, r, TOLERANCE);
957 }
958
959 {
960 bool ok = StringToDouble(r, "-1.70545858631691000000");
961 EXPECT_TRUE(ok);
962 EXPECT_NEAR(-1.70545858631691000000, r, TOLERANCE);
963 }
964
965 {
966 bool ok = StringToDouble(r, "-2.99837322296447000000");
967 EXPECT_TRUE(ok);
968 EXPECT_NEAR(-2.99837322296447000000, r, TOLERANCE);
969 }
970
971 {
972 bool ok = StringToDouble(r, "2.52931499785106000000");
973 EXPECT_TRUE(ok);
974 EXPECT_NEAR(2.52931499785106000000, r, TOLERANCE);
975 }
976
977 {
978 bool ok = StringToDouble(r, "1.50600351005455000000");
979 EXPECT_TRUE(ok);
980 EXPECT_NEAR(1.50600351005455000000, r, TOLERANCE);
981 }
982
983 {
984 bool ok = StringToDouble(r, "-0.83191012798055900000");
985 EXPECT_TRUE(ok);
986 EXPECT_NEAR(-0.83191012798055900000, r, TOLERANCE);
987 }
988 }
989
990 TEST(GenericToolbox, TestStringToDouble2)
991 {
992 using OrthancStone::GenericToolbox::StringToDouble;
993
994 const double TOLERANCE = 0.00000000000001;
995 double r = 0.0;
996
997 {
998 bool ok = StringToDouble(r, "2.58090819604341000000");
999 EXPECT_TRUE(ok);
1000 EXPECT_NEAR(2.58090819604341000000, r, TOLERANCE);
1001 }
1002
1003 {
1004 bool ok = StringToDouble(r, "-1.95182376827953000000");
1005 EXPECT_TRUE(ok);
1006 EXPECT_NEAR(-1.95182376827953000000, r, TOLERANCE);
1007 }
1008
1009 {
1010 bool ok = StringToDouble(r, "-5.04199841193785000000");
1011 EXPECT_TRUE(ok);
1012 EXPECT_NEAR(-5.04199841193785000000, r, TOLERANCE);
1013 }
1014
1015 {
1016 bool ok = StringToDouble(r, "-4.17938850513021000000");
1017 EXPECT_TRUE(ok);
1018 EXPECT_NEAR(-4.17938850513021000000, r, TOLERANCE);
1019 }
1020
1021 {
1022 bool ok = StringToDouble(r, "-1.66797071567664000000");
1023 EXPECT_TRUE(ok);
1024 EXPECT_NEAR(-1.66797071567664000000, r, TOLERANCE);
1025 }
1026
1027 {
1028 bool ok = StringToDouble(r, "3.37221015583147000000");
1029 EXPECT_TRUE(ok);
1030 EXPECT_NEAR(3.37221015583147000000, r, TOLERANCE);
1031 }
1032
1033 {
1034 bool ok = StringToDouble(r, "-4.75673862000485000000");
1035 EXPECT_TRUE(ok);
1036 EXPECT_NEAR(-4.75673862000485000000, r, TOLERANCE);
1037 }
1038
1039 {
1040 bool ok = StringToDouble(r, "0.79003986824116500000");
1041 EXPECT_TRUE(ok);
1042 EXPECT_NEAR(0.79003986824116500000, r, TOLERANCE);
1043 }
1044
1045 {
1046 bool ok = StringToDouble(r, "-3.86020949016507000000");
1047 EXPECT_TRUE(ok);
1048 EXPECT_NEAR(-3.86020949016507000000, r, TOLERANCE);
1049 }
1050
1051 {
1052 bool ok = StringToDouble(r, "-2.14082258481500000000");
1053 EXPECT_TRUE(ok);
1054 EXPECT_NEAR(-2.14082258481500000000, r, TOLERANCE);
1055 }
1056
1057 {
1058 bool ok = StringToDouble(r, "-3.71685664840859000000");
1059 EXPECT_TRUE(ok);
1060 EXPECT_NEAR(-3.71685664840859000000, r, TOLERANCE);
1061 }
1062
1063 {
1064 bool ok = StringToDouble(r, "-0.93998389083824300000");
1065 EXPECT_TRUE(ok);
1066 EXPECT_NEAR(-0.93998389083824300000, r, TOLERANCE);
1067 }
1068
1069 {
1070 bool ok = StringToDouble(r, "2.77244357996158000000");
1071 EXPECT_TRUE(ok);
1072 EXPECT_NEAR(2.77244357996158000000, r, TOLERANCE);
1073 }
1074
1075 {
1076 bool ok = StringToDouble(r, "-0.10595524850565900000");
1077 EXPECT_TRUE(ok);
1078 EXPECT_NEAR(-0.10595524850565900000, r, TOLERANCE);
1079 }
1080
1081 {
1082 bool ok = StringToDouble(r, "3.69799635213612000000");
1083 EXPECT_TRUE(ok);
1084 EXPECT_NEAR(3.69799635213612000000, r, TOLERANCE);
1085 }
1086
1087 {
1088 bool ok = StringToDouble(r, "-0.57971250175452400000");
1089 EXPECT_TRUE(ok);
1090 EXPECT_NEAR(-0.57971250175452400000, r, TOLERANCE);
1091 }
1092
1093 {
1094 bool ok = StringToDouble(r, "-0.92766866933807100000");
1095 EXPECT_TRUE(ok);
1096 EXPECT_NEAR(-0.92766866933807100000, r, TOLERANCE);
1097 }
1098
1099 {
1100 bool ok = StringToDouble(r, "-5.46991620588858000000");
1101 EXPECT_TRUE(ok);
1102 EXPECT_NEAR(-5.46991620588858000000, r, TOLERANCE);
1103 }
1104
1105 {
1106 bool ok = StringToDouble(r, "5.94569644123488000000");
1107 EXPECT_TRUE(ok);
1108 EXPECT_NEAR(5.94569644123488000000, r, TOLERANCE);
1109 }
1110
1111 {
1112 bool ok = StringToDouble(r, "4.18859094010287000000");
1113 EXPECT_TRUE(ok);
1114 EXPECT_NEAR(4.18859094010287000000, r, TOLERANCE);
1115 }
1116
1117 {
1118 bool ok = StringToDouble(r, "3.03213167005865000000");
1119 EXPECT_TRUE(ok);
1120 EXPECT_NEAR(3.03213167005865000000, r, TOLERANCE);
1121 }
1122
1123 {
1124 bool ok = StringToDouble(r, "8.81754146434609000000");
1125 EXPECT_TRUE(ok);
1126 EXPECT_NEAR(8.81754146434609000000, r, TOLERANCE);
1127 }
1128
1129 {
1130 bool ok = StringToDouble(r, "-0.75897430327076600000");
1131 EXPECT_TRUE(ok);
1132 EXPECT_NEAR(-0.75897430327076600000, r, TOLERANCE);
1133 }
1134
1135 {
1136 bool ok = StringToDouble(r, "1.80047028975912000000");
1137 EXPECT_TRUE(ok);
1138 EXPECT_NEAR(1.80047028975912000000, r, TOLERANCE);
1139 }
1140
1141 {
1142 bool ok = StringToDouble(r, "-0.00529573224131364000");
1143 EXPECT_TRUE(ok);
1144 EXPECT_NEAR(-0.00529573224131364000, r, TOLERANCE);
1145 }
1146
1147 {
1148 bool ok = StringToDouble(r, "2.71024073322357000000");
1149 EXPECT_TRUE(ok);
1150 EXPECT_NEAR(2.71024073322357000000, r, TOLERANCE);
1151 }
1152
1153 {
1154 bool ok = StringToDouble(r, "1.60642130185119000000");
1155 EXPECT_TRUE(ok);
1156 EXPECT_NEAR(1.60642130185119000000, r, TOLERANCE);
1157 }
1158
1159 {
1160 bool ok = StringToDouble(r, "5.09793780927960000000");
1161 EXPECT_TRUE(ok);
1162 EXPECT_NEAR(5.09793780927960000000, r, TOLERANCE);
1163 }
1164
1165 {
1166 bool ok = StringToDouble(r, "-3.18560965637846000000");
1167 EXPECT_TRUE(ok);
1168 EXPECT_NEAR(-3.18560965637846000000, r, TOLERANCE);
1169 }
1170
1171 {
1172 bool ok = StringToDouble(r, "-3.13078526893487000000");
1173 EXPECT_TRUE(ok);
1174 EXPECT_NEAR(-3.13078526893487000000, r, TOLERANCE);
1175 }
1176
1177 {
1178 bool ok = StringToDouble(r, "-4.19951899215254000000");
1179 EXPECT_TRUE(ok);
1180 EXPECT_NEAR(-4.19951899215254000000, r, TOLERANCE);
1181 }
1182
1183 {
1184 bool ok = StringToDouble(r, "-2.81885534502479000000");
1185 EXPECT_TRUE(ok);
1186 EXPECT_NEAR(-2.81885534502479000000, r, TOLERANCE);
1187 }
1188
1189 {
1190 bool ok = StringToDouble(r, "1.00480638980341000000");
1191 EXPECT_TRUE(ok);
1192 EXPECT_NEAR(1.00480638980341000000, r, TOLERANCE);
1193 }
1194
1195 {
1196 bool ok = StringToDouble(r, "-0.35315675289406200000");
1197 EXPECT_TRUE(ok);
1198 EXPECT_NEAR(-0.35315675289406200000, r, TOLERANCE);
1199 }
1200
1201 {
1202 bool ok = StringToDouble(r, "-1.29812812014442000000");
1203 EXPECT_TRUE(ok);
1204 EXPECT_NEAR(-1.29812812014442000000, r, TOLERANCE);
1205 }
1206
1207 {
1208 bool ok = StringToDouble(r, "-2.98878626408816000000");
1209 EXPECT_TRUE(ok);
1210 EXPECT_NEAR(-2.98878626408816000000, r, TOLERANCE);
1211 }
1212
1213 {
1214 bool ok = StringToDouble(r, "1.34644737073484000000");
1215 EXPECT_TRUE(ok);
1216 EXPECT_NEAR(1.34644737073484000000, r, TOLERANCE);
1217 }
1218
1219 {
1220 bool ok = StringToDouble(r, "-3.37478492823657000000");
1221 EXPECT_TRUE(ok);
1222 EXPECT_NEAR(-3.37478492823657000000, r, TOLERANCE);
1223 }
1224
1225 {
1226 bool ok = StringToDouble(r, "-2.97205178784195000000");
1227 EXPECT_TRUE(ok);
1228 EXPECT_NEAR(-2.97205178784195000000, r, TOLERANCE);
1229 }
1230
1231 {
1232 bool ok = StringToDouble(r, "-4.65165003646427000000");
1233 EXPECT_TRUE(ok);
1234 EXPECT_NEAR(-4.65165003646427000000, r, TOLERANCE);
1235 }
1236
1237 {
1238 bool ok = StringToDouble(r, "4.89236175545723000000");
1239 EXPECT_TRUE(ok);
1240 EXPECT_NEAR(4.89236175545723000000, r, TOLERANCE);
1241 }
1242
1243 {
1244 bool ok = StringToDouble(r, "3.80366872242454000000");
1245 EXPECT_TRUE(ok);
1246 EXPECT_NEAR(3.80366872242454000000, r, TOLERANCE);
1247 }
1248
1249 {
1250 bool ok = StringToDouble(r, "7.65465855719486000000");
1251 EXPECT_TRUE(ok);
1252 EXPECT_NEAR(7.65465855719486000000, r, TOLERANCE);
1253 }
1254
1255 {
1256 bool ok = StringToDouble(r, "-0.51455943741659600000");
1257 EXPECT_TRUE(ok);
1258 EXPECT_NEAR(-0.51455943741659600000, r, TOLERANCE);
1259 }
1260
1261 {
1262 bool ok = StringToDouble(r, "5.14337541345649000000");
1263 EXPECT_TRUE(ok);
1264 EXPECT_NEAR(5.14337541345649000000, r, TOLERANCE);
1265 }
1266
1267 {
1268 bool ok = StringToDouble(r, "1.06909574569091000000");
1269 EXPECT_TRUE(ok);
1270 EXPECT_NEAR(1.06909574569091000000, r, TOLERANCE);
1271 }
1272
1273 {
1274 bool ok = StringToDouble(r, "-1.07698497525470000000");
1275 EXPECT_TRUE(ok);
1276 EXPECT_NEAR(-1.07698497525470000000, r, TOLERANCE);
1277 }
1278
1279 {
1280 bool ok = StringToDouble(r, "2.04223854975535000000");
1281 EXPECT_TRUE(ok);
1282 EXPECT_NEAR(2.04223854975535000000, r, TOLERANCE);
1283 }
1284
1285 {
1286 bool ok = StringToDouble(r, "1.46422724459484000000");
1287 EXPECT_TRUE(ok);
1288 EXPECT_NEAR(1.46422724459484000000, r, TOLERANCE);
1289 }
1290
1291 {
1292 bool ok = StringToDouble(r, "-1.65888981424971000000");
1293 EXPECT_TRUE(ok);
1294 EXPECT_NEAR(-1.65888981424971000000, r, TOLERANCE);
1295 }
1296
1297 {
1298 bool ok = StringToDouble(r, "-7.10193673069906000000");
1299 EXPECT_TRUE(ok);
1300 EXPECT_NEAR(-7.10193673069906000000, r, TOLERANCE);
1301 }
1302
1303 {
1304 bool ok = StringToDouble(r, "-0.77638222509466500000");
1305 EXPECT_TRUE(ok);
1306 EXPECT_NEAR(-0.77638222509466500000, r, TOLERANCE);
1307 }
1308
1309 {
1310 bool ok = StringToDouble(r, "2.15543610545042000000");
1311 EXPECT_TRUE(ok);
1312 EXPECT_NEAR(2.15543610545042000000, r, TOLERANCE);
1313 }
1314
1315 {
1316 bool ok = StringToDouble(r, "2.51787760900314000000");
1317 EXPECT_TRUE(ok);
1318 EXPECT_NEAR(2.51787760900314000000, r, TOLERANCE);
1319 }
1320
1321 {
1322 bool ok = StringToDouble(r, "-1.09022915694655000000");
1323 EXPECT_TRUE(ok);
1324 EXPECT_NEAR(-1.09022915694655000000, r, TOLERANCE);
1325 }
1326
1327 {
1328 bool ok = StringToDouble(r, "-1.41861013154040000000");
1329 EXPECT_TRUE(ok);
1330 EXPECT_NEAR(-1.41861013154040000000, r, TOLERANCE);
1331 }
1332
1333 {
1334 bool ok = StringToDouble(r, "-1.40227565288403000000");
1335 EXPECT_TRUE(ok);
1336 EXPECT_NEAR(-1.40227565288403000000, r, TOLERANCE);
1337 }
1338
1339 {
1340 bool ok = StringToDouble(r, "-0.44321592617247400000");
1341 EXPECT_TRUE(ok);
1342 EXPECT_NEAR(-0.44321592617247400000, r, TOLERANCE);
1343 }
1344
1345 {
1346 bool ok = StringToDouble(r, "-2.34090258417639000000");
1347 EXPECT_TRUE(ok);
1348 EXPECT_NEAR(-2.34090258417639000000, r, TOLERANCE);
1349 }
1350
1351 {
1352 bool ok = StringToDouble(r, "0.54291265629528700000");
1353 EXPECT_TRUE(ok);
1354 EXPECT_NEAR(0.54291265629528700000, r, TOLERANCE);
1355 }
1356
1357 {
1358 bool ok = StringToDouble(r, "1.70700051509186000000");
1359 EXPECT_TRUE(ok);
1360 EXPECT_NEAR(1.70700051509186000000, r, TOLERANCE);
1361 }
1362
1363 {
1364 bool ok = StringToDouble(r, "-6.55072864947955000000");
1365 EXPECT_TRUE(ok);
1366 EXPECT_NEAR(-6.55072864947955000000, r, TOLERANCE);
1367 }
1368
1369 {
1370 bool ok = StringToDouble(r, "-1.96741942560520000000");
1371 EXPECT_TRUE(ok);
1372 EXPECT_NEAR(-1.96741942560520000000, r, TOLERANCE);
1373 }
1374
1375 {
1376 bool ok = StringToDouble(r, "3.55202552301084000000");
1377 EXPECT_TRUE(ok);
1378 EXPECT_NEAR(3.55202552301084000000, r, TOLERANCE);
1379 }
1380
1381 {
1382 bool ok = StringToDouble(r, "0.36133250863907300000");
1383 EXPECT_TRUE(ok);
1384 EXPECT_NEAR(0.36133250863907300000, r, TOLERANCE);
1385 }
1386
1387 {
1388 bool ok = StringToDouble(r, "-1.46513564511238000000");
1389 EXPECT_TRUE(ok);
1390 EXPECT_NEAR(-1.46513564511238000000, r, TOLERANCE);
1391 }
1392
1393 {
1394 bool ok = StringToDouble(r, "1.97424909475891000000");
1395 EXPECT_TRUE(ok);
1396 EXPECT_NEAR(1.97424909475891000000, r, TOLERANCE);
1397 }
1398
1399 {
1400 bool ok = StringToDouble(r, "0.87005014400085000000");
1401 EXPECT_TRUE(ok);
1402 EXPECT_NEAR(0.87005014400085000000, r, TOLERANCE);
1403 }
1404
1405 {
1406 bool ok = StringToDouble(r, "-1.25552308785543000000");
1407 EXPECT_TRUE(ok);
1408 EXPECT_NEAR(-1.25552308785543000000, r, TOLERANCE);
1409 }
1410
1411 {
1412 bool ok = StringToDouble(r, "-0.43365620710902500000");
1413 EXPECT_TRUE(ok);
1414 EXPECT_NEAR(-0.43365620710902500000, r, TOLERANCE);
1415 }
1416
1417 {
1418 bool ok = StringToDouble(r, "1.17392137573999000000");
1419 EXPECT_TRUE(ok);
1420 EXPECT_NEAR(1.17392137573999000000, r, TOLERANCE);
1421 }
1422
1423 {
1424 bool ok = StringToDouble(r, "-4.56870774575795000000");
1425 EXPECT_TRUE(ok);
1426 EXPECT_NEAR(-4.56870774575795000000, r, TOLERANCE);
1427 }
1428
1429 {
1430 bool ok = StringToDouble(r, "0.07449225479459900000");
1431 EXPECT_TRUE(ok);
1432 EXPECT_NEAR(0.07449225479459900000, r, TOLERANCE);
1433 }
1434
1435 {
1436 bool ok = StringToDouble(r, "5.25905472211571000000");
1437 EXPECT_TRUE(ok);
1438 EXPECT_NEAR(5.25905472211571000000, r, TOLERANCE);
1439 }
1440
1441 {
1442 bool ok = StringToDouble(r, "-2.13708454690765000000");
1443 EXPECT_TRUE(ok);
1444 EXPECT_NEAR(-2.13708454690765000000, r, TOLERANCE);
1445 }
1446
1447 {
1448 bool ok = StringToDouble(r, "0.08223808231444500000");
1449 EXPECT_TRUE(ok);
1450 EXPECT_NEAR(0.08223808231444500000, r, TOLERANCE);
1451 }
1452
1453 {
1454 bool ok = StringToDouble(r, "-1.69624060459529000000");
1455 EXPECT_TRUE(ok);
1456 EXPECT_NEAR(-1.69624060459529000000, r, TOLERANCE);
1457 }
1458
1459 {
1460 bool ok = StringToDouble(r, "4.87232652840742000000");
1461 EXPECT_TRUE(ok);
1462 EXPECT_NEAR(4.87232652840742000000, r, TOLERANCE);
1463 }
1464
1465 {
1466 bool ok = StringToDouble(r, "-0.20739068103174300000");
1467 EXPECT_TRUE(ok);
1468 EXPECT_NEAR(-0.20739068103174300000, r, TOLERANCE);
1469 }
1470
1471 {
1472 bool ok = StringToDouble(r, "-0.45449313279700600000");
1473 EXPECT_TRUE(ok);
1474 EXPECT_NEAR(-0.45449313279700600000, r, TOLERANCE);
1475 }
1476
1477 {
1478 bool ok = StringToDouble(r, "-1.06604828436047000000");
1479 EXPECT_TRUE(ok);
1480 EXPECT_NEAR(-1.06604828436047000000, r, TOLERANCE);
1481 }
1482
1483 {
1484 bool ok = StringToDouble(r, "0.16603807756896700000");
1485 EXPECT_TRUE(ok);
1486 EXPECT_NEAR(0.16603807756896700000, r, TOLERANCE);
1487 }
1488
1489 {
1490 bool ok = StringToDouble(r, "6.56288534361719000000");
1491 EXPECT_TRUE(ok);
1492 EXPECT_NEAR(6.56288534361719000000, r, TOLERANCE);
1493 }
1494
1495 {
1496 bool ok = StringToDouble(r, "1.28481655900710000000");
1497 EXPECT_TRUE(ok);
1498 EXPECT_NEAR(1.28481655900710000000, r, TOLERANCE);
1499 }
1500
1501 {
1502 bool ok = StringToDouble(r, "0.79412040010646300000");
1503 EXPECT_TRUE(ok);
1504 EXPECT_NEAR(0.79412040010646300000, r, TOLERANCE);
1505 }
1506
1507 {
1508 bool ok = StringToDouble(r, "-2.90088144503330000000");
1509 EXPECT_TRUE(ok);
1510 EXPECT_NEAR(-2.90088144503330000000, r, TOLERANCE);
1511 }
1512
1513 {
1514 bool ok = StringToDouble(r, "-0.65278657648370200000");
1515 EXPECT_TRUE(ok);
1516 EXPECT_NEAR(-0.65278657648370200000, r, TOLERANCE);
1517 }
1518
1519 {
1520 bool ok = StringToDouble(r, "-2.40305895338068000000");
1521 EXPECT_TRUE(ok);
1522 EXPECT_NEAR(-2.40305895338068000000, r, TOLERANCE);
1523 }
1524
1525 {
1526 bool ok = StringToDouble(r, "1.07193308249503000000");
1527 EXPECT_TRUE(ok);
1528 EXPECT_NEAR(1.07193308249503000000, r, TOLERANCE);
1529 }
1530
1531 {
1532 bool ok = StringToDouble(r, "0.83752112822253600000");
1533 EXPECT_TRUE(ok);
1534 EXPECT_NEAR(0.83752112822253600000, r, TOLERANCE);
1535 }
1536
1537 {
1538 bool ok = StringToDouble(r, "-0.63174453257058400000");
1539 EXPECT_TRUE(ok);
1540 EXPECT_NEAR(-0.63174453257058400000, r, TOLERANCE);
1541 }
1542
1543 {
1544 bool ok = StringToDouble(r, "1.80163760021425000000");
1545 EXPECT_TRUE(ok);
1546 EXPECT_NEAR(1.80163760021425000000, r, TOLERANCE);
1547 }
1548
1549 {
1550 bool ok = StringToDouble(r, "-3.57922670044433000000");
1551 EXPECT_TRUE(ok);
1552 EXPECT_NEAR(-3.57922670044433000000, r, TOLERANCE);
1553 }
1554
1555 {
1556 bool ok = StringToDouble(r, "6.80309348037215000000");
1557 EXPECT_TRUE(ok);
1558 EXPECT_NEAR(6.80309348037215000000, r, TOLERANCE);
1559 }
1560
1561 {
1562 bool ok = StringToDouble(r, "4.03658264005365000000");
1563 EXPECT_TRUE(ok);
1564 EXPECT_NEAR(4.03658264005365000000, r, TOLERANCE);
1565 }
1566
1567 {
1568 bool ok = StringToDouble(r, "8.57714214650747000000");
1569 EXPECT_TRUE(ok);
1570 EXPECT_NEAR(8.57714214650747000000, r, TOLERANCE);
1571 }
1572
1573 {
1574 bool ok = StringToDouble(r, "-0.25657256359494300000");
1575 EXPECT_TRUE(ok);
1576 EXPECT_NEAR(-0.25657256359494300000, r, TOLERANCE);
1577 }
1578
1579 {
1580 bool ok = StringToDouble(r, "2.07218601388076000000");
1581 EXPECT_TRUE(ok);
1582 EXPECT_NEAR(2.07218601388076000000, r, TOLERANCE);
1583 }
1584
1585 {
1586 bool ok = StringToDouble(r, "-0.70300607815345600000");
1587 EXPECT_TRUE(ok);
1588 EXPECT_NEAR(-0.70300607815345600000, r, TOLERANCE);
1589 }
1590
1591 {
1592 bool ok = StringToDouble(r, "-0.06822028770915030000");
1593 EXPECT_TRUE(ok);
1594 EXPECT_NEAR(-0.06822028770915030000, r, TOLERANCE);
1595 }
1596
1597 {
1598 bool ok = StringToDouble(r, "-0.52253514473857300000");
1599 EXPECT_TRUE(ok);
1600 EXPECT_NEAR(-0.52253514473857300000, r, TOLERANCE);
1601 }
1602
1603 {
1604 bool ok = StringToDouble(r, "-2.89211508282910000000");
1605 EXPECT_TRUE(ok);
1606 EXPECT_NEAR(-2.89211508282910000000, r, TOLERANCE);
1607 }
1608
1609 {
1610 bool ok = StringToDouble(r, "-1.47331243043688000000");
1611 EXPECT_TRUE(ok);
1612 EXPECT_NEAR(-1.47331243043688000000, r, TOLERANCE);
1613 }
1614
1615 {
1616 bool ok = StringToDouble(r, "-3.77190031720697000000");
1617 EXPECT_TRUE(ok);
1618 EXPECT_NEAR(-3.77190031720697000000, r, TOLERANCE);
1619 }
1620
1621 {
1622 bool ok = StringToDouble(r, "-0.80704979593058400000");
1623 EXPECT_TRUE(ok);
1624 EXPECT_NEAR(-0.80704979593058400000, r, TOLERANCE);
1625 }
1626
1627 {
1628 bool ok = StringToDouble(r, "1.58398766715845000000");
1629 EXPECT_TRUE(ok);
1630 EXPECT_NEAR(1.58398766715845000000, r, TOLERANCE);
1631 }
1632
1633 {
1634 bool ok = StringToDouble(r, "2.59532008540482000000");
1635 EXPECT_TRUE(ok);
1636 EXPECT_NEAR(2.59532008540482000000, r, TOLERANCE);
1637 }
1638
1639 {
1640 bool ok = StringToDouble(r, "-2.92824570343456000000");
1641 EXPECT_TRUE(ok);
1642 EXPECT_NEAR(-2.92824570343456000000, r, TOLERANCE);
1643 }
1644
1645 {
1646 bool ok = StringToDouble(r, "-0.15232705272560400000");
1647 EXPECT_TRUE(ok);
1648 EXPECT_NEAR(-0.15232705272560400000, r, TOLERANCE);
1649 }
1650
1651 {
1652 bool ok = StringToDouble(r, "0.13670276871382500000");
1653 EXPECT_TRUE(ok);
1654 EXPECT_NEAR(0.13670276871382500000, r, TOLERANCE);
1655 }
1656
1657 {
1658 bool ok = StringToDouble(r, "2.20063314286385000000");
1659 EXPECT_TRUE(ok);
1660 EXPECT_NEAR(2.20063314286385000000, r, TOLERANCE);
1661 }
1662
1663 {
1664 bool ok = StringToDouble(r, "2.20390958339690000000");
1665 EXPECT_TRUE(ok);
1666 EXPECT_NEAR(2.20390958339690000000, r, TOLERANCE);
1667 }
1668
1669 {
1670 bool ok = StringToDouble(r, "-1.01999231401200000000");
1671 EXPECT_TRUE(ok);
1672 EXPECT_NEAR(-1.01999231401200000000, r, TOLERANCE);
1673 }
1674
1675 {
1676 bool ok = StringToDouble(r, "-4.33696129476675000000");
1677 EXPECT_TRUE(ok);
1678 EXPECT_NEAR(-4.33696129476675000000, r, TOLERANCE);
1679 }
1680
1681 {
1682 bool ok = StringToDouble(r, "-3.97472839619216000000");
1683 EXPECT_TRUE(ok);
1684 EXPECT_NEAR(-3.97472839619216000000, r, TOLERANCE);
1685 }
1686
1687 {
1688 bool ok = StringToDouble(r, "-3.25935508044004000000");
1689 EXPECT_TRUE(ok);
1690 EXPECT_NEAR(-3.25935508044004000000, r, TOLERANCE);
1691 }
1692
1693 {
1694 bool ok = StringToDouble(r, "3.98737992668548000000");
1695 EXPECT_TRUE(ok);
1696 EXPECT_NEAR(3.98737992668548000000, r, TOLERANCE);
1697 }
1698
1699 {
1700 bool ok = StringToDouble(r, "3.12647380973595000000");
1701 EXPECT_TRUE(ok);
1702 EXPECT_NEAR(3.12647380973595000000, r, TOLERANCE);
1703 }
1704
1705 {
1706 bool ok = StringToDouble(r, "2.04573005673487000000");
1707 EXPECT_TRUE(ok);
1708 EXPECT_NEAR(2.04573005673487000000, r, TOLERANCE);
1709 }
1710
1711 {
1712 bool ok = StringToDouble(r, "-3.40131707240240000000");
1713 EXPECT_TRUE(ok);
1714 EXPECT_NEAR(-3.40131707240240000000, r, TOLERANCE);
1715 }
1716
1717 {
1718 bool ok = StringToDouble(r, "-5.65350895248975000000");
1719 EXPECT_TRUE(ok);
1720 EXPECT_NEAR(-5.65350895248975000000, r, TOLERANCE);
1721 }
1722
1723 {
1724 bool ok = StringToDouble(r, "1.94344081509933000000");
1725 EXPECT_TRUE(ok);
1726 EXPECT_NEAR(1.94344081509933000000, r, TOLERANCE);
1727 }
1728
1729 {
1730 bool ok = StringToDouble(r, "4.72697189247371000000");
1731 EXPECT_TRUE(ok);
1732 EXPECT_NEAR(4.72697189247371000000, r, TOLERANCE);
1733 }
1734
1735 {
1736 bool ok = StringToDouble(r, "-6.67990308483490000000");
1737 EXPECT_TRUE(ok);
1738 EXPECT_NEAR(-6.67990308483490000000, r, TOLERANCE);
1739 }
1740
1741 {
1742 bool ok = StringToDouble(r, "1.32343310660542000000");
1743 EXPECT_TRUE(ok);
1744 EXPECT_NEAR(1.32343310660542000000, r, TOLERANCE);
1745 }
1746
1747 {
1748 bool ok = StringToDouble(r, "-2.78517123090950000000");
1749 EXPECT_TRUE(ok);
1750 EXPECT_NEAR(-2.78517123090950000000, r, TOLERANCE);
1751 }
1752
1753 {
1754 bool ok = StringToDouble(r, "5.25849816293583000000");
1755 EXPECT_TRUE(ok);
1756 EXPECT_NEAR(5.25849816293583000000, r, TOLERANCE);
1757 }
1758
1759 {
1760 bool ok = StringToDouble(r, "4.75396267700095000000");
1761 EXPECT_TRUE(ok);
1762 EXPECT_NEAR(4.75396267700095000000, r, TOLERANCE);
1763 }
1764
1765 {
1766 bool ok = StringToDouble(r, "-2.07647901824168000000");
1767 EXPECT_TRUE(ok);
1768 EXPECT_NEAR(-2.07647901824168000000, r, TOLERANCE);
1769 }
1770
1771 {
1772 bool ok = StringToDouble(r, "-3.38047538070258000000");
1773 EXPECT_TRUE(ok);
1774 EXPECT_NEAR(-3.38047538070258000000, r, TOLERANCE);
1775 }
1776
1777 {
1778 bool ok = StringToDouble(r, "0.20758597742145100000");
1779 EXPECT_TRUE(ok);
1780 EXPECT_NEAR(0.20758597742145100000, r, TOLERANCE);
1781 }
1782
1783 {
1784 bool ok = StringToDouble(r, "-0.85537090667122100000");
1785 EXPECT_TRUE(ok);
1786 EXPECT_NEAR(-0.85537090667122100000, r, TOLERANCE);
1787 }
1788
1789 {
1790 bool ok = StringToDouble(r, "0.76805423797310000000");
1791 EXPECT_TRUE(ok);
1792 EXPECT_NEAR(0.76805423797310000000, r, TOLERANCE);
1793 }
1794
1795 {
1796 bool ok = StringToDouble(r, "4.40449492713592000000");
1797 EXPECT_TRUE(ok);
1798 EXPECT_NEAR(4.40449492713592000000, r, TOLERANCE);
1799 }
1800
1801 {
1802 bool ok = StringToDouble(r, "-3.62167096457336000000");
1803 EXPECT_TRUE(ok);
1804 EXPECT_NEAR(-3.62167096457336000000, r, TOLERANCE);
1805 }
1806
1807 {
1808 bool ok = StringToDouble(r, "3.74002997550002000000");
1809 EXPECT_TRUE(ok);
1810 EXPECT_NEAR(3.74002997550002000000, r, TOLERANCE);
1811 }
1812
1813 {
1814 bool ok = StringToDouble(r, "0.42443064164790400000");
1815 EXPECT_TRUE(ok);
1816 EXPECT_NEAR(0.42443064164790400000, r, TOLERANCE);
1817 }
1818
1819 {
1820 bool ok = StringToDouble(r, "-0.27951604455776900000");
1821 EXPECT_TRUE(ok);
1822 EXPECT_NEAR(-0.27951604455776900000, r, TOLERANCE);
1823 }
1824
1825 {
1826 bool ok = StringToDouble(r, "-0.51579267322296100000");
1827 EXPECT_TRUE(ok);
1828 EXPECT_NEAR(-0.51579267322296100000, r, TOLERANCE);
1829 }
1830
1831 {
1832 bool ok = StringToDouble(r, "-2.36457251883339000000");
1833 EXPECT_TRUE(ok);
1834 EXPECT_NEAR(-2.36457251883339000000, r, TOLERANCE);
1835 }
1836
1837 {
1838 bool ok = StringToDouble(r, "-0.24583724281163800000");
1839 EXPECT_TRUE(ok);
1840 EXPECT_NEAR(-0.24583724281163800000, r, TOLERANCE);
1841 }
1842
1843 {
1844 bool ok = StringToDouble(r, "0.89377268220461400000");
1845 EXPECT_TRUE(ok);
1846 EXPECT_NEAR(0.89377268220461400000, r, TOLERANCE);
1847 }
1848 }
1849
1850 TEST(GenericToolbox, TestStringToDouble3)
1851 {
1852 using OrthancStone::GenericToolbox::StringToDouble;
1853
1854 const double TOLERANCE = 0.00000000000001;
1855 double r = 0.0;
1856
1857 {
1858 bool ok = StringToDouble(r, "1.45674815825147000000");
1859 EXPECT_TRUE(ok);
1860 EXPECT_NEAR(1.45674815825147000000, r, TOLERANCE);
1861 }
1862
1863 {
1864 bool ok = StringToDouble(r, "-3.85885778179785000000");
1865 EXPECT_TRUE(ok);
1866 EXPECT_NEAR(-3.85885778179785000000, r, TOLERANCE);
1867 }
1868
1869 {
1870 bool ok = StringToDouble(r, "-1.46665640857091000000");
1871 EXPECT_TRUE(ok);
1872 EXPECT_NEAR(-1.46665640857091000000, r, TOLERANCE);
1873 }
1874
1875 {
1876 bool ok = StringToDouble(r, "-2.20955012166670000000");
1877 EXPECT_TRUE(ok);
1878 EXPECT_NEAR(-2.20955012166670000000, r, TOLERANCE);
1879 }
1880
1881 {
1882 bool ok = StringToDouble(r, "-3.56901773371710000000");
1883 EXPECT_TRUE(ok);
1884 EXPECT_NEAR(-3.56901773371710000000, r, TOLERANCE);
1885 }
1886
1887 {
1888 bool ok = StringToDouble(r, "-0.28236715260714000000");
1889 EXPECT_TRUE(ok);
1890 EXPECT_NEAR(-0.28236715260714000000, r, TOLERANCE);
1891 }
1892
1893 {
1894 bool ok = StringToDouble(r, "-3.68701183150938000000");
1895 EXPECT_TRUE(ok);
1896 EXPECT_NEAR(-3.68701183150938000000, r, TOLERANCE);
1897 }
1898
1899 {
1900 bool ok = StringToDouble(r, "-2.52491544332882000000");
1901 EXPECT_TRUE(ok);
1902 EXPECT_NEAR(-2.52491544332882000000, r, TOLERANCE);
1903 }
1904
1905 {
1906 bool ok = StringToDouble(r, "-0.35369978756681100000");
1907 EXPECT_TRUE(ok);
1908 EXPECT_NEAR(-0.35369978756681100000, r, TOLERANCE);
1909 }
1910
1911 {
1912 bool ok = StringToDouble(r, "1.37511760913818000000");
1913 EXPECT_TRUE(ok);
1914 EXPECT_NEAR(1.37511760913818000000, r, TOLERANCE);
1915 }
1916
1917 {
1918 bool ok = StringToDouble(r, "-2.97143364160106000000");
1919 EXPECT_TRUE(ok);
1920 EXPECT_NEAR(-2.97143364160106000000, r, TOLERANCE);
1921 }
1922
1923 {
1924 bool ok = StringToDouble(r, "0.24559477959438200000");
1925 EXPECT_TRUE(ok);
1926 EXPECT_NEAR(0.24559477959438200000, r, TOLERANCE);
1927 }
1928
1929 {
1930 bool ok = StringToDouble(r, "4.75423032204965000000");
1931 EXPECT_TRUE(ok);
1932 EXPECT_NEAR(4.75423032204965000000, r, TOLERANCE);
1933 }
1934
1935 {
1936 bool ok = StringToDouble(r, "-0.32370293533555300000");
1937 EXPECT_TRUE(ok);
1938 EXPECT_NEAR(-0.32370293533555300000, r, TOLERANCE);
1939 }
1940
1941 {
1942 bool ok = StringToDouble(r, "-0.91057697616735300000");
1943 EXPECT_TRUE(ok);
1944 EXPECT_NEAR(-0.91057697616735300000, r, TOLERANCE);
1945 }
1946
1947 {
1948 bool ok = StringToDouble(r, "5.47061739750017000000");
1949 EXPECT_TRUE(ok);
1950 EXPECT_NEAR(5.47061739750017000000, r, TOLERANCE);
1951 }
1952
1953 {
1954 bool ok = StringToDouble(r, "4.00584944044255000000");
1955 EXPECT_TRUE(ok);
1956 EXPECT_NEAR(4.00584944044255000000, r, TOLERANCE);
1957 }
1958
1959 {
1960 bool ok = StringToDouble(r, "4.50109276836214000000");
1961 EXPECT_TRUE(ok);
1962 EXPECT_NEAR(4.50109276836214000000, r, TOLERANCE);
1963 }
1964
1965 {
1966 bool ok = StringToDouble(r, "-3.55007311077336000000");
1967 EXPECT_TRUE(ok);
1968 EXPECT_NEAR(-3.55007311077336000000, r, TOLERANCE);
1969 }
1970
1971 {
1972 bool ok = StringToDouble(r, "6.72362848947278000000");
1973 EXPECT_TRUE(ok);
1974 EXPECT_NEAR(6.72362848947278000000, r, TOLERANCE);
1975 }
1976
1977 {
1978 bool ok = StringToDouble(r, "0.01151577930873910000");
1979 EXPECT_TRUE(ok);
1980 EXPECT_NEAR(0.01151577930873910000, r, TOLERANCE);
1981 }
1982
1983 {
1984 bool ok = StringToDouble(r, "-0.42911860719965600000");
1985 EXPECT_TRUE(ok);
1986 EXPECT_NEAR(-0.42911860719965600000, r, TOLERANCE);
1987 }
1988
1989 {
1990 bool ok = StringToDouble(r, "0.66111289816664900000");
1991 EXPECT_TRUE(ok);
1992 EXPECT_NEAR(0.66111289816664900000, r, TOLERANCE);
1993 }
1994
1995 {
1996 bool ok = StringToDouble(r, "-2.86619326895662000000");
1997 EXPECT_TRUE(ok);
1998 EXPECT_NEAR(-2.86619326895662000000, r, TOLERANCE);
1999 }
2000
2001 {
2002 bool ok = StringToDouble(r, "0.55732089555551800000");
2003 EXPECT_TRUE(ok);
2004 EXPECT_NEAR(0.55732089555551800000, r, TOLERANCE);
2005 }
2006
2007 {
2008 bool ok = StringToDouble(r, "1.30341160871063000000");
2009 EXPECT_TRUE(ok);
2010 EXPECT_NEAR(1.30341160871063000000, r, TOLERANCE);
2011 }
2012
2013 {
2014 bool ok = StringToDouble(r, "-1.56416171751671000000");
2015 EXPECT_TRUE(ok);
2016 EXPECT_NEAR(-1.56416171751671000000, r, TOLERANCE);
2017 }
2018
2019 {
2020 bool ok = StringToDouble(r, "-0.18594183907073900000");
2021 EXPECT_TRUE(ok);
2022 EXPECT_NEAR(-0.18594183907073900000, r, TOLERANCE);
2023 }
2024
2025 {
2026 bool ok = StringToDouble(r, "-1.76842629255481000000");
2027 EXPECT_TRUE(ok);
2028 EXPECT_NEAR(-1.76842629255481000000, r, TOLERANCE);
2029 }
2030
2031 {
2032 bool ok = StringToDouble(r, "-0.51401910241563500000");
2033 EXPECT_TRUE(ok);
2034 EXPECT_NEAR(-0.51401910241563500000, r, TOLERANCE);
2035 }
2036
2037 {
2038 bool ok = StringToDouble(r, "0.22475819701855600000");
2039 EXPECT_TRUE(ok);
2040 EXPECT_NEAR(0.22475819701855600000, r, TOLERANCE);
2041 }
2042
2043 {
2044 bool ok = StringToDouble(r, "4.52647532265208000000");
2045 EXPECT_TRUE(ok);
2046 EXPECT_NEAR(4.52647532265208000000, r, TOLERANCE);
2047 }
2048
2049 {
2050 bool ok = StringToDouble(r, "0.36302691626541400000");
2051 EXPECT_TRUE(ok);
2052 EXPECT_NEAR(0.36302691626541400000, r, TOLERANCE);
2053 }
2054
2055 {
2056 bool ok = StringToDouble(r, "3.97344494357431000000");
2057 EXPECT_TRUE(ok);
2058 EXPECT_NEAR(3.97344494357431000000, r, TOLERANCE);
2059 }
2060
2061 {
2062 bool ok = StringToDouble(r, "1.55983273528683000000");
2063 EXPECT_TRUE(ok);
2064 EXPECT_NEAR(1.55983273528683000000, r, TOLERANCE);
2065 }
2066
2067 {
2068 bool ok = StringToDouble(r, "-1.11831213859734000000");
2069 EXPECT_TRUE(ok);
2070 EXPECT_NEAR(-1.11831213859734000000, r, TOLERANCE);
2071 }
2072
2073 {
2074 bool ok = StringToDouble(r, "-1.65912510665320000000");
2075 EXPECT_TRUE(ok);
2076 EXPECT_NEAR(-1.65912510665320000000, r, TOLERANCE);
2077 }
2078
2079 {
2080 bool ok = StringToDouble(r, "-0.49382686162217300000");
2081 EXPECT_TRUE(ok);
2082 EXPECT_NEAR(-0.49382686162217300000, r, TOLERANCE);
2083 }
2084
2085 {
2086 bool ok = StringToDouble(r, "-2.82681319206813000000");
2087 EXPECT_TRUE(ok);
2088 EXPECT_NEAR(-2.82681319206813000000, r, TOLERANCE);
2089 }
2090
2091 {
2092 bool ok = StringToDouble(r, "0.63990018376158400000");
2093 EXPECT_TRUE(ok);
2094 EXPECT_NEAR(0.63990018376158400000, r, TOLERANCE);
2095 }
2096
2097 {
2098 bool ok = StringToDouble(r, "-1.46190583889476000000");
2099 EXPECT_TRUE(ok);
2100 EXPECT_NEAR(-1.46190583889476000000, r, TOLERANCE);
2101 }
2102
2103 {
2104 bool ok = StringToDouble(r, "-5.33778970852365000000");
2105 EXPECT_TRUE(ok);
2106 EXPECT_NEAR(-5.33778970852365000000, r, TOLERANCE);
2107 }
2108
2109 {
2110 bool ok = StringToDouble(r, "-3.67479071577411000000");
2111 EXPECT_TRUE(ok);
2112 EXPECT_NEAR(-3.67479071577411000000, r, TOLERANCE);
2113 }
2114
2115 {
2116 bool ok = StringToDouble(r, "-0.92524843393689500000");
2117 EXPECT_TRUE(ok);
2118 EXPECT_NEAR(-0.92524843393689500000, r, TOLERANCE);
2119 }
2120
2121 {
2122 bool ok = StringToDouble(r, "-5.25880026429762000000");
2123 EXPECT_TRUE(ok);
2124 EXPECT_NEAR(-5.25880026429762000000, r, TOLERANCE);
2125 }
2126
2127 {
2128 bool ok = StringToDouble(r, "0.74489327613996700000");
2129 EXPECT_TRUE(ok);
2130 EXPECT_NEAR(0.74489327613996700000, r, TOLERANCE);
2131 }
2132
2133 {
2134 bool ok = StringToDouble(r, "-0.81221138965657700000");
2135 EXPECT_TRUE(ok);
2136 EXPECT_NEAR(-0.81221138965657700000, r, TOLERANCE);
2137 }
2138
2139 {
2140 bool ok = StringToDouble(r, "2.63922583575742000000");
2141 EXPECT_TRUE(ok);
2142 EXPECT_NEAR(2.63922583575742000000, r, TOLERANCE);
2143 }
2144
2145 {
2146 bool ok = StringToDouble(r, "-1.46277795175279000000");
2147 EXPECT_TRUE(ok);
2148 EXPECT_NEAR(-1.46277795175279000000, r, TOLERANCE);
2149 }
2150
2151 {
2152 bool ok = StringToDouble(r, "1.92701639727950000000");
2153 EXPECT_TRUE(ok);
2154 EXPECT_NEAR(1.92701639727950000000, r, TOLERANCE);
2155 }
2156
2157 {
2158 bool ok = StringToDouble(r, "-1.00608886511047000000");
2159 EXPECT_TRUE(ok);
2160 EXPECT_NEAR(-1.00608886511047000000, r, TOLERANCE);
2161 }
2162
2163 {
2164 bool ok = StringToDouble(r, "2.59692755566202000000");
2165 EXPECT_TRUE(ok);
2166 EXPECT_NEAR(2.59692755566202000000, r, TOLERANCE);
2167 }
2168
2169 {
2170 bool ok = StringToDouble(r, "-4.43660191582482000000");
2171 EXPECT_TRUE(ok);
2172 EXPECT_NEAR(-4.43660191582482000000, r, TOLERANCE);
2173 }
2174
2175 {
2176 bool ok = StringToDouble(r, "2.81340386111566000000");
2177 EXPECT_TRUE(ok);
2178 EXPECT_NEAR(2.81340386111566000000, r, TOLERANCE);
2179 }
2180
2181 {
2182 bool ok = StringToDouble(r, "4.41381029424169000000");
2183 EXPECT_TRUE(ok);
2184 EXPECT_NEAR(4.41381029424169000000, r, TOLERANCE);
2185 }
2186
2187 {
2188 bool ok = StringToDouble(r, "-1.19067619994638000000");
2189 EXPECT_TRUE(ok);
2190 EXPECT_NEAR(-1.19067619994638000000, r, TOLERANCE);
2191 }
2192
2193 {
2194 bool ok = StringToDouble(r, "0.41344288416300500000");
2195 EXPECT_TRUE(ok);
2196 EXPECT_NEAR(0.41344288416300500000, r, TOLERANCE);
2197 }
2198
2199 {
2200 bool ok = StringToDouble(r, "1.19449050806631000000");
2201 EXPECT_TRUE(ok);
2202 EXPECT_NEAR(1.19449050806631000000, r, TOLERANCE);
2203 }
2204
2205 {
2206 bool ok = StringToDouble(r, "1.94346623486537000000");
2207 EXPECT_TRUE(ok);
2208 EXPECT_NEAR(1.94346623486537000000, r, TOLERANCE);
2209 }
2210
2211 {
2212 bool ok = StringToDouble(r, "-0.15222182306952000000");
2213 EXPECT_TRUE(ok);
2214 EXPECT_NEAR(-0.15222182306952000000, r, TOLERANCE);
2215 }
2216
2217 {
2218 bool ok = StringToDouble(r, "1.16597270635016000000");
2219 EXPECT_TRUE(ok);
2220 EXPECT_NEAR(1.16597270635016000000, r, TOLERANCE);
2221 }
2222
2223 {
2224 bool ok = StringToDouble(r, "0.70800933434033500000");
2225 EXPECT_TRUE(ok);
2226 EXPECT_NEAR(0.70800933434033500000, r, TOLERANCE);
2227 }
2228
2229 {
2230 bool ok = StringToDouble(r, "1.01520859362049000000");
2231 EXPECT_TRUE(ok);
2232 EXPECT_NEAR(1.01520859362049000000, r, TOLERANCE);
2233 }
2234
2235 {
2236 bool ok = StringToDouble(r, "-0.99808924291921000000");
2237 EXPECT_TRUE(ok);
2238 EXPECT_NEAR(-0.99808924291921000000, r, TOLERANCE);
2239 }
2240
2241 {
2242 bool ok = StringToDouble(r, "-2.46413571523617000000");
2243 EXPECT_TRUE(ok);
2244 EXPECT_NEAR(-2.46413571523617000000, r, TOLERANCE);
2245 }
2246
2247 {
2248 bool ok = StringToDouble(r, "0.23372155013436100000");
2249 EXPECT_TRUE(ok);
2250 EXPECT_NEAR(0.23372155013436100000, r, TOLERANCE);
2251 }
2252
2253 {
2254 bool ok = StringToDouble(r, "0.22220872747082200000");
2255 EXPECT_TRUE(ok);
2256 EXPECT_NEAR(0.22220872747082200000, r, TOLERANCE);
2257 }
2258
2259 {
2260 bool ok = StringToDouble(r, "4.45231083327185000000");
2261 EXPECT_TRUE(ok);
2262 EXPECT_NEAR(4.45231083327185000000, r, TOLERANCE);
2263 }
2264
2265 {
2266 bool ok = StringToDouble(r, "0.18629931302726700000");
2267 EXPECT_TRUE(ok);
2268 EXPECT_NEAR(0.18629931302726700000, r, TOLERANCE);
2269 }
2270
2271 {
2272 bool ok = StringToDouble(r, "-1.25902351261081000000");
2273 EXPECT_TRUE(ok);
2274 EXPECT_NEAR(-1.25902351261081000000, r, TOLERANCE);
2275 }
2276
2277 {
2278 bool ok = StringToDouble(r, "-4.74979626491734000000");
2279 EXPECT_TRUE(ok);
2280 EXPECT_NEAR(-4.74979626491734000000, r, TOLERANCE);
2281 }
2282
2283 {
2284 bool ok = StringToDouble(r, "0.96938763187002300000");
2285 EXPECT_TRUE(ok);
2286 EXPECT_NEAR(0.96938763187002300000, r, TOLERANCE);
2287 }
2288
2289 {
2290 bool ok = StringToDouble(r, "4.01957662295404000000");
2291 EXPECT_TRUE(ok);
2292 EXPECT_NEAR(4.01957662295404000000, r, TOLERANCE);
2293 }
2294
2295 {
2296 bool ok = StringToDouble(r, "-4.29052978268713000000");
2297 EXPECT_TRUE(ok);
2298 EXPECT_NEAR(-4.29052978268713000000, r, TOLERANCE);
2299 }
2300
2301 {
2302 bool ok = StringToDouble(r, "1.72223107008226000000");
2303 EXPECT_TRUE(ok);
2304 EXPECT_NEAR(1.72223107008226000000, r, TOLERANCE);
2305 }
2306
2307 {
2308 bool ok = StringToDouble(r, "-1.02075269473024000000");
2309 EXPECT_TRUE(ok);
2310 EXPECT_NEAR(-1.02075269473024000000, r, TOLERANCE);
2311 }
2312
2313 {
2314 bool ok = StringToDouble(r, "1.41254866425811000000");
2315 EXPECT_TRUE(ok);
2316 EXPECT_NEAR(1.41254866425811000000, r, TOLERANCE);
2317 }
2318
2319 {
2320 bool ok = StringToDouble(r, "-5.79485280000328000000");
2321 EXPECT_TRUE(ok);
2322 EXPECT_NEAR(-5.79485280000328000000, r, TOLERANCE);
2323 }
2324
2325 {
2326 bool ok = StringToDouble(r, "1.71346724218879000000");
2327 EXPECT_TRUE(ok);
2328 EXPECT_NEAR(1.71346724218879000000, r, TOLERANCE);
2329 }
2330
2331 {
2332 bool ok = StringToDouble(r, "0.02769972220451300000");
2333 EXPECT_TRUE(ok);
2334 EXPECT_NEAR(0.02769972220451300000, r, TOLERANCE);
2335 }
2336
2337 {
2338 bool ok = StringToDouble(r, "0.30840233811538300000");
2339 EXPECT_TRUE(ok);
2340 EXPECT_NEAR(0.30840233811538300000, r, TOLERANCE);
2341 }
2342
2343 {
2344 bool ok = StringToDouble(r, "2.46998368658050000000");
2345 EXPECT_TRUE(ok);
2346 EXPECT_NEAR(2.46998368658050000000, r, TOLERANCE);
2347 }
2348
2349 {
2350 bool ok = StringToDouble(r, "-1.39027116095637000000");
2351 EXPECT_TRUE(ok);
2352 EXPECT_NEAR(-1.39027116095637000000, r, TOLERANCE);
2353 }
2354
2355 {
2356 bool ok = StringToDouble(r, "-4.76287623175477000000");
2357 EXPECT_TRUE(ok);
2358 EXPECT_NEAR(-4.76287623175477000000, r, TOLERANCE);
2359 }
2360
2361 {
2362 bool ok = StringToDouble(r, "-1.32254147772188000000");
2363 EXPECT_TRUE(ok);
2364 EXPECT_NEAR(-1.32254147772188000000, r, TOLERANCE);
2365 }
2366
2367 {
2368 bool ok = StringToDouble(r, "-0.43476530791568300000");
2369 EXPECT_TRUE(ok);
2370 EXPECT_NEAR(-0.43476530791568300000, r, TOLERANCE);
2371 }
2372
2373 {
2374 bool ok = StringToDouble(r, "1.15293149279800000000");
2375 EXPECT_TRUE(ok);
2376 EXPECT_NEAR(1.15293149279800000000, r, TOLERANCE);
2377 }
2378
2379 {
2380 bool ok = StringToDouble(r, "2.52187680632247000000");
2381 EXPECT_TRUE(ok);
2382 EXPECT_NEAR(2.52187680632247000000, r, TOLERANCE);
2383 }
2384
2385 {
2386 bool ok = StringToDouble(r, "-2.81464816227136000000");
2387 EXPECT_TRUE(ok);
2388 EXPECT_NEAR(-2.81464816227136000000, r, TOLERANCE);
2389 }
2390
2391 {
2392 bool ok = StringToDouble(r, "1.45410471462063000000");
2393 EXPECT_TRUE(ok);
2394 EXPECT_NEAR(1.45410471462063000000, r, TOLERANCE);
2395 }
2396
2397 {
2398 bool ok = StringToDouble(r, "2.05770661428355000000");
2399 EXPECT_TRUE(ok);
2400 EXPECT_NEAR(2.05770661428355000000, r, TOLERANCE);
2401 }
2402
2403 {
2404 bool ok = StringToDouble(r, "1.13365631051443000000");
2405 EXPECT_TRUE(ok);
2406 EXPECT_NEAR(1.13365631051443000000, r, TOLERANCE);
2407 }
2408
2409 {
2410 bool ok = StringToDouble(r, "1.78752268413674000000");
2411 EXPECT_TRUE(ok);
2412 EXPECT_NEAR(1.78752268413674000000, r, TOLERANCE);
2413 }
2414
2415 {
2416 bool ok = StringToDouble(r, "-3.07653691039301000000");
2417 EXPECT_TRUE(ok);
2418 EXPECT_NEAR(-3.07653691039301000000, r, TOLERANCE);
2419 }
2420
2421 {
2422 bool ok = StringToDouble(r, "0.69590678743817200000");
2423 EXPECT_TRUE(ok);
2424 EXPECT_NEAR(0.69590678743817200000, r, TOLERANCE);
2425 }
2426
2427 {
2428 bool ok = StringToDouble(r, "0.16750017237716000000");
2429 EXPECT_TRUE(ok);
2430 EXPECT_NEAR(0.16750017237716000000, r, TOLERANCE);
2431 }
2432
2433 {
2434 bool ok = StringToDouble(r, "-0.80454059859949500000");
2435 EXPECT_TRUE(ok);
2436 EXPECT_NEAR(-0.80454059859949500000, r, TOLERANCE);
2437 }
2438
2439 {
2440 bool ok = StringToDouble(r, "1.01080121519000000000");
2441 EXPECT_TRUE(ok);
2442 EXPECT_NEAR(1.01080121519000000000, r, TOLERANCE);
2443 }
2444
2445 {
2446 bool ok = StringToDouble(r, "-6.26823154211325000000");
2447 EXPECT_TRUE(ok);
2448 EXPECT_NEAR(-6.26823154211325000000, r, TOLERANCE);
2449 }
2450
2451 {
2452 bool ok = StringToDouble(r, "-2.27168923945051000000");
2453 EXPECT_TRUE(ok);
2454 EXPECT_NEAR(-2.27168923945051000000, r, TOLERANCE);
2455 }
2456
2457 {
2458 bool ok = StringToDouble(r, "2.95882006177823000000");
2459 EXPECT_TRUE(ok);
2460 EXPECT_NEAR(2.95882006177823000000, r, TOLERANCE);
2461 }
2462
2463 {
2464 bool ok = StringToDouble(r, "-1.29782169884960000000");
2465 EXPECT_TRUE(ok);
2466 EXPECT_NEAR(-1.29782169884960000000, r, TOLERANCE);
2467 }
2468
2469 {
2470 bool ok = StringToDouble(r, "-5.18868107998160000000");
2471 EXPECT_TRUE(ok);
2472 EXPECT_NEAR(-5.18868107998160000000, r, TOLERANCE);
2473 }
2474
2475 {
2476 bool ok = StringToDouble(r, "4.42221680213317000000");
2477 EXPECT_TRUE(ok);
2478 EXPECT_NEAR(4.42221680213317000000, r, TOLERANCE);
2479 }
2480
2481 {
2482 bool ok = StringToDouble(r, "-1.97658929351465000000");
2483 EXPECT_TRUE(ok);
2484 EXPECT_NEAR(-1.97658929351465000000, r, TOLERANCE);
2485 }
2486
2487 {
2488 bool ok = StringToDouble(r, "3.76786358453912000000");
2489 EXPECT_TRUE(ok);
2490 EXPECT_NEAR(3.76786358453912000000, r, TOLERANCE);
2491 }
2492
2493 {
2494 bool ok = StringToDouble(r, "-2.63996015852897000000");
2495 EXPECT_TRUE(ok);
2496 EXPECT_NEAR(-2.63996015852897000000, r, TOLERANCE);
2497 }
2498
2499 {
2500 bool ok = StringToDouble(r, "5.53048948235281000000");
2501 EXPECT_TRUE(ok);
2502 EXPECT_NEAR(5.53048948235281000000, r, TOLERANCE);
2503 }
2504
2505 {
2506 bool ok = StringToDouble(r, "-2.72713707173900000000");
2507 EXPECT_TRUE(ok);
2508 EXPECT_NEAR(-2.72713707173900000000, r, TOLERANCE);
2509 }
2510
2511 {
2512 bool ok = StringToDouble(r, "-3.67678586641071000000");
2513 EXPECT_TRUE(ok);
2514 EXPECT_NEAR(-3.67678586641071000000, r, TOLERANCE);
2515 }
2516
2517 {
2518 bool ok = StringToDouble(r, "2.27938145860632000000");
2519 EXPECT_TRUE(ok);
2520 EXPECT_NEAR(2.27938145860632000000, r, TOLERANCE);
2521 }
2522
2523 {
2524 bool ok = StringToDouble(r, "2.67198854485259000000");
2525 EXPECT_TRUE(ok);
2526 EXPECT_NEAR(2.67198854485259000000, r, TOLERANCE);
2527 }
2528
2529 {
2530 bool ok = StringToDouble(r, "1.08448300379640000000");
2531 EXPECT_TRUE(ok);
2532 EXPECT_NEAR(1.08448300379640000000, r, TOLERANCE);
2533 }
2534
2535 {
2536 bool ok = StringToDouble(r, "0.89200760812645600000");
2537 EXPECT_TRUE(ok);
2538 EXPECT_NEAR(0.89200760812645600000, r, TOLERANCE);
2539 }
2540
2541 {
2542 bool ok = StringToDouble(r, "5.84610740591283000000");
2543 EXPECT_TRUE(ok);
2544 EXPECT_NEAR(5.84610740591283000000, r, TOLERANCE);
2545 }
2546
2547 {
2548 bool ok = StringToDouble(r, "2.33520422865196000000");
2549 EXPECT_TRUE(ok);
2550 EXPECT_NEAR(2.33520422865196000000, r, TOLERANCE);
2551 }
2552
2553 {
2554 bool ok = StringToDouble(r, "-0.26977509689943300000");
2555 EXPECT_TRUE(ok);
2556 EXPECT_NEAR(-0.26977509689943300000, r, TOLERANCE);
2557 }
2558
2559 {
2560 bool ok = StringToDouble(r, "-1.06556998317024000000");
2561 EXPECT_TRUE(ok);
2562 EXPECT_NEAR(-1.06556998317024000000, r, TOLERANCE);
2563 }
2564
2565 {
2566 bool ok = StringToDouble(r, "0.10187258099846900000");
2567 EXPECT_TRUE(ok);
2568 EXPECT_NEAR(0.10187258099846900000, r, TOLERANCE);
2569 }
2570
2571 {
2572 bool ok = StringToDouble(r, "2.17925123727943000000");
2573 EXPECT_TRUE(ok);
2574 EXPECT_NEAR(2.17925123727943000000, r, TOLERANCE);
2575 }
2576
2577 {
2578 bool ok = StringToDouble(r, "3.53744857107300000000");
2579 EXPECT_TRUE(ok);
2580 EXPECT_NEAR(3.53744857107300000000, r, TOLERANCE);
2581 }
2582
2583 {
2584 bool ok = StringToDouble(r, "4.79170718052687000000");
2585 EXPECT_TRUE(ok);
2586 EXPECT_NEAR(4.79170718052687000000, r, TOLERANCE);
2587 }
2588
2589 {
2590 bool ok = StringToDouble(r, "-1.70094405912437000000");
2591 EXPECT_TRUE(ok);
2592 EXPECT_NEAR(-1.70094405912437000000, r, TOLERANCE);
2593 }
2594
2595 {
2596 bool ok = StringToDouble(r, "-1.36090079790873000000");
2597 EXPECT_TRUE(ok);
2598 EXPECT_NEAR(-1.36090079790873000000, r, TOLERANCE);
2599 }
2600
2601 {
2602 bool ok = StringToDouble(r, "-0.24214402582849600000");
2603 EXPECT_TRUE(ok);
2604 EXPECT_NEAR(-0.24214402582849600000, r, TOLERANCE);
2605 }
2606
2607 {
2608 bool ok = StringToDouble(r, "0.61857148054390100000");
2609 EXPECT_TRUE(ok);
2610 EXPECT_NEAR(0.61857148054390100000, r, TOLERANCE);
2611 }
2612
2613 {
2614 bool ok = StringToDouble(r, "-4.49681404951875000000");
2615 EXPECT_TRUE(ok);
2616 EXPECT_NEAR(-4.49681404951875000000, r, TOLERANCE);
2617 }
2618
2619 {
2620 bool ok = StringToDouble(r, "-1.62901170744691000000");
2621 EXPECT_TRUE(ok);
2622 EXPECT_NEAR(-1.62901170744691000000, r, TOLERANCE);
2623 }
2624
2625 {
2626 bool ok = StringToDouble(r, "-4.31812686057237000000");
2627 EXPECT_TRUE(ok);
2628 EXPECT_NEAR(-4.31812686057237000000, r, TOLERANCE);
2629 }
2630
2631 {
2632 bool ok = StringToDouble(r, "4.29232513324991000000");
2633 EXPECT_TRUE(ok);
2634 EXPECT_NEAR(4.29232513324991000000, r, TOLERANCE);
2635 }
2636
2637 {
2638 bool ok = StringToDouble(r, "-4.30415968616239000000");
2639 EXPECT_TRUE(ok);
2640 EXPECT_NEAR(-4.30415968616239000000, r, TOLERANCE);
2641 }
2642
2643 {
2644 bool ok = StringToDouble(r, "0.23085063327904200000");
2645 EXPECT_TRUE(ok);
2646 EXPECT_NEAR(0.23085063327904200000, r, TOLERANCE);
2647 }
2648
2649 {
2650 bool ok = StringToDouble(r, "0.55328286749515200000");
2651 EXPECT_TRUE(ok);
2652 EXPECT_NEAR(0.55328286749515200000, r, TOLERANCE);
2653 }
2654
2655 {
2656 bool ok = StringToDouble(r, "-2.85987085857330000000");
2657 EXPECT_TRUE(ok);
2658 EXPECT_NEAR(-2.85987085857330000000, r, TOLERANCE);
2659 }
2660
2661 {
2662 bool ok = StringToDouble(r, "1.91580898949892000000");
2663 EXPECT_TRUE(ok);
2664 EXPECT_NEAR(1.91580898949892000000, r, TOLERANCE);
2665 }
2666
2667 {
2668 bool ok = StringToDouble(r, "0.83451772893723400000");
2669 EXPECT_TRUE(ok);
2670 EXPECT_NEAR(0.83451772893723400000, r, TOLERANCE);
2671 }
2672
2673 {
2674 bool ok = StringToDouble(r, "8.47663066417390000000");
2675 EXPECT_TRUE(ok);
2676 EXPECT_NEAR(8.47663066417390000000, r, TOLERANCE);
2677 }
2678
2679 {
2680 bool ok = StringToDouble(r, "3.07750241770625000000");
2681 EXPECT_TRUE(ok);
2682 EXPECT_NEAR(3.07750241770625000000, r, TOLERANCE);
2683 }
2684
2685 {
2686 bool ok = StringToDouble(r, "-0.79888627452876900000");
2687 EXPECT_TRUE(ok);
2688 EXPECT_NEAR(-0.79888627452876900000, r, TOLERANCE);
2689 }
2690
2691 {
2692 bool ok = StringToDouble(r, "3.62390154942094000000");
2693 EXPECT_TRUE(ok);
2694 EXPECT_NEAR(3.62390154942094000000, r, TOLERANCE);
2695 }
2696
2697 {
2698 bool ok = StringToDouble(r, "-1.15344123017231000000");
2699 EXPECT_TRUE(ok);
2700 EXPECT_NEAR(-1.15344123017231000000, r, TOLERANCE);
2701 }
2702
2703 {
2704 bool ok = StringToDouble(r, "0.29946850732165400000");
2705 EXPECT_TRUE(ok);
2706 EXPECT_NEAR(0.29946850732165400000, r, TOLERANCE);
2707 }
2708
2709 {
2710 bool ok = StringToDouble(r, "0.43195118421230900000");
2711 EXPECT_TRUE(ok);
2712 EXPECT_NEAR(0.43195118421230900000, r, TOLERANCE);
2713 }
2714
2715 {
2716 bool ok = StringToDouble(r, "-0.96541584823575200000");
2717 EXPECT_TRUE(ok);
2718 EXPECT_NEAR(-0.96541584823575200000, r, TOLERANCE);
2719 }
2720
2721 {
2722 bool ok = StringToDouble(r, "5.31046639376194000000");
2723 EXPECT_TRUE(ok);
2724 EXPECT_NEAR(5.31046639376194000000, r, TOLERANCE);
2725 }
2726
2727 {
2728 bool ok = StringToDouble(r, "5.80868720295308000000");
2729 EXPECT_TRUE(ok);
2730 EXPECT_NEAR(5.80868720295308000000, r, TOLERANCE);
2731 }
2732
2733 {
2734 bool ok = StringToDouble(r, "3.91875650345864000000");
2735 EXPECT_TRUE(ok);
2736 EXPECT_NEAR(3.91875650345864000000, r, TOLERANCE);
2737 }
2738
2739 {
2740 bool ok = StringToDouble(r, "0.16383120358956700000");
2741 EXPECT_TRUE(ok);
2742 EXPECT_NEAR(0.16383120358956700000, r, TOLERANCE);
2743 }
2744
2745 {
2746 bool ok = StringToDouble(r, "-0.70602187714556100000");
2747 EXPECT_TRUE(ok);
2748 EXPECT_NEAR(-0.70602187714556100000, r, TOLERANCE);
2749 }
2750
2751 {
2752 bool ok = StringToDouble(r, "4.59908461641224000000");
2753 EXPECT_TRUE(ok);
2754 EXPECT_NEAR(4.59908461641224000000, r, TOLERANCE);
2755 }
2756
2757 {
2758 bool ok = StringToDouble(r, "-1.75777826959967000000");
2759 EXPECT_TRUE(ok);
2760 EXPECT_NEAR(-1.75777826959967000000, r, TOLERANCE);
2761 }
2762
2763 {
2764 bool ok = StringToDouble(r, "7.51297060665513000000");
2765 EXPECT_TRUE(ok);
2766 EXPECT_NEAR(7.51297060665513000000, r, TOLERANCE);
2767 }
2768
2769 {
2770 bool ok = StringToDouble(r, "0.26428182282563100000");
2771 EXPECT_TRUE(ok);
2772 EXPECT_NEAR(0.26428182282563100000, r, TOLERANCE);
2773 }
2774
2775 {
2776 bool ok = StringToDouble(r, "-1.39790664337099000000");
2777 EXPECT_TRUE(ok);
2778 EXPECT_NEAR(-1.39790664337099000000, r, TOLERANCE);
2779 }
2780
2781 {
2782 bool ok = StringToDouble(r, "-3.52727246472497000000");
2783 EXPECT_TRUE(ok);
2784 EXPECT_NEAR(-3.52727246472497000000, r, TOLERANCE);
2785 }
2786
2787 {
2788 bool ok = StringToDouble(r, "3.15622706860781000000");
2789 EXPECT_TRUE(ok);
2790 EXPECT_NEAR(3.15622706860781000000, r, TOLERANCE);
2791 }
2792
2793 {
2794 bool ok = StringToDouble(r, "-4.33838258813926000000");
2795 EXPECT_TRUE(ok);
2796 EXPECT_NEAR(-4.33838258813926000000, r, TOLERANCE);
2797 }
2798
2799 {
2800 bool ok = StringToDouble(r, "-3.68209356689853000000");
2801 EXPECT_TRUE(ok);
2802 EXPECT_NEAR(-3.68209356689853000000, r, TOLERANCE);
2803 }
2804
2805 {
2806 bool ok = StringToDouble(r, "2.12950059731897000000");
2807 EXPECT_TRUE(ok);
2808 EXPECT_NEAR(2.12950059731897000000, r, TOLERANCE);
2809 }
2810
2811 {
2812 bool ok = StringToDouble(r, "1.24366467557925000000");
2813 EXPECT_TRUE(ok);
2814 EXPECT_NEAR(1.24366467557925000000, r, TOLERANCE);
2815 }
2816
2817 {
2818 bool ok = StringToDouble(r, "-1.49620375847259000000");
2819 EXPECT_TRUE(ok);
2820 EXPECT_NEAR(-1.49620375847259000000, r, TOLERANCE);
2821 }
2822 }
2823
2824 TEST(GenericToolbox, TestStringToDouble4)
2825 {
2826 using OrthancStone::GenericToolbox::StringToDouble;
2827
2828 const double TOLERANCE = 0.00000000000001;
2829 double r = 0.0;
2830
2831 {
2832 bool ok = StringToDouble(r, "-2.04336416841016000000");
2833 EXPECT_TRUE(ok);
2834 EXPECT_NEAR(-2.04336416841016000000, r, TOLERANCE);
2835 }
2836
2837 {
2838 bool ok = StringToDouble(r, "2.67258592218424000000");
2839 EXPECT_TRUE(ok);
2840 EXPECT_NEAR(2.67258592218424000000, r, TOLERANCE);
2841 }
2842
2843 {
2844 bool ok = StringToDouble(r, "0.50983053528049600000");
2845 EXPECT_TRUE(ok);
2846 EXPECT_NEAR(0.50983053528049600000, r, TOLERANCE);
2847 }
2848
2849 {
2850 bool ok = StringToDouble(r, "0.91671084717300400000");
2851 EXPECT_TRUE(ok);
2852 EXPECT_NEAR(0.91671084717300400000, r, TOLERANCE);
2853 }
2854
2855 {
2856 bool ok = StringToDouble(r, "-8.44023177630015000000");
2857 EXPECT_TRUE(ok);
2858 EXPECT_NEAR(-8.44023177630015000000, r, TOLERANCE);
2859 }
2860
2861 {
2862 bool ok = StringToDouble(r, "5.74048232685721000000");
2863 EXPECT_TRUE(ok);
2864 EXPECT_NEAR(5.74048232685721000000, r, TOLERANCE);
2865 }
2866
2867 {
2868 bool ok = StringToDouble(r, "-2.26893036021697000000");
2869 EXPECT_TRUE(ok);
2870 EXPECT_NEAR(-2.26893036021697000000, r, TOLERANCE);
2871 }
2872
2873 {
2874 bool ok = StringToDouble(r, "-1.81851986861265000000");
2875 EXPECT_TRUE(ok);
2876 EXPECT_NEAR(-1.81851986861265000000, r, TOLERANCE);
2877 }
2878
2879 {
2880 bool ok = StringToDouble(r, "1.15033199581975000000");
2881 EXPECT_TRUE(ok);
2882 EXPECT_NEAR(1.15033199581975000000, r, TOLERANCE);
2883 }
2884
2885 {
2886 bool ok = StringToDouble(r, "1.78498201393837000000");
2887 EXPECT_TRUE(ok);
2888 EXPECT_NEAR(1.78498201393837000000, r, TOLERANCE);
2889 }
2890
2891 {
2892 bool ok = StringToDouble(r, "-0.05287486584367510000");
2893 EXPECT_TRUE(ok);
2894 EXPECT_NEAR(-0.05287486584367510000, r, TOLERANCE);
2895 }
2896
2897 {
2898 bool ok = StringToDouble(r, "-4.61135813076181000000");
2899 EXPECT_TRUE(ok);
2900 EXPECT_NEAR(-4.61135813076181000000, r, TOLERANCE);
2901 }
2902
2903 {
2904 bool ok = StringToDouble(r, "2.28026567889772000000");
2905 EXPECT_TRUE(ok);
2906 EXPECT_NEAR(2.28026567889772000000, r, TOLERANCE);
2907 }
2908
2909 {
2910 bool ok = StringToDouble(r, "4.42191037602383000000");
2911 EXPECT_TRUE(ok);
2912 EXPECT_NEAR(4.42191037602383000000, r, TOLERANCE);
2913 }
2914
2915 {
2916 bool ok = StringToDouble(r, "4.91926628714024000000");
2917 EXPECT_TRUE(ok);
2918 EXPECT_NEAR(4.91926628714024000000, r, TOLERANCE);
2919 }
2920
2921 {
2922 bool ok = StringToDouble(r, "2.13695172353534000000");
2923 EXPECT_TRUE(ok);
2924 EXPECT_NEAR(2.13695172353534000000, r, TOLERANCE);
2925 }
2926
2927 {
2928 bool ok = StringToDouble(r, "-1.19234124167404000000");
2929 EXPECT_TRUE(ok);
2930 EXPECT_NEAR(-1.19234124167404000000, r, TOLERANCE);
2931 }
2932
2933 {
2934 bool ok = StringToDouble(r, "1.54749310279860000000");
2935 EXPECT_TRUE(ok);
2936 EXPECT_NEAR(1.54749310279860000000, r, TOLERANCE);
2937 }
2938
2939 {
2940 bool ok = StringToDouble(r, "0.79683457995789900000");
2941 EXPECT_TRUE(ok);
2942 EXPECT_NEAR(0.79683457995789900000, r, TOLERANCE);
2943 }
2944
2945 {
2946 bool ok = StringToDouble(r, "-0.35976469553121900000");
2947 EXPECT_TRUE(ok);
2948 EXPECT_NEAR(-0.35976469553121900000, r, TOLERANCE);
2949 }
2950
2951 {
2952 bool ok = StringToDouble(r, "0.77036485893720200000");
2953 EXPECT_TRUE(ok);
2954 EXPECT_NEAR(0.77036485893720200000, r, TOLERANCE);
2955 }
2956
2957 {
2958 bool ok = StringToDouble(r, "3.05245602278075000000");
2959 EXPECT_TRUE(ok);
2960 EXPECT_NEAR(3.05245602278075000000, r, TOLERANCE);
2961 }
2962
2963 {
2964 bool ok = StringToDouble(r, "5.82693752156961000000");
2965 EXPECT_TRUE(ok);
2966 EXPECT_NEAR(5.82693752156961000000, r, TOLERANCE);
2967 }
2968
2969 {
2970 bool ok = StringToDouble(r, "2.59176692084240000000");
2971 EXPECT_TRUE(ok);
2972 EXPECT_NEAR(2.59176692084240000000, r, TOLERANCE);
2973 }
2974
2975 {
2976 bool ok = StringToDouble(r, "4.59390017044970000000");
2977 EXPECT_TRUE(ok);
2978 EXPECT_NEAR(4.59390017044970000000, r, TOLERANCE);
2979 }
2980
2981 {
2982 bool ok = StringToDouble(r, "4.33597209441560000000");
2983 EXPECT_TRUE(ok);
2984 EXPECT_NEAR(4.33597209441560000000, r, TOLERANCE);
2985 }
2986
2987 {
2988 bool ok = StringToDouble(r, "-1.73223852215944000000");
2989 EXPECT_TRUE(ok);
2990 EXPECT_NEAR(-1.73223852215944000000, r, TOLERANCE);
2991 }
2992
2993 {
2994 bool ok = StringToDouble(r, "0.36562951036666300000");
2995 EXPECT_TRUE(ok);
2996 EXPECT_NEAR(0.36562951036666300000, r, TOLERANCE);
2997 }
2998
2999 {
3000 bool ok = StringToDouble(r, "1.16083819415565000000");
3001 EXPECT_TRUE(ok);
3002 EXPECT_NEAR(1.16083819415565000000, r, TOLERANCE);
3003 }
3004
3005 {
3006 bool ok = StringToDouble(r, "-5.19457461912900000000");
3007 EXPECT_TRUE(ok);
3008 EXPECT_NEAR(-5.19457461912900000000, r, TOLERANCE);
3009 }
3010
3011 {
3012 bool ok = StringToDouble(r, "2.48993781857833000000");
3013 EXPECT_TRUE(ok);
3014 EXPECT_NEAR(2.48993781857833000000, r, TOLERANCE);
3015 }
3016
3017 {
3018 bool ok = StringToDouble(r, "2.91089514047878000000");
3019 EXPECT_TRUE(ok);
3020 EXPECT_NEAR(2.91089514047878000000, r, TOLERANCE);
3021 }
3022
3023 {
3024 bool ok = StringToDouble(r, "-2.67713158365996000000");
3025 EXPECT_TRUE(ok);
3026 EXPECT_NEAR(-2.67713158365996000000, r, TOLERANCE);
3027 }
3028
3029 {
3030 bool ok = StringToDouble(r, "-0.14929866451844800000");
3031 EXPECT_TRUE(ok);
3032 EXPECT_NEAR(-0.14929866451844800000, r, TOLERANCE);
3033 }
3034
3035 {
3036 bool ok = StringToDouble(r, "-3.76110653286820000000");
3037 EXPECT_TRUE(ok);
3038 EXPECT_NEAR(-3.76110653286820000000, r, TOLERANCE);
3039 }
3040
3041 {
3042 bool ok = StringToDouble(r, "-0.05937778946509720000");
3043 EXPECT_TRUE(ok);
3044 EXPECT_NEAR(-0.05937778946509720000, r, TOLERANCE);
3045 }
3046
3047 {
3048 bool ok = StringToDouble(r, "1.67737188304973000000");
3049 EXPECT_TRUE(ok);
3050 EXPECT_NEAR(1.67737188304973000000, r, TOLERANCE);
3051 }
3052
3053 {
3054 bool ok = StringToDouble(r, "-3.58425440578219000000");
3055 EXPECT_TRUE(ok);
3056 EXPECT_NEAR(-3.58425440578219000000, r, TOLERANCE);
3057 }
3058
3059 {
3060 bool ok = StringToDouble(r, "1.30491550374261000000");
3061 EXPECT_TRUE(ok);
3062 EXPECT_NEAR(1.30491550374261000000, r, TOLERANCE);
3063 }
3064
3065 {
3066 bool ok = StringToDouble(r, "2.48379945880357000000");
3067 EXPECT_TRUE(ok);
3068 EXPECT_NEAR(2.48379945880357000000, r, TOLERANCE);
3069 }
3070
3071 {
3072 bool ok = StringToDouble(r, "-0.62987027701035800000");
3073 EXPECT_TRUE(ok);
3074 EXPECT_NEAR(-0.62987027701035800000, r, TOLERANCE);
3075 }
3076
3077 {
3078 bool ok = StringToDouble(r, "-2.97181285150671000000");
3079 EXPECT_TRUE(ok);
3080 EXPECT_NEAR(-2.97181285150671000000, r, TOLERANCE);
3081 }
3082
3083 {
3084 bool ok = StringToDouble(r, "-0.24881707556359700000");
3085 EXPECT_TRUE(ok);
3086 EXPECT_NEAR(-0.24881707556359700000, r, TOLERANCE);
3087 }
3088
3089 {
3090 bool ok = StringToDouble(r, "-2.83925282156180000000");
3091 EXPECT_TRUE(ok);
3092 EXPECT_NEAR(-2.83925282156180000000, r, TOLERANCE);
3093 }
3094
3095 {
3096 bool ok = StringToDouble(r, "-2.07567311295324000000");
3097 EXPECT_TRUE(ok);
3098 EXPECT_NEAR(-2.07567311295324000000, r, TOLERANCE);
3099 }
3100
3101 {
3102 bool ok = StringToDouble(r, "-2.78919598870022000000");
3103 EXPECT_TRUE(ok);
3104 EXPECT_NEAR(-2.78919598870022000000, r, TOLERANCE);
3105 }
3106
3107 {
3108 bool ok = StringToDouble(r, "4.51240908161798000000");
3109 EXPECT_TRUE(ok);
3110 EXPECT_NEAR(4.51240908161798000000, r, TOLERANCE);
3111 }
3112
3113 {
3114 bool ok = StringToDouble(r, "2.51275535534832000000");
3115 EXPECT_TRUE(ok);
3116 EXPECT_NEAR(2.51275535534832000000, r, TOLERANCE);
3117 }
3118
3119 {
3120 bool ok = StringToDouble(r, "1.58920518726789000000");
3121 EXPECT_TRUE(ok);
3122 EXPECT_NEAR(1.58920518726789000000, r, TOLERANCE);
3123 }
3124
3125 {
3126 bool ok = StringToDouble(r, "3.81944139206950000000");
3127 EXPECT_TRUE(ok);
3128 EXPECT_NEAR(3.81944139206950000000, r, TOLERANCE);
3129 }
3130
3131 {
3132 bool ok = StringToDouble(r, "-1.20584689863215000000");
3133 EXPECT_TRUE(ok);
3134 EXPECT_NEAR(-1.20584689863215000000, r, TOLERANCE);
3135 }
3136
3137 {
3138 bool ok = StringToDouble(r, "0.52387820278697400000");
3139 EXPECT_TRUE(ok);
3140 EXPECT_NEAR(0.52387820278697400000, r, TOLERANCE);
3141 }
3142
3143 {
3144 bool ok = StringToDouble(r, "1.41030960929320000000");
3145 EXPECT_TRUE(ok);
3146 EXPECT_NEAR(1.41030960929320000000, r, TOLERANCE);
3147 }
3148
3149 {
3150 bool ok = StringToDouble(r, "-1.92103214885374000000");
3151 EXPECT_TRUE(ok);
3152 EXPECT_NEAR(-1.92103214885374000000, r, TOLERANCE);
3153 }
3154
3155 {
3156 bool ok = StringToDouble(r, "-5.24231540245246000000");
3157 EXPECT_TRUE(ok);
3158 EXPECT_NEAR(-5.24231540245246000000, r, TOLERANCE);
3159 }
3160
3161 {
3162 bool ok = StringToDouble(r, "-0.16908726665941100000");
3163 EXPECT_TRUE(ok);
3164 EXPECT_NEAR(-0.16908726665941100000, r, TOLERANCE);
3165 }
3166
3167 {
3168 bool ok = StringToDouble(r, "-4.44589887686242000000");
3169 EXPECT_TRUE(ok);
3170 EXPECT_NEAR(-4.44589887686242000000, r, TOLERANCE);
3171 }
3172
3173 {
3174 bool ok = StringToDouble(r, "-2.49069006371512000000");
3175 EXPECT_TRUE(ok);
3176 EXPECT_NEAR(-2.49069006371512000000, r, TOLERANCE);
3177 }
3178
3179 {
3180 bool ok = StringToDouble(r, "-0.80650544937931100000");
3181 EXPECT_TRUE(ok);
3182 EXPECT_NEAR(-0.80650544937931100000, r, TOLERANCE);
3183 }
3184
3185 {
3186 bool ok = StringToDouble(r, "-1.97976397104165000000");
3187 EXPECT_TRUE(ok);
3188 EXPECT_NEAR(-1.97976397104165000000, r, TOLERANCE);
3189 }
3190
3191 {
3192 bool ok = StringToDouble(r, "4.98766812819005000000");
3193 EXPECT_TRUE(ok);
3194 EXPECT_NEAR(4.98766812819005000000, r, TOLERANCE);
3195 }
3196
3197 {
3198 bool ok = StringToDouble(r, "-0.72989593663204100000");
3199 EXPECT_TRUE(ok);
3200 EXPECT_NEAR(-0.72989593663204100000, r, TOLERANCE);
3201 }
3202
3203 {
3204 bool ok = StringToDouble(r, "-1.61947487048298000000");
3205 EXPECT_TRUE(ok);
3206 EXPECT_NEAR(-1.61947487048298000000, r, TOLERANCE);
3207 }
3208
3209 {
3210 bool ok = StringToDouble(r, "0.14305085135282200000");
3211 EXPECT_TRUE(ok);
3212 EXPECT_NEAR(0.14305085135282200000, r, TOLERANCE);
3213 }
3214
3215 {
3216 bool ok = StringToDouble(r, "-0.19625994631193500000");
3217 EXPECT_TRUE(ok);
3218 EXPECT_NEAR(-0.19625994631193500000, r, TOLERANCE);
3219 }
3220
3221 {
3222 bool ok = StringToDouble(r, "3.37918205114016000000");
3223 EXPECT_TRUE(ok);
3224 EXPECT_NEAR(3.37918205114016000000, r, TOLERANCE);
3225 }
3226
3227 {
3228 bool ok = StringToDouble(r, "6.59599108171267000000");
3229 EXPECT_TRUE(ok);
3230 EXPECT_NEAR(6.59599108171267000000, r, TOLERANCE);
3231 }
3232
3233 {
3234 bool ok = StringToDouble(r, "2.96455017519345000000");
3235 EXPECT_TRUE(ok);
3236 EXPECT_NEAR(2.96455017519345000000, r, TOLERANCE);
3237 }
3238
3239 {
3240 bool ok = StringToDouble(r, "2.54659210340770000000");
3241 EXPECT_TRUE(ok);
3242 EXPECT_NEAR(2.54659210340770000000, r, TOLERANCE);
3243 }
3244
3245 {
3246 bool ok = StringToDouble(r, "-3.34333955584988000000");
3247 EXPECT_TRUE(ok);
3248 EXPECT_NEAR(-3.34333955584988000000, r, TOLERANCE);
3249 }
3250
3251 {
3252 bool ok = StringToDouble(r, "-2.97945807230247000000");
3253 EXPECT_TRUE(ok);
3254 EXPECT_NEAR(-2.97945807230247000000, r, TOLERANCE);
3255 }
3256
3257 {
3258 bool ok = StringToDouble(r, "-1.16309656911088000000");
3259 EXPECT_TRUE(ok);
3260 EXPECT_NEAR(-1.16309656911088000000, r, TOLERANCE);
3261 }
3262
3263 {
3264 bool ok = StringToDouble(r, "-3.25046325751587000000");
3265 EXPECT_TRUE(ok);
3266 EXPECT_NEAR(-3.25046325751587000000, r, TOLERANCE);
3267 }
3268
3269 {
3270 bool ok = StringToDouble(r, "-1.95513333613538000000");
3271 EXPECT_TRUE(ok);
3272 EXPECT_NEAR(-1.95513333613538000000, r, TOLERANCE);
3273 }
3274
3275 {
3276 bool ok = StringToDouble(r, "0.44180657712571200000");
3277 EXPECT_TRUE(ok);
3278 EXPECT_NEAR(0.44180657712571200000, r, TOLERANCE);
3279 }
3280
3281 {
3282 bool ok = StringToDouble(r, "-5.62068238736436000000");
3283 EXPECT_TRUE(ok);
3284 EXPECT_NEAR(-5.62068238736436000000, r, TOLERANCE);
3285 }
3286
3287 {
3288 bool ok = StringToDouble(r, "-1.06550714914445000000");
3289 EXPECT_TRUE(ok);
3290 EXPECT_NEAR(-1.06550714914445000000, r, TOLERANCE);
3291 }
3292
3293 {
3294 bool ok = StringToDouble(r, "-1.50821128944561000000");
3295 EXPECT_TRUE(ok);
3296 EXPECT_NEAR(-1.50821128944561000000, r, TOLERANCE);
3297 }
3298
3299 {
3300 bool ok = StringToDouble(r, "2.15508838007900000000");
3301 EXPECT_TRUE(ok);
3302 EXPECT_NEAR(2.15508838007900000000, r, TOLERANCE);
3303 }
3304
3305 {
3306 bool ok = StringToDouble(r, "-1.95233817795899000000");
3307 EXPECT_TRUE(ok);
3308 EXPECT_NEAR(-1.95233817795899000000, r, TOLERANCE);
3309 }
3310
3311 {
3312 bool ok = StringToDouble(r, "-2.51496658163574000000");
3313 EXPECT_TRUE(ok);
3314 EXPECT_NEAR(-2.51496658163574000000, r, TOLERANCE);
3315 }
3316
3317 {
3318 bool ok = StringToDouble(r, "-0.78333801715048000000");
3319 EXPECT_TRUE(ok);
3320 EXPECT_NEAR(-0.78333801715048000000, r, TOLERANCE);
3321 }
3322
3323 {
3324 bool ok = StringToDouble(r, "-3.21314186040171000000");
3325 EXPECT_TRUE(ok);
3326 EXPECT_NEAR(-3.21314186040171000000, r, TOLERANCE);
3327 }
3328
3329 {
3330 bool ok = StringToDouble(r, "0.66527690284710800000");
3331 EXPECT_TRUE(ok);
3332 EXPECT_NEAR(0.66527690284710800000, r, TOLERANCE);
3333 }
3334
3335 {
3336 bool ok = StringToDouble(r, "-3.15441313415350000000");
3337 EXPECT_TRUE(ok);
3338 EXPECT_NEAR(-3.15441313415350000000, r, TOLERANCE);
3339 }
3340
3341 {
3342 bool ok = StringToDouble(r, "-2.23491685110319000000");
3343 EXPECT_TRUE(ok);
3344 EXPECT_NEAR(-2.23491685110319000000, r, TOLERANCE);
3345 }
3346
3347 {
3348 bool ok = StringToDouble(r, "-1.72724695951577000000");
3349 EXPECT_TRUE(ok);
3350 EXPECT_NEAR(-1.72724695951577000000, r, TOLERANCE);
3351 }
3352
3353 {
3354 bool ok = StringToDouble(r, "-0.24050455306641300000");
3355 EXPECT_TRUE(ok);
3356 EXPECT_NEAR(-0.24050455306641300000, r, TOLERANCE);
3357 }
3358
3359 {
3360 bool ok = StringToDouble(r, "-1.21656863480457000000");
3361 EXPECT_TRUE(ok);
3362 EXPECT_NEAR(-1.21656863480457000000, r, TOLERANCE);
3363 }
3364
3365 {
3366 bool ok = StringToDouble(r, "-2.26488830552906000000");
3367 EXPECT_TRUE(ok);
3368 EXPECT_NEAR(-2.26488830552906000000, r, TOLERANCE);
3369 }
3370
3371 {
3372 bool ok = StringToDouble(r, "3.75588617365038000000");
3373 EXPECT_TRUE(ok);
3374 EXPECT_NEAR(3.75588617365038000000, r, TOLERANCE);
3375 }
3376
3377 {
3378 bool ok = StringToDouble(r, "-0.03323480544193850000");
3379 EXPECT_TRUE(ok);
3380 EXPECT_NEAR(-0.03323480544193850000, r, TOLERANCE);
3381 }
3382
3383 {
3384 bool ok = StringToDouble(r, "-0.09120742547457650000");
3385 EXPECT_TRUE(ok);
3386 EXPECT_NEAR(-0.09120742547457650000, r, TOLERANCE);
3387 }
3388
3389 {
3390 bool ok = StringToDouble(r, "-7.88263056036503000000");
3391 EXPECT_TRUE(ok);
3392 EXPECT_NEAR(-7.88263056036503000000, r, TOLERANCE);
3393 }
3394
3395 {
3396 bool ok = StringToDouble(r, "-1.43816026309627000000");
3397 EXPECT_TRUE(ok);
3398 EXPECT_NEAR(-1.43816026309627000000, r, TOLERANCE);
3399 }
3400
3401 {
3402 bool ok = StringToDouble(r, "-7.03193105607121000000");
3403 EXPECT_TRUE(ok);
3404 EXPECT_NEAR(-7.03193105607121000000, r, TOLERANCE);
3405 }
3406
3407 {
3408 bool ok = StringToDouble(r, "-1.60611554369909000000");
3409 EXPECT_TRUE(ok);
3410 EXPECT_NEAR(-1.60611554369909000000, r, TOLERANCE);
3411 }
3412
3413 {
3414 bool ok = StringToDouble(r, "-5.51585989717609000000");
3415 EXPECT_TRUE(ok);
3416 EXPECT_NEAR(-5.51585989717609000000, r, TOLERANCE);
3417 }
3418
3419 {
3420 bool ok = StringToDouble(r, "1.07820571638609000000");
3421 EXPECT_TRUE(ok);
3422 EXPECT_NEAR(1.07820571638609000000, r, TOLERANCE);
3423 }
3424
3425 {
3426 bool ok = StringToDouble(r, "-2.06101375865811000000");
3427 EXPECT_TRUE(ok);
3428 EXPECT_NEAR(-2.06101375865811000000, r, TOLERANCE);
3429 }
3430
3431 {
3432 bool ok = StringToDouble(r, "-2.20736962161768000000");
3433 EXPECT_TRUE(ok);
3434 EXPECT_NEAR(-2.20736962161768000000, r, TOLERANCE);
3435 }
3436
3437 {
3438 bool ok = StringToDouble(r, "1.90243061828996000000");
3439 EXPECT_TRUE(ok);
3440 EXPECT_NEAR(1.90243061828996000000, r, TOLERANCE);
3441 }
3442
3443 {
3444 bool ok = StringToDouble(r, "-2.85299495975262000000");
3445 EXPECT_TRUE(ok);
3446 EXPECT_NEAR(-2.85299495975262000000, r, TOLERANCE);
3447 }
3448
3449 {
3450 bool ok = StringToDouble(r, "2.12934888152265000000");
3451 EXPECT_TRUE(ok);
3452 EXPECT_NEAR(2.12934888152265000000, r, TOLERANCE);
3453 }
3454
3455 {
3456 bool ok = StringToDouble(r, "-2.67072919212958000000");
3457 EXPECT_TRUE(ok);
3458 EXPECT_NEAR(-2.67072919212958000000, r, TOLERANCE);
3459 }
3460
3461 {
3462 bool ok = StringToDouble(r, "-0.83114509924264900000");
3463 EXPECT_TRUE(ok);
3464 EXPECT_NEAR(-0.83114509924264900000, r, TOLERANCE);
3465 }
3466
3467 {
3468 bool ok = StringToDouble(r, "5.30250616100438000000");
3469 EXPECT_TRUE(ok);
3470 EXPECT_NEAR(5.30250616100438000000, r, TOLERANCE);
3471 }
3472
3473 {
3474 bool ok = StringToDouble(r, "1.12093048302870000000");
3475 EXPECT_TRUE(ok);
3476 EXPECT_NEAR(1.12093048302870000000, r, TOLERANCE);
3477 }
3478
3479 {
3480 bool ok = StringToDouble(r, "1.05552960660102000000");
3481 EXPECT_TRUE(ok);
3482 EXPECT_NEAR(1.05552960660102000000, r, TOLERANCE);
3483 }
3484
3485 {
3486 bool ok = StringToDouble(r, "1.49292325032676000000");
3487 EXPECT_TRUE(ok);
3488 EXPECT_NEAR(1.49292325032676000000, r, TOLERANCE);
3489 }
3490
3491 {
3492 bool ok = StringToDouble(r, "-1.17400757029104000000");
3493 EXPECT_TRUE(ok);
3494 EXPECT_NEAR(-1.17400757029104000000, r, TOLERANCE);
3495 }
3496
3497 {
3498 bool ok = StringToDouble(r, "-2.14267109660887000000");
3499 EXPECT_TRUE(ok);
3500 EXPECT_NEAR(-2.14267109660887000000, r, TOLERANCE);
3501 }
3502
3503 {
3504 bool ok = StringToDouble(r, "-1.10546669054034000000");
3505 EXPECT_TRUE(ok);
3506 EXPECT_NEAR(-1.10546669054034000000, r, TOLERANCE);
3507 }
3508
3509 {
3510 bool ok = StringToDouble(r, "-0.21371952871041700000");
3511 EXPECT_TRUE(ok);
3512 EXPECT_NEAR(-0.21371952871041700000, r, TOLERANCE);
3513 }
3514
3515 {
3516 bool ok = StringToDouble(r, "4.78156583044177000000");
3517 EXPECT_TRUE(ok);
3518 EXPECT_NEAR(4.78156583044177000000, r, TOLERANCE);
3519 }
3520
3521 {
3522 bool ok = StringToDouble(r, "-1.50472792044367000000");
3523 EXPECT_TRUE(ok);
3524 EXPECT_NEAR(-1.50472792044367000000, r, TOLERANCE);
3525 }
3526
3527 {
3528 bool ok = StringToDouble(r, "-0.12605755507866600000");
3529 EXPECT_TRUE(ok);
3530 EXPECT_NEAR(-0.12605755507866600000, r, TOLERANCE);
3531 }
3532
3533 {
3534 bool ok = StringToDouble(r, "1.70371185139311000000");
3535 EXPECT_TRUE(ok);
3536 EXPECT_NEAR(1.70371185139311000000, r, TOLERANCE);
3537 }
3538
3539 {
3540 bool ok = StringToDouble(r, "-3.10053982101354000000");
3541 EXPECT_TRUE(ok);
3542 EXPECT_NEAR(-3.10053982101354000000, r, TOLERANCE);
3543 }
3544
3545 {
3546 bool ok = StringToDouble(r, "-1.83624586947925000000");
3547 EXPECT_TRUE(ok);
3548 EXPECT_NEAR(-1.83624586947925000000, r, TOLERANCE);
3549 }
3550
3551 {
3552 bool ok = StringToDouble(r, "-4.05046060224221000000");
3553 EXPECT_TRUE(ok);
3554 EXPECT_NEAR(-4.05046060224221000000, r, TOLERANCE);
3555 }
3556
3557 {
3558 bool ok = StringToDouble(r, "0.28157147555257100000");
3559 EXPECT_TRUE(ok);
3560 EXPECT_NEAR(0.28157147555257100000, r, TOLERANCE);
3561 }
3562
3563 {
3564 bool ok = StringToDouble(r, "1.59637285322805000000");
3565 EXPECT_TRUE(ok);
3566 EXPECT_NEAR(1.59637285322805000000, r, TOLERANCE);
3567 }
3568
3569 {
3570 bool ok = StringToDouble(r, "-0.75470175557419100000");
3571 EXPECT_TRUE(ok);
3572 EXPECT_NEAR(-0.75470175557419100000, r, TOLERANCE);
3573 }
3574
3575 {
3576 bool ok = StringToDouble(r, "-1.70838399472621000000");
3577 EXPECT_TRUE(ok);
3578 EXPECT_NEAR(-1.70838399472621000000, r, TOLERANCE);
3579 }
3580
3581 {
3582 bool ok = StringToDouble(r, "2.45654131621183000000");
3583 EXPECT_TRUE(ok);
3584 EXPECT_NEAR(2.45654131621183000000, r, TOLERANCE);
3585 }
3586
3587 {
3588 bool ok = StringToDouble(r, "2.28443945581399000000");
3589 EXPECT_TRUE(ok);
3590 EXPECT_NEAR(2.28443945581399000000, r, TOLERANCE);
3591 }
3592
3593 {
3594 bool ok = StringToDouble(r, "1.68823597183684000000");
3595 EXPECT_TRUE(ok);
3596 EXPECT_NEAR(1.68823597183684000000, r, TOLERANCE);
3597 }
3598
3599 {
3600 bool ok = StringToDouble(r, "1.29650435341174000000");
3601 EXPECT_TRUE(ok);
3602 EXPECT_NEAR(1.29650435341174000000, r, TOLERANCE);
3603 }
3604
3605 {
3606 bool ok = StringToDouble(r, "1.90134290476188000000");
3607 EXPECT_TRUE(ok);
3608 EXPECT_NEAR(1.90134290476188000000, r, TOLERANCE);
3609 }
3610
3611 {
3612 bool ok = StringToDouble(r, "-1.18487205108194000000");
3613 EXPECT_TRUE(ok);
3614 EXPECT_NEAR(-1.18487205108194000000, r, TOLERANCE);
3615 }
3616
3617 {
3618 bool ok = StringToDouble(r, "-0.14778330708372000000");
3619 EXPECT_TRUE(ok);
3620 EXPECT_NEAR(-0.14778330708372000000, r, TOLERANCE);
3621 }
3622
3623 {
3624 bool ok = StringToDouble(r, "-3.98574838531856000000");
3625 EXPECT_TRUE(ok);
3626 EXPECT_NEAR(-3.98574838531856000000, r, TOLERANCE);
3627 }
3628
3629 {
3630 bool ok = StringToDouble(r, "-2.38116626593387000000");
3631 EXPECT_TRUE(ok);
3632 EXPECT_NEAR(-2.38116626593387000000, r, TOLERANCE);
3633 }
3634
3635 {
3636 bool ok = StringToDouble(r, "0.18109367323846900000");
3637 EXPECT_TRUE(ok);
3638 EXPECT_NEAR(0.18109367323846900000, r, TOLERANCE);
3639 }
3640
3641 {
3642 bool ok = StringToDouble(r, "-2.54919024558896000000");
3643 EXPECT_TRUE(ok);
3644 EXPECT_NEAR(-2.54919024558896000000, r, TOLERANCE);
3645 }
3646
3647 {
3648 bool ok = StringToDouble(r, "-3.01819062231017000000");
3649 EXPECT_TRUE(ok);
3650 EXPECT_NEAR(-3.01819062231017000000, r, TOLERANCE);
3651 }
3652
3653 {
3654 bool ok = StringToDouble(r, "2.86141885135950000000");
3655 EXPECT_TRUE(ok);
3656 EXPECT_NEAR(2.86141885135950000000, r, TOLERANCE);
3657 }
3658
3659 {
3660 bool ok = StringToDouble(r, "0.31984756442573800000");
3661 EXPECT_TRUE(ok);
3662 EXPECT_NEAR(0.31984756442573800000, r, TOLERANCE);
3663 }
3664
3665 {
3666 bool ok = StringToDouble(r, "-2.35256585949514000000");
3667 EXPECT_TRUE(ok);
3668 EXPECT_NEAR(-2.35256585949514000000, r, TOLERANCE);
3669 }
3670
3671 {
3672 bool ok = StringToDouble(r, "-6.04254591090669000000");
3673 EXPECT_TRUE(ok);
3674 EXPECT_NEAR(-6.04254591090669000000, r, TOLERANCE);
3675 }
3676
3677 {
3678 bool ok = StringToDouble(r, "-0.31151799331342300000");
3679 EXPECT_TRUE(ok);
3680 EXPECT_NEAR(-0.31151799331342300000, r, TOLERANCE);
3681 }
3682
3683 {
3684 bool ok = StringToDouble(r, "-2.77556498660193000000");
3685 EXPECT_TRUE(ok);
3686 EXPECT_NEAR(-2.77556498660193000000, r, TOLERANCE);
3687 }
3688
3689 {
3690 bool ok = StringToDouble(r, "5.90371566906766000000");
3691 EXPECT_TRUE(ok);
3692 EXPECT_NEAR(5.90371566906766000000, r, TOLERANCE);
3693 }
3694
3695 {
3696 bool ok = StringToDouble(r, "-1.29825016398122000000");
3697 EXPECT_TRUE(ok);
3698 EXPECT_NEAR(-1.29825016398122000000, r, TOLERANCE);
3699 }
3700
3701 {
3702 bool ok = StringToDouble(r, "-1.01456323654512000000");
3703 EXPECT_TRUE(ok);
3704 EXPECT_NEAR(-1.01456323654512000000, r, TOLERANCE);
3705 }
3706
3707 {
3708 bool ok = StringToDouble(r, "-6.19305288625244000000");
3709 EXPECT_TRUE(ok);
3710 EXPECT_NEAR(-6.19305288625244000000, r, TOLERANCE);
3711 }
3712
3713 {
3714 bool ok = StringToDouble(r, "0.99509367627092600000");
3715 EXPECT_TRUE(ok);
3716 EXPECT_NEAR(0.99509367627092600000, r, TOLERANCE);
3717 }
3718
3719 {
3720 bool ok = StringToDouble(r, "-0.08519786419394440000");
3721 EXPECT_TRUE(ok);
3722 EXPECT_NEAR(-0.08519786419394440000, r, TOLERANCE);
3723 }
3724
3725 {
3726 bool ok = StringToDouble(r, "2.88317752752055000000");
3727 EXPECT_TRUE(ok);
3728 EXPECT_NEAR(2.88317752752055000000, r, TOLERANCE);
3729 }
3730
3731 {
3732 bool ok = StringToDouble(r, "1.69592260047492000000");
3733 EXPECT_TRUE(ok);
3734 EXPECT_NEAR(1.69592260047492000000, r, TOLERANCE);
3735 }
3736
3737 {
3738 bool ok = StringToDouble(r, "-4.66260089028084000000");
3739 EXPECT_TRUE(ok);
3740 EXPECT_NEAR(-4.66260089028084000000, r, TOLERANCE);
3741 }
3742
3743 {
3744 bool ok = StringToDouble(r, "-1.12882625389413000000");
3745 EXPECT_TRUE(ok);
3746 EXPECT_NEAR(-1.12882625389413000000, r, TOLERANCE);
3747 }
3748
3749 {
3750 bool ok = StringToDouble(r, "2.79536921500302000000");
3751 EXPECT_TRUE(ok);
3752 EXPECT_NEAR(2.79536921500302000000, r, TOLERANCE);
3753 }
3754
3755 {
3756 bool ok = StringToDouble(r, "-4.51399167357593000000");
3757 EXPECT_TRUE(ok);
3758 EXPECT_NEAR(-4.51399167357593000000, r, TOLERANCE);
3759 }
3760
3761 {
3762 bool ok = StringToDouble(r, "-0.75817764527332300000");
3763 EXPECT_TRUE(ok);
3764 EXPECT_NEAR(-0.75817764527332300000, r, TOLERANCE);
3765 }
3766
3767 {
3768 bool ok = StringToDouble(r, "-2.12821371262498000000");
3769 EXPECT_TRUE(ok);
3770 EXPECT_NEAR(-2.12821371262498000000, r, TOLERANCE);
3771 }
3772
3773 {
3774 bool ok = StringToDouble(r, "-1.08153732327358000000");
3775 EXPECT_TRUE(ok);
3776 EXPECT_NEAR(-1.08153732327358000000, r, TOLERANCE);
3777 }
3778
3779 {
3780 bool ok = StringToDouble(r, "0.71608571781169600000");
3781 EXPECT_TRUE(ok);
3782 EXPECT_NEAR(0.71608571781169600000, r, TOLERANCE);
3783 }
3784
3785 {
3786 bool ok = StringToDouble(r, "2.42004689052701000000");
3787 EXPECT_TRUE(ok);
3788 EXPECT_NEAR(2.42004689052701000000, r, TOLERANCE);
3789 }
3790
3791 {
3792 bool ok = StringToDouble(r, "2.84542164846610000000");
3793 EXPECT_TRUE(ok);
3794 EXPECT_NEAR(2.84542164846610000000, r, TOLERANCE);
3795 }
3796
3797 {
3798 bool ok = StringToDouble(r, "2.97822513569917000000");
3799 EXPECT_TRUE(ok);
3800 EXPECT_NEAR(2.97822513569917000000, r, TOLERANCE);
3801 }
3802 }
3803
3804 TEST(GenericToolbox, TestStringToDoubleHard)
3805 {
3806 using OrthancStone::GenericToolbox::StringToDouble;
3807 const double TOLERANCE = 0.00000000000001;
3808
3809 size_t i = 0;
3810 const size_t COUNT = 125;
3811 //const double FACTOR = 1.000000000171271211;
3812 const double FACTOR = 1.71271211;
3813 for (double b = DBL_EPSILON; b < DBL_MAX && i < COUNT; ++i, b *= FACTOR)
3814 {
3815 char txt[1024];
3816 #if defined(_MSC_VER)
3817 sprintf_s(txt, "%.17f", b);
3818 #else
3819 snprintf(txt, sizeof(txt) - 1, "%.17f", b);
3820 #endif
3821 double r = 0.0;
3822 bool ok = StringToDouble(r, txt);
3823
3824 #if 0
3825 if (ok)
3826 {
3827 printf("OK for txt = \"%s\" and r = %.17f\n", txt, r);
3828 }
3829 else
3830 {
3831 printf("Not ok for txt = \"%s\" and r = %.17f\n", txt, r);
3832 ok = StringToDouble(r, txt);
3833 }
3834 #endif
3835
3836 EXPECT_TRUE(ok);
3837
3838 #if 0
3839 if (fabs(b - r) > TOLERANCE)
3840 {
3841 printf("fabs(b (%.17f) - r (%.17f)) ((%.17f)) > TOLERANCE (%.17f)\n", b, r, fabs(b-r), TOLERANCE);
3842 }
3843 #endif
3844 EXPECT_NEAR(b, r, TOLERANCE);
3845 }
3846 }
3847
3848 TEST(GenericToolbox, TestStringToDoubleHardNeg)
3849 {
3850 using OrthancStone::GenericToolbox::StringToDouble;
3851 const double TOLERANCE = 0.00000000000001;
3852
3853 size_t i = 0;
3854 const size_t COUNT = 125;
3855 //const double FACTOR = 1.000000000171271211;
3856 const double FACTOR = 1.71271211;
3857 for (double b = -1.0*DBL_EPSILON; b < DBL_MAX && i < COUNT; ++i, b *= FACTOR)
3858 {
3859 char txt[1024];
3860 #if defined(_MSC_VER)
3861 sprintf_s(txt, "%.17f", b);
3862 #else
3863 snprintf(txt, sizeof(txt) - 1, "%.17f", b);
3864 #endif
3865 double r = 0.0;
3866 bool ok = StringToDouble(r, txt);
3867
3868 #if 0
3869 if (ok)
3870 {
3871 printf("OK for txt = \"%s\" and r = %.17f\n", txt, r);
3872 }
3873 else
3874 {
3875 printf("Not ok for txt = \"%s\" and r = %.17f\n", txt, r);
3876 ok = StringToDouble(r, txt);
3877 }
3878 #endif
3879
3880 EXPECT_TRUE(ok);
3881
3882 #if 0
3883 if (fabs(b - r) > TOLERANCE)
3884 {
3885 printf("fabs(b (%.17f) - r (%.17f)) ((%.17f)) > TOLERANCE (%.17f)\n", b, r, fabs(b - r), TOLERANCE);
3886 }
3887 #endif
3888 EXPECT_NEAR(b, r, TOLERANCE);
3889 }
3890 }
3891
3892 static const size_t NUM_TIMINGS_CONVS = 1; // set to 2000 if you want to measure perfs;
3893
3894
3895 //4444444444444444$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
3896
3897 TEST(GenericToolbox, TestStringToDoubleHardNeg_lexical_cast_vs_StringToDouble)
3898 {
3899 using OrthancStone::GenericToolbox::StringToDouble;
3900 const double TOLERANCE = 0.00000000000001;
3901
3902 double total_us_StringToDouble = 0.0;
3903 double total_us_lexical_cast = 0.0;
3904 int64_t numConversions = 0;
3905
3906 size_t i = 0;
3907 const size_t COUNT = 125;
3908 //const double FACTOR = 1.000000000171271211;
3909 const double FACTOR = 1.71271211;
3910 for (double b = -1.0 * DBL_EPSILON; b < DBL_MAX && i < COUNT; ++i, b *= FACTOR)
3911 {
3912 char txt[1024];
3913 #if defined(_MSC_VER)
3914 sprintf_s(txt, "%.17f", b);
3915 #else
3916 snprintf(txt, sizeof(txt) - 1, "%.17f", b);
3917 #endif
3918
3919
3920 double r = 0.0;
3921
3922 bool ok = true;
3923
3924 {
3925 boost::posix_time::ptime start = boost::posix_time::microsec_clock::local_time();
3926 for (size_t i = 0; i < NUM_TIMINGS_CONVS; ++i)
3927 {
3928 ok = StringToDouble(r, txt);
3929 }
3930 boost::posix_time::ptime end = boost::posix_time::microsec_clock::local_time();
3931 total_us_StringToDouble += (end - start).total_microseconds();
3932 }
3933
3934 {
3935 boost::posix_time::ptime start = boost::posix_time::microsec_clock::local_time();
3936 for (size_t i = 0; i < NUM_TIMINGS_CONVS; ++i)
3937 {
3938 try
3939 {
3940 r = boost::lexical_cast<double>(txt);
3941 ok = true;
3942 }
3943 catch (boost::bad_lexical_cast& )
3944 {
3945 ok = false;
3946 }
3947 }
3948 boost::posix_time::ptime end = boost::posix_time::microsec_clock::local_time();
3949 total_us_lexical_cast += (end - start).total_microseconds();
3950 }
3951 numConversions += NUM_TIMINGS_CONVS;
3952
3953 #if 0
3954 if (ok)
3955 {
3956 printf("OK for txt = \"%s\" and r = %.17f\n", txt, r);
3957 }
3958 else
3959 {
3960 printf("Not ok for txt = \"%s\" and r = %.17f\n", txt, r);
3961 ok = StringToDouble(r, txt);
3962 }
3963 #endif
3964
3965 EXPECT_TRUE(ok);
3966
3967 #if 0
3968 if (fabs(b - r) > TOLERANCE)
3969 {
3970 printf("fabs(b (%.17f) - r (%.17f)) ((%.17f)) > TOLERANCE (%.17f)\n", b, r, fabs(b - r), TOLERANCE);
3971 }
3972 #endif
3973 EXPECT_NEAR(b, r, TOLERANCE);
3974 }
3975 std::cout << "Total time (us) for " << numConversions
3976 << " conversions using StringToDouble (with NO scientific notation) = "
3977 << static_cast<int64_t>(total_us_StringToDouble) << std::endl;
3978
3979 std::cout << "Time per conversion using StringToDouble (ns) = "
3980 << (int64_t)( (total_us_StringToDouble * 1000) /((double)numConversions)) << std::endl;
3981
3982 std::cout << "Total time (us) for " << numConversions
3983 << " conversions using boost::lexical_cast (with NO scientific notation) = "
3984 << static_cast<int64_t>(total_us_lexical_cast) << std::endl;
3985
3986 std::cout << "Time per conversion using boost::lexical_cast (ns) = "
3987 << (int64_t)( (total_us_lexical_cast * 1000) / ((double)numConversions)) << std::endl;
3988
3989 std::cout << "StringToDouble is " << (int)((total_us_lexical_cast / total_us_StringToDouble) + 0.5) << " times faster than boost::lexical_cast" << std::endl;
3990
3991 }
3992 //4444444444444444$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
3993
3994
3995 TEST(GenericToolbox, TestStringToDoubleHardScientific)
3996 {
3997 using OrthancStone::GenericToolbox::StringToDouble;
3998 const double TOLERANCE = 0.00000000000001;
3999
4000 size_t i = 0;
4001 const size_t COUNT = 125;
4002 //const double FACTOR = 1.000000000171271211;
4003 const double FACTOR = 1.71271211;
4004 for (double b = DBL_EPSILON; b < DBL_MAX && i < COUNT; ++i, b *= FACTOR)
4005 {
4006
4007 // the tolerance must be adapted depending on the exponent
4008 double exponent = (b == 0) ? 0 : 1.0 + std::floor(std::log10(std::fabs(b)));
4009 double actualTolerance = TOLERANCE * pow(10.0, exponent);
4010
4011 char txt[1024];
4012 #if defined(_MSC_VER)
4013 sprintf_s(txt, "%.17e", b);
4014 #else
4015 snprintf(txt, sizeof(txt) - 1, "%.17e", b);
4016 #endif
4017 double r = 0.0;
4018 bool ok = StringToDouble(r, txt);
4019
4020 #if 0
4021 if (ok)
4022 {
4023 printf("OK for txt = \"%s\" and r = %.17e\n", txt, r);
4024 }
4025 else
4026 {
4027 printf("Not ok for txt = \"%s\" and r = %.17e\n", txt, r);
4028 ok = StringToDouble(r, txt);
4029 }
4030 #endif
4031
4032 EXPECT_TRUE(ok);
4033
4034 #if 0
4035 if (fabs(b - r) > actualTolerance)
4036 {
4037 printf("NOK fabs(b (%.17f) - r (%.17f)) ((%.17f)) > actualTolerance (%.17f)\n", b, r, fabs(b - r), actualTolerance);
4038 printf("NOK fabs(b (%.17e) - r (%.17e)) ((%.17e)) > actualTolerance (%.17e)\n", b, r, fabs(b - r), actualTolerance);
4039 ok = StringToDouble(r, txt);
4040 }
4041 else
4042 {
4043 printf("OK fabs(b (%.17f) - r (%.17f)) ((%.17f)) <= actualTolerance (%.17f)\n", b, r, fabs(b - r), actualTolerance);
4044 printf("OK fabs(b (%.17e) - r (%.17e)) ((%.17e)) <= actualTolerance (%.17e)\n", b, r, fabs(b - r), actualTolerance);
4045 }
4046 #endif
4047 EXPECT_NEAR(b, r, actualTolerance);
4048 }
4049 }
4050
4051 TEST(GenericToolbox, TestStringToDoubleHardNegScientific)
4052 {
4053 using OrthancStone::GenericToolbox::StringToDouble;
4054 const double TOLERANCE = 0.00000000000001;
4055
4056 size_t i = 0;
4057 const size_t COUNT = 125;
4058 //const double FACTOR = 1.000000000171271211;
4059 const double FACTOR = 1.71271211;
4060 for (double b = -1.0 * DBL_EPSILON; b < DBL_MAX && i < COUNT; ++i, b *= FACTOR)
4061 {
4062 // the tolerance must be adapted depending on the exponent
4063 double exponent = (b == 0) ? 0 : 1.0 + std::floor(std::log10(std::fabs(b)));
4064 double actualTolerance = TOLERANCE * pow(10.0, exponent);
4065
4066 char txt[1024];
4067 #if defined(_MSC_VER)
4068 sprintf_s(txt, "%.17e", b);
4069 #else
4070 snprintf(txt, sizeof(txt) - 1, "%.17e", b);
4071 #endif
4072 double r = 0.0;
4073 bool ok = StringToDouble(r, txt);
4074
4075 #if 0
4076 if (ok)
4077 {
4078 printf("OK for txt = \"%s\" and r = %.17e\n", txt, r);
4079 }
4080 else
4081 {
4082 printf("Not ok for txt = \"%s\" and r = %.17e\n", txt, r);
4083 ok = StringToDouble(r, txt);
4084 }
4085 #endif
4086
4087 EXPECT_TRUE(ok);
4088
4089 #if 0
4090 if (fabs(b - r) > actualTolerance)
4091 {
4092 printf("NOK fabs(b (%.17f) - r (%.17f)) ((%.17f)) > actualTolerance (%.17f)\n", b, r, fabs(b - r), actualTolerance);
4093 printf("NOK fabs(b (%.17e) - r (%.17e)) ((%.17e)) > actualTolerance (%.17e)\n", b, r, fabs(b - r), actualTolerance);
4094 ok = StringToDouble(r, txt);
4095 }
4096 else
4097 {
4098 printf("OK fabs(b (%.17f) - r (%.17f)) ((%.17f)) <= actualTolerance (%.17f)\n", b, r, fabs(b - r), actualTolerance);
4099 printf("OK fabs(b (%.17e) - r (%.17e)) ((%.17e)) <= actualTolerance (%.17e)\n", b, r, fabs(b - r), actualTolerance);
4100 }
4101 #endif
4102 EXPECT_NEAR(b, r, actualTolerance);
4103 }
4104 }
4105
4106
4107 TEST(GenericToolbox, TestStringToDoubleHardNegScientific_lexical_cast_vs_StringToDouble)
4108 {
4109 using OrthancStone::GenericToolbox::StringToDouble;
4110 const double TOLERANCE = 0.00000000000001;
4111
4112 size_t i = 0;
4113 const size_t COUNT = 125;
4114 //const double FACTOR = 1.000000000171271211;
4115 const double FACTOR = 1.71271211;
4116
4117 double total_us_StringToDouble = 0.0;
4118 double total_us_lexical_cast = 0.0;
4119 int64_t numConversions = 0;
4120
4121 for (double b = -1.0 * DBL_EPSILON; b < DBL_MAX && i < COUNT; ++i, b *= FACTOR)
4122 {
4123 // the tolerance must be adapted depending on the exponent
4124 double exponent = (b == 0) ? 0 : 1.0 + std::floor(std::log10(std::fabs(b)));
4125 double actualTolerance = TOLERANCE * pow(10.0, exponent);
4126
4127 char txt[1024];
4128 #if defined(_MSC_VER)
4129 sprintf_s(txt, "%.17e", b);
4130 #else
4131 snprintf(txt, sizeof(txt) - 1, "%.17e", b);
4132 #endif
4133 double r = 0.0;
4134
4135 bool ok = true;
4136
4137 {
4138 boost::posix_time::ptime start = boost::posix_time::microsec_clock::local_time();
4139 for (size_t i = 0; i < NUM_TIMINGS_CONVS; ++i)
4140 {
4141 ok = StringToDouble(r, txt);
4142 }
4143 boost::posix_time::ptime end = boost::posix_time::microsec_clock::local_time();
4144 total_us_StringToDouble += (end - start).total_microseconds();
4145 }
4146
4147 {
4148 boost::posix_time::ptime start = boost::posix_time::microsec_clock::local_time();
4149 for (size_t i = 0; i < NUM_TIMINGS_CONVS; ++i)
4150 {
4151 try
4152 {
4153 r = boost::lexical_cast<double>(txt);
4154 ok = true;
4155 }
4156 catch (boost::bad_lexical_cast& )
4157 {
4158 ok = false;
4159 }
4160 }
4161 boost::posix_time::ptime end = boost::posix_time::microsec_clock::local_time();
4162 total_us_lexical_cast += (end - start).total_microseconds();
4163 }
4164 numConversions += NUM_TIMINGS_CONVS;
4165
4166 #if 0
4167 if (ok)
4168 {
4169 printf("OK for txt = \"%s\" and r = %.17e\n", txt, r);
4170 }
4171 else
4172 {
4173 printf("Not ok for txt = \"%s\" and r = %.17e\n", txt, r);
4174 ok = StringToDouble(r, txt);
4175 }
4176 #endif
4177
4178 EXPECT_TRUE(ok);
4179
4180 #if 0
4181 if (fabs(b - r) > actualTolerance)
4182 {
4183 printf("NOK fabs(b (%.17f) - r (%.17f)) ((%.17f)) > actualTolerance (%.17f)\n", b, r, fabs(b - r), actualTolerance);
4184 printf("NOK fabs(b (%.17e) - r (%.17e)) ((%.17e)) > actualTolerance (%.17e)\n", b, r, fabs(b - r), actualTolerance);
4185 ok = StringToDouble(r, txt);
4186 }
4187 else
4188 {
4189 printf("OK fabs(b (%.17f) - r (%.17f)) ((%.17f)) <= actualTolerance (%.17f)\n", b, r, fabs(b - r), actualTolerance);
4190 printf("OK fabs(b (%.17e) - r (%.17e)) ((%.17e)) <= actualTolerance (%.17e)\n", b, r, fabs(b - r), actualTolerance);
4191 }
4192 #endif
4193 EXPECT_NEAR(b, r, actualTolerance);
4194 }
4195
4196 std::cout << "Total time (us) for " << numConversions
4197 << " conversions using StringToDouble (WITH scientific notation) = "
4198 << static_cast<int64_t>(total_us_StringToDouble) << std::endl;
4199
4200 std::cout << "Time per conversion using StringToDouble (ns) = "
4201 << (int64_t)( (total_us_StringToDouble*1000) / ((double)numConversions)) << std::endl;
4202
4203 std::cout << "Total time (us) for " << numConversions
4204 << " conversions using boost::lexical_cast (WITH scientific notation) = "
4205 << static_cast<int64_t>(total_us_lexical_cast) << std::endl;
4206
4207 std::cout << "Time per conversion using boost::lexical_cast (ns) = "
4208 << (int64_t)( (total_us_lexical_cast * 1000) / ((double)numConversions)) << std::endl;
4209
4210 std::cout << "StringToDouble is " << (int)((total_us_lexical_cast / total_us_StringToDouble)+ 0.5) << " times faster than boost::lexical_cast" << std::endl;
4211 }
4212
4213
4214 TEST(GenericToolbox, TestStringToIntegerHard)
4215 {
4216 using OrthancStone::GenericToolbox::StringToInteger;
4217
4218 size_t i = 0;
4219 const size_t COUNT = 125;
4220 //const double FACTOR = 1.000000000171271211;
4221 const double FACTOR = 1.71271211;
4222 for (double b = DBL_EPSILON; b < DBL_MAX && i < COUNT; ++i, b *= FACTOR)
4223 {
4224 int64_t bi = static_cast<int64_t>(b);
4225
4226 char txt[1024];
4227 #if defined(_MSC_VER)
4228 # if (_MSC_VER > 1800)
4229 sprintf_s(txt, "%lld", bi);
4230 # else
4231 sprintf_s(txt, "%I64d", bi);
4232 # endif
4233 #else
4234 snprintf(txt, sizeof(txt) - 1, "%" PRId64, bi); // https://stackoverflow.com/a/9225648/881731
4235 #endif
4236
4237 int64_t r = 0;
4238 bool ok = StringToInteger<int64_t>(r, txt);
4239 EXPECT_TRUE(ok);
4240 EXPECT_EQ(bi, r);
4241 #if 0
4242 if (ok)
4243 {
4244 printf("OK for b = %.17f bi = %" PRId64 " txt = \"%s\" and r = %" PRId64 "\n", b, bi, txt, r);
4245 }
4246 else
4247 {
4248 printf("NOK for b = %.17f bi = %" PRId64 " txt = \"%s\" and r = %" PRId64 "\n", b, bi, txt, r);
4249 ok = StringToInteger<int64_t>(r, txt);
4250 }
4251 #endif
4252 }
4253 }
4254
4255
4256 TEST(GenericToolbox, TestGetRgbValuesFromString)
4257 {
4258 using OrthancStone::GenericToolbox::GetRgbValuesFromString;
4259
4260 uint8_t red = 0;
4261 uint8_t green = 0;
4262 uint8_t blue = 0;
4263
4264 EXPECT_FALSE(GetRgbValuesFromString(red, green, blue, ""));
4265 EXPECT_FALSE(GetRgbValuesFromString(red, green, blue, " "));
4266 EXPECT_FALSE(GetRgbValuesFromString(red, green, blue, "rgb() "));
4267 EXPECT_FALSE(GetRgbValuesFromString(red, green, blue, "rgb(12,30 2563) "));
4268 EXPECT_FALSE(GetRgbValuesFromString(red, green, blue, "rgb(12,30 2563,45) "));
4269 EXPECT_FALSE(GetRgbValuesFromString(red, green, blue, "rgb(12,303.23,45)"));
4270 EXPECT_FALSE(GetRgbValuesFromString(red, green, blue, "rgb(12,303,45 "));
4271
4272 ASSERT_TRUE(GetRgbValuesFromString(red, green, blue, "rgb(12,255,45)"));
4273 EXPECT_EQ(12, red);
4274 EXPECT_EQ(255, green);
4275 EXPECT_EQ(45, blue);
4276
4277 ASSERT_TRUE(GetRgbValuesFromString(red, green, blue, " rgb ( 72 , 257 , 47 ) "));
4278 EXPECT_EQ(72, red);
4279 EXPECT_EQ(1, green); //rollover 255 --> 255, 256 --> 0, 257 --> 1,...
4280 EXPECT_EQ(47, blue);
4281
4282 ASSERT_TRUE(GetRgbValuesFromString(red, green, blue, " rgb ( 72 , 247 , 47 ) "));
4283 EXPECT_EQ(72, red);
4284 EXPECT_EQ(247, green);
4285 EXPECT_EQ(47, blue);
4286
4287 ASSERT_TRUE(GetRgbValuesFromString(red, green, blue, " rgb ( 000, 0, 000) "));
4288 EXPECT_EQ(0, red);
4289 EXPECT_EQ(0, green);
4290 EXPECT_EQ(0, blue);
4291 }
4292
4293 TEST(GenericToolbox, FastParseTest_StringToDoubleEx01)
4294 {
4295 using OrthancStone::GenericToolbox::StringToDoubleEx;
4296
4297 const char* s = "0.0/.123/3/12.5//-43.1";
4298
4299 int32_t size;
4300 double r;
4301 const char* p = s;
4302
4303 size = StringToDoubleEx(r, p, '/');
4304 // -->
4305 // r = 0 and size = 3
4306 ASSERT_EQ(3, size);
4307 ASSERT_DOUBLE_EQ(0, r);
4308
4309 p += (size + 1);
4310 size = StringToDoubleEx(r, p, '/');
4311 ASSERT_EQ(4, size);
4312 ASSERT_DOUBLE_EQ(0.123, r);
4313
4314 p += (size + 1);
4315 size = StringToDoubleEx(r, p, '/');
4316 ASSERT_EQ(1, size);
4317 ASSERT_DOUBLE_EQ(3, r);
4318
4319 p += (size + 1);
4320 size = StringToDoubleEx(r, p, '/');
4321 ASSERT_EQ(4, size);
4322 ASSERT_DOUBLE_EQ(12.5, r);
4323
4324 p += (size + 1);
4325 size = StringToDoubleEx(r, p, '/');
4326 ASSERT_EQ(0, size);
4327 ASSERT_DOUBLE_EQ(0, r);
4328
4329 p += (size + 1);
4330 size = StringToDoubleEx(r, p, '/');
4331 ASSERT_EQ(5, size);
4332 ASSERT_DOUBLE_EQ(-43.1, r);
4333
4334 p += size;
4335 ASSERT_EQ(0, *p);
4336 }
4337
4338 TEST(GenericToolbox, FastParseTest_StringToDoubleEx02)
4339 {
4340 using OrthancStone::GenericToolbox::StringToDoubleEx;
4341
4342 const char* s = " \t 0.0/.123/3 \t/12.5e-3//-43.1 \t ";
4343
4344 int32_t size;
4345 double r;
4346 const char* p = s;
4347
4348 while (*p == ' ' || *p == '\t')
4349 ++p;
4350
4351 size = StringToDoubleEx(r, p, '/');
4352 // -->
4353 // r = 0 and size = 3
4354 ASSERT_EQ(3, size);
4355 ASSERT_DOUBLE_EQ(0, r);
4356
4357 p += (size + 1);
4358 size = StringToDoubleEx(r, p, '/');
4359 ASSERT_EQ(4, size);
4360 ASSERT_DOUBLE_EQ(0.123, r);
4361
4362 p += (size + 1);
4363 size = StringToDoubleEx(r, p, '/');
4364 ASSERT_EQ(4, size);
4365 ASSERT_DOUBLE_EQ(3, r);
4366
4367 p += (size + 1);
4368 size = StringToDoubleEx(r, p, '/');
4369 ASSERT_EQ(7, size);
4370 ASSERT_DOUBLE_EQ(12.5e-3, r);
4371
4372 p += (size + 1);
4373 size = StringToDoubleEx(r, p, '/');
4374 ASSERT_EQ(0, size);
4375 ASSERT_DOUBLE_EQ(0, r);
4376
4377 p += (size + 1);
4378 size = StringToDoubleEx(r, p, '/');
4379 ASSERT_EQ(14, size);
4380 ASSERT_DOUBLE_EQ(-43.1, r);
4381
4382 p += size;
4383 ASSERT_EQ(0, *p);
4384 }
4385
4386 TEST(GenericToolbox, FastParseTest_StringToDoubleEx03)
4387 {
4388 using OrthancStone::GenericToolbox::StringToDoubleEx;
4389
4390 const char* s = " \t 0.0/.123/3/12.5e-3//-43.1e-2 \t ";
4391
4392 int32_t size;
4393 double r;
4394 const char* p = s;
4395
4396 while (*p == ' ' || *p == '\t')
4397 ++p;
4398
4399 size = StringToDoubleEx(r, p, '/');
4400 // -->
4401 // r = 0 and size = 3
4402 ASSERT_EQ(3, size);
4403 ASSERT_DOUBLE_EQ(0, r);
4404
4405 p += (size + 1);
4406 size = StringToDoubleEx(r, p, '/');
4407 ASSERT_EQ(4, size);
4408 ASSERT_DOUBLE_EQ(0.123, r);
4409
4410 p += (size + 1);
4411 size = StringToDoubleEx(r, p, '/');
4412 ASSERT_EQ(1, size);
4413 ASSERT_DOUBLE_EQ(3, r);
4414
4415 p += (size + 1);
4416 size = StringToDoubleEx(r, p, '/');
4417 ASSERT_EQ(7, size);
4418 ASSERT_DOUBLE_EQ(12.5e-3, r);
4419
4420 p += (size + 1);
4421 size = StringToDoubleEx(r, p, '/');
4422 ASSERT_EQ(0, size);
4423 ASSERT_DOUBLE_EQ(0, r);
4424
4425 p += (size + 1);
4426 size = StringToDoubleEx(r, p, '/');
4427 ASSERT_EQ(17, size);
4428 ASSERT_DOUBLE_EQ(-43.1e-2, r);
4429
4430 p += size;
4431 ASSERT_EQ(0, *p);
4432 }
4433
4434
4435 TEST(GenericToolbox, FastParseTest_GetCharCount)
4436 {
4437 using OrthancStone::GenericToolbox::GetCharCount;
4438
4439 ASSERT_EQ(0u, GetCharCount("-1e-22", '\\'));
4440 ASSERT_EQ(0u, GetCharCount(" -1e-22", '\\'));
4441 ASSERT_EQ(0u, GetCharCount(" -1e-22 ", '\\'));
4442 ASSERT_EQ(0u, GetCharCount("-1e-22 ", '\\'));
4443
4444 ASSERT_EQ(1u, GetCharCount("-1e-2\\2", '\\'));
4445 ASSERT_EQ(1u, GetCharCount(" -1e-2\\2", '\\'));
4446 ASSERT_EQ(1u, GetCharCount("-1e-2\\2 ", '\\'));
4447 ASSERT_EQ(1u, GetCharCount(" -1e-2\\2 ", '\\'));
4448
4449
4450 ASSERT_EQ(11u, GetCharCount(" -1e-2\\\\3\\12.473\\-2.34e4\\-284\\423.23\\\\0.234423\\.786 \\ 9093\\ ", '\\'));
4451 }
4452
4453
4454 TEST(GenericToolbox, FastParseTest_FastParseVector01)
4455 {
4456 using OrthancStone::GenericToolbox::FastParseVector;
4457
4458 OrthancStone::Vector v;
4459
4460 ASSERT_TRUE(FastParseVector(v, "1.2"));
4461 ASSERT_EQ(1u, v.size());
4462 ASSERT_DOUBLE_EQ(1.2, v[0]);
4463
4464 ASSERT_TRUE(FastParseVector(v, "-1.2e+2"));
4465 ASSERT_EQ(1u, v.size());
4466 ASSERT_DOUBLE_EQ(-120.0, v[0]);
4467
4468 ASSERT_TRUE(FastParseVector(v, "-1e-2\\2"));
4469 ASSERT_EQ(2u, v.size());
4470 ASSERT_DOUBLE_EQ(-0.01, v[0]);
4471 ASSERT_DOUBLE_EQ(2.0, v[1]);
4472
4473 ASSERT_TRUE(FastParseVector(v, "1.3671875\\1.3671875"));
4474 ASSERT_EQ(2u, v.size());
4475 ASSERT_DOUBLE_EQ(1.3671875, v[0]);
4476 ASSERT_DOUBLE_EQ(1.3671875, v[1]);
4477 }
4478
4479 TEST(GenericToolbox, FastParseTest_FastParseVector02)
4480 {
4481 using OrthancStone::GenericToolbox::FastParseVector;
4482
4483 const char* vectorString = " -1e-2\\\\3\\12.473\\-2.34e4\\-284\\423.23\\\\0.234423\\.786 \\9093\\ ";
4484
4485 OrthancStone::Vector v;
4486
4487 ASSERT_TRUE(FastParseVector(v, vectorString));
4488 ASSERT_EQ(12u, v.size());
4489 ASSERT_DOUBLE_EQ(-1e-2 , v[ 0]);
4490 ASSERT_DOUBLE_EQ(0 , v[ 1]);
4491 ASSERT_DOUBLE_EQ(3 , v[ 2]);
4492 ASSERT_DOUBLE_EQ(12.473 , v[ 3]);
4493 ASSERT_DOUBLE_EQ(-2.34e4 , v[ 4]);
4494 ASSERT_DOUBLE_EQ(-284 , v[ 5]);
4495 ASSERT_DOUBLE_EQ(423.23 , v[ 6]);
4496 ASSERT_DOUBLE_EQ(0 , v[ 7]);
4497 ASSERT_DOUBLE_EQ(0.234423 , v[ 8]);
4498 ASSERT_DOUBLE_EQ(.786 , v[ 9]);
4499 ASSERT_DOUBLE_EQ(9093 , v[10]);
4500 ASSERT_DOUBLE_EQ(0 , v[11]);
4501 }