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