git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/vartest.c

   1 /*
   2  * VARIANT test program
   3  *
   4  * Copyright 1998 Jean-Claude Cote
   5  *
   6  * The purpose of this program is validate the implementation
   7  * of the APIs related to VARIANTs. The validation is done
   8  * by comparing the results given by the Windows implementation
   9  * versus the Wine implementation.
  10  *
  11  * This program tests the creation/coercion/destruction of VARIANTs.
  12  *
  13  * The program does not currently test any API that takes
  14  * arguments of type: IDispatch, IUnknown, DECIMAL, CURRENCY.
  15  *
  16  * Since the purpose of this program is to compare the results
  17  * from Windows and Wine it is written so that with a simple
  18  * define it can be compiled either in Windows or Linux.
  19  *
  20  * This library is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU Lesser General Public
  22  * License as published by the Free Software Foundation; either
  23  * version 2.1 of the License, or (at your option) any later version.
  24  *
  25  * This library is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  28  * Lesser General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU Lesser General Public
  31  * License along with this library; if not, write to the Free Software
  32  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  33  *
  34  * NOTES
  35  *       - The Variant structure in Windows has a non-named union. This means
  36  *       the member of the union are accessible simply by doing pVariant->pfltVal.
  37  *       With gcc it is not possible to have non-named union so it has been named
  38  *       'u'.  So it's members are accessible using this name like so
  39  *       pVariant->u.pfltVal.  So if this program is compiled in Windows
  40  *       the references to 'u' will need to be take out of this file.
  41  *
  42  *       - Also the printf is a little different so the format specifiers may
  43  *       need to be tweaked if this file is compile in Windows.
  44  *       Printf is also different in that it continues printing numbers
  45  *       even after there is no more significative digits left to print.  These
  46  *       number are garbage and in windows they are set to zero but not
  47  *       on Linux.
  48  *
  49  *       - The VarDateFromStr is not implemented yet.
  50  *
  51  *       - The date and floating point format may not be the exact same format has the one in
  52  *       windows depending on what the Internatinal setting are in windows.
  53  *
  54  */
  55
  56
  57
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <math.h>
  61 #include <float.h>
  62 #include <time.h>
  63
  64 #include "wine/test.h"
  65 #include "winbase.h"
  66 #include "winuser.h"
  67 #include "wingdi.h"
  68 #include "winnls.h"
  69 #include "winerror.h"
  70 #include "winnt.h"
  71
  72 #include "wtypes.h"
  73 #include "oleauto.h"
  74
  75
  76 #define MAX_BUFFER  1024
  77
  78 static char* WtoA( OLECHAR* p )
  79 {
  80     static char buffer[MAX_BUFFER];
  81     DWORD len = WideCharToMultiByte( CP_ACP, 0, p, -1, buffer+1, sizeof(buffer)-3, NULL, NULL );
  82     buffer[0] = '\"';
  83     buffer[len] = '\"';
  84     buffer[len+1] = 0;
  85     return buffer;
  86 }
  87
  88 static OLECHAR* AtoW( char* p )
  89 {
  90     OLECHAR *buffer;
  91     DWORD len = MultiByteToWideChar( CP_ACP, 0, p, -1, NULL, 0 );
  92     buffer = malloc( len * sizeof(OLECHAR) );
  93     MultiByteToWideChar( CP_ACP, 0, p, -1, buffer, len );
  94     return buffer;
  95 }
  96
  97 static const struct _vartypes {
  98     int ind;
  99     DWORD vcind1,vcind2,vcex1,vcex2;
 100 } vartypes[] = {
 101     {0, 0, 0x80070057, 0, 0x80020008 },
 102     {1, 0, 0x80070057, 0, 0x80020008 },
 103     {2, 0, 0, 0, 0x80020005 },
 104     {3, 0, 0, 0, 0x80020005 },
 105     {4, 0, 0, 0, 0x80020005 },
 106     {5, 0, 0, 0, 0x80020005 },
 107     {6, 0, 0, 0, 0x80020005 },
 108     {7, 0, 0, 0, 0x80020005 },
 109     {77,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 110     {78,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 111     {79,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 112     {80,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 113     {81,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 114     {82,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 115     {83,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 116     {84,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 117     {85,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 118     {86,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 119     {87,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 120     {88,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 121     {89,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 122     {90,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 123     {91,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 124     {92,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 125     {93,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 126     {94,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 127     {95,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 128     {96,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 129     {97,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 130     {98,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 131     {99,0x80020008, 0x80070057, 0x80020008, 0x80020008 },
 132 };
 133
 134 static const char *strfromr8[] = {
 135 "1",
 136 "-1",
 137 "21",
 138 "-21",
 139 "321",
 140 "-321",
 141 "4321",
 142 "-4321",
 143 "54321",
 144 "-54321",
 145 "654321",
 146 "-654321",
 147 "7654321",
 148 "-7654321",
 149 "87654321",
 150 "-87654321",
 151 "987654321",
 152 "-987654321",
 153 "1987654321",
 154 "-1987654321",
 155 "21987654321",
 156 "-21987654321",
 157 "321987654321",
 158 "-321987654321",
 159 "4321987654321",
 160 "-4321987654321",
 161 "54321987654321",
 162 "-54321987654321",
 163 "654321987654321",
 164 "-654321987654321",
 165 "7.65432198765432e+15",
 166 "-7.65432198765432e+15",
 167 "8.76543219876543e+16",
 168 "-8.76543219876543e+16",
 169 "9.87654321987654e+17",
 170 "-9.87654321987654e+17",
 171 "1.98765432198765e+18",
 172 "-1.98765432198765e+18",
 173 "2.19876543219877e+19",
 174 "-2.19876543219877e+19",
 175 "1",
 176 "0",
 177 "-1",
 178 "1.2",
 179 "0.2",
 180 "-1.2",
 181 "1.23",
 182 "0.23",
 183 "-1.23",
 184 "1.234",
 185 "0.234",
 186 "-1.234",
 187 "1.2345",
 188 "0.2345",
 189 "-1.2345",
 190 "1.23456",
 191 "0.23456",
 192 "-1.23456",
 193 "1.234567",
 194 "0.234567",
 195 "-1.234567",
 196 "1.2345678",
 197 "0.2345678",
 198 "-1.2345678",
 199 "1.23456789",
 200 "0.23456789",
 201 "-1.23456789",
 202 "1.234567891",
 203 "0.234567891",
 204 "-1.234567891",
 205 "1.2345678912",
 206 "0.2345678912",
 207 "-1.2345678912",
 208 "1.23456789123",
 209 "0.23456789123",
 210 "-1.23456789123",
 211 "1.234567891234",
 212 "0.234567891234",
 213 "-1.234567891234",
 214 "1.2345678912345",
 215 "0.2345678912345",
 216 "-1.2345678912345",
 217 "1.23456789123456",
 218 "0.23456789123456",
 219 "-1.23456789123456",
 220 "1.23456789123457",
 221 "0.234567891234567",
 222 "-1.23456789123457",
 223 "1.23456789123457",
 224 "0.234567891234568",
 225 "-1.23456789123457",
 226 "1.23456789123457",
 227 "0.234567891234568",
 228 "-1.23456789123457",
 229 "1.23456789123457",
 230 "0.234567891234568",
 231 "-1.23456789123457",
 232 "1.23456789123457",
 233 "0.234567891234568",
 234 "-1.23456789123457",
 235 "2",
 236 "-2",
 237 "22.2",
 238 "-22.2",
 239 "322.23",
 240 "-322.23",
 241 "4322.234",
 242 "-4322.234",
 243 "54322.2345",
 244 "-54322.2345",
 245 "654322.23456",
 246 "-654322.23456",
 247 "7654322.234567",
 248 "-7654322.234567",
 249 "87654322.2345678",
 250 "-87654322.2345678",
 251 "987654322.234568",
 252 "-987654322.234568",
 253 "1987654322.23457",
 254 "-1987654322.23457",
 255 "21987654322.2346",
 256 "-21987654322.2346",
 257 "321987654322.235",
 258 "-321987654322.235",
 259 "4321987654322.23",
 260 "-4321987654322.23",
 261 "54321987654322.2",
 262 "-54321987654322.2",
 263 "654321987654322",
 264 "-654321987654322",
 265 "7.65432198765432e+15",
 266 "-7.65432198765432e+15",
 267 "8.76543219876543e+16",
 268 "-8.76543219876543e+16",
 269 "9.87654321987654e+17",
 270 "-9.87654321987654e+17",
 271 "1.98765432198765e+18",
 272 "-1.98765432198765e+18",
 273 "2.19876543219877e+19",
 274 "-2.19876543219877e+19",
 275 /* r4 tests */
 276 "1",
 277 "-1",
 278 "21",
 279 "-21",
 280 "321",
 281 "-321",
 282 "4321",
 283 "-4321",
 284 "54321",
 285 "-54321",
 286 "654321",
 287 "-654321",
 288 "7654321",
 289 "-7654321",
 290 "8.765432e+07",
 291 "-8.765432e+07",
 292 "9.876543e+08",
 293 "-9.876543e+08",
 294 "1.987654e+09",
 295 "-1.987654e+09",
 296 "1",
 297 "0",
 298 "-1",
 299 "1.2",
 300 "0.2",
 301 "-1.2",
 302 "1.23",
 303 "0.23",
 304 "-1.23",
 305 "1.234",
 306 "0.234",
 307 "-1.234",
 308 "1.2345",
 309 "0.2345001", /* FIXME: should be 0.2345 ? */
 310 "-1.2345",
 311 "1.23456",
 312 "0.23456",
 313 "-1.23456",
 314 "1.234567",
 315 "0.234567",
 316 "-1.234567",
 317 "1.234568",
 318 "0.2345678",
 319 "-1.234568",
 320 "1.234568",
 321 "0.2345679",
 322 "-1.234568",
 323 "1.234568",
 324 "0.2345679",
 325 "-1.234568",
 326 "2",
 327 "-2",
 328 "22.2",
 329 "-22.2",
 330 "322.23",
 331 "-322.23",
 332 "4322.234",
 333 "-4322.234",
 334 "54322.23",
 335 "-54322.23",
 336 "654322.2", /* FIXME: should be 654322.3 */
 337 "-654322.2",/* FIXME: should be -654322.3 */
 338 "7654322",
 339 "-7654322",
 340 "8.765432e+07",
 341 "-8.765432e+07",
 342 "9.876543e+08",
 343 "-9.876543e+08",
 344 "1.987654e+09",
 345 "-1.987654e+09",
 346 };
 347
 348 static const struct _strret_date {
 349     DATE        retval;
 350     DWORD       error;
 351     BOOL        todo;
 352 } strrets_DATE[] = {
 353 {  -2.000000, 0x80020005 },
 354 {  -2.000000, 0x80020005 },
 355 {  -2.000000, 0x80020005 },
 356 {  -2.000000, 0x80020005 },
 357 {  -2.000000, 0x80020005 },
 358 {  -2.000000, 0x80020005 },
 359 {  0.000000, 0 },
 360 {  0.034028, 0 },
 361 {  0.003472, 0 },
 362 {  0.035417, 0 },
 363 {  0.035417, 0x80020005 },
 364 {  0.035417, 0x80020005 },
 365 {  0.035417, 0x80020005 },
 366 {  0.035417, 0x80020005 },
 367 {  0.035417, 0x80020005 },
 368 {  0.035417, 0x80020005 },
 369 {  0.035417, 0x80020005 },
 370 {  0.035417, 0x80020005 },
 371 {  0.035417, 0x80020005 },
 372 {  0.035417, 0x80020005 },
 373 {  0.035417, 0x80020005 },
 374 {  0.035417, 0x80020005 },
 375 {  0.035417, 0x80020005 },
 376 {  0.035417, 0x80020005 },
 377 {  0.035417, 0x80020005 },
 378 {  0.035417, 0x80020005 },
 379 {  0.035417, 0x80020005 },
 380 {  0.035417, 0x80020005 },
 381 {  0.035417, 0x80020005 },
 382 {  0.035417, 0x80020005 },
 383 {  0.035417, 0x80020005 },
 384 {  0.035417, 0x80020005 },
 385 {  0.035417, 0x80020005 },
 386 {  0.035417, 0x80020005 },
 387 {  35797.000000, 0 },
 388 {  37623.000000, 0 },
 389 {  37623.000000, 0 },
 390 {  37623.000000, 0 },
 391 {  37623.000000, 0x80020005 },
 392 {  0.043090, 0 },
 393 {  0.043090, 0x80020005 },
 394 {  0.043090, 0x80020005 },
 395 {  0.043090, 0x80020005 },
 396 {  0.043090, 0x80020005 },
 397 {  0.043090, 0x80020005 },
 398 {  0.043090, 0x80020005 },
 399 {  0.043090, 0x80020005 },
 400 {  0.043090, 0x80020005 },
 401 {  0.043090, 0x80020005 },
 402 {  0.043090, 0x80020005 },
 403 {  0.043090, 0x80020005 },
 404 {  0.043090, 0x80020005 },
 405 {  0.043090, 0x80020005 },
 406 {  0.043090, 0x80020005 },
 407 {  0.043090, 0x80020005 },
 408 {  0.043090, 0x80020005 },
 409 {  0.043090, 0x80020005 },
 410 {  0.043090, 0x80020005 },
 411 {  0.043090, 0x80020005 },
 412 {  0.043090, 0x80020005 },
 413 {  36161.000000, 0 },
 414 {  65380.000000, 0 },
 415 {  2.000000, 0 },
 416 {  3.000000, 0 },
 417 {  3.000000, 0x80020005 },
 418 {  36475.000000, 0 },
 419 {  36475.000000, 0 },
 420 {  36475.000000, 0x80020005 },
 421 {  36475.000000, 0x80020005 },
 422 {  36485.466100, 0 },
 423 {  36475.466100, 0 },
 424 {  36475.966100, 0 },
 425 {  36475.966100, 0x80020005 },
 426 {  36475.000127, 0 },
 427 {  36475.000127, 0x80020005 },
 428 {  36475.466100, 0 },
 429 {  36475.466100, 0x80020005 },
 430 {  36475.465972, 0 },
 431 {  36475.041667, 0 },
 432 {  36475.000000, 0 },
 433 {  36475.466100, 0 },
 434 {  36477.000000, 0 },
 435 {  36477.000000, 0x80020005 },
 436 {  36477.000000, 0 },
 437 {  36477.000000, 0x80020005 },
 438 {  36477.000000, 0x80020005 },
 439 {  36526.000000, 0 },
 440 {  36526.000000, 0x80020005 },
 441 {  36163.375000, 0 },
 442 {  36161.458333, 0 },
 443 {  36475.166667, 0 },
 444 {  36475.166667, 0x80020005 },
 445 {  36475.166667, 0x80020005 },
 446 {  36475.166667, 0x80020005 },
 447 {  36475.166667, 0x80020005 },
 448 {  65380.000000, 0 },
 449 {  65380.000000, 0x80020005 },
 450 {  65380.000000, 0 },
 451 {  36465.000000, 0 },
 452 {  36465.000000, 0 },
 453 {  36465.000000, 0x80020005 },
 454 {  36465.000000, 0x80020005 },
 455 {  36465.000000, 0x80020005 },
 456 {  36465.000000, 0x80020005 },
 457 {  36465.000000, 0x80020005 },
 458 {  36465.000000, 0x80020005 },
 459 {  36465.000000, 0x80020005 },
 460 {  36465.000000, 0x80020005 },
 461 {  36465.000000, 0x80020005 },
 462 {  36465.000000, 0x80020005 },
 463 {  0.045139, 0 },
 464 {  0.086806, 0 },
 465 {  0.128472, 0 },
 466 {  0.170139, 0 },
 467 {  0.170139, 0x80020005 },
 468 {  0.170139, 0x80020005 },
 469 {  0.170139, 0x80020005 },
 470 {  0.170139, 0x80020005 },
 471 {  0.170139, 0x80020005 },
 472 {  0.170139, 0x80020005 },
 473 };
 474 static const struct _strret_b {
 475     BOOL retval;
 476     DWORD error;
 477 } strrets_B[] = {
 478 {  VARIANT_TRUE, 0 },
 479 {  VARIANT_TRUE, 0 },
 480 {  VARIANT_TRUE, 0 },
 481 {  VARIANT_TRUE, 0 },
 482 {  VARIANT_TRUE, 0 },
 483 {  VARIANT_FALSE, 0 },
 484 {  VARIANT_FALSE, 0 },
 485 {  VARIANT_TRUE, 0 },
 486 {  VARIANT_TRUE, 0 },
 487 {  VARIANT_TRUE, 0 },
 488 {  VARIANT_TRUE, 0 },
 489 {  VARIANT_TRUE, 0 },
 490 {  VARIANT_TRUE, 0 },
 491 {  VARIANT_TRUE, 0 },
 492 {  VARIANT_TRUE, 0 },
 493 {  VARIANT_TRUE, 0 },
 494 {  VARIANT_TRUE, 0 },
 495 {  VARIANT_TRUE, 0 },
 496 {  VARIANT_TRUE, 0 },
 497 {  VARIANT_TRUE, 0 },
 498 {  VARIANT_TRUE, 0 },
 499 {  VARIANT_TRUE, 0 },
 500 {  VARIANT_TRUE, 0 },
 501 {  VARIANT_TRUE, 0 },
 502 {  VARIANT_TRUE, 0 },
 503 {  VARIANT_TRUE, 0 },
 504 {  VARIANT_TRUE, 0 },
 505 {  VARIANT_TRUE, 0 },
 506 {  VARIANT_TRUE, 0 },
 507 {  VARIANT_TRUE, 0x80020005 },
 508 {  VARIANT_TRUE, 0x80020005 },
 509 {  VARIANT_TRUE, 0x80020005 },
 510 {  VARIANT_TRUE, 0x80020005 },
 511 {  VARIANT_TRUE, 0 },
 512 {  VARIANT_TRUE, 0x80020005 },
 513 {  VARIANT_TRUE, 0 },
 514 {  VARIANT_TRUE, 0x80020005 },
 515 {  VARIANT_TRUE, 0x80020005 },
 516 {  VARIANT_TRUE, 0x80020005 },
 517 {  VARIANT_TRUE, 0x80020005 },
 518 {  VARIANT_FALSE, 0 },
 519 {  VARIANT_FALSE, 0 },
 520 {  VARIANT_TRUE, 0 },
 521 {  VARIANT_TRUE, 0 },
 522 {  VARIANT_TRUE, 0 },
 523 {  VARIANT_TRUE, 0x80020005 },
 524 {  VARIANT_TRUE, 0 },
 525 {  VARIANT_TRUE, 0x80020005 },
 526 {  VARIANT_TRUE, 0x80020005 },
 527 {  VARIANT_TRUE, 0x80020005 },
 528 {  VARIANT_TRUE, 0 },
 529 {  VARIANT_TRUE, 0 },
 530 {  VARIANT_TRUE, 0 },
 531 {  VARIANT_TRUE, 0 },
 532 {  VARIANT_TRUE, 0 },
 533 {  VARIANT_TRUE, 0 },
 534 {  VARIANT_TRUE, 0 },
 535 {  VARIANT_TRUE, 0 },
 536 {  VARIANT_TRUE, 0 },
 537 {  VARIANT_TRUE, 0 },
 538 {  VARIANT_TRUE, 0x80020005 },
 539 {  VARIANT_TRUE, 0x80020005 },
 540 {  VARIANT_TRUE, 0x80020005 },
 541 {  VARIANT_TRUE, 0x80020005 },
 542 {  VARIANT_TRUE, 0x80020005 },
 543 {  VARIANT_TRUE, 0x80020005 },
 544 {  VARIANT_TRUE, 0x80020005 },
 545 {  VARIANT_TRUE, 0x80020005 },
 546 {  VARIANT_TRUE, 0x80020005 },
 547 {  VARIANT_TRUE, 0x80020005 },
 548 {  VARIANT_TRUE, 0x80020005 },
 549 {  VARIANT_TRUE, 0x80020005 },
 550 {  VARIANT_TRUE, 0x80020005 },
 551 {  VARIANT_TRUE, 0x80020005 },
 552 {  VARIANT_TRUE, 0x80020005 },
 553 {  VARIANT_TRUE, 0x80020005 },
 554 {  VARIANT_TRUE, 0x80020005 },
 555 {  VARIANT_TRUE, 0x80020005 },
 556 {  VARIANT_TRUE, 0x80020005 },
 557 {  VARIANT_TRUE, 0x80020005 },
 558 {  VARIANT_TRUE, 0x80020005 },
 559 {  VARIANT_TRUE, 0x80020005 },
 560 {  VARIANT_TRUE, 0x80020005 },
 561 {  VARIANT_TRUE, 0x80020005 },
 562 {  VARIANT_TRUE, 0x80020005 },
 563 {  VARIANT_TRUE, 0x80020005 },
 564 {  VARIANT_TRUE, 0x80020005 },
 565 {  VARIANT_TRUE, 0x80020005 },
 566 {  VARIANT_TRUE, 0x80020005 },
 567 {  VARIANT_TRUE, 0x80020005 },
 568 {  VARIANT_TRUE, 0x80020005 },
 569 {  VARIANT_TRUE, 0x80020005 },
 570 {  VARIANT_TRUE, 0x80020005 },
 571 {  VARIANT_TRUE, 0x80020005 },
 572 {  VARIANT_TRUE, 0x80020005 },
 573 {  VARIANT_TRUE, 0x80020005 },
 574 {  VARIANT_TRUE, 0x80020005 },
 575 {  VARIANT_TRUE, 0x80020005 },
 576 {  VARIANT_TRUE, 0x80020005 },
 577 {  VARIANT_TRUE, 0x80020005 },
 578 {  VARIANT_TRUE, 0 },
 579 {  VARIANT_TRUE, 0 },
 580 {  VARIANT_TRUE, 0 },
 581 {  VARIANT_TRUE, 0 },
 582 {  VARIANT_TRUE, 0x80020005 },
 583 {  VARIANT_TRUE, 0x80020005 },
 584 {  VARIANT_FALSE, 0 },
 585 {  VARIANT_FALSE, 0x80020005 },
 586 {  VARIANT_FALSE, 0x80020005 },
 587 {  VARIANT_FALSE, 0x80020005 },
 588 {  VARIANT_TRUE, 0 },
 589 {  VARIANT_TRUE, 0 },
 590 {  VARIANT_TRUE, 0 },
 591 {  VARIANT_TRUE, 0 },
 592 {  VARIANT_TRUE, 0x80020005 },
 593 {  VARIANT_TRUE, 0x80020005 },
 594 {  VARIANT_TRUE, 0x80020005 },
 595 {  VARIANT_TRUE, 0x80020005 },
 596 {  VARIANT_TRUE, 0x80020005 },
 597 {  VARIANT_TRUE, 0x80020005 },
 598 };
 599 static const struct _strret_r8 {
 600     DOUBLE retval;
 601     DWORD error;
 602 } strrets_R8[] = {
 603 {  -2.000000, 0 },
 604 {  -1.000000, 0 },
 605 {  -0.510000, 0 },
 606 {  -0.500000, 0 },
 607 {  -0.490000, 0 },
 608 {  0.000000, 0 },
 609 {  0.000000, 0 },
 610 {  0.490000, 0 },
 611 {  0.500000, 0 },
 612 {  0.510000, 0 },
 613 {  1.000000, 0 },
 614 {  127.000000, 0 },
 615 {  128.000000, 0 },
 616 {  129.000000, 0 },
 617 {  255.000000, 0 },
 618 {  256.000000, 0 },
 619 {  257.000000, 0 },
 620 {  32767.000000, 0 },
 621 {  32768.000000, 0 },
 622 {  -32768.000000, 0 },
 623 {  -32769.000000, 0 },
 624 {  16777216.000000, 0 },
 625 {  16777217.000000, 0 },
 626 {  -16777216.000000, 0 },
 627 {  16777217.000000, 0 },
 628 {  2147483647.000000, 0 },
 629 {  2147483648.000000, 0 },
 630 {  -2147483647.000000, 0 },
 631 {  -2147483648.000000, 0 },
 632 {  -2147483648.000000, 0x80020005 },
 633 {  -2147483648.000000, 0x80020005 },
 634 {  -2147483648.000000, 0x80020005 },
 635 {  -2147483648.000000, 0x80020005 },
 636 {  1.000000, 0 },
 637 {  1.000000, 0x80020005 },
 638 {  123.000000, 0 },
 639 {  123.000000, 0x80020005 },
 640 {  123.000000, 0x80020005 },
 641 {  123.000000, 0x80020005 },
 642 {  123.000000, 0x80020005 },
 643 {  0.000000, 0 },
 644 {  0.000000, 0 },
 645 {  100000000000.000000, 0 },
 646 {  24.000000, 0 },
 647 {  32.000000, 0 },
 648 {  32.000000, 0x80020005 },
 649 {  200.000000, 0 },
 650 {  200.000000, 0x80020005 },
 651 {  200.000000, 0x80020005 },
 652 {  200.000000, 0x80020005 },
 653 {  1000000000000000100000000000000000000000000000000000000000000000.000000, 0 },
 654 {  1.000000, 0 },
 655 {  1.000000, 0 },
 656 {  99999999999999997000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000, 0 },
 657 {  1.000000, 0 },
 658 {  65535.000000, 0 },
 659 {  65535.500000, 0 },
 660 {  65536.000000, 0 },
 661 {  4294967295.000000, 0 },
 662 {  4294967296.000000, 0 },
 663 {  4294967296.000000, 0x80020005 },
 664 {  4294967296.000000, 0x80020005 },
 665 {  4294967296.000000, 0x80020005 },
 666 {  4294967296.000000, 0x80020005 },
 667 {  4294967296.000000, 0x80020005 },
 668 {  4294967296.000000, 0x80020005 },
 669 {  4294967296.000000, 0x80020005 },
 670 {  4294967296.000000, 0x80020005 },
 671 {  4294967296.000000, 0x80020005 },
 672 {  4294967296.000000, 0x80020005 },
 673 {  4294967296.000000, 0x80020005 },
 674 {  4294967296.000000, 0x80020005 },
 675 {  4294967296.000000, 0x80020005 },
 676 {  4294967296.000000, 0x80020005 },
 677 {  4294967296.000000, 0x80020005 },
 678 {  4294967296.000000, 0x80020005 },
 679 {  4294967296.000000, 0x80020005 },
 680 {  4294967296.000000, 0x80020005 },
 681 {  4294967296.000000, 0x80020005 },
 682 {  4294967296.000000, 0x80020005 },
 683 {  4294967296.000000, 0x80020005 },
 684 {  4294967296.000000, 0x80020005 },
 685 {  4294967296.000000, 0x80020005 },
 686 {  4294967296.000000, 0x80020005 },
 687 {  4294967296.000000, 0x80020005 },
 688 {  4294967296.000000, 0x80020005 },
 689 {  4294967296.000000, 0x80020005 },
 690 {  4294967296.000000, 0x80020005 },
 691 {  4294967296.000000, 0x80020005 },
 692 {  4294967296.000000, 0x80020005 },
 693 {  4294967296.000000, 0x80020005 },
 694 {  4294967296.000000, 0x80020005 },
 695 {  4294967296.000000, 0x80020005 },
 696 {  4294967296.000000, 0x80020005 },
 697 {  4294967296.000000, 0x80020005 },
 698 {  4294967296.000000, 0x80020005 },
 699 {  4294967296.000000, 0x80020005 },
 700 {  4294967296.000000, 0x80020005 },
 701 {  4294967296.000000, 0x80020005 },
 702 {  4294967296.000000, 0x80020005 },
 703 {  4294967296.000000, 0x80020005 },
 704 {  4294967296.000000, 0x80020005 },
 705 {  4294967296.000000, 0x80020005 },
 706 {  4294967296.000000, 0x80020005 },
 707 {  4294967296.000000, 0x80020005 },
 708 {  4294967296.000000, 0x80020005 },
 709 {  4294967296.000000, 0x80020005 },
 710 {  4294967296.000000, 0x80020005 },
 711 {  4294967296.000000, 0x80020005 },
 712 {  4294967296.000000, 0x80020005 },
 713 {  1.500000, 0 },
 714 {  2.500000, 0 },
 715 {  3.500000, 0 },
 716 {  4.500000, 0 },
 717 {  4.500000, 0x80020005 },
 718 {  4.500000, 0x80020005 },
 719 {  4.500000, 0x80020005 },
 720 {  4.500000, 0x80020005 },
 721 {  4.500000, 0x80020005 },
 722 {  4.500000, 0x80020005 },
 723 };
 724 static const struct _strret_r4 {
 725     FLOAT retval;
 726     DWORD error;
 727 } strrets_R4[] = {
 728 {  -2.000000, 0 },
 729 {  -1.000000, 0 },
 730 {  -0.510000, 0 },
 731 {  -0.500000, 0 },
 732 {  -0.490000, 0 },
 733 {  0.000000, 0 },
 734 {  0.000000, 0 },
 735 {  0.490000, 0 },
 736 {  0.500000, 0 },
 737 {  0.510000, 0 },
 738 {  1.000000, 0 },
 739 {  127.000000, 0 },
 740 {  128.000000, 0 },
 741 {  129.000000, 0 },
 742 {  255.000000, 0 },
 743 {  256.000000, 0 },
 744 {  257.000000, 0 },
 745 {  32767.000000, 0 },
 746 {  32768.000000, 0 },
 747 {  -32768.000000, 0 },
 748 {  -32769.000000, 0 },
 749 {  16777216.000000, 0 },
 750 {  16777216.000000, 0 },
 751 {  -16777216.000000, 0 },
 752 {  16777216.000000, 0 },
 753 {  2147483648.000000, 0 },
 754 {  2147483648.000000, 0 },
 755 {  -2147483648.000000, 0 },
 756 {  -2147483648.000000, 0 },
 757 {  -2147483648.000000, 0x80020005 },
 758 {  -2147483648.000000, 0x80020005 },
 759 {  -2147483648.000000, 0x80020005 },
 760 {  -2147483648.000000, 0x80020005 },
 761 {  1.000000, 0 },
 762 {  1.000000, 0x80020005 },
 763 {  123.000000, 0 },
 764 {  123.000000, 0x80020005 },
 765 {  123.000000, 0x80020005 },
 766 {  123.000000, 0x80020005 },
 767 {  123.000000, 0x80020005 },
 768 {  0.000000, 0 },
 769 {  0.000000, 0 },
 770 {  99999997952.000000, 0 },
 771 {  24.000000, 0 },
 772 {  32.000000, 0 },
 773 {  32.000000, 0x80020005 },
 774 {  200.000000, 0 },
 775 {  200.000000, 0x80020005 },
 776 {  200.000000, 0x80020005 },
 777 {  200.000000, 0x80020005 },
 778 {  200.000000, 0x8002000A },
 779 {  1.000000, 0 },
 780 {  1.000000, 0 },
 781 {  1.000000, 0x8002000A },
 782 {  1.000000, 0 },
 783 {  65535.000000, 0 },
 784 {  65535.500000, 0 },
 785 {  65536.000000, 0 },
 786 {  4294967296.000000, 0 },
 787 {  4294967296.000000, 0 },
 788 {  4294967296.000000, 0x80020005 },
 789 {  4294967296.000000, 0x80020005 },
 790 {  4294967296.000000, 0x80020005 },
 791 {  4294967296.000000, 0x80020005 },
 792 {  4294967296.000000, 0x80020005 },
 793 {  4294967296.000000, 0x80020005 },
 794 {  4294967296.000000, 0x80020005 },
 795 {  4294967296.000000, 0x80020005 },
 796 {  4294967296.000000, 0x80020005 },
 797 {  4294967296.000000, 0x80020005 },
 798 {  4294967296.000000, 0x80020005 },
 799 {  4294967296.000000, 0x80020005 },
 800 {  4294967296.000000, 0x80020005 },
 801 {  4294967296.000000, 0x80020005 },
 802 {  4294967296.000000, 0x80020005 },
 803 {  4294967296.000000, 0x80020005 },
 804 {  4294967296.000000, 0x80020005 },
 805 {  4294967296.000000, 0x80020005 },
 806 {  4294967296.000000, 0x80020005 },
 807 {  4294967296.000000, 0x80020005 },
 808 {  4294967296.000000, 0x80020005 },
 809 {  4294967296.000000, 0x80020005 },
 810 {  4294967296.000000, 0x80020005 },
 811 {  4294967296.000000, 0x80020005 },
 812 {  4294967296.000000, 0x80020005 },
 813 {  4294967296.000000, 0x80020005 },
 814 {  4294967296.000000, 0x80020005 },
 815 {  4294967296.000000, 0x80020005 },
 816 {  4294967296.000000, 0x80020005 },
 817 {  4294967296.000000, 0x80020005 },
 818 {  4294967296.000000, 0x80020005 },
 819 {  4294967296.000000, 0x80020005 },
 820 {  4294967296.000000, 0x80020005 },
 821 {  4294967296.000000, 0x80020005 },
 822 {  4294967296.000000, 0x80020005 },
 823 {  4294967296.000000, 0x80020005 },
 824 {  4294967296.000000, 0x80020005 },
 825 {  4294967296.000000, 0x80020005 },
 826 {  4294967296.000000, 0x80020005 },
 827 {  4294967296.000000, 0x80020005 },
 828 {  4294967296.000000, 0x80020005 },
 829 {  4294967296.000000, 0x80020005 },
 830 {  4294967296.000000, 0x80020005 },
 831 {  4294967296.000000, 0x80020005 },
 832 {  4294967296.000000, 0x80020005 },
 833 {  4294967296.000000, 0x80020005 },
 834 {  4294967296.000000, 0x80020005 },
 835 {  4294967296.000000, 0x80020005 },
 836 {  4294967296.000000, 0x80020005 },
 837 {  4294967296.000000, 0x80020005 },
 838 {  1.500000, 0 },
 839 {  2.500000, 0 },
 840 {  3.500000, 0 },
 841 {  4.500000, 0 },
 842 {  4.500000, 0x80020005 },
 843 {  4.500000, 0x80020005 },
 844 {  4.500000, 0x80020005 },
 845 {  4.500000, 0x80020005 },
 846 {  4.500000, 0x80020005 },
 847 {  4.500000, 0x80020005 },
 848 };
 849 static const struct _strret_i4 {
 850     LONG retval;
 851     DWORD error;
 852 } strrets_I4[] = {
 853 {  -2, 0 },
 854 {  -1, 0 },
 855 {  -1, 0 },
 856 {  0, 0 },
 857 {  0, 0 },
 858 {  0, 0 },
 859 {  0, 0 },
 860 {  0, 0 },
 861 {  0, 0 },
 862 {  1, 0 },
 863 {  1, 0 },
 864 {  127, 0 },
 865 {  128, 0 },
 866 {  129, 0 },
 867 {  255, 0 },
 868 {  256, 0 },
 869 {  257, 0 },
 870 {  32767, 0 },
 871 {  32768, 0 },
 872 {  -32768, 0 },
 873 {  -32769, 0 },
 874 {  16777216, 0 },
 875 {  16777217, 0 },
 876 {  -16777216, 0 },
 877 {  16777217, 0 },
 878 {  2147483647, 0 },
 879 {  2147483647, 0x8002000A },
 880 {  -2147483647, 0 },
 881 {  -2147483648, 0 },
 882 {  -2147483648, 0x80020005 },
 883 {  -2147483648, 0x80020005 },
 884 {  -2147483648, 0x80020005 },
 885 {  -2147483648, 0x80020005 },
 886 {  1, 0 },
 887 {  1, 0x80020005 },
 888 {  123, 0 },
 889 {  123, 0x80020005 },
 890 {  123, 0x80020005 },
 891 {  123, 0x80020005 },
 892 {  123, 0x80020005 },
 893 {  0, 0 },
 894 {  0, 0 },
 895 {  0, 0x8002000A },
 896 {  24, 0 },
 897 {  32, 0 },
 898 {  32, 0x80020005 },
 899 {  200, 0 },
 900 {  200, 0x80020005 },
 901 {  200, 0x80020005 },
 902 {  200, 0x80020005 },
 903 {  200, 0x8002000A },
 904 {  1, 0 },
 905 {  1, 0 },
 906 {  1, 0x8002000A },
 907 {  1, 0 },
 908 {  65535, 0 },
 909 {  65536, 0 },
 910 {  65536, 0 },
 911 {  65536, 0x8002000A },
 912 {  65536, 0x8002000A },
 913 {  65536, 0x80020005 },
 914 {  65536, 0x80020005 },
 915 {  65536, 0x80020005 },
 916 {  65536, 0x80020005 },
 917 {  65536, 0x80020005 },
 918 {  65536, 0x80020005 },
 919 {  65536, 0x80020005 },
 920 {  65536, 0x80020005 },
 921 {  65536, 0x80020005 },
 922 {  65536, 0x80020005 },
 923 {  65536, 0x80020005 },
 924 {  65536, 0x80020005 },
 925 {  65536, 0x80020005 },
 926 {  65536, 0x80020005 },
 927 {  65536, 0x80020005 },
 928 {  65536, 0x80020005 },
 929 {  65536, 0x80020005 },
 930 {  65536, 0x80020005 },
 931 {  65536, 0x80020005 },
 932 {  65536, 0x80020005 },
 933 {  65536, 0x80020005 },
 934 {  65536, 0x80020005 },
 935 {  65536, 0x80020005 },
 936 {  65536, 0x80020005 },
 937 {  65536, 0x80020005 },
 938 {  65536, 0x80020005 },
 939 {  65536, 0x80020005 },
 940 {  65536, 0x80020005 },
 941 {  65536, 0x80020005 },
 942 {  65536, 0x80020005 },
 943 {  65536, 0x80020005 },
 944 {  65536, 0x80020005 },
 945 {  65536, 0x80020005 },
 946 {  65536, 0x80020005 },
 947 {  65536, 0x80020005 },
 948 {  65536, 0x80020005 },
 949 {  65536, 0x80020005 },
 950 {  65536, 0x80020005 },
 951 {  65536, 0x80020005 },
 952 {  65536, 0x80020005 },
 953 {  65536, 0x80020005 },
 954 {  65536, 0x80020005 },
 955 {  65536, 0x80020005 },
 956 {  65536, 0x80020005 },
 957 {  65536, 0x80020005 },
 958 {  65536, 0x80020005 },
 959 {  65536, 0x80020005 },
 960 {  65536, 0x80020005 },
 961 {  65536, 0x80020005 },
 962 {  65536, 0x80020005 },
 963 {  2, 0 },
 964 {  2, 0 },
 965 {  4, 0 },
 966 {  4, 0 },
 967 {  4, 0x80020005 },
 968 {  4, 0x80020005 },
 969 {  4, 0x80020005 },
 970 {  4, 0x80020005 },
 971 {  4, 0x80020005 },
 972 {  4, 0x80020005 },
 973 };
 974 static const struct _strret_i2 {
 975     SHORT retval;
 976     DWORD error;
 977 } strrets_I2[] = {
 978 {  -2, 0 },
 979 {  -1, 0 },
 980 {  -1, 0 },
 981 {  0, 0 },
 982 {  0, 0 },
 983 {  0, 0 },
 984 {  0, 0 },
 985 {  0, 0 },
 986 {  0, 0 },
 987 {  1, 0 },
 988 {  1, 0 },
 989 {  127, 0 },
 990 {  128, 0 },
 991 {  129, 0 },
 992 {  255, 0 },
 993 {  256, 0 },
 994 {  257, 0 },
 995 {  32767, 0 },
 996 {  32767, 0x8002000A },
 997 {  -32768, 0 },
 998 {  -32768, 0x8002000A },
 999 {  -32768, 0x8002000A },
1000 {  -32768, 0x8002000A },
1001 {  -32768, 0x8002000A },
1002 {  -32768, 0x8002000A },
1003 {  -32768, 0x8002000A },
1004 {  -32768, 0x8002000A },
1005 {  -32768, 0x8002000A },
1006 {  -32768, 0x8002000A },
1007 {  -32768, 0x80020005 },
1008 {  -32768, 0x80020005 },
1009 {  -32768, 0x80020005 },
1010 {  -32768, 0x80020005 },
1011 {  1, 0 },
1012 {  1, 0x80020005 },
1013 {  123, 0 },
1014 {  123, 0x80020005 },
1015 {  123, 0x80020005 },
1016 {  123, 0x80020005 },
1017 {  123, 0x80020005 },
1018 {  0, 0 },
1019 {  0, 0 },
1020 {  0, 0x8002000A },
1021 {  24, 0 },
1022 {  32, 0 },
1023 {  32, 0x80020005 },
1024 {  200, 0 },
1025 {  200, 0x80020005 },
1026 {  200, 0x80020005 },
1027 {  200, 0x80020005 },
1028 {  200, 0x8002000A },
1029 {  1, 0 },
1030 {  1, 0 },
1031 {  1, 0x8002000A },
1032 {  1, 0 },
1033 {  1, 0x8002000A },
1034 {  1, 0x8002000A },
1035 {  1, 0x8002000A },
1036 {  1, 0x8002000A },
1037 {  1, 0x8002000A },
1038 {  1, 0x80020005 },
1039 {  1, 0x80020005 },
1040 {  1, 0x80020005 },
1041 {  1, 0x80020005 },
1042 {  1, 0x80020005 },
1043 {  1, 0x80020005 },
1044 {  1, 0x80020005 },
1045 {  1, 0x80020005 },
1046 {  1, 0x80020005 },
1047 {  1, 0x80020005 },
1048 {  1, 0x80020005 },
1049 {  1, 0x80020005 },
1050 {  1, 0x80020005 },
1051 {  1, 0x80020005 },
1052 {  1, 0x80020005 },
1053 {  1, 0x80020005 },
1054 {  1, 0x80020005 },
1055 {  1, 0x80020005 },
1056 {  1, 0x80020005 },
1057 {  1, 0x80020005 },
1058 {  1, 0x80020005 },
1059 {  1, 0x80020005 },
1060 {  1, 0x80020005 },
1061 {  1, 0x80020005 },
1062 {  1, 0x80020005 },
1063 {  1, 0x80020005 },
1064 {  1, 0x80020005 },
1065 {  1, 0x80020005 },
1066 {  1, 0x80020005 },
1067 {  1, 0x80020005 },
1068 {  1, 0x80020005 },
1069 {  1, 0x80020005 },
1070 {  1, 0x80020005 },
1071 {  1, 0x80020005 },
1072 {  1, 0x80020005 },
1073 {  1, 0x80020005 },
1074 {  1, 0x80020005 },
1075 {  1, 0x80020005 },
1076 {  1, 0x80020005 },
1077 {  1, 0x80020005 },
1078 {  1, 0x80020005 },
1079 {  1, 0x80020005 },
1080 {  1, 0x80020005 },
1081 {  1, 0x80020005 },
1082 {  1, 0x80020005 },
1083 {  1, 0x80020005 },
1084 {  1, 0x80020005 },
1085 {  1, 0x80020005 },
1086 {  1, 0x80020005 },
1087 {  1, 0x80020005 },
1088 {  2, 0 },
1089 {  2, 0 },
1090 {  4, 0 },
1091 {  4, 0 },
1092 {  4, 0x80020005 },
1093 {  4, 0x80020005 },
1094 {  4, 0x80020005 },
1095 {  4, 0x80020005 },
1096 {  4, 0x80020005 },
1097 {  4, 0x80020005 },
1098 };
1099 static const struct _strret_i1 {
1100     CHAR retval;
1101     DWORD error;
1102 } strrets_I1[] = {
1103 {  -2, 0 },
1104 {  -1, 0 },
1105 {  -1, 0 },
1106 {  0, 0 },
1107 {  0, 0 },
1108 {  0, 0 },
1109 {  0, 0 },
1110 {  0, 0 },
1111 {  0, 0 },
1112 {  1, 0 },
1113 {  1, 0 },
1114 {  127, 0 },
1115 {  127, 0x8002000A },
1116 {  127, 0x8002000A },
1117 {  127, 0x8002000A },
1118 {  127, 0x8002000A },
1119 {  127, 0x8002000A },
1120 {  127, 0x8002000A },
1121 {  127, 0x8002000A },
1122 {  127, 0x8002000A },
1123 {  127, 0x8002000A },
1124 {  127, 0x8002000A },
1125 {  127, 0x8002000A },
1126 {  127, 0x8002000A },
1127 {  127, 0x8002000A },
1128 {  127, 0x8002000A },
1129 {  127, 0x8002000A },
1130 {  127, 0x8002000A },
1131 {  127, 0x8002000A },
1132 {  127, 0x80020005 },
1133 {  127, 0x80020005 },
1134 {  127, 0x80020005 },
1135 {  127, 0x80020005 },
1136 {  1, 0 },
1137 {  1, 0x80020005 },
1138 {  123, 0 },
1139 {  123, 0x80020005 },
1140 {  123, 0x80020005 },
1141 {  123, 0x80020005 },
1142 {  123, 0x80020005 },
1143 {  0, 0 },
1144 {  0, 0 },
1145 {  0, 0x8002000A },
1146 {  24, 0 },
1147 {  32, 0 },
1148 {  32, 0x80020005 },
1149 {  32, 0x8002000A },
1150 {  32, 0x80020005 },
1151 {  32, 0x80020005 },
1152 {  32, 0x80020005 },
1153 {  32, 0x8002000A },
1154 {  1, 0 },
1155 {  1, 0 },
1156 {  1, 0x8002000A },
1157 {  1, 0 },
1158 {  1, 0x8002000A },
1159 {  1, 0x8002000A },
1160 {  1, 0x8002000A },
1161 {  1, 0x8002000A },
1162 {  1, 0x8002000A },
1163 {  1, 0x80020005 },
1164 {  1, 0x80020005 },
1165 {  1, 0x80020005 },
1166 {  1, 0x80020005 },
1167 {  1, 0x80020005 },
1168 {  1, 0x80020005 },
1169 {  1, 0x80020005 },
1170 {  1, 0x80020005 },
1171 {  1, 0x80020005 },
1172 {  1, 0x80020005 },
1173 {  1, 0x80020005 },
1174 {  1, 0x80020005 },
1175 {  1, 0x80020005 },
1176 {  1, 0x80020005 },
1177 {  1, 0x80020005 },
1178 {  1, 0x80020005 },
1179 {  1, 0x80020005 },
1180 {  1, 0x80020005 },
1181 {  1, 0x80020005 },
1182 {  1, 0x80020005 },
1183 {  1, 0x80020005 },
1184 {  1, 0x80020005 },
1185 {  1, 0x80020005 },
1186 {  1, 0x80020005 },
1187 {  1, 0x80020005 },
1188 {  1, 0x80020005 },
1189 {  1, 0x80020005 },
1190 {  1, 0x80020005 },
1191 {  1, 0x80020005 },
1192 {  1, 0x80020005 },
1193 {  1, 0x80020005 },
1194 {  1, 0x80020005 },
1195 {  1, 0x80020005 },
1196 {  1, 0x80020005 },
1197 {  1, 0x80020005 },
1198 {  1, 0x80020005 },
1199 {  1, 0x80020005 },
1200 {  1, 0x80020005 },
1201 {  1, 0x80020005 },
1202 {  1, 0x80020005 },
1203 {  1, 0x80020005 },
1204 {  1, 0x80020005 },
1205 {  1, 0x80020005 },
1206 {  1, 0x80020005 },
1207 {  1, 0x80020005 },
1208 {  1, 0x80020005 },
1209 {  1, 0x80020005 },
1210 {  1, 0x80020005 },
1211 {  1, 0x80020005 },
1212 {  1, 0x80020005 },
1213 {  2, 0 },
1214 {  2, 0 },
1215 {  4, 0 },
1216 {  4, 0 },
1217 {  4, 0x80020005 },
1218 {  4, 0x80020005 },
1219 {  4, 0x80020005 },
1220 {  4, 0x80020005 },
1221 {  4, 0x80020005 },
1222 {  4, 0x80020005 },
1223 };
1224 static const struct _strret_u1 {
1225     BYTE retval;
1226     DWORD error;
1227 } strrets_U1[] = {
1228 {  0, 0x8002000A },
1229 {  0, 0x8002000A },
1230 {  0, 0x8002000A },
1231 {  0, 0 },
1232 {  0, 0 },
1233 {  0, 0 },
1234 {  0, 0 },
1235 {  0, 0 },
1236 {  0, 0 },
1237 {  1, 0 },
1238 {  1, 0 },
1239 {  0x7F, 0 },
1240 {  0x80, 0 },
1241 {  0x81, 0 },
1242 {  0xFF, 0 },
1243 {  0xFF, 0x8002000A },
1244 {  0xFF, 0x8002000A },
1245 {  0xFF, 0x8002000A },
1246 {  0xFF, 0x8002000A },
1247 {  0xFF, 0x8002000A },
1248 {  0xFF, 0x8002000A },
1249 {  0xFF, 0x8002000A },
1250 {  0xFF, 0x8002000A },
1251 {  0xFF, 0x8002000A },
1252 {  0xFF, 0x8002000A },
1253 {  0xFF, 0x8002000A },
1254 {  0xFF, 0x8002000A },
1255 {  0xFF, 0x8002000A },
1256 {  0xFF, 0x8002000A },
1257 {  0xFF, 0x80020005 },
1258 {  0xFF, 0x80020005 },
1259 {  0xFF, 0x80020005 },
1260 {  0xFF, 0x80020005 },
1261 {  1, 0 },
1262 {  1, 0x80020005 },
1263 {  0x7B, 0 },
1264 {  0x7B, 0x80020005 },
1265 {  0x7B, 0x80020005 },
1266 {  0x7B, 0x80020005 },
1267 {  0x7B, 0x80020005 },
1268 {  0, 0 },
1269 {  0, 0 },
1270 {  0, 0x8002000A },
1271 {  0x18, 0 },
1272 {  0x20, 0 },
1273 {  0x20, 0x80020005 },
1274 {  0xC8, 0 },
1275 {  0xC8, 0x80020005 },
1276 {  0xC8, 0x80020005 },
1277 {  0xC8, 0x80020005 },
1278 {  0xC8, 0x8002000A },
1279 {  1, 0 },
1280 {  1, 0 },
1281 {  1, 0x8002000A },
1282 {  1, 0 },
1283 {  1, 0x8002000A },
1284 {  1, 0x8002000A },
1285 {  1, 0x8002000A },
1286 {  1, 0x8002000A },
1287 {  1, 0x8002000A },
1288 {  1, 0x80020005 },
1289 {  1, 0x80020005 },
1290 {  1, 0x80020005 },
1291 {  1, 0x80020005 },
1292 {  1, 0x80020005 },
1293 {  1, 0x80020005 },
1294 {  1, 0x80020005 },
1295 {  1, 0x80020005 },
1296 {  1, 0x80020005 },
1297 {  1, 0x80020005 },
1298 {  1, 0x80020005 },
1299 {  1, 0x80020005 },
1300 {  1, 0x80020005 },
1301 {  1, 0x80020005 },
1302 {  1, 0x80020005 },
1303 {  1, 0x80020005 },
1304 {  1, 0x80020005 },
1305 {  1, 0x80020005 },
1306 {  1, 0x80020005 },
1307 {  1, 0x80020005 },
1308 {  1, 0x80020005 },
1309 {  1, 0x80020005 },
1310 {  1, 0x80020005 },
1311 {  1, 0x80020005 },
1312 {  1, 0x80020005 },
1313 {  1, 0x80020005 },
1314 {  1, 0x80020005 },
1315 {  1, 0x80020005 },
1316 {  1, 0x80020005 },
1317 {  1, 0x80020005 },
1318 {  1, 0x80020005 },
1319 {  1, 0x80020005 },
1320 {  1, 0x80020005 },
1321 {  1, 0x80020005 },
1322 {  1, 0x80020005 },
1323 {  1, 0x80020005 },
1324 {  1, 0x80020005 },
1325 {  1, 0x80020005 },
1326 {  1, 0x80020005 },
1327 {  1, 0x80020005 },
1328 {  1, 0x80020005 },
1329 {  1, 0x80020005 },
1330 {  1, 0x80020005 },
1331 {  1, 0x80020005 },
1332 {  1, 0x80020005 },
1333 {  1, 0x80020005 },
1334 {  1, 0x80020005 },
1335 {  1, 0x80020005 },
1336 {  1, 0x80020005 },
1337 {  1, 0x80020005 },
1338 {  2, 0 },
1339 {  2, 0 },
1340 {  4, 0 },
1341 {  4, 0 },
1342 {  4, 0x80020005 },
1343 {  4, 0x80020005 },
1344 {  4, 0x80020005 },
1345 {  4, 0x80020005 },
1346 {  4, 0x80020005 },
1347 {  4, 0x80020005 },
1348 };
1349
1350 static const struct _strret_U2 {
1351     WORD retval;
1352     DWORD error;
1353 } strrets_U2[] = {
1354         {  0, 0x8002000A },
1355         {  0, 0x8002000A },
1356         {  0, 0x8002000A },
1357         {  0, 0 },
1358         {  0, 0 },
1359         {  0, 0 },
1360         {  0, 0 },
1361         {  0, 0 },
1362         {  0, 0 },
1363         {  1, 0 },
1364         {  1, 0 },
1365         {  127, 0 },
1366         {  128, 0 },
1367         {  129, 0 },
1368         {  255, 0 },
1369         {  256, 0 },
1370         {  257, 0 },
1371         {  32767, 0 },
1372         {  32768, 0 },
1373         {  32768, 0x8002000A },
1374         {  32768, 0x8002000A },
1375         {  32768, 0x8002000A },
1376         {  32768, 0x8002000A },
1377         {  32768, 0x8002000A },
1378         {  32768, 0x8002000A },
1379         {  32768, 0x8002000A },
1380         {  32768, 0x8002000A },
1381         {  32768, 0x8002000A },
1382         {  32768, 0x8002000A },
1383         {  32768, 0x80020005 },
1384         {  32768, 0x80020005 },
1385         {  32768, 0x80020005 },
1386         {  32768, 0x80020005 },
1387         {  1, 0 },
1388         {  1, 0x80020005 },
1389         {  123, 0 },
1390         {  123, 0x80020005 },
1391         {  123, 0x80020005 },
1392         {  123, 0x80020005 },
1393         {  123, 0x80020005 },
1394         {  0, 0 },
1395         {  0, 0 },
1396         {  0, 0x8002000A },
1397         {  24, 0 },
1398         {  32, 0 },
1399         {  32, 0x80020005 },
1400         {  200, 0 },
1401         {  200, 0x80020005 },
1402         {  200, 0x80020005 },
1403         {  200, 0x80020005 },
1404         {  200, 0x8002000A },
1405         {  1, 0 },
1406         {  1, 0 },
1407         {  1, 0x8002000A },
1408         {  1, 0 },
1409         {  65535, 0 },
1410         {  65535, 0x8002000A },
1411         {  65535, 0x8002000A },
1412         {  65535, 0x8002000A },
1413         {  65535, 0x8002000A },
1414         {  65535, 0x80020005 },
1415         {  65535, 0x80020005 },
1416         {  65535, 0x80020005 },
1417         {  65535, 0x80020005 },
1418         {  65535, 0x80020005 },
1419         {  65535, 0x80020005 },
1420         {  65535, 0x80020005 },
1421         {  65535, 0x80020005 },
1422         {  65535, 0x80020005 },
1423         {  65535, 0x80020005 },
1424         {  65535, 0x80020005 },
1425         {  65535, 0x80020005 },
1426         {  65535, 0x80020005 },
1427         {  65535, 0x80020005 },
1428         {  65535, 0x80020005 },
1429         {  65535, 0x80020005 },
1430         {  65535, 0x80020005 },
1431         {  65535, 0x80020005 },
1432         {  65535, 0x80020005 },
1433         {  65535, 0x80020005 },
1434         {  65535, 0x80020005 },
1435         {  65535, 0x80020005 },
1436         {  65535, 0x80020005 },
1437         {  65535, 0x80020005 },
1438         {  65535, 0x80020005 },
1439         {  65535, 0x80020005 },
1440         {  65535, 0x80020005 },
1441         {  65535, 0x80020005 },
1442         {  65535, 0x80020005 },
1443         {  65535, 0x80020005 },
1444         {  65535, 0x80020005 },
1445         {  65535, 0x80020005 },
1446         {  65535, 0x80020005 },
1447         {  65535, 0x80020005 },
1448         {  65535, 0x80020005 },
1449         {  65535, 0x80020005 },
1450         {  65535, 0x80020005 },
1451         {  65535, 0x80020005 },
1452         {  65535, 0x80020005 },
1453         {  65535, 0x80020005 },
1454         {  65535, 0x80020005 },
1455         {  65535, 0x80020005 },
1456         {  65535, 0x80020005 },
1457         {  65535, 0x80020005 },
1458         {  65535, 0x80020005 },
1459         {  65535, 0x80020005 },
1460         {  65535, 0x80020005 },
1461         {  65535, 0x80020005 },
1462         {  65535, 0x80020005 },
1463         {  65535, 0x80020005 },
1464         {  2, 0 },
1465         {  2, 0 },
1466         {  4, 0 },
1467         {  4, 0 },
1468         {  4, 0x80020005 },
1469         {  4, 0x80020005 },
1470         {  4, 0x80020005 },
1471         {  4, 0x80020005 },
1472         {  4, 0x80020005 },
1473         {  4, 0x80020005 },
1474 };
1475
1476 static const struct _strret_U4 {
1477     DWORD retval;
1478     DWORD error;
1479 } strrets_U4[] = {
1480         {  0, 0x8002000A },
1481         {  0, 0x8002000A },
1482         {  0, 0x8002000A },
1483         {  0, 0 },
1484         {  0, 0 },
1485         {  0, 0 },
1486         {  0, 0 },
1487         {  0, 0 },
1488         {  0, 0 },
1489         {  1, 0 },
1490         {  1, 0 },
1491         {  127, 0 },
1492         {  128, 0 },
1493         {  129, 0 },
1494         {  255, 0 },
1495         {  256, 0 },
1496         {  257, 0 },
1497         {  32767, 0 },
1498         {  32768, 0 },
1499         {  32768, 0x8002000A },
1500         {  32768, 0x8002000A },
1501         {  16777216, 0 },
1502         {  16777217, 0 },
1503         {  16777217, 0x8002000A },
1504         {  16777217, 0 },
1505         {  2147483647, 0 },
1506         {  2147483648U, 0 },
1507         {  2147483648U, 0x8002000A },
1508         {  2147483648U, 0x8002000A },
1509         {  2147483648U, 0x80020005 },
1510         {  2147483648U, 0x80020005 },
1511         {  2147483648U, 0x80020005 },
1512         {  2147483648U, 0x80020005 },
1513         {  1, 0 },
1514         {  1, 0x80020005 },
1515         {  123, 0 },
1516         {  123, 0x80020005 },
1517         {  123, 0x80020005 },
1518         {  123, 0x80020005 },
1519         {  123, 0x80020005 },
1520         {  0, 0 },
1521         {  0, 0 },
1522         {  0, 0x8002000A },
1523         {  24, 0 },
1524         {  32, 0 },
1525         {  32, 0x80020005 },
1526         {  200, 0 },
1527         {  200, 0x80020005 },
1528         {  200, 0x80020005 },
1529         {  200, 0x80020005 },
1530         {  200, 0x8002000A },
1531         {  1, 0 },
1532         {  1, 0 },
1533         {  1, 0x8002000A },
1534         {  1, 0 },
1535         {  65535, 0 },
1536         {  65536, 0 },
1537         {  65536, 0 },
1538         {  4294967295U, 0 },
1539         {  4294967295U, 0x8002000A },
1540         {  4294967295U, 0x80020005 },
1541         {  4294967295U, 0x80020005 },
1542         {  4294967295U, 0x80020005 },
1543         {  4294967295U, 0x80020005 },
1544         {  4294967295U, 0x80020005 },
1545         {  4294967295U, 0x80020005 },
1546         {  4294967295U, 0x80020005 },
1547         {  4294967295U, 0x80020005 },
1548         {  4294967295U, 0x80020005 },
1549         {  4294967295U, 0x80020005 },
1550         {  4294967295U, 0x80020005 },
1551         {  4294967295U, 0x80020005 },
1552         {  4294967295U, 0x80020005 },
1553         {  4294967295U, 0x80020005 },
1554         {  4294967295U, 0x80020005 },
1555         {  4294967295U, 0x80020005 },
1556         {  4294967295U, 0x80020005 },
1557         {  4294967295U, 0x80020005 },
1558         {  4294967295U, 0x80020005 },
1559         {  4294967295U, 0x80020005 },
1560         {  4294967295U, 0x80020005 },
1561         {  4294967295U, 0x80020005 },
1562         {  4294967295U, 0x80020005 },
1563         {  4294967295U, 0x80020005 },
1564         {  4294967295U, 0x80020005 },
1565         {  4294967295U, 0x80020005 },
1566         {  4294967295U, 0x80020005 },
1567         {  4294967295U, 0x80020005 },
1568         {  4294967295U, 0x80020005 },
1569         {  4294967295U, 0x80020005 },
1570         {  4294967295U, 0x80020005 },
1571         {  4294967295U, 0x80020005 },
1572         {  4294967295U, 0x80020005 },
1573         {  4294967295U, 0x80020005 },
1574         {  4294967295U, 0x80020005 },
1575         {  4294967295U, 0x80020005 },
1576         {  4294967295U, 0x80020005 },
1577         {  4294967295U, 0x80020005 },
1578         {  4294967295U, 0x80020005 },
1579         {  4294967295U, 0x80020005 },
1580         {  4294967295U, 0x80020005 },
1581         {  4294967295U, 0x80020005 },
1582         {  4294967295U, 0x80020005 },
1583         {  4294967295U, 0x80020005 },
1584         {  4294967295U, 0x80020005 },
1585         {  4294967295U, 0x80020005 },
1586         {  4294967295U, 0x80020005 },
1587         {  4294967295U, 0x80020005 },
1588         {  4294967295U, 0x80020005 },
1589         {  4294967295U, 0x80020005 },
1590         {  2, 0 },
1591         {  2, 0 },
1592         {  4, 0 },
1593         {  4, 0 },
1594         {  4, 0x80020005 },
1595         {  4, 0x80020005 },
1596         {  4, 0x80020005 },
1597         {  4, 0x80020005 },
1598         {  4, 0x80020005 },
1599         {  4, 0x80020005 },
1600 };
1601
1602 START_TEST(vartest)
1603 {
1604         VARIANTARG va;
1605         VARIANTARG vb;
1606         VARIANTARG vc;
1607         VARIANTARG vd;
1608         VARIANTARG ve;
1609
1610         int theInt = 0;
1611         int* pInt = &theInt;
1612         VARIANT_BOOL b = 0;
1613         VARIANT_BOOL* pBool = &b;
1614         unsigned short uShort = 0;
1615         unsigned short* pUShort = &uShort;
1616         unsigned long uLong = 0;
1617         unsigned long* pULong = &uLong;
1618         CHAR theChar;
1619         CHAR* pChar = &theChar;
1620         BYTE byte;
1621         BYTE* pByte = &byte;
1622         short s = 0;
1623         short* pShort = &s;
1624         long Long = 0;
1625         long* pLong = &Long;
1626         float f = 0;
1627         float* pFloat = &f;
1628         double d = 0;
1629         double* pDouble = &d;
1630
1631         BSTR bstr = NULL;
1632         int off, i = 0;
1633         int nOlePtrs = 120;
1634         OLECHAR* pOleChar[120];
1635         char msg[200];
1636
1637         pOleChar[0] = AtoW( "-2" );
1638         pOleChar[1] = AtoW( "-1" );
1639         pOleChar[2] = AtoW( "-0.51" );
1640         pOleChar[3] = AtoW( "-0.5" );
1641         pOleChar[4] = AtoW( "-0.49" );
1642         pOleChar[5] = AtoW( "-0.0" );
1643         pOleChar[6] = AtoW( "0.0" );
1644         pOleChar[7] = AtoW( "0.49" );
1645         pOleChar[8] = AtoW( "0.5" );
1646         pOleChar[9] = AtoW( "0.51" );
1647         pOleChar[10] = AtoW( "1" );
1648         pOleChar[11] = AtoW( "127" );
1649         pOleChar[12] = AtoW( "128" );
1650         pOleChar[13] = AtoW( "129" );
1651         pOleChar[14] = AtoW( "255" );
1652         pOleChar[15] = AtoW( "256" );
1653         pOleChar[16] = AtoW( "257" );
1654         pOleChar[17] = AtoW( "32767" );
1655         pOleChar[18] = AtoW( "32768" );
1656         pOleChar[19] = AtoW( "-32768" );
1657         pOleChar[20] = AtoW( "-32769" );
1658         pOleChar[21] = AtoW( "16777216" );
1659         pOleChar[22] = AtoW( "16777217" );
1660         pOleChar[23] = AtoW( "-16777216" );
1661         pOleChar[24] = AtoW( "16777217" );
1662         pOleChar[25] = AtoW( "2147483647" );
1663         pOleChar[26] = AtoW( "2147483648" );
1664         pOleChar[27] = AtoW( "-2147483647" );
1665         pOleChar[28] = AtoW( "-2147483648" );
1666
1667         pOleChar[29] = AtoW( "" );
1668         pOleChar[30] = AtoW( " " );
1669         pOleChar[31] = AtoW( "1F" );
1670         pOleChar[32] = AtoW( "1G" );
1671         pOleChar[33] = AtoW( " 1 " );
1672         pOleChar[34] = AtoW( " 1 2 " );
1673         pOleChar[35] = AtoW( "1,2,3" );
1674         pOleChar[36] = AtoW( "1 2 3" );
1675         pOleChar[37] = AtoW( "1,2, 3" );
1676         pOleChar[38] = AtoW( "1;2;3" );
1677         pOleChar[39] = AtoW( "1.2.3" );
1678
1679         pOleChar[40] = AtoW( "0." );
1680         pOleChar[41] = AtoW( ".0" );
1681         pOleChar[42] = AtoW( "0.1E12" );
1682         pOleChar[43] = AtoW( "2.4,E1" );
1683         pOleChar[44] = AtoW( "  +3.2,E1" );
1684         pOleChar[45] = AtoW( "4E2.5" );
1685         pOleChar[46] = AtoW( "  2E+2" );
1686         pOleChar[47] = AtoW( "1 E+2" );
1687         pOleChar[48] = AtoW( "." );
1688         pOleChar[49] = AtoW( ".E2" );
1689         pOleChar[50] = AtoW( "1000000000000000000000000000000000000000000000000000000000000000" );
1690         pOleChar[51] = AtoW( "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
1691         pOleChar[52] = AtoW( "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
1692         pOleChar[53] = AtoW( "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
1693         pOleChar[54] = AtoW( "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
1694         pOleChar[55] = AtoW( "65535" );
1695         pOleChar[56] = AtoW( "65535.5" );
1696         pOleChar[57] = AtoW( "65536" );
1697         pOleChar[58] = AtoW( "4294967295" );
1698         pOleChar[59] = AtoW( "4294967296" );
1699
1700         pOleChar[60] = AtoW( "1 January 99" );
1701         pOleChar[61] = AtoW( "December 31, 2078" );
1702         pOleChar[62] = AtoW( "January 1, 1900" );
1703         pOleChar[63] = AtoW( "January 2 1900" );
1704         pOleChar[64] = AtoW( "11.11.1999" );
1705         pOleChar[65] = AtoW( "11/11/1999" );
1706         pOleChar[66] = AtoW( " 11 / 11 / 1999" );
1707         pOleChar[67] = AtoW( "11/11/1999:11:11:1134" );
1708         pOleChar[68] = AtoW( "11/11/1999 11:11:11:1" );
1709         pOleChar[69] = AtoW( "\t1999/\t11/21 11 :11:11am" );
1710
1711         pOleChar[70] = AtoW( "11/11/1999 11:11:11Am" );
1712         pOleChar[71] = AtoW( "11/11/1999 11:11:11PM" );
1713         pOleChar[72] = AtoW( "11/11/199911:11:11PM" );
1714         pOleChar[73] = AtoW( "11/11/1999 0:0:11am" );
1715         pOleChar[74] = AtoW( "11/11/1999 11,11:11am" );
1716         pOleChar[75] = AtoW( "11/11/1999 11:11:11am" );
1717         pOleChar[76] = AtoW( "11/11/1999 11/11:11am" );
1718         pOleChar[77] = AtoW( "11/11/1999 11:11AM" );
1719         pOleChar[78] = AtoW( "11/11/1999 1AM" );
1720         pOleChar[79] = AtoW( "11/11/1999 0AM" );
1721
1722         pOleChar[80] = AtoW( "11/11/1999 11:11:11" );
1723         pOleChar[81] = AtoW( "11/13/1999 0AM" );
1724         pOleChar[82] = AtoW( "13/13/1999 0AM" );
1725         pOleChar[83] = AtoW( "13/11/1999 0AM" );
1726         pOleChar[84] = AtoW( "11/33/1999 0AM" );
1727         pOleChar[85] = AtoW( "11/11/1999 AM" );
1728         pOleChar[86] = AtoW( "1/1/0 0AM" );
1729         pOleChar[87] = AtoW( "1/1/-1 0AM" );
1730         pOleChar[88] = AtoW( "1999 January 3 9AM" );
1731         pOleChar[89] = AtoW( "1 January 1999 11AM" );
1732
1733         pOleChar[90] = AtoW( "4AM 11/11/1999" );
1734         pOleChar[91] = AtoW( "4:22 11/11/1999 AM" );
1735         pOleChar[92] = AtoW( " 1 1 /11/1999" );
1736         pOleChar[93] = AtoW( "11-11/1999 11:11:11.12AM" );
1737         pOleChar[94] = AtoW( "1999 January 3, 9AM" );
1738         pOleChar[95] = AtoW( "December, 31, 2078" );
1739         pOleChar[96] = AtoW( "December, 31, 2078," );
1740         pOleChar[97] = AtoW( "December, 31 2078" );
1741         pOleChar[98] = AtoW( "11/99" );
1742         pOleChar[99] = AtoW( "11-1999" );
1743
1744         pOleChar[100] = AtoW( "true" );
1745         pOleChar[101] = AtoW( "True" );
1746         pOleChar[102] = AtoW( "TRue" );
1747         pOleChar[103] = AtoW( "TRUE" );
1748         pOleChar[104] = AtoW( " TRUE" );
1749         pOleChar[105] = AtoW( "FALSE " );
1750         pOleChar[106] = AtoW( "False" );
1751         pOleChar[107] = AtoW( "JustSomeText" );
1752         pOleChar[108] = AtoW( "Just Some Text" );
1753         pOleChar[109] = AtoW( "" );
1754
1755         pOleChar[110] = AtoW( "1.5" );
1756         pOleChar[111] = AtoW( "2.5" );
1757         pOleChar[112] = AtoW( "3.5" );
1758         pOleChar[113] = AtoW( "4.5" );
1759         pOleChar[114] = AtoW( "" );
1760         pOleChar[115] = AtoW( "" );
1761         pOleChar[116] = AtoW( "" );
1762         pOleChar[117] = AtoW( "" );
1763         pOleChar[118] = AtoW( "" );
1764         pOleChar[119] = AtoW( "" );
1765
1766
1767         /* Start testing the Low-Level API ( the coercions )
1768          */
1769
1770
1771         /* unsigned char from...
1772          */
1773         trace( "\n\n======== Testing VarUI1FromXXX ========\n");
1774
1775 #define XOK "should return S_OK"
1776 #define XOV "should return DISP_E_OVERFLOW"
1777         /* ok(S_OK == VarUI1FromI2( 0, NULL ), XOK);
1778          */
1779         trace( "VarUI1FromI2: passing in NULL as return val makes it crash, need to write proper test.\n" );
1780
1781         ok(VarUI1FromStr(NULL,0,0,pByte) == DISP_E_TYPEMISMATCH,"should return DISP_E_TYPEMISMATCH");
1782         ok(S_OK == VarUI1FromI2( 0, pByte ), XOK);
1783         ok(*pByte == 0,"should give 0 byte value");
1784
1785         ok(S_OK == VarUI1FromI2( 69, pByte ), XOK);
1786         ok(*pByte == 69,"should give 69 byte value");
1787
1788         ok(S_OK == VarUI1FromI2( 70, pByte ), XOK);
1789         ok(*pByte == 70,"should give 70 byte value");
1790
1791         ok(S_OK == VarUI1FromI2( 128, pByte ), XOK);
1792         ok(*pByte == 128,"should give 128 byte value");
1793
1794         ok(S_OK == VarUI1FromI2( 255, pByte ), XOK);
1795         ok(*pByte == 255,"should give 255 byte value");
1796
1797         ok(DISP_E_OVERFLOW == VarUI1FromI2( 256, pByte ), XOV);
1798         ok(DISP_E_OVERFLOW == VarUI1FromI2( 257, pByte ), XOV);
1799
1800         ok(S_OK == VarUI1FromR8( 0.0, pByte ), XOK);
1801         ok(*pByte == 0,"0.0 float should be converted to 0");
1802
1803         ok(S_OK == VarUI1FromR8( 69.33, pByte ), XOK);
1804         ok(*pByte == 0x45, "expected 69 (hex 0x45) as byte value");
1805
1806         ok(S_OK == VarUI1FromR8( 69.66, pByte ), XOK);
1807         ok(*pByte == 0x46, "expected 70 (hex 0x46) as byte value");
1808
1809         ok(DISP_E_OVERFLOW == VarUI1FromR8( -69.33, pByte ), XOV);
1810         ok(DISP_E_OVERFLOW == VarUI1FromR8( -69.66, pByte ), XOV);
1811
1812         ok(S_OK == VarUI1FromR8( -0.5, pByte ), XOK);
1813         ok(*pByte == 0,"-0.5 should give return 0");
1814
1815         ok(DISP_E_OVERFLOW == VarUI1FromR8( -0.51, pByte ), XOV);
1816
1817         ok(S_OK == VarUI1FromR8( -0.49, pByte ), XOK);
1818         ok(*pByte == 0,"-0.49 should give return 0");
1819
1820         ok(S_OK == VarUI1FromR8( 0.5, pByte ), XOK);
1821         ok(*pByte == 0,"0.5 should give return 0");
1822
1823         ok(S_OK == VarUI1FromR8( 0.51, pByte ), XOK);
1824         ok(*pByte == 1,"0.51 should give return 1");
1825
1826         ok(S_OK == VarUI1FromR8( 0.49, pByte ), XOK);
1827         ok(*pByte == 0,"0.49 should give return 0");
1828
1829         ok(S_OK == VarUI1FromDate( 0.0, pByte ), XOK);
1830         ok(*pByte == 0,"0.0 date should give return 0");
1831
1832         ok(S_OK == VarUI1FromDate( 69.33, pByte ), XOK);
1833         ok(*pByte == 0x45,"69.33 date should give return 0x45");
1834
1835         ok(S_OK == VarUI1FromDate( 69.66, pByte ), XOK);
1836         ok(*pByte == 0x46,"69.66 date should give return 0x46");
1837
1838         ok(DISP_E_OVERFLOW == VarUI1FromDate( -69.33, pByte ), XOV);
1839
1840         ok(DISP_E_OVERFLOW == VarUI1FromDate( -69.66, pByte ), XOV);
1841
1842         ok(S_OK == VarUI1FromBool( VARIANT_TRUE, pByte ), XOK);
1843         ok(*pByte == 0xff, "true should be converted to 0xff");
1844
1845         ok(S_OK == VarUI1FromBool( VARIANT_FALSE, pByte ), XOK);
1846         ok(*pByte == 0, "false should be converted to 0");
1847
1848         for( i = 0; i < nOlePtrs; i ++ )
1849         {
1850                 char msg[200];
1851
1852                 sprintf(msg,"offset %d was expecting return code %lx\n",i,strrets_U1[i].error);
1853                 ok(strrets_U1[i].error == VarUI1FromStr( pOleChar[i], 0, 0, pByte ), msg);
1854                 sprintf(msg,"offset %d was expecting return value %02x\n",i,strrets_U1[i].retval);
1855                 ok(strrets_U1[i].retval == *pByte,msg);
1856         }
1857
1858         /* unsigned short from ... */
1859         trace( "\n\n======== Testing VarUI2FromXXX ========\n");
1860
1861         ok(DISP_E_OVERFLOW == VarUI2FromI2( -1, pUShort ), XOV);
1862         /* ok(S_OK == VarUI2FromI2( 0, NULL ), XOK);
1863          */
1864         trace("VarUI2FromI2: passing in NULL as return val makes it crash, needs to be fixed.\n");
1865
1866         ok(DISP_E_TYPEMISMATCH == VarUI2FromStr( NULL, 0, 0, pUShort ), "should return DISP_E_TYPEMISMATCH");
1867
1868         ok(S_OK == VarUI2FromI2( 0, pUShort ), XOK);
1869         ok(*pUShort == 0,"0 should be 0");
1870         ok(S_OK == VarUI2FromI2( 69, pUShort ), XOK);
1871         ok(*pUShort == 69,"69 should be 69");
1872         ok(S_OK == VarUI2FromI2( 70, pUShort ), XOK);
1873         ok(*pUShort == 70,"70 should be 70");
1874
1875         ok(S_OK == VarUI2FromI2( 128, pUShort ), XOK);
1876         ok(*pUShort == 128,"128 should be 128");
1877
1878         ok(S_OK == VarUI2FromI4( 65535, pUShort ), XOK);
1879         ok(*pUShort == 65535,"65535 should be 65535");
1880         ok(DISP_E_OVERFLOW == VarUI2FromI4( 65536, pUShort ), XOV);
1881         ok(DISP_E_OVERFLOW == VarUI2FromI4( 65537, pUShort ), XOV);
1882         ok(S_OK == VarUI2FromR8( 0.0, pUShort ), XOK);
1883         ok(*pUShort == 0,"0.0 should be 0");
1884         ok(S_OK == VarUI2FromR8( 69.33, pUShort ), XOK);
1885         ok(*pUShort == 69,"69.33 should be 69");
1886         ok(S_OK == VarUI2FromR8( 69.66, pUShort ), XOK);
1887         ok(*pUShort == 70,"69.66 should be 70");
1888
1889         ok(DISP_E_OVERFLOW == VarUI2FromR8( -69.33, pUShort ), XOV);
1890         ok(DISP_E_OVERFLOW == VarUI2FromR8( -69.66, pUShort ), XOV);
1891
1892         ok(S_OK == VarUI2FromR8( -0.5, pUShort ), XOK);
1893         ok(*pUShort == 0, "-0.5 -> 0");
1894         ok(DISP_E_OVERFLOW == VarUI2FromR8( -0.51, pUShort ), XOV);
1895         ok(S_OK == VarUI2FromR8( -0.49, pUShort ), XOK);
1896         ok(*pUShort == 0, "-0.49 -> 0");
1897
1898         ok(S_OK == VarUI2FromR8( 0.5, pUShort ), XOK);
1899         ok(*pUShort == 0,"0.5 should be 0");
1900         ok(S_OK == VarUI2FromR8( 0.51, pUShort ), XOK);
1901         ok(*pUShort == 1,"0.51 should be 1");
1902         ok(S_OK == VarUI2FromR8( 0.49, pUShort ), XOK);
1903         ok(*pUShort == 0,"0.49 should be 0");
1904
1905         ok(S_OK == VarUI2FromDate( 0.0, pUShort ), XOK);
1906         ok(*pUShort == 0,"0.0 should be 0");
1907         ok(S_OK == VarUI2FromDate( 69.33, pUShort ), XOK);
1908         ok(*pUShort == 69,"69.33 should be 69");
1909         ok(S_OK == VarUI2FromDate( 69.66, pUShort ), XOK);
1910         ok(*pUShort == 70,"69.66 should be 70");
1911         ok(DISP_E_OVERFLOW == VarUI2FromDate( -69.33, pUShort ), XOV);
1912         ok(DISP_E_OVERFLOW == VarUI2FromDate( -69.66, pUShort ), XOV);
1913
1914         ok(S_OK == VarUI2FromBool( VARIANT_TRUE, pUShort ), XOK);
1915         ok(*pUShort == 65535,"TRUE should be 65535");
1916         ok(S_OK == VarUI2FromBool( VARIANT_FALSE, pUShort ), XOK);
1917         ok(*pUShort == 0,"FALSE should be 0");
1918
1919         for( i = 0; i < nOlePtrs; i ++ )
1920         {
1921                 char msg[200];
1922
1923                 sprintf(msg,"offset %d, expecting error 0x%lx\n",i,strrets_U2[i].error);
1924                 ok(strrets_U2[i].error == VarUI2FromStr( pOleChar[i], 0, 0, pUShort ), msg);
1925                 sprintf(msg,"offset %d, expecting retval 0x%x\n",i,strrets_U2[i].retval);
1926                 ok(strrets_U2[i].retval == *pUShort, msg);
1927         }
1928
1929         /* unsigned long from ...
1930          */
1931         trace( "\n\n======== Testing VarUI4FromXXX ========\n");
1932         /*ok(S_OK == VarUI4FromI2( 0, NULL ), XOK);
1933          */
1934         trace( "VarUI4FromI2: passing in NULL as return val makes it crash, implement me.\n");
1935
1936         ok(DISP_E_TYPEMISMATCH == VarUI4FromStr( NULL, 0, 0, pULong ), "should erturn DISP_E_TYPEMISMATCH");
1937
1938         ok(S_OK == VarUI4FromI2( 0, pULong ), XOK);
1939         ok(*pULong == 0,"0 should be 0");
1940         ok(S_OK == VarUI4FromI2( 69, pULong ), XOK);
1941         ok(*pULong == 69,"69 should be 69");
1942
1943         ok(S_OK == VarUI4FromI2( 70, pULong ), XOK);
1944         ok(*pULong == 70,"70 should be 70");
1945
1946         ok(S_OK == VarUI4FromI2( 128, pULong ), XOK);
1947         ok(*pULong == 128,"128 should be 128");
1948         ok(S_OK == VarUI4FromI2( 255, pULong ), XOK);
1949         ok(*pULong == 255,"255 should be 255");
1950
1951         ok(S_OK == VarUI4FromR8( 4294967295.0, pULong ), XOK);
1952         ok(*pULong == 4294967295U,"4294967295.0 should be 4294967295");
1953         ok(DISP_E_OVERFLOW == VarUI4FromR8( 4294967296.0, pULong ), XOV);
1954
1955         ok(S_OK == VarUI4FromR8( 0.0, pULong ), XOK);
1956         ok(*pULong == 0,"0 should be 0");
1957         ok(S_OK == VarUI4FromR8( 69.33, pULong ), XOK);
1958         ok(*pULong == 69,"69.33 should be 69");
1959         ok(S_OK == VarUI4FromR8( 69.66, pULong ), XOK);
1960         ok(*pULong == 70,"69.66 should be 70");
1961         ok(DISP_E_OVERFLOW == VarUI4FromR8( -69.33, pULong ), XOV);
1962         ok(DISP_E_OVERFLOW == VarUI4FromR8( -69.66, pULong ), XOV);
1963
1964         ok(S_OK == VarUI4FromR8( -0.5, pULong ), XOK);
1965         ok(*pULong == 0,"-0.5 should be 0");
1966
1967         ok(DISP_E_OVERFLOW == VarUI4FromR8( -0.51, pULong ), XOV);
1968
1969         ok(S_OK == VarUI4FromR8( -0.49, pULong ), XOK);
1970         ok(*pULong == 0,"-0.49 should be 0");
1971
1972         ok(S_OK == VarUI4FromR8( 0.5, pULong ), XOK);
1973         ok(*pULong == 0,"0.5 should be 0");
1974         ok(S_OK == VarUI4FromR8( 0.51, pULong ), XOK);
1975         ok(*pULong == 1,"0.51 should be 1");
1976         ok(S_OK == VarUI4FromR8( 0.49, pULong ), XOK);
1977         ok(*pULong == 0,"0.49 should be 0");
1978
1979         ok(S_OK == VarUI4FromDate( 0.0, pULong ), XOK);
1980         ok(*pULong == 0,"0.0 should be 0");
1981         ok(S_OK == VarUI4FromDate( 69.33, pULong ), XOK);
1982         ok(*pULong == 69,"69.33 should be 69");
1983         ok(S_OK == VarUI4FromDate( 69.66, pULong ), XOK);
1984         ok(*pULong == 70,"69.66 should be 70");
1985         ok(DISP_E_OVERFLOW == VarUI4FromDate( -69.33, pULong ), XOV);
1986         ok(DISP_E_OVERFLOW == VarUI4FromDate( -69.66, pULong ), XOV);
1987
1988         ok(S_OK == VarUI4FromBool( VARIANT_TRUE, pULong ), XOK);
1989         ok(*pULong == 4294967295U, "TRUE should be 4294967295");
1990         ok(S_OK == VarUI4FromBool( VARIANT_FALSE, pULong ), XOK);
1991         ok(*pULong == 0, "FALSE should be 0");
1992
1993         for( i = 0; i < nOlePtrs; i ++ )
1994         {
1995                 char msg[200];
1996
1997                 sprintf(msg,"offset %d should return 0x%lx\n",i,
1998                         strrets_U4[i].error);
1999                 ok(strrets_U4[i].error == VarUI4FromStr( pOleChar[i], 0, 0, pULong ), msg);
2000                 sprintf(msg,"offset %d should have retval 0x%lx\n",i,
2001                         strrets_U4[i].retval);
2002                 ok(*pULong == strrets_U4[i].retval,msg);
2003         }
2004
2005         /* CHAR from ...
2006          */
2007         trace( "\n\n======== Testing VarI1FromXXX ========\n");
2008
2009         ok(S_OK == VarI1FromBool( VARIANT_TRUE, pByte ), XOK);
2010         ok(*pByte == 255, " TRUE should be 255");
2011
2012         ok(S_OK == VarI1FromBool( VARIANT_TRUE, pChar ), XOK);
2013         ok(*pChar == -1, "TRUE should be -1");
2014
2015         ok(S_OK == VarI1FromBool( VARIANT_FALSE, pChar ), XOK);
2016         ok(*pChar == 0, "FALSE should be 0");
2017
2018         ok(DISP_E_OVERFLOW == VarI1FromUI1( (unsigned char)32767, pChar ), XOV);
2019         ok(*pChar == 0, "should still be 0");
2020         ok(DISP_E_OVERFLOW == VarI1FromUI1( (unsigned char)65535, pChar ), XOV);
2021         ok(*pChar == 0, "should still be 0");
2022
2023         ok(DISP_E_OVERFLOW == VarI1FromI4( 32767, pChar ), XOV);
2024         ok(*pChar == 0, "should still be 0");
2025         ok(DISP_E_OVERFLOW == VarI1FromI4( 32768, pChar ), XOV);
2026         ok(*pChar == 0, "should still be 0");
2027         ok(DISP_E_OVERFLOW == VarI1FromI4( -32768, pChar ), XOV);
2028         ok(*pChar == 0, "should still be 0");
2029         ok(DISP_E_OVERFLOW == VarI1FromI4( -32769, pChar ), XOV);
2030         ok(*pChar == 0, "should still be 0");
2031
2032         ok(S_OK == VarI1FromR8( 69.33, pChar ), XOK);
2033         ok(*pChar == 69, "69.33 should be 69");
2034         ok(S_OK == VarI1FromR8( 69.66, pChar ), XOK);
2035         ok(*pChar == 70, "69.66 should be 70");
2036
2037         ok(S_OK == VarI1FromR8( -69.33, pChar ), XOK);
2038         ok(*pChar == -69, "-69.33 should be -69");
2039         ok(S_OK == VarI1FromR8( -69.66, pChar ), XOK);
2040         ok(*pChar == -70, "-69.66 should be -70");
2041         ok(S_OK == VarI1FromDate( -69.66, pChar ), XOK);
2042         ok(*pChar == -70, "-69.66 should be -70");
2043
2044         for( i = 0; i < nOlePtrs; i ++ )
2045         {
2046                 char msg[200];
2047
2048                 sprintf(msg,"offset %d should return 0x%lx\n",i,strrets_I1[i].error);
2049                 ok(strrets_I1[i].error == VarI1FromStr( pOleChar[i], 0, 0, pChar ), msg);
2050                 sprintf(msg,"offset %d should have retval %d\n",i,strrets_I1[i].retval);
2051                 ok(strrets_I1[i].retval == *pChar, msg);
2052         }
2053
2054         /* short from ...
2055          */
2056         trace( "\n\n======== Testing VarI2FromXXX ========\n");
2057
2058         ok(S_OK == VarI2FromUI2( 32767, pShort ), XOK);
2059         ok(*pShort == 32767, "should be 32767");
2060         ok(DISP_E_OVERFLOW == VarI2FromUI2( 65535, pShort ), XOV);
2061         ok(*pShort == 32767, "pShort should be unchanged");
2062
2063         ok(S_OK == VarI2FromI4( 32767, pShort ), XOK);
2064         ok(*pShort == 32767, "should be 32767");
2065         ok(DISP_E_OVERFLOW == VarI2FromI4( 32768, pShort ), XOV);
2066         ok(*pShort == 32767, "should still be 32767");
2067         ok(S_OK == VarI2FromI4( -32768, pShort ), XOK);
2068         ok(*pShort == -32768, "should be -32768");
2069         ok(DISP_E_OVERFLOW == VarI2FromI4( -32769, pShort ), XOV);
2070         ok(*pShort == -32768, "should still be -32768");
2071
2072         ok(S_OK == VarI2FromR8( 69.33, pShort ), XOK);
2073         ok(*pShort == 69, "should be 69");
2074         ok(S_OK == VarI2FromR8( 69.66, pShort ), XOK);
2075         ok(*pShort == 70, "should be 70");
2076         ok(S_OK == VarI2FromR8( -69.33, pShort ), XOK);
2077         ok(*pShort == -69, "should be -69");
2078         ok(S_OK == VarI2FromR8( -69.66, pShort ), XOK);
2079         ok(*pShort == -70, "should be -70");
2080         ok(S_OK == VarI2FromDate( -69.66, pShort ), XOK);
2081         ok(*pShort == -70, "should be -70");
2082
2083         for( i = 0; i < nOlePtrs; i ++ )
2084         {
2085                 char msg[200];
2086                 sprintf(msg,"offset %d, expected return 0x%lx",i,strrets_I2[i].error);
2087                 ok(strrets_I2[i].error == VarI2FromStr( pOleChar[i], 0, 0, pShort ), msg);
2088                 sprintf(msg,"offset %d, expect retval %d",i,strrets_I2[i].retval);
2089                 ok(strrets_I2[i].retval == *pShort,msg);
2090         }
2091
2092         /* long from ...
2093          */
2094         trace( "\n\n======== Testing VarI4FromXXX ========\n");
2095
2096         ok(S_OK == VarI4FromI2( 3, (long*)pInt ), XOK);
2097         ok(*pInt == 3,"should be 3");
2098
2099         ok(S_OK == VarI4FromR8( 69.33, pLong ), XOK);
2100         ok(*pLong == 69,"should be 69");
2101         ok(S_OK == VarI4FromR8( 69.66, pLong ), XOK);
2102         ok(*pLong == 70,"should be 70");
2103         ok(S_OK == VarI4FromR8( -69.33, pLong ), XOK);
2104         ok(*pLong == -69,"should be -69");
2105         ok(S_OK == VarI4FromR8( -69.66, pLong ), XOK);
2106         ok(*pLong == -70,"should be -70");
2107
2108         ok(S_OK == VarI4FromR8( 2147483647.0, pLong ), XOK);
2109         ok(*pLong == 2147483647,"should be 2147483647");
2110         ok(DISP_E_OVERFLOW == VarI4FromR8( 2147483648.0, pLong ), XOV);
2111         ok(*pLong == 2147483647,"should still be 2147483647");
2112
2113         ok(S_OK == VarI4FromR8( -2147483647.0, pLong ), XOK);
2114         ok(*pLong == -2147483647,"should be -2147483647");
2115         ok(S_OK == VarI4FromR8( -2147483648.0, pLong ), XOK);
2116         ok(*pLong == -2147483648,"should be -2147483648");
2117         ok(DISP_E_OVERFLOW == VarI4FromR8( -2147483649.0, pLong ), XOV);
2118         ok(*pLong == -2147483648,"should still be -2147483648");
2119         ok(DISP_E_OVERFLOW == VarI4FromDate( -2147483649.0, pLong ), XOV);
2120         ok(*pLong == -2147483648,"should still be -2147483648");
2121
2122         for( i = 0; i < nOlePtrs; i ++ )
2123         {
2124                 char msg[200];
2125
2126                 sprintf(msg,"offset %d, should have retcode %lx",i,strrets_I4[i].error);
2127                 ok(strrets_I4[i].error == VarI4FromStr( pOleChar[i], 0, 0, pLong ), msg);
2128                 sprintf(msg,"offset %d, should have retval %ld",i,strrets_I4[i].retval);
2129                 ok(strrets_I4[i].retval == *pLong,msg);
2130         }
2131
2132         /* float from ...
2133          */
2134         trace( "\n\n======== Testing VarR4FromXXX ========\n");
2135
2136         ok(S_OK == VarR4FromI4( 16777216, pFloat ), XOK);
2137         ok(16777216.0 == *pFloat,"should be 16777216.0");
2138
2139         ok(S_OK == VarR4FromI4( 16777217, pFloat ), XOK);
2140         ok(16777216.0 == *pFloat,"should be 16777216.0");
2141         ok(S_OK == VarR4FromI4( -16777216, pFloat ), XOK);
2142         ok(-16777216.0 == *pFloat,"should be -16777216.0");
2143         ok(S_OK == VarR4FromI4( -16777217, pFloat ), XOK);
2144         ok(-16777216.0 == *pFloat,"should be -16777216.0");
2145
2146         ok(S_OK == VarR4FromR8( 16777216.0, pFloat ), XOK);
2147         ok(16777216.0 == *pFloat,"should be 16777216.0");
2148         ok(S_OK == VarR4FromR8( 16777217.0, pFloat ), XOK);
2149         ok(16777216.0 == *pFloat,"should be 16777216.0");
2150         ok(S_OK == VarR4FromR8( -16777216.0, pFloat ), XOK);
2151         ok(-16777216.0 == *pFloat,"should be -16777216.0");
2152         ok(S_OK == VarR4FromR8( -16777217.0, pFloat ), XOK);
2153         ok(-16777216.0 == *pFloat,"should be -16777216.0");
2154
2155         ok(S_OK == VarR4FromR8( 16777218e31, pFloat ), XOK);
2156         ok(*pFloat == 167772177736353110000000000000000000000.000000,
2157                 "should be 167772177736353110000000000000000000000.000000");
2158         ok(DISP_E_OVERFLOW == VarR4FromR8( 16777218e32, pFloat ), XOV);
2159         ok(*pFloat == 167772177736353110000000000000000000000.000000,
2160                 "should still be 167772177736353110000000000000000000000.000000");
2161         ok(S_OK == VarR4FromDate( 16777218e31, pFloat ), XOK);
2162         ok(*pFloat == 167772177736353110000000000000000000000.000000,
2163                 "should be 167772177736353110000000000000000000000.000000");
2164
2165         for( i = 0; i < nOlePtrs; i ++ )
2166         {
2167                 char msg[200];
2168
2169                 sprintf(msg,"offset %d, retcode should be 0x%08lx",i,strrets_R4[i].error);
2170                 ok(strrets_R4[i].error == VarR4FromStr( pOleChar[i], 0, 0, pFloat ), msg);
2171                 sprintf(msg,"offset %d, retval should be %f",i,strrets_R4[i].retval);
2172                 ok(strrets_R4[i].retval == *pFloat,msg);
2173         }
2174
2175         /* double from ...
2176          */
2177         trace( "\n\n======== Testing VarR8FromXXX ========\n");
2178
2179         ok(S_OK == VarR8FromDate( 900719925474099.0, pDouble ), XOK);
2180         ok(*pDouble == 900719925474099.000000,"should be 900719925474099.000000\n");
2181         for( i = 0; i < nOlePtrs; i ++ )
2182         {
2183                 char msg[200];
2184
2185                 sprintf(msg,"offset %d, retcode should be 0x%lx",i,strrets_R8[i].error);
2186                 ok(strrets_R8[i].error == VarR8FromStr( pOleChar[i], 0, 0, pDouble ), msg);
2187                 sprintf(msg,"offset %d, retval should be %g",i,strrets_R8[i].retval);
2188                 ok(strrets_R8[i].retval == *pDouble,msg);
2189         }
2190
2191         /* date from ...
2192          */
2193         trace( "\n\n======== Testing VarDateFromXXX ========\n");
2194
2195         ok(S_OK == VarDateFromI4( 2958465, pDouble ), XOK);
2196         ok(*pDouble == 2958465.000000,"should be 2958465.000000");
2197         ok(DISP_E_OVERFLOW == VarDateFromI4( 2958466, pDouble ), XOV);
2198         ok(*pDouble == 2958465.000000,"should still be 2958465.000000");
2199         ok(S_OK == VarDateFromI4( -657434, pDouble ), XOK);
2200         ok(*pDouble == -657434.000000,"should be -657434.000000");
2201         ok(DISP_E_OVERFLOW == VarDateFromI4( -657435, pDouble ), XOV);
2202         ok(*pDouble == -657434.000000,"should still be -657434.000000");
2203
2204         ok(S_OK == VarDateFromR8( 2958465.9999, pDouble ), XOK);
2205         ok(*pDouble == 2958465.999900, "should be 2958465.999900");
2206         ok(DISP_E_OVERFLOW == VarDateFromR8( 2958466, pDouble ), XOV);
2207         ok(*pDouble == 2958465.999900, "should still be 2958465.999900");
2208         ok(S_OK == VarDateFromR8( -657434.9999, pDouble ), XOK);
2209         ok(*pDouble == -657434.999900,"should be -657434.999900");
2210         ok(DISP_E_OVERFLOW == VarDateFromR8( -657435, pDouble ), XOV);
2211         ok(*pDouble == -657434.999900,"should still be -657434.999900");
2212
2213         ok(S_OK == VarDateFromR8( 0.0, pDouble ), XOK);
2214         ok(*pDouble == 0.0,"0.0 should be 0.0");
2215         ok(S_OK == VarDateFromR8( 1.0, pDouble ), XOK);
2216         ok(*pDouble == 1.0,"1.0 should be 1.0");
2217         ok(S_OK == VarDateFromR8( 2.25, pDouble ), XOK);
2218         ok(*pDouble == 2.25,"2.25 should be 2.25");
2219         ok(S_OK == VarDateFromR8( -2.0, pDouble ), XOK);
2220         ok(*pDouble == -2.0,"-2.0 should be -2.0");
2221
2222         /* Need some parsing function in Linux to emulate this...
2223          * Still in progess.
2224          */
2225 #ifdef FIXED_DATE_FUNCTIONS
2226         for( i = 0; i < nOlePtrs; i ++ )
2227         {
2228                 char msg[200];
2229                 DWORD retcode;
2230
2231                 retcode = VarDateFromStr( pOleChar[i], 0, 0, pDouble );
2232                 sprintf(msg,"offset %d, string %s, retcode should be 0x%lx, but was 0x%lx",i,WtoA(pOleChar[i]),strrets_DATE[i].error,retcode);
2233                 ok(strrets_DATE[i].error == retcode, msg);
2234                 sprintf(msg,"offset %d, retval %g ",i,strrets_DATE[i].retval);
2235                 ok(*pDouble == strrets_DATE[i].retval,msg);
2236         }
2237 #endif
2238         /* bool from ...
2239          */
2240         trace( "\n\n======== Testing VarBoolFromXXX ========\n");
2241
2242         ok(S_OK == VarBoolFromI4( 0, pBool ), XOK);
2243         ok(VARIANT_FALSE == *pBool, "expected FALSE");
2244         ok(S_OK == VarBoolFromI4( 1, pBool ), XOK);
2245         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2246         ok(S_OK == VarBoolFromI4( -1, pBool ), XOK);
2247         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2248         ok(S_OK == VarBoolFromI4( 2, pBool ), XOK);
2249         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2250
2251         ok(S_OK == VarBoolFromUI1( ' ', pBool ), XOK);
2252         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2253         ok(S_OK == VarBoolFromUI1( '\0', pBool ), XOK);
2254         ok(VARIANT_FALSE == *pBool, "expected FALSE");
2255         ok(S_OK == VarBoolFromUI1( 0x0000, pBool ), XOK);
2256         ok(VARIANT_FALSE == *pBool, "expected FALSE");
2257         ok(S_OK == VarBoolFromUI1( (unsigned char)0xFFF, pBool ), XOK);
2258         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2259         ok(S_OK == VarBoolFromUI1( (unsigned char)0xFFFF, pBool ), XOK);
2260         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2261
2262         ok(S_OK == VarBoolFromR8( 0.0, pBool ), XOK);
2263         ok(VARIANT_FALSE == *pBool, "expected FALSE");
2264         ok(S_OK == VarBoolFromR8( 1.1, pBool ), XOK);
2265         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2266         ok(S_OK == VarBoolFromR8( 0.5, pBool ), XOK);
2267         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2268         ok(S_OK == VarBoolFromR8( 0.49, pBool ), XOK);
2269         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2270         ok(S_OK == VarBoolFromR8( 0.51, pBool ), XOK);
2271         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2272         ok(S_OK == VarBoolFromR8( -0.5, pBool ), XOK);
2273         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2274         ok(S_OK == VarBoolFromR8( -0.49, pBool ), XOK);
2275         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2276         ok(S_OK == VarBoolFromR8( -0.51, pBool ), XOK);
2277         ok(VARIANT_TRUE == *pBool, "expected TRUE");
2278
2279
2280         for( i = 0; i < nOlePtrs; i ++ )
2281         {
2282                 char msg[200];
2283
2284                 sprintf(msg,"offset %d, retcode should be 0x%lx",i,strrets_B[i].error);
2285                 ok(strrets_B[i].error == VarBoolFromStr( pOleChar[i], 0, 0, pBool ), msg);
2286                 sprintf(msg,"offset %d, retval should be 0x%x",i,strrets_B[i].retval);
2287                 ok(strrets_B[i].retval == *pBool,msg);
2288         }
2289
2290         ok(S_OK == VarI1FromBool( VARIANT_TRUE, pByte ), XOK);
2291         ok(*pByte == 0xff,"true should be 0xff");
2292         ok(DISP_E_OVERFLOW == VarUI2FromI2( -1, pUShort ), XOV);
2293
2294         /* BSTR from ...
2295          */
2296         trace( "\n\n======== Testing VarBSTRFromXXX ========\n");
2297
2298         /* integers...
2299          */
2300         ok(S_OK == VarBstrFromI1( -100, 0, 0, &bstr ), XOK);
2301         ok(!strcmp(WtoA(bstr),"\"-100\""),"should be string -100");
2302
2303         ok(S_OK == VarBstrFromUI1( 0x5A, 0, 0, &bstr ), XOK);
2304         ok(!strcmp(WtoA(bstr),"\"90\""),"should be string 90");
2305         ok(S_OK == VarBstrFromI4( 2958465, 0, 0, &bstr ), XOK);
2306         ok(!strcmp(WtoA(bstr),"\"2958465\""),"should be string 2958465");
2307
2308         /* reals...
2309          */
2310         off = 0;
2311         d=0;
2312         for( i=0; i<20; i++ )
2313         {
2314                 char xval[80];
2315                 /* add an integer to the real number
2316                  */
2317                 d += ((i%9)+1) * pow( 10, i );
2318
2319                 ok(S_OK == VarBstrFromR8( d, 0, 0, &bstr ), XOK);
2320                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d,strfromr8[off],WtoA(bstr));
2321                 sprintf(xval,"\"%s\"",strfromr8[off]);
2322                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2323
2324                 ok(S_OK == VarBstrFromR8( -d, 0, 0, &bstr ), XOK);
2325                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",-d,strfromr8[off],WtoA(bstr));
2326                 sprintf(xval,"\"%s\"",strfromr8[off]);
2327                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2328         }
2329         d=0;
2330         for( i=0; i<20; i++ )
2331         {
2332                 char xval[80];
2333                 /* add a decimal to the real number
2334                  */
2335                 d += ((i%9)+1) * pow( 10, (i*-1) );
2336                 ok(S_OK == VarBstrFromR8( d, 0, 0, &bstr ), XOK);
2337                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d,strfromr8[off],WtoA(bstr));
2338                 sprintf(xval,"\"%s\"",strfromr8[off]);
2339                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2340                 ok(S_OK == VarBstrFromR8( d-1, 0, 0, &bstr ), XOK);
2341                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d-1,strfromr8[off],WtoA(bstr));
2342                 sprintf(xval,"\"%s\"",strfromr8[off]);
2343                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2344                 ok(S_OK == VarBstrFromR8( -d, 0, 0, &bstr ), XOK);
2345                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",-d,strfromr8[off],WtoA(bstr));
2346                 sprintf(xval,"\"%s\"",strfromr8[off]);
2347                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2348         }
2349
2350         d=0;
2351         for( i=0; i<20; i++ )
2352         {
2353                 char xval[80];
2354                 /* add an integer to the real number
2355                  */
2356                 d += ((i%9)+1) * pow( 10, i );
2357                 /* add a decimal to the real number
2358                  */
2359                 d += ((i%9)+1) * pow( 10, (i*-1) );
2360                 ok(S_OK == VarBstrFromR8( d, 0, 0, &bstr ), XOK);
2361                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d,strfromr8[off],WtoA(bstr));
2362                 sprintf(xval,"\"%s\"",strfromr8[off]);
2363                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2364                 ok(S_OK == VarBstrFromR8( -d, 0, 0, &bstr ), XOK);
2365                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",-d,strfromr8[off],WtoA(bstr));
2366                 sprintf(xval,"\"%s\"",strfromr8[off]);
2367                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2368         }
2369
2370
2371
2372         d=0;
2373         for( i=0; i<10; i++ )
2374         {
2375                 char xval[80];
2376                 /* add an integer to the real number
2377                  */
2378                 d += ((i%9)+1) * pow( 10, i );
2379                 ok(S_OK == VarBstrFromR4( (float)d, 0, 0, &bstr ), XOK);
2380                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d,strfromr8[off],WtoA(bstr));
2381                 sprintf(xval,"\"%s\"",strfromr8[off]);
2382                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2383                 ok(S_OK == VarBstrFromR4( (float)-d, 0, 0, &bstr ), XOK);
2384                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",-d,strfromr8[off],WtoA(bstr));
2385                 sprintf(xval,"\"%s\"",strfromr8[off]);
2386                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2387         }
2388         d=0;
2389         for( i=0; i<10; i++ )
2390         {
2391                 char xval[80];
2392                 /* add a decimal to the real number
2393                  */
2394                 d += ((i%9)+1) * pow( 10, (i*-1) );
2395                 ok(S_OK == VarBstrFromR4( (float)d, 0, 0, &bstr ), XOK);
2396                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d,strfromr8[off],WtoA(bstr));
2397                 sprintf(xval,"\"%s\"",strfromr8[off]);
2398                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2399                 ok(S_OK == VarBstrFromR4( (float)d-1, 0, 0, &bstr ), XOK);
2400                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d-1,strfromr8[off],WtoA(bstr));
2401                 sprintf(xval,"\"%s\"",strfromr8[off]);
2402                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2403                 ok(S_OK == VarBstrFromR4( (float)-d, 0, 0, &bstr ), XOK);
2404                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",-d,strfromr8[off],WtoA(bstr));
2405                 sprintf(xval,"\"%s\"",strfromr8[off]);
2406                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2407         }
2408
2409         d=0;
2410         for( i=0; i<10; i++ )
2411         {
2412                 char xval[80];
2413                 /* add an integer to the real number
2414                  */
2415                 d += ((i%9)+1) * pow( 10, i );
2416                 /* add a decimal to the real number
2417                  */
2418                 d += ((i%9)+1) * pow( 10, (i*-1) );
2419                 ok(S_OK == VarBstrFromR4( (float)d, 0, 0, &bstr ), XOK);
2420                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",d,strfromr8[off],WtoA(bstr));
2421                 sprintf(xval,"\"%s\"",strfromr8[off]);
2422                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2423                 ok(S_OK == VarBstrFromR4( (float)-d, 0, 0, &bstr ), XOK);
2424                 sprintf(msg,"d is %g, should be cvt. to %s, but return val is %s",-d,strfromr8[off],WtoA(bstr));
2425                 sprintf(xval,"\"%s\"",strfromr8[off]);
2426                 ok(!strcmp(xval,WtoA(bstr)),msg);off++;
2427         }
2428
2429         ok(S_OK == VarBstrFromBool( 0x00, 0, 0, &bstr ), XOK);
2430         ok(!strcmp(WtoA(bstr),"\"False\""),"should be 'False'");
2431         ok(S_OK == VarBstrFromBool( 0xFF, 0, 0, &bstr ), XOK);
2432         ok(!strcmp(WtoA(bstr),"\"True\""),"should be 'True'");
2433
2434         ok(S_OK == VarBstrFromDate( 0.0, 0, 0, &bstr ), XOK);
2435         todo_wine {
2436             sprintf(msg,"should be '12:00:00 AM', but is %s\n",WtoA(bstr));
2437             ok(!strcmp(WtoA(bstr),"\"12:00:00 AM\""),msg);
2438         }
2439
2440         ok(S_OK == VarBstrFromDate( 3.34, 0, 0, &bstr ), XOK);
2441         todo_wine {
2442             sprintf(msg,"should be '1/2/1900 8:09:36 AM', but is %s\n",WtoA(bstr));
2443             ok(!strcmp(WtoA(bstr),"\"1/2/1900 8:09:36 AM\""),msg);
2444         }
2445
2446         ok(S_OK == VarBstrFromDate( 3339.34, 0, 0, &bstr ), XOK);
2447         todo_wine {
2448             sprintf(msg,"should be '2/20/1909 8:09:36 AM', but is %s\n",WtoA(bstr));
2449             ok(!strcmp(WtoA(bstr),"\"2/20/1909 8:09:36 AM\""),msg);
2450         }
2451
2452         ok(S_OK == VarBstrFromDate( 365.00, 0, 0, &bstr ), XOK);
2453         todo_wine {
2454             sprintf(msg,"should be '12/30/1900', but is %s\n",WtoA(bstr));
2455             ok(!strcmp(WtoA(bstr),"\"12/30/1900\""),msg);
2456         }
2457
2458         ok(S_OK == VarBstrFromDate( 365.25, 0, 0, &bstr ), XOK);
2459         todo_wine {
2460             sprintf(msg,"should be '12/30/1900 6:00:00 AM', but is %s\n",WtoA(bstr));
2461             ok(!strcmp(WtoA(bstr),"\"12/30/1900 6:00:00 AM\""),msg);
2462         }
2463
2464         ok(S_OK == VarBstrFromDate( 1461.0, 0, 0, &bstr ), XOK);
2465         todo_wine {
2466             sprintf(msg,"should be '12/31/1903', but is %s\n",WtoA(bstr));
2467             ok(!strcmp(WtoA(bstr),"\"12/31/1903\""),msg);
2468         }
2469
2470         ok(S_OK == VarBstrFromDate( 1461.5, 0, 0, &bstr ), XOK);
2471         todo_wine {
2472             sprintf(msg,"should be '12/31/1903 12:00:00 PM', but is %s\n",WtoA(bstr));
2473             ok(!strcmp(WtoA(bstr),"\"12/31/1903 12:00:00 PM\""),msg);
2474         }
2475
2476         /* Test variant API...
2477          */
2478         trace( "\n\n======== Testing Hi-Level Variant API ========\n");
2479
2480         bstr = SysAllocString( pOleChar[4] );
2481
2482         VariantClear( &va );
2483
2484         VariantInit( &va );
2485         VariantInit( &vb );
2486         VariantInit( &vc );
2487         VariantInit( &vd );
2488         VariantInit( &ve );
2489
2490         V_VT(&va) = VT_BSTR;
2491         V_UNION(&va,bstrVal) = bstr;
2492         ok(S_OK == VariantClear( &va ), XOK);
2493         SysFreeString( bstr );
2494         SysFreeString( bstr );
2495
2496         ok(S_OK == VariantCopy( &vb, &va ), XOK);
2497         ok(S_OK == VariantClear( &vb ), XOK);
2498         ok(S_OK == VariantClear( &va ), XOK);
2499
2500         V_VT(&va) = VT_R8;
2501         d = 4.123;
2502         V_UNION(&va,dblVal) = d;
2503         ok(S_OK == VariantCopy( &va, &va ), XOK);
2504         ok(V_R8(&va) == 4.123,"should be 4.123");
2505
2506         V_VT(&va) = VT_R8 | VT_BYREF;
2507         d = 31.123;
2508         V_UNION(&va,pdblVal) = &d;
2509         ok(S_OK == VariantCopyInd( &va, &va ), XOK);
2510         ok(V_R8(&va) == 31.123,"should be 31.123");
2511
2512         V_VT(&va) = VT_R8;
2513         d = 1.123;
2514         V_UNION(&va,dblVal) = d;
2515         ok(S_OK == VariantCopy( &vb, &va ), XOK);
2516         ok(V_R8(&vb) == 1.123,"should be 1.123");
2517
2518         V_VT(&va) = VT_R8 | VT_BYREF;
2519         d = 123.123;
2520         V_UNION(&va,pdblVal) = &d;
2521         ok(S_OK == VariantCopy( &vb, &va ), XOK);
2522         ok(*(V_R8REF(&vb)) == 123.123,"should be 123.123");
2523
2524         V_VT(&va) = VT_R8 | VT_BYREF;
2525         d = 111.2;
2526         V_UNION(&va,pdblVal) = &d;
2527         ok(S_OK == VariantCopyInd( &vb, &va ), XOK);
2528         ok(V_R8(&vb) == 111.2,"should be 111.2");
2529
2530         V_VT(&va) = VT_R8 | VT_BYREF;
2531         d = 1211.123453;
2532         V_UNION(&va,pdblVal) = &d;
2533         ok(S_OK == VariantChangeTypeEx( &va, &va, 0, 0, VT_I2 ), XOK);
2534         ok(V_VT(&va) == VT_I2,"should be type VT_I2");
2535
2536         V_VT(&va) = VT_INT;
2537         V_UNION(&va,intVal) = 4;
2538         ok(S_OK == VariantChangeTypeEx(&vb, &va, 0, 0, VT_BSTR ), XOK);
2539         ok(!strcmp(WtoA(V_BSTR(&vb)),"\"4\""),"should be 4");
2540
2541         V_VT(&va) = VT_DATE;
2542         V_UNION(&va,date) = 34465.332431;
2543         ok(S_OK == VariantChangeTypeEx(&vb, &va, 0, 0, VT_BSTR ), XOK);
2544         todo_wine {
2545             ok(!strcmp(WtoA(V_BSTR(&vb)),"\"5/11/94 7:58:42 AM\""),"should be 5/11/94 7:58:42 AM");
2546         }
2547
2548         bstr = pOleChar[4];
2549         V_VT(&va) = VT_BSTR;
2550         V_UNION(&va,bstrVal) = bstr;
2551         ok(S_OK == VariantChangeTypeEx(&vb, &va, 0, 0, VT_R8 ), XOK);
2552         ok(V_R8(&vb) == -0.490000,"should be -0.49");
2553
2554         V_VT(&vc) = VT_BSTR | VT_BYREF;
2555         V_UNION(&vc,pbstrVal) = &bstr;
2556         V_VT(&vb) = VT_VARIANT | VT_BYREF;
2557         V_UNION(&vb,pvarVal) = &vc;
2558         V_VT(&va) = VT_VARIANT | VT_BYREF;
2559         V_UNION(&va,pvarVal) = &vb;
2560         ok(E_INVALIDARG == VariantCopyInd( &vd, &va ), "expect E_INVALIDARG");
2561
2562         /* test what happens when bad vartypes are passed in */
2563         trace( "-------------- Testing different VARTYPES ----------------\n" );
2564
2565 #ifdef FIXED_THIS
2566         for( i=0; i<sizeof(vartypes)/sizeof(vartypes[0]); i++ )
2567         {
2568                     /* Trying to use variants that are set to be BSTR but
2569                      * do not contain a valid pointer makes the program crash
2570                      * in Windows so we will skip those. We do not need them
2571                      * anyway to illustrate the behavior.
2572                      */
2573                     V_VT(&va) = vartypes[i].ind;
2574                     d = 4.123;
2575                     V_UNION(&va,dblVal) = d;
2576                     res = VariantCopyInd( &vb, &va );
2577                     sprintf(msg,"vt %d, return value %lx, expected was %lx",vartypes[i].ind,res,vartypes[i].vcind1);
2578                     ok(vartypes[i].vcind1 == res, msg);
2579                     V_VT(&va) = vartypes[i].ind | VT_BYREF;
2580                     d = 4.123;
2581                     V_UNION(&va,pdblVal) = &d;
2582                     res = VariantCopyInd( &vb, &va );
2583                     sprintf(msg,"vt %d, return value %lx, expected was %lx",vartypes[i].ind,res,vartypes[i].vcind2);
2584                     ok(vartypes[i].vcind2 == res, msg);
2585                     V_VT(&va) = VT_R8;
2586                     d = 4.123;
2587                     V_UNION(&va,dblVal) = d;
2588                     res = VariantChangeTypeEx( &vb, &va, 0, 0, i );
2589                     sprintf(msg,"vt %d, return value %lx, expected was %lx",vartypes[i].ind,res,vartypes[i].vcex1);
2590                     ok(vartypes[i].vcex1 == res, msg);
2591                     V_VT(&va) = VT_R8;
2592                     d = 4.123;
2593                     V_UNION(&va,dblVal) = d;
2594                     res = VariantChangeTypeEx( &vb, &va, 0, 0, i | VT_BYREF );
2595                     sprintf(msg,"vt %d, return value %lx, expected was %lx",vartypes[i].ind,res,vartypes[i].vcex1);
2596                     ok(vartypes[i].vcex2 == res, msg);
2597
2598                 V_VT(&va) = 99;
2599                 d = 4.123;
2600                 V_UNION(&va,dblVal) = d;
2601                 ok(DISP_E_BADVARTYPE == VariantClear( &va ), "should give DISP_E_BADVARTYPE");
2602         }
2603 #endif
2604         VariantClear( &va );
2605         VariantClear( &vb );
2606         VariantClear( &vc );
2607         VariantClear( &vd );
2608         VariantClear( &ve );
2609         /* There is alot of memory leaks but this is simply a test program.
2610          */
2611 }