1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 25 // MARKER(update_precomp.py): autogen include statement, do not remove 26 #include "precompiled_sal.hxx" 27 #include "gtest/gtest.h" 28 29 #include <rtl/digest.h> 30 #include <rtl/ustring.hxx> 31 #include <rtl/ustrbuf.hxx> 32 #include <rtl/strbuf.hxx> 33 34 // sample, how to use digest 35 36 rtl::OUString CreateMD5FromString( const rtl::OUString& aMsg ) 37 { 38 // PRE: aStr "file" 39 // BACK: Str "ababab....0f" Hexcode String 40 41 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 42 if ( handle > 0 ) 43 { 44 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 45 sal_uInt32 nSize = ( aMsg.getLength() * sizeof( sal_Unicode )); 46 sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle ); 47 sal_uInt8* pMD5KeyBuffer = new sal_uInt8[ nMD5KeyLen ]; 48 49 rtl_digest_init( handle, pData, nSize ); 50 rtl_digest_update( handle, pData, nSize ); 51 rtl_digest_get( handle, pMD5KeyBuffer, nMD5KeyLen ); 52 rtl_digest_destroy( handle ); 53 54 // Create hex-value string from the MD5 value to keep the string size minimal 55 rtl::OUStringBuffer aBuffer( nMD5KeyLen * 2 + 1 ); 56 for ( sal_uInt32 i = 0; i < nMD5KeyLen; i++ ) 57 aBuffer.append( (sal_Int32)pMD5KeyBuffer[i], 16 ); 58 59 delete [] pMD5KeyBuffer; 60 return aBuffer.makeStringAndClear(); 61 } 62 63 return rtl::OUString(); 64 } 65 66 // ----------------------------------------------------------------------------- 67 namespace rtl_digest 68 { 69 70 rtl::OString sSampleString = "This is a sample sentence, which we use to check some crypto functions in sal."; 71 rtl::OString sSampleString_MD2 = "647ee6c9d4aa5fdd374ed9d7a156acbf"; 72 rtl::OString sSampleString_MD5 = "b16b903e6fc0b62ae389013ed93fe531"; 73 rtl::OString sSampleString_SHA = "eab2814429b2613301c8a077b806af3680548914"; 74 rtl::OString sSampleString_SHA1 = "2bc5bdb7506a2cdc2fd27fc8b9889343012d5008"; 75 rtl::OString sSampleString_HMAC_MD5 = "dd9cba48c972fba0a882baa72b079674"; 76 rtl::OString sSampleString_HMAC_SHA1 = "5d7f43ce6abd1de4438d7e69e01495864490cf3e"; 77 78 rtl::OString sSampleString_only_one_diff = "This is a sample sentence. which we use to check some crypto functions in sal."; 79 80 class create : public ::testing::Test 81 { 82 public: 83 // initialise your test code values here. 84 void SetUp() 85 { 86 } 87 88 void TearDown() 89 { 90 } 91 }; // class create 92 93 TEST_F(create, create_001) 94 { 95 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 96 ASSERT_TRUE(handle != 0) << "create with rtl_Digest_AlgorithmMD5"; 97 rtl_digest_destroy( handle ); 98 } 99 TEST_F(create, create_002) 100 { 101 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 102 ASSERT_TRUE(handle != 0) << "create with rtl_Digest_AlgorithmMD2"; 103 rtl_digest_destroy( handle ); 104 } 105 TEST_F(create, create_003) 106 { 107 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 108 ASSERT_TRUE(handle != 0) << "create with rtl_Digest_AlgorithmSHA"; 109 rtl_digest_destroy( handle ); 110 } 111 TEST_F(create, create_004) 112 { 113 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 114 ASSERT_TRUE(handle != 0) << "create with rtl_Digest_AlgorithmSHA1"; 115 rtl_digest_destroy( handle ); 116 } 117 TEST_F(create, create_005) 118 { 119 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 120 ASSERT_TRUE(handle != 0) << "create with rtl_Digest_AlgorithmHMAC_MD5"; 121 rtl_digest_destroy( handle ); 122 } 123 TEST_F(create, create_006) 124 { 125 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 126 ASSERT_TRUE(handle != 0) << "create with rtl_Digest_AlgorithmHMAC_SHA1"; 127 rtl_digest_destroy( handle ); 128 } 129 TEST_F(create, create_007) 130 { 131 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); 132 printf("Handle is %p\n", handle); 133 ASSERT_TRUE(handle == 0) << "create with NULL"; 134 rtl_digest_destroy( handle ); 135 } 136 137 138 139 // ----------------------------------------------------------------------------- 140 141 class createMD5 : public ::testing::Test 142 { 143 public: 144 // initialise your test code values here. 145 void SetUp() 146 { 147 } 148 149 void TearDown() 150 { 151 } 152 }; // class create 153 154 TEST_F(createMD5, createMD5_001) 155 { 156 rtlDigest handle = rtl_digest_createMD5(); 157 158 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 159 ASSERT_TRUE(rtl_Digest_AlgorithmMD5 == aAlgo) << "query handle"; 160 161 rtl_digest_destroy( handle ); 162 } 163 164 165 // ----------------------------------------------------------------------------- 166 167 class createMD2 : public ::testing::Test 168 { 169 public: 170 // initialise your test code values here. 171 void SetUp() 172 { 173 } 174 175 void TearDown() 176 { 177 } 178 }; // class create 179 180 TEST_F(createMD2, createMD2_001) 181 { 182 rtlDigest handle = rtl_digest_createMD2( ); 183 184 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 185 ASSERT_TRUE(rtl_Digest_AlgorithmMD2 == aAlgo) << "query handle"; 186 187 rtl_digest_destroy( handle ); 188 } 189 190 // ----------------------------------------------------------------------------- 191 192 class createSHA : public ::testing::Test 193 { 194 public: 195 // initialise your test code values here. 196 void SetUp() 197 { 198 } 199 200 void TearDown() 201 { 202 } 203 }; // class create 204 205 TEST_F(createSHA, createSHA_001) 206 { 207 rtlDigest handle = rtl_digest_createSHA( ); 208 209 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 210 ASSERT_TRUE(rtl_Digest_AlgorithmSHA == aAlgo) << "query handle"; 211 212 rtl_digest_destroy( handle ); 213 } 214 215 // ----------------------------------------------------------------------------- 216 217 class createSHA1 : public ::testing::Test 218 { 219 public: 220 // initialise your test code values here. 221 void SetUp() 222 { 223 } 224 225 void TearDown() 226 { 227 } 228 }; // class create 229 230 TEST_F(createSHA1, createSHA1_001) 231 { 232 rtlDigest handle = rtl_digest_createSHA1(); 233 234 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 235 ASSERT_TRUE(rtl_Digest_AlgorithmSHA1 == aAlgo) << "query handle"; 236 237 rtl_digest_destroy( handle ); 238 } 239 240 // ----------------------------------------------------------------------------- 241 242 class createHMAC_MD5 : public ::testing::Test 243 { 244 public: 245 // initialise your test code values here. 246 void SetUp() 247 { 248 } 249 250 void TearDown() 251 { 252 } 253 }; // class create 254 255 TEST_F(createHMAC_MD5, createHMAC_MD5_001) 256 { 257 rtlDigest handle = rtl_digest_createHMAC_MD5(); 258 259 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 260 ASSERT_TRUE(rtl_Digest_AlgorithmHMAC_MD5 == aAlgo) << "query handle"; 261 262 rtl_digest_destroy( handle ); 263 } 264 265 // ----------------------------------------------------------------------------- 266 267 class createHMAC_SHA1 : public ::testing::Test 268 { 269 public: 270 // initialise your test code values here. 271 void SetUp() 272 { 273 } 274 275 void TearDown() 276 { 277 } 278 }; // class create 279 280 TEST_F(createHMAC_SHA1, createHMAC_SHA1_001) 281 { 282 rtlDigest handle = rtl_digest_createHMAC_SHA1(); 283 284 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 285 ASSERT_TRUE(rtl_Digest_AlgorithmHMAC_SHA1 == aAlgo) << "query handle"; 286 287 rtl_digest_destroy( handle ); 288 } 289 290 // ----------------------------------------------------------------------------- 291 292 class queryAlgorithm : public ::testing::Test 293 { 294 public: 295 // initialise your test code values here. 296 void SetUp() 297 { 298 } 299 300 void TearDown() 301 { 302 } 303 }; // class create 304 305 TEST_F(queryAlgorithm, query_001) 306 { 307 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 308 309 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 310 ASSERT_TRUE(rtl_Digest_AlgorithmMD5 == aAlgo) << "query handle"; 311 312 rtl_digest_destroy( handle ); 313 } 314 TEST_F(queryAlgorithm, query_002) 315 { 316 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 317 318 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 319 ASSERT_TRUE(rtl_Digest_AlgorithmMD2 == aAlgo) << "query handle"; 320 321 rtl_digest_destroy( handle ); 322 } 323 TEST_F(queryAlgorithm, query_003) 324 { 325 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 326 327 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 328 ASSERT_TRUE(rtl_Digest_AlgorithmSHA == aAlgo) << "query handle"; 329 330 rtl_digest_destroy( handle ); 331 } 332 TEST_F(queryAlgorithm, query_004) 333 { 334 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 335 336 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 337 ASSERT_TRUE(rtl_Digest_AlgorithmSHA1 == aAlgo) << "query handle"; 338 339 rtl_digest_destroy( handle ); 340 } 341 TEST_F(queryAlgorithm, query_005) 342 { 343 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 344 345 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 346 ASSERT_TRUE(rtl_Digest_AlgorithmHMAC_MD5 == aAlgo) << "query handle"; 347 348 rtl_digest_destroy( handle ); 349 } 350 TEST_F(queryAlgorithm, query_006) 351 { 352 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 353 354 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 355 ASSERT_TRUE(rtl_Digest_AlgorithmHMAC_SHA1 == aAlgo) << "query handle"; 356 357 rtl_digest_destroy( handle ); 358 } 359 TEST_F(queryAlgorithm, query_007) 360 { 361 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); 362 363 rtlDigestAlgorithm aAlgo = rtl_digest_queryAlgorithm(handle); 364 ASSERT_TRUE(rtl_Digest_AlgorithmInvalid == aAlgo) << "query handle"; 365 366 rtl_digest_destroy( handle ); 367 } 368 369 // ----------------------------------------------------------------------------- 370 class queryLength : public ::testing::Test 371 { 372 public: 373 // initialise your test code values here. 374 void SetUp() 375 { 376 } 377 378 void TearDown() 379 { 380 } 381 382 }; // class create 383 384 TEST_F(queryLength, queryLength_MD5) 385 { 386 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 387 388 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 389 // printf("nAlgoLength:=%d\n", nAlgoLength); 390 ASSERT_TRUE(RTL_DIGEST_LENGTH_MD5 == nAlgoLength) << "query Length"; 391 392 rtl_digest_destroy( handle ); 393 } 394 TEST_F(queryLength, queryLength_MD2) 395 { 396 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 397 398 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 399 // printf("nAlgoLength:=%d\n", nAlgoLength); 400 ASSERT_TRUE(RTL_DIGEST_LENGTH_MD2 == nAlgoLength) << "query length"; 401 402 rtl_digest_destroy( handle ); 403 } 404 TEST_F(queryLength, queryLength_SHA) 405 { 406 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 407 408 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 409 // printf("nAlgoLength:=%d\n", nAlgoLength); 410 ASSERT_TRUE(RTL_DIGEST_LENGTH_SHA == nAlgoLength) << "query length"; 411 412 rtl_digest_destroy( handle ); 413 } 414 TEST_F(queryLength, queryLength_SHA1) 415 { 416 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 417 418 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 419 // printf("nAlgoLength:=%d\n", nAlgoLength); 420 ASSERT_TRUE(RTL_DIGEST_LENGTH_SHA1 == nAlgoLength) << "query length"; 421 422 rtl_digest_destroy( handle ); 423 } 424 TEST_F(queryLength, queryLength_HMAC_MD5) 425 { 426 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 427 428 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 429 // printf("nAlgoLength:=%d\n", nAlgoLength); 430 ASSERT_TRUE(RTL_DIGEST_LENGTH_HMAC_MD5 == nAlgoLength) << "query length"; 431 432 rtl_digest_destroy( handle ); 433 } 434 TEST_F(queryLength, queryLength_HMAC_SHA1) 435 { 436 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 437 438 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 439 // printf("nAlgoLength:=%d\n", nAlgoLength); 440 ASSERT_TRUE(RTL_DIGEST_LENGTH_HMAC_SHA1 == nAlgoLength) << "query length"; 441 442 rtl_digest_destroy( handle ); 443 } 444 445 TEST_F(queryLength, queryLength_Illegal) 446 { 447 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmInvalid ); 448 449 sal_uInt32 nAlgoLength = rtl_digest_queryLength(handle); 450 // printf("nAlgoLength:=%d\n", nAlgoLength); 451 ASSERT_TRUE(0 == nAlgoLength) << "query length"; 452 453 rtl_digest_destroy( handle ); 454 } 455 456 // ----------------------------------------------------------------------------- 457 458 rtl::OString createHex(sal_uInt8 *_pMD5KeyBuffer, sal_uInt32 _nMD5KeyLen) 459 { 460 // Create hex-value string from the MD5 value to keep the string size minimal 461 rtl::OStringBuffer aBuffer( _nMD5KeyLen * 2 + 1 ); 462 for ( sal_uInt32 i = 0; i < _nMD5KeyLen; i++ ) 463 { 464 sal_Int32 nValue = (sal_Int32)_pMD5KeyBuffer[i]; 465 if (nValue < 16) // maximul hex value for 1 byte 466 { 467 aBuffer.append( sal_Int32(0), sal_Int16(16) /* radix */ ); 468 } 469 aBuffer.append( nValue, 16 /* radix */ ); 470 } 471 472 return aBuffer.makeStringAndClear(); 473 } 474 475 476 // ----------------------------------------------------------------------------- 477 class init : public ::testing::Test 478 { 479 public: 480 // initialise your test code values here. 481 void SetUp() 482 { 483 } 484 485 void TearDown() 486 { 487 } 488 }; // class init 489 490 TEST_F(init, init_000) 491 { 492 rtlDigest handle = NULL; 493 494 rtlDigestError aError = rtl_digest_init(handle, NULL, 0); 495 496 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "init(NULL, 0, 0)"; 497 } 498 499 TEST_F(init, init_001) 500 { 501 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 502 503 rtlDigestError aError = rtl_digest_init(handle, NULL, 0); 504 505 ASSERT_TRUE(aError == rtl_Digest_E_None) << "init(handle, 0, 0)"; 506 507 rtl_digest_destroy( handle ); 508 } 509 510 // ------------------------------------ 511 TEST_F(init, init_MD2) 512 { 513 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 514 515 rtl::OString aMsg = sSampleString; 516 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 517 sal_uInt32 nSize = ( aMsg.getLength() ); 518 519 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 520 521 ASSERT_TRUE(aError == rtl_Digest_E_None) << "init(handle, pData, nSize)"; 522 523 rtl_digest_update( handle, pData, nSize ); 524 525 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 526 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 527 528 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 529 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 530 delete [] pKeyBuffer; 531 532 printf("MD2 Sum: %s\n", aSum.getStr()); 533 // LLA: how to check right values 534 // samples? 535 536 rtl_digest_destroy( handle ); 537 } 538 539 TEST_F(init, init_MD5) 540 { 541 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 542 543 rtl::OString aMsg = sSampleString; 544 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 545 sal_uInt32 nSize = ( aMsg.getLength() ); 546 547 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 548 549 ASSERT_TRUE(aError == rtl_Digest_E_None) << "init(handle, pData, nSize)"; 550 551 rtl_digest_update( handle, pData, nSize ); 552 553 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 554 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 555 556 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 557 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 558 delete [] pKeyBuffer; 559 560 printf("MD5 Sum: %s\n", aSum.getStr()); 561 // LLA: how to check right values 562 // samples? 563 564 rtl_digest_destroy( handle ); 565 } 566 567 TEST_F(init, init_SHA) 568 { 569 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA ); 570 571 rtl::OString aMsg = sSampleString; 572 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 573 sal_uInt32 nSize = ( aMsg.getLength() ); 574 575 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 576 577 ASSERT_TRUE(aError == rtl_Digest_E_None) << "init(handle, pData, nSize)"; 578 579 rtl_digest_update( handle, pData, nSize ); 580 581 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 582 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 583 584 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 585 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 586 delete [] pKeyBuffer; 587 588 printf("SHA Sum: %s\n", aSum.getStr()); 589 // LLA: how to check right values 590 // samples? 591 592 rtl_digest_destroy( handle ); 593 } 594 TEST_F(init, init_SHA1) 595 { 596 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmSHA1 ); 597 598 rtl::OString aMsg = sSampleString; 599 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 600 sal_uInt32 nSize = ( aMsg.getLength() ); 601 602 rtlDigestError aError = rtl_digest_init(handle, pData, nSize); 603 604 ASSERT_TRUE(aError == rtl_Digest_E_None) << "init(handle, pData, nSize)"; 605 606 rtl_digest_update( handle, pData, nSize ); 607 608 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 609 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 610 611 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 612 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 613 delete [] pKeyBuffer; 614 615 printf("SHA1 Sum: %s\n", aSum.getStr()); 616 // LLA: how to check right values 617 // samples? 618 619 rtl_digest_destroy( handle ); 620 } 621 TEST_F(init, init_HMAC_MD5) 622 { 623 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_MD5 ); 624 625 rtl::OString aMsg = sSampleString; 626 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 627 sal_uInt32 nSize = ( aMsg.getLength() ); 628 629 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 630 ASSERT_TRUE(nKeyLen) << "Keylen must be greater 0"; 631 632 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 633 ASSERT_TRUE( pKeyBuffer ); 634 memset(pKeyBuffer, 0, nKeyLen); 635 636 rtlDigestError aError = rtl_digest_init(handle, pKeyBuffer, nKeyLen ); 637 638 ASSERT_TRUE(aError == rtl_Digest_E_None) << "init(handle, pData, nSize)"; 639 640 rtl_digest_update( handle, pData, nSize ); 641 642 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 643 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 644 delete [] pKeyBuffer; 645 646 printf("HMAC_MD5 Sum: %s\n", aSum.getStr()); 647 // LLA: how to check right values 648 // samples? 649 650 rtl_digest_destroy( handle ); 651 } 652 TEST_F(init, init_HMAC_SHA1) 653 { 654 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmHMAC_SHA1 ); 655 656 rtl::OString aMsg = sSampleString; 657 const sal_uInt8 *pData = (const sal_uInt8*)aMsg.getStr(); 658 sal_uInt32 nSize = ( aMsg.getLength() ); 659 660 sal_uInt32 nKeyLen = rtl_digest_queryLength( handle ); 661 ASSERT_TRUE(nKeyLen) << "Keylen must be greater 0"; 662 663 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 664 ASSERT_TRUE( pKeyBuffer ); 665 memset(pKeyBuffer, 0, nKeyLen); 666 667 rtlDigestError aError = rtl_digest_init(handle, pKeyBuffer, nKeyLen ); 668 669 ASSERT_TRUE(aError == rtl_Digest_E_None) << "init(handle, pData, nSize)"; 670 671 rtl_digest_update( handle, pData, nSize ); 672 673 rtl_digest_get( handle, pKeyBuffer, nKeyLen ); 674 rtl::OString aSum = createHex(pKeyBuffer, nKeyLen); 675 delete [] pKeyBuffer; 676 677 printf("HMAC_SHA1 Sum: %s\n", aSum.getStr()); 678 // LLA: how to check right values 679 // samples? 680 681 rtl_digest_destroy( handle ); 682 } 683 // ------------------------------------ 684 685 rtl::OString getMD5Sum(rtl::OString const& _aMsg ) 686 { 687 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 688 689 const sal_uInt8 *pData = (const sal_uInt8*)_aMsg.getStr(); 690 sal_uInt32 nSize = ( _aMsg.getLength() ); 691 692 rtl_digest_init(handle, pData, nSize); 693 rtl_digest_update( handle, pData, nSize ); 694 695 sal_uInt32 nMD5KeyLen = rtl_digest_queryLength( handle ); 696 sal_uInt8 *pMD5KeyBuffer = new sal_uInt8[ nMD5KeyLen ]; 697 698 rtl_digest_get( handle, pMD5KeyBuffer, nMD5KeyLen ); 699 rtl::OString aMD5Sum = createHex(pMD5KeyBuffer, nMD5KeyLen); 700 delete [] pMD5KeyBuffer; 701 702 rtl_digest_destroy( handle ); 703 return aMD5Sum; 704 } 705 706 // ----------------------------------------------------------------------------- 707 708 class equalTests : public ::testing::Test 709 { 710 public: 711 // initialise your test code values here. 712 void SetUp() 713 { 714 } 715 716 void TearDown() 717 { 718 } 719 }; // class create 720 721 TEST_F(equalTests, equal_001) 722 { 723 rtl::OString aMsg1 = sSampleString; 724 rtl::OString aMsg2 = sSampleString; 725 726 rtl::OString aMsgMD5Sum1 = getMD5Sum(aMsg1); 727 rtl::OString aMsgMD5Sum2 = getMD5Sum(aMsg2); 728 729 ASSERT_TRUE(aMsgMD5Sum1.getLength() == 32 && aMsgMD5Sum2.getLength() == 32) << "md5sum must have a length"; 730 ASSERT_TRUE(aMsgMD5Sum1.equals(aMsgMD5Sum2) == sal_True) << "source is the same, dest must be also the same"; 731 } 732 // ------------------------------------ 733 TEST_F(equalTests, equal_002) 734 { 735 rtl::OString aMsg1 = sSampleString; 736 rtl::OString aMsg2 = sSampleString_only_one_diff; 737 738 rtl::OString aMsgMD5Sum1 = getMD5Sum(aMsg1); 739 rtl::OString aMsgMD5Sum2 = getMD5Sum(aMsg2); 740 741 ASSERT_TRUE(aMsgMD5Sum1.getLength() == 32 && aMsgMD5Sum2.getLength() == 32) << "md5sum must have a length"; 742 ASSERT_TRUE(aMsgMD5Sum1.equals(aMsgMD5Sum2) == sal_False) << "differ only in one char"; 743 } 744 745 746 // ----------------------------------------------------------------------------- 747 class digest_MD2 : public ::testing::Test 748 { 749 public: 750 // initialise your test code values here. 751 void SetUp() 752 { 753 } 754 755 void TearDown() 756 { 757 } 758 }; // class digest_MD2 759 760 TEST_F(digest_MD2, MD2_001) 761 { 762 rtl::OString aMsg1 = sSampleString; 763 764 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_MD2 ]; 765 ASSERT_TRUE( pBuffer ); 766 memset(pBuffer, 0, RTL_DIGEST_LENGTH_MD2 ); 767 768 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 769 sal_Int32 nLen = aMsg1.getLength(); 770 771 rtlDigestError aError = rtl_digest_MD2(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_MD2); 772 773 ASSERT_TRUE(aError == rtl_Digest_E_None ); 774 775 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_MD2); 776 printf("Decrypt MD2: %s\n", aStr.getStr()); 777 ASSERT_TRUE(aStr.equals(sSampleString_MD2)) << 778 "checksum of sample string is wrong. Code changes or sample problems, please check."; 779 780 delete [] pBuffer; 781 } 782 // ----------------------------------------------------------------------------- 783 class digest_MD5 : public ::testing::Test 784 { 785 public: 786 // initialise your test code values here. 787 void SetUp() 788 { 789 } 790 791 void TearDown() 792 { 793 } 794 }; // class digest_MD5 795 796 TEST_F(digest_MD5, MD5_001) 797 { 798 rtl::OString aMsg1 = sSampleString; 799 800 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_MD5 ]; 801 ASSERT_TRUE( pBuffer ); 802 memset(pBuffer, 0, RTL_DIGEST_LENGTH_MD5 ); 803 804 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 805 sal_Int32 nLen = aMsg1.getLength(); 806 807 rtlDigestError aError = rtl_digest_MD5(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_MD5); 808 809 ASSERT_TRUE(aError == rtl_Digest_E_None ); 810 811 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_MD5); 812 printf("Decrypt MD5: %s\n", aStr.getStr()); 813 ASSERT_TRUE(aStr.equals(sSampleString_MD5) ) << 814 "checksum of sample string is wrong. Code changes or sample problems, please check."; 815 816 delete [] pBuffer; 817 } 818 819 // ----------------------------------------------------------------------------- 820 class digest_SHA : public ::testing::Test 821 { 822 public: 823 // initialise your test code values here. 824 void SetUp() 825 { 826 } 827 828 void TearDown() 829 { 830 } 831 }; // class create 832 833 TEST_F(digest_SHA, SHA_001) 834 { 835 rtl::OString aMsg1 = sSampleString; 836 837 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_SHA ]; 838 ASSERT_TRUE( pBuffer ); 839 memset(pBuffer, 0, RTL_DIGEST_LENGTH_SHA); 840 841 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 842 sal_Int32 nLen = aMsg1.getLength(); 843 844 rtlDigestError aError = rtl_digest_SHA(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_SHA); 845 846 ASSERT_TRUE(aError == rtl_Digest_E_None ); 847 848 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_SHA); 849 printf("Decrypt SHA: %s\n", aStr.getStr()); 850 ASSERT_TRUE(aStr.equals(sSampleString_SHA)) << 851 "checksum of sample string is wrong. Code changes or sample problems, please check."; 852 853 delete [] pBuffer; 854 } 855 // ----------------------------------------------------------------------------- 856 class digest_SHA1 : public ::testing::Test 857 { 858 public: 859 // initialise your test code values here. 860 void SetUp() 861 { 862 } 863 864 void TearDown() 865 { 866 } 867 }; // class create 868 869 TEST_F(digest_SHA1, SHA1_001) 870 { 871 rtl::OString aMsg1 = sSampleString; 872 873 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_SHA1 ]; 874 ASSERT_TRUE( pBuffer ); 875 memset(pBuffer, 0, RTL_DIGEST_LENGTH_SHA1); 876 877 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 878 sal_Int32 nLen = aMsg1.getLength(); 879 880 rtlDigestError aError = rtl_digest_SHA1(pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_SHA1); 881 882 ASSERT_TRUE(aError == rtl_Digest_E_None ); 883 884 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_SHA1); 885 printf("Decrypt SHA1: %s\n", aStr.getStr()); 886 ASSERT_TRUE(aStr.equals(sSampleString_SHA1)) << 887 "checksum of sample string is wrong. Code changes or sample problems, please check."; 888 889 delete [] pBuffer; 890 } 891 // ----------------------------------------------------------------------------- 892 class digest_HMAC_MD5 : public ::testing::Test 893 { 894 public: 895 // initialise your test code values here. 896 void SetUp() 897 { 898 } 899 900 void TearDown() 901 { 902 } 903 }; // class create 904 905 TEST_F(digest_HMAC_MD5, HMAC_MD5_001) 906 { 907 rtl::OString aMsg1 = sSampleString; 908 909 sal_uInt8 *pKeyBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_MD5 ]; 910 ASSERT_TRUE( pKeyBuffer ); 911 memset(pKeyBuffer, 0, RTL_DIGEST_LENGTH_HMAC_MD5); 912 913 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_MD5 ]; 914 ASSERT_TRUE( pBuffer ); 915 memset(pBuffer, 0, RTL_DIGEST_LENGTH_HMAC_MD5); 916 917 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 918 sal_Int32 nLen = aMsg1.getLength(); 919 920 rtlDigestError aError = rtl_digest_HMAC_MD5(pKeyBuffer, RTL_DIGEST_LENGTH_HMAC_MD5, pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_HMAC_MD5); 921 922 ASSERT_TRUE(aError == rtl_Digest_E_None ); 923 924 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_HMAC_MD5); 925 printf("Decrypt HMAC_MD5: %s\n", aStr.getStr()); 926 ASSERT_TRUE(aStr.equals(sSampleString_HMAC_MD5)) << 927 "md5sum of sample string is wrong. Code changes or sample problems, please check."; 928 929 delete [] pBuffer; 930 } 931 932 // ----------------------------------------------------------------------------- 933 class digest_HMAC_SHA1 : public ::testing::Test 934 { 935 public: 936 // initialise your test code values here. 937 void SetUp() 938 { 939 } 940 941 void TearDown() 942 { 943 } 944 }; // class create 945 946 TEST_F(digest_HMAC_SHA1, HMAC_SHA1_001) 947 { 948 rtl::OString aMsg1 = sSampleString; 949 950 sal_uInt8 *pKeyBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_SHA1 ]; 951 ASSERT_TRUE( pKeyBuffer ); 952 memset(pKeyBuffer, 0, RTL_DIGEST_LENGTH_HMAC_SHA1); 953 954 sal_uInt8 *pBuffer = new sal_uInt8[ RTL_DIGEST_LENGTH_HMAC_SHA1 ]; 955 ASSERT_TRUE( pBuffer ); 956 memset(pBuffer, 0, RTL_DIGEST_LENGTH_HMAC_SHA1); 957 958 sal_uInt8 *pMsg1 = (sal_uInt8*)aMsg1.getStr(); 959 sal_Int32 nLen = aMsg1.getLength(); 960 961 rtlDigestError aError = rtl_digest_HMAC_SHA1(pKeyBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1, pMsg1, nLen, pBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1); 962 963 ASSERT_TRUE(aError == rtl_Digest_E_None ); 964 965 rtl::OString aStr = createHex(pBuffer, RTL_DIGEST_LENGTH_HMAC_SHA1); 966 printf("Decrypt HMAC_SHA1: %s\n", aStr.getStr()); 967 ASSERT_TRUE(aStr.equals(sSampleString_HMAC_SHA1)) << 968 "md5sum of sample string is wrong. Code changes or sample problems, please check."; 969 970 delete [] pBuffer; 971 } 972 // ----------------------------------------------------------------------------- 973 class digest_PBKDF2 : public ::testing::Test 974 { 975 public: 976 // initialise your test code values here. 977 void SetUp() 978 { 979 } 980 981 void TearDown() 982 { 983 } 984 985 rtl::OString /* key */ run_check_PBKDF2(rtl::OString const& _sPassword, bool _bClearSalt, sal_uInt32 _nCount) 986 { 987 sal_uInt32 nKeyLen = RTL_DIGEST_LENGTH_HMAC_SHA1; 988 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 989 EXPECT_TRUE( pKeyBuffer ); 990 memset(pKeyBuffer, 0, nKeyLen); 991 992 sal_uInt8 *pPassword = (sal_uInt8*)_sPassword.getStr(); 993 sal_Int32 nPasswordLen = _sPassword.getLength(); 994 995 sal_uInt32 nSaltDataLen = RTL_DIGEST_LENGTH_HMAC_SHA1; 996 sal_uInt8 *pSaltData = new sal_uInt8[ nSaltDataLen ]; 997 EXPECT_TRUE( pSaltData ); 998 memset(pSaltData, 0, nSaltDataLen); 999 1000 if (! _bClearSalt) 1001 { 1002 // wilful contamination 1003 pSaltData[0] = 1; 1004 } 1005 1006 rtlDigestError aError = rtl_digest_PBKDF2(pKeyBuffer, nKeyLen, pPassword, nPasswordLen, pSaltData, nSaltDataLen, _nCount); 1007 1008 EXPECT_TRUE(aError == rtl_Digest_E_None ); 1009 1010 rtl::OString aKey = createHex(pKeyBuffer, nKeyLen); 1011 printf("Key: %s\n", aKey.getStr()); 1012 1013 // rtl::OString sSalt = createHex(pSaltData, nSaltDataLen); 1014 // printf("Salt: %s\n", sSalt.getStr()); 1015 1016 // EXPECT_TRUE(aStr.equals(sSampleString_PBKDF2)) << 1017 // "md5sum of sample string is wrong. Code changes or sample problems, please check."; 1018 1019 delete [] pSaltData; 1020 delete [] pKeyBuffer; 1021 return aKey; 1022 } 1023 }; // class create 1024 1025 TEST_F(digest_PBKDF2, PBKDF2_001) 1026 { 1027 rtl::OString aPassword = "Password"; 1028 1029 // all permutations 1030 run_check_PBKDF2(aPassword, false, 1); 1031 run_check_PBKDF2(aPassword, false, 2); 1032 run_check_PBKDF2(aPassword, true, 1); 1033 run_check_PBKDF2(aPassword, true, 2); 1034 run_check_PBKDF2(aPassword, false, 3); 1035 run_check_PBKDF2(aPassword, false, 4); 1036 run_check_PBKDF2(aPassword, true, 3); 1037 run_check_PBKDF2(aPassword, true, 4); 1038 } 1039 1040 // ----------------------------------------------------------------------------- 1041 1042 class update : public ::testing::Test 1043 { 1044 public: 1045 // initialise your test code values here. 1046 void SetUp() 1047 { 1048 } 1049 1050 void TearDown() 1051 { 1052 } 1053 }; // class create 1054 1055 TEST_F(update, update_000) 1056 { 1057 rtlDigest aHandle = NULL; 1058 rtlDigestError aError = rtl_digest_update(aHandle, NULL, 0); 1059 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1060 } 1061 1062 TEST_F(update, updateMD2_000) 1063 { 1064 rtlDigest aHandle = NULL; 1065 rtlDigestError aError = rtl_digest_updateMD2(aHandle, NULL, 0); 1066 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1067 } 1068 1069 TEST_F(update, updateMD2_001) 1070 { 1071 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 1072 ASSERT_TRUE(aHandle != 0) << "create with rtl_Digest_AlgorithmMD2"; 1073 1074 rtl::OString aMsg = sSampleString; 1075 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 1076 1077 rtlDigestError aError = rtl_digest_updateMD2(aHandle, NULL, 0); 1078 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "handle parameter 'pData' wrong"; 1079 1080 /* rtlDigestError */ aError = rtl_digest_updateMD2(aHandle, pData, 0); 1081 ASSERT_TRUE(aError == rtl_Digest_E_None) << "handle parameter 'nSize' wrong"; 1082 1083 rtl_digest_destroyMD2(aHandle); 1084 } 1085 TEST_F(update, updateMD5_000) 1086 { 1087 rtlDigest aHandle = NULL; 1088 rtlDigestError aError = rtl_digest_updateMD5(aHandle, NULL, 0); 1089 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1090 } 1091 1092 TEST_F(update, updateMD5_001) 1093 { 1094 // use wrong Algorithm!!! This is volitional! 1095 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 1096 ASSERT_TRUE(aHandle != 0) << "create with rtl_Digest_AlgorithmMD2"; 1097 1098 rtl::OString aMsg = sSampleString; 1099 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 1100 sal_uInt32 nSize = ( aMsg.getLength() ); 1101 1102 rtlDigestError aError = rtl_digest_updateMD5(aHandle, pData, nSize); 1103 ASSERT_TRUE(aError == rtl_Digest_E_Algorithm) << "handle parameter 'handle' wrong"; 1104 1105 rtl_digest_destroyMD5(aHandle); 1106 } 1107 1108 TEST_F(update, updateMD5_002) 1109 { 1110 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 1111 ASSERT_TRUE(aHandle != 0) << "create with rtl_Digest_AlgorithmMD5"; 1112 1113 rtl::OString aMsg = sSampleString; 1114 const sal_uInt8* pData = (const sal_uInt8*)aMsg.getStr(); 1115 1116 rtlDigestError aError = rtl_digest_updateMD5(aHandle, NULL, 0); 1117 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "handle parameter 'pData' wrong"; 1118 1119 /* rtlDigestError */ aError = rtl_digest_updateMD5(aHandle, pData, 0); 1120 ASSERT_TRUE(aError == rtl_Digest_E_None) << "handle parameter 'nSize' wrong"; 1121 1122 rtl_digest_destroyMD5(aHandle); 1123 } 1124 1125 TEST_F(update, updateSHA_000) 1126 { 1127 rtlDigest aHandle = NULL; 1128 rtlDigestError aError = rtl_digest_updateSHA(aHandle, NULL, 0); 1129 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1130 } 1131 1132 TEST_F(update, updateSHA1_000) 1133 { 1134 rtlDigest aHandle = NULL; 1135 rtlDigestError aError = rtl_digest_updateSHA1(aHandle, NULL, 0); 1136 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1137 } 1138 1139 TEST_F(update, updateHMAC_MD5_000) 1140 { 1141 rtlDigest aHandle = NULL; 1142 rtlDigestError aError = rtl_digest_updateHMAC_MD5(aHandle, NULL, 0); 1143 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1144 } 1145 1146 TEST_F(update, updateHMAC_SHA1_000) 1147 { 1148 rtlDigest aHandle = NULL; 1149 rtlDigestError aError = rtl_digest_updateHMAC_SHA1(aHandle, NULL, 0); 1150 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1151 } 1152 1153 // ----------------------------------------------------------------------------- 1154 1155 class get : public ::testing::Test 1156 { 1157 public: 1158 // initialise your test code values here. 1159 void SetUp() 1160 { 1161 } 1162 1163 void TearDown() 1164 { 1165 } 1166 }; // class create 1167 1168 TEST_F(get, get_000) 1169 { 1170 rtlDigest aHandle = NULL; 1171 rtlDigestError aError = rtl_digest_get(aHandle, NULL, 0); 1172 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1173 } 1174 TEST_F(get, getMD5_000) 1175 { 1176 rtlDigest aHandle = NULL; 1177 rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL, 0); 1178 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "does not handle wrong parameter"; 1179 } 1180 TEST_F(get, getMD5_001) 1181 { 1182 // test with wrong algorithm 1183 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD2 ); 1184 ASSERT_TRUE(aHandle != 0) << "create with rtl_Digest_AlgorithmMD2"; 1185 1186 sal_uInt32 nKeyLen = rtl_digest_queryLength( aHandle ); 1187 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 1188 1189 rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL, 0); 1190 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "handle 2. parameter wrong"; 1191 1192 /* rtlDigestError */ aError = rtl_digest_getMD5(aHandle, pKeyBuffer, 0); 1193 ASSERT_TRUE(aError == rtl_Digest_E_Algorithm) << "handle parameter 'handle' wrong"; 1194 1195 rtl_digest_destroyMD2(aHandle); 1196 } 1197 1198 TEST_F(get, getMD5_002) 1199 { 1200 rtlDigest aHandle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 1201 ASSERT_TRUE(aHandle != 0) << "create with rtl_Digest_AlgorithmMD5"; 1202 1203 sal_uInt32 nKeyLen = rtl_digest_queryLength( aHandle ); 1204 sal_uInt8 *pKeyBuffer = new sal_uInt8[ nKeyLen ]; 1205 1206 rtlDigestError aError = rtl_digest_getMD5(aHandle, NULL /* pKeyBuffer */ , nKeyLen); 1207 ASSERT_TRUE(aError == rtl_Digest_E_Argument) << "handle parameter 'pData' wrong"; 1208 1209 /* rtlDigestError */ aError = rtl_digest_getMD5(aHandle, pKeyBuffer, 0); 1210 ASSERT_TRUE(aError == rtl_Digest_E_BufferSize) << "handle parameter 'nSize' wrong"; 1211 1212 rtl_digest_destroyMD5(aHandle); 1213 delete [] pKeyBuffer; 1214 } 1215 // ----------------------------------------------------------------------------- 1216 class destroy : public ::testing::Test 1217 { 1218 public: 1219 // initialise your test code values here. 1220 void SetUp() 1221 { 1222 } 1223 1224 void TearDown() 1225 { 1226 } 1227 }; // class create 1228 1229 TEST_F(destroy, destroy_001) 1230 { 1231 rtlDigest handle = rtl_digest_create( rtl_Digest_AlgorithmMD5 ); 1232 ASSERT_TRUE(handle != 0) << "create with rtl_Digest_AlgorithmMD5"; 1233 1234 // not really testable 1235 // LLA: good will test. 1236 rtl_digest_destroy( handle ); 1237 } 1238 // ----------------------------------------------------------------------------- 1239 1240 } // namespace rtl_digest 1241 1242 int main(int argc, char **argv) 1243 { 1244 ::testing::InitGoogleTest(&argc, argv); 1245 return RUN_ALL_TESTS(); 1246 } 1247