Mercurial > hg > orthanc-stone
comparison OrthancStone/UnitTestsSources/GenericToolboxTests.cpp @ 1877:a2955abe4c2e
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 } |