svl/qa/unit/lockfiles/test_lockfiles.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <sal/config.h>
  11
  12 #include <string_view>
  13
  14 #include <cppunit/extensions/HelperMacros.h>
  15 #include <cppunit/plugin/TestPlugIn.h>
  16 #include <test/bootstrapfixture.hxx>
  17
  18 #include <o3tl/cppunittraitshelper.hxx>
  19 #include <unotest/directories.hxx>
  20 #include <svl/lockfilecommon.hxx>
  21 #include <svl/documentlockfile.hxx>
  22 #include <svl/msodocumentlockfile.hxx>
  23 #include <unotools/useroptions.hxx>
  24 #include <tools/stream.hxx>
  25 #include <rtl/strbuf.hxx>
  26 #include <osl/security.hxx>
  27 #include <osl/socket.hxx>
  28 #include <unotools/bootstrap.hxx>
  29
  30 namespace
  31 {
  32 class LockfileTest : public test::BootstrapFixture
  33 {
  34     OUString generateTestURL(std::u16string_view sFileName) const;
  35
  36 public:
  37     void testLOLockFileURL();
  38     void testLOLockFileContent();
  39     void testLOLockFileRT();
  40     void testLOLockFileUnicodeUsername();
  41     void testLOLockFileOverwrite();
  42     void testWordLockFileURL();
  43     void testExcelLockFileURL();
  44     void testPowerPointLockFileURL();
  45     void testWordLockFileContent();
  46     void testExcelLockFileContent();
  47     void testPowerPointLockFileContent();
  48     void testWordLockFileRT();
  49     void testExcelLockFileRT();
  50     void testPowerPointLockFileRT();
  51     void testMSOLockFileLongUserName();
  52     void testMSOLockFileUnicodeUsername();
  53     void testMSOLockFileOverwrite();
  54
  55 private:
  56     CPPUNIT_TEST_SUITE(LockfileTest);
  57     CPPUNIT_TEST(testLOLockFileURL);
  58     CPPUNIT_TEST(testLOLockFileContent);
  59     CPPUNIT_TEST(testLOLockFileRT);
  60     CPPUNIT_TEST(testLOLockFileUnicodeUsername);
  61     CPPUNIT_TEST(testLOLockFileOverwrite);
  62     CPPUNIT_TEST(testWordLockFileURL);
  63     CPPUNIT_TEST(testExcelLockFileURL);
  64     CPPUNIT_TEST(testPowerPointLockFileURL);
  65     CPPUNIT_TEST(testWordLockFileContent);
  66     CPPUNIT_TEST(testExcelLockFileContent);
  67     CPPUNIT_TEST(testPowerPointLockFileContent);
  68     CPPUNIT_TEST(testWordLockFileRT);
  69     CPPUNIT_TEST(testExcelLockFileRT);
  70     CPPUNIT_TEST(testPowerPointLockFileRT);
  71     CPPUNIT_TEST(testMSOLockFileLongUserName);
  72     CPPUNIT_TEST(testMSOLockFileUnicodeUsername);
  73     CPPUNIT_TEST(testMSOLockFileOverwrite);
  74     CPPUNIT_TEST_SUITE_END();
  75 };
  76
  77 OUString readLockFile(const OUString& aSource)
  78 {
  79     SvFileStream aFileStream(aSource, StreamMode::READ);
  80     std::size_t nSize = aFileStream.remainingSize();
  81     std::unique_ptr<sal_Int8[]> pBuffer(new sal_Int8[nSize]);
  82     aFileStream.ReadBytes(pBuffer.get(), nSize);
  83
  84     const css::uno::Sequence<sal_Int8> aData(pBuffer.get(), nSize);
  85     OStringBuffer aResult(static_cast<int>(nSize));
  86     for (sal_Int8 nByte : aData)
  87     {
  88         aResult.append(static_cast<char>(nByte));
  89     }
  90     return OStringToOUString(aResult.makeStringAndClear(), RTL_TEXTENCODING_UTF8);
  91 }
  92
  93 OUString GetLockFileName(const svt::GenDocumentLockFile& rLockFile)
  94 {
  95     INetURLObject aDocURL = svt::LockFileCommon::ResolveLinks(INetURLObject(rLockFile.GetURL()));
  96     return aDocURL.GetLastName();
  97 }
  98
  99 OUString LockfileTest::generateTestURL(std::u16string_view sFileName) const
 100 {
 101     return m_directories.getURLFromWorkdir(u"/CppunitTest/svl_lockfiles.test.user/") + sFileName;
 102 }
 103
 104 void LockfileTest::testLOLockFileURL()
 105 {
 106     // Test the generated file name for LibreOffice lock files
 107     OUString aTestODT = generateTestURL(u"testLOLockFileURL.odt");
 108
 109     svt::DocumentLockFile aLockFile(aTestODT);
 110     CPPUNIT_ASSERT_EQUAL(OUString(".~lock.testLOLockFileURL.odt%23"), GetLockFileName(aLockFile));
 111 }
 112
 113 void LockfileTest::testLOLockFileContent()
 114 {
 115     // Test the lockfile generated for the specified ODT document
 116     OUString aTestODT = generateTestURL(u"testLOLockFileContent.odt");
 117
 118     // Set user name
 119     SvtUserOptions aUserOpt;
 120     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 121     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 122
 123     // Write the lock file and check the content
 124     svt::DocumentLockFile aLockFile(aTestODT);
 125     aLockFile.CreateOwnLockFile();
 126     OUString sLockFileContent(readLockFile(aLockFile.GetURL()));
 127     aLockFile.RemoveFileDirectly();
 128
 129     // User name
 130     sal_Int32 nFirstChar = 0;
 131     sal_Int32 nNextComma = sLockFileContent.indexOf(',', nFirstChar);
 132     OUString sUserName = aUserOpt.GetFirstName() + " " + aUserOpt.GetLastName();
 133     CPPUNIT_ASSERT_EQUAL(sUserName, sLockFileContent.copy(nFirstChar, nNextComma - nFirstChar));
 134
 135     // System user name
 136     nFirstChar = nNextComma + 1;
 137     nNextComma = sLockFileContent.indexOf(',', nFirstChar);
 138     ::osl::Security aSecurity;
 139     OUString sSysUserName;
 140     aSecurity.getUserName(sSysUserName);
 141     CPPUNIT_ASSERT_EQUAL(sSysUserName, sLockFileContent.copy(nFirstChar, nNextComma - nFirstChar));
 142
 143     // Local host
 144     nFirstChar = nNextComma + 1;
 145     nNextComma = sLockFileContent.indexOf(',', nFirstChar);
 146     CPPUNIT_ASSERT_EQUAL(::osl::SocketAddr::getLocalHostname(),
 147                          sLockFileContent.copy(nFirstChar, nNextComma - nFirstChar));
 148
 149     // Skip date and time because it changes after the lock file was created
 150     nFirstChar = nNextComma + 1;
 151     nNextComma = sLockFileContent.indexOf(',', nFirstChar);
 152
 153     // user url
 154     nFirstChar = nNextComma + 1;
 155     OUString aUserInstDir;
 156     ::utl::Bootstrap::locateUserInstallation(aUserInstDir);
 157     CPPUNIT_ASSERT_EQUAL(
 158         aUserInstDir,
 159         sLockFileContent.copy(nFirstChar, sLockFileContent.getLength() - nFirstChar - 1));
 160 }
 161
 162 void LockfileTest::testLOLockFileRT()
 163 {
 164     // Test the lockfile generated for the specified ODT document
 165     OUString aTestODT = generateTestURL(u"testLOLockFileRT.odt");
 166
 167     // Set user name
 168     SvtUserOptions aUserOpt;
 169     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 170     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 171
 172     // Write the lock file and read it back
 173     svt::DocumentLockFile aLockFile(aTestODT);
 174     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 175     aLockFile.CreateOwnLockFile();
 176     LockFileEntry aRTEntry = aLockFile.GetLockData();
 177
 178     // Check whether the lock file attributes are the same
 179     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 180                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 181     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::SYSUSERNAME],
 182                          aRTEntry[LockFileComponent::SYSUSERNAME]);
 183     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::LOCALHOST],
 184                          aRTEntry[LockFileComponent::LOCALHOST]);
 185     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::USERURL],
 186                          aRTEntry[LockFileComponent::USERURL]);
 187     // LockFileComponent::EDITTIME can change
 188
 189     aLockFile.RemoveFileDirectly();
 190 }
 191
 192 void LockfileTest::testLOLockFileUnicodeUsername()
 193 {
 194     // Test the lockfile generated for the specified ODT document
 195     OUString aTestODT = generateTestURL(u"testLOLockFileUnicodeUsername.odt");
 196
 197     // Set user name
 198     SvtUserOptions aUserOpt;
 199     sal_Unicode vFirstName[] = { 2351, 2676, 3117, 5279 };
 200     aUserOpt.SetToken(UserOptToken::FirstName, OUString(vFirstName, 4));
 201     sal_Unicode vLastName[] = { 671, 1245, 1422, 1822 };
 202     aUserOpt.SetToken(UserOptToken::LastName, OUString(vLastName, 4));
 203
 204     // Write the lock file and read it back
 205     svt::DocumentLockFile aLockFile(aTestODT);
 206     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 207     aLockFile.CreateOwnLockFile();
 208     LockFileEntry aRTEntry = aLockFile.GetLockData();
 209
 210     // Check whether the lock file attributes are the same
 211     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 212                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 213     CPPUNIT_ASSERT_EQUAL(OUString(aUserOpt.GetFirstName() + " " + aUserOpt.GetLastName()),
 214                          aOrigEntry[LockFileComponent::OOOUSERNAME]);
 215
 216     aLockFile.RemoveFileDirectly();
 217 }
 218
 219 void LockfileTest::testLOLockFileOverwrite()
 220 {
 221     OUString aTestODT = generateTestURL(u"testLOLockFileOverwrite.odt");
 222
 223     // Set user name
 224     SvtUserOptions aUserOpt;
 225     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 226     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 227
 228     // Write the lock file and read it back
 229     svt::DocumentLockFile aLockFile(aTestODT);
 230     aLockFile.CreateOwnLockFile();
 231
 232     // Change user name
 233     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile2");
 234     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 235
 236     // Overwrite lockfile
 237     svt::DocumentLockFile aLockFile2(aTestODT);
 238     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 239     aLockFile2.OverwriteOwnLockFile();
 240
 241     LockFileEntry aRTEntry = aLockFile.GetLockData();
 242
 243     // Check whether the lock file attributes are the same
 244     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 245                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 246     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::SYSUSERNAME],
 247                          aRTEntry[LockFileComponent::SYSUSERNAME]);
 248     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::LOCALHOST],
 249                          aRTEntry[LockFileComponent::LOCALHOST]);
 250     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::USERURL],
 251                          aRTEntry[LockFileComponent::USERURL]);
 252
 253     aLockFile2.RemoveFileDirectly();
 254 }
 255
 256 void LockfileTest::testWordLockFileURL()
 257 {
 258     // Test the generated file name for Word lock files
 259
 260     // Word specific file format
 261     {
 262         OUString aTestFile = generateTestURL(u"testWordLockFileURL.docx");
 263         svt::MSODocumentLockFile aLockFile(aTestFile);
 264         CPPUNIT_ASSERT_EQUAL(OUString("~$stWordLockFileURL.docx"), GetLockFileName(aLockFile));
 265     }
 266
 267     // Eight character file name (cuts two characters)
 268     {
 269         OUString aTestFile = generateTestURL(u"12345678.docx");
 270         svt::MSODocumentLockFile aLockFile(aTestFile);
 271         CPPUNIT_ASSERT_EQUAL(OUString("~$345678.docx"), GetLockFileName(aLockFile));
 272     }
 273
 274     // Seven character file name (cuts one character)
 275     {
 276         OUString aTestFile = generateTestURL(u"1234567.docx");
 277         svt::MSODocumentLockFile aLockFile(aTestFile);
 278         CPPUNIT_ASSERT_EQUAL(OUString("~$234567.docx"), GetLockFileName(aLockFile));
 279     }
 280
 281     // Six character file name (cuts no character)
 282     {
 283         OUString aTestFile = generateTestURL(u"123456.docx");
 284         svt::MSODocumentLockFile aLockFile(aTestFile);
 285         CPPUNIT_ASSERT_EQUAL(OUString("~$123456.docx"), GetLockFileName(aLockFile));
 286     }
 287
 288     // One character file name
 289     {
 290         OUString aTestFile = generateTestURL(u"1.docx");
 291         svt::MSODocumentLockFile aLockFile(aTestFile);
 292         CPPUNIT_ASSERT_EQUAL(OUString("~$1.docx"), GetLockFileName(aLockFile));
 293     }
 294
 295     // Test for ODT format
 296     {
 297         OUString aTestFile = generateTestURL(u"12345678.odt");
 298         svt::MSODocumentLockFile aLockFile(aTestFile);
 299         CPPUNIT_ASSERT_EQUAL(OUString("~$345678.odt"), GetLockFileName(aLockFile));
 300     }
 301
 302     // Test for DOC format
 303     {
 304         OUString aTestFile = generateTestURL(u"12345678.doc");
 305         svt::MSODocumentLockFile aLockFile(aTestFile);
 306         CPPUNIT_ASSERT_EQUAL(OUString("~$345678.doc"), GetLockFileName(aLockFile));
 307     }
 308
 309     // Test for RTF format
 310     {
 311         OUString aTestFile = generateTestURL(u"12345678.rtf");
 312         svt::MSODocumentLockFile aLockFile(aTestFile);
 313         CPPUNIT_ASSERT_EQUAL(OUString("~$345678.rtf"), GetLockFileName(aLockFile));
 314     }
 315 }
 316
 317 void LockfileTest::testExcelLockFileURL()
 318 {
 319     // Test the generated file name for Excel lock files
 320     {
 321         OUString aTestFile = generateTestURL(u"testExcelLockFileURL.xlsx");
 322         svt::MSODocumentLockFile aLockFile(aTestFile);
 323         CPPUNIT_ASSERT_EQUAL(OUString("~$testExcelLockFileURL.xlsx"), GetLockFileName(aLockFile));
 324     }
 325
 326     // Eight character file name
 327     {
 328         OUString aTestFile = generateTestURL(u"12345678.xlsx");
 329         svt::MSODocumentLockFile aLockFile(aTestFile);
 330         CPPUNIT_ASSERT_EQUAL(OUString("~$12345678.xlsx"), GetLockFileName(aLockFile));
 331     }
 332
 333     // One character file name
 334     {
 335         OUString aTestFile = generateTestURL(u"1.xlsx");
 336         svt::MSODocumentLockFile aLockFile(aTestFile);
 337         CPPUNIT_ASSERT_EQUAL(OUString("~$1.xlsx"), GetLockFileName(aLockFile));
 338     }
 339
 340     // Test for ODS format
 341     {
 342         OUString aTestFile = generateTestURL(u"12345678.ods");
 343         svt::MSODocumentLockFile aLockFile(aTestFile);
 344         CPPUNIT_ASSERT_EQUAL(OUString("~$12345678.ods"), GetLockFileName(aLockFile));
 345     }
 346 }
 347
 348 void LockfileTest::testPowerPointLockFileURL()
 349 {
 350     // Test the generated file name for PowerPoint lock files
 351     {
 352         OUString aTestFile = generateTestURL(u"testPowerPointLockFileURL.pptx");
 353         svt::MSODocumentLockFile aLockFile(aTestFile);
 354         CPPUNIT_ASSERT_EQUAL(OUString("~$testPowerPointLockFileURL.pptx"),
 355                              GetLockFileName(aLockFile));
 356     }
 357
 358     // Eight character file name
 359     {
 360         OUString aTestFile = generateTestURL(u"12345678.pptx");
 361         svt::MSODocumentLockFile aLockFile(aTestFile);
 362         CPPUNIT_ASSERT_EQUAL(OUString("~$12345678.pptx"), GetLockFileName(aLockFile));
 363     }
 364
 365     // One character file name
 366     {
 367         OUString aTestFile = generateTestURL(u"1.pptx");
 368         svt::MSODocumentLockFile aLockFile(aTestFile);
 369         CPPUNIT_ASSERT_EQUAL(OUString("~$1.pptx"), GetLockFileName(aLockFile));
 370     }
 371
 372     // Test for PPT format
 373     {
 374         OUString aTestFile = generateTestURL(u"12345678.ppt");
 375         svt::MSODocumentLockFile aLockFile(aTestFile);
 376         CPPUNIT_ASSERT_EQUAL(OUString("~$12345678.ppt"), GetLockFileName(aLockFile));
 377     }
 378
 379     // Test for ODP format
 380     {
 381         OUString aTestFile = generateTestURL(u"/12345678.odp");
 382         svt::MSODocumentLockFile aLockFile(aTestFile);
 383         CPPUNIT_ASSERT_EQUAL(OUString("~$12345678.odp"), GetLockFileName(aLockFile));
 384     }
 385 }
 386
 387 void LockfileTest::testWordLockFileContent()
 388 {
 389     // Test the lockfile generated for the specified DOCX document
 390     OUString aTestFile = generateTestURL(u"testWordLockFileContent.docx");
 391
 392     // Set user name
 393     SvtUserOptions aUserOpt;
 394     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 395     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 396
 397     // Write the lock file and check the content
 398     svt::MSODocumentLockFile aLockFile(aTestFile);
 399     aLockFile.CreateOwnLockFile();
 400     OUString sLockFileContent(readLockFile(aLockFile.GetURL()));
 401     aLockFile.RemoveFileDirectly();
 402
 403     // First character is the size of the user name
 404     OUString sUserName = aUserOpt.GetFirstName() + " " + aUserOpt.GetLastName();
 405     int nIndex = 0;
 406     CPPUNIT_ASSERT_EQUAL(sUserName.getLength(), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 407
 408     // Then we have the user name
 409     CPPUNIT_ASSERT_EQUAL(sUserName, sLockFileContent.copy(1, sUserName.getLength()));
 410
 411     // We have some filling 0 bytes after the user name
 412     for (nIndex = sUserName.getLength() + 1; nIndex < MSO_USERNAME_MAX_LENGTH + 2; ++nIndex)
 413     {
 414         CPPUNIT_ASSERT_EQUAL(sal_Int32(0), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 415     }
 416
 417     // Then we have the user name's length again
 418     CPPUNIT_ASSERT_EQUAL(sUserName.getLength(), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 419
 420     // Then we have the user name again with 16 bit coding
 421     for (int i = 0; i < sUserName.getLength(); ++i)
 422     {
 423         CPPUNIT_ASSERT_EQUAL(
 424             sUserName[i],
 425             static_cast<sal_Unicode>(static_cast<sal_Int16>(sLockFileContent[55 + i * 2])
 426                                      + static_cast<sal_Int16>(sLockFileContent[55 + i * 2 + 1])));
 427     }
 428
 429     // We have some filling 0 bytes after the user name
 430     for (nIndex += sUserName.getLength() * 2 + 1; nIndex < MSO_WORD_LOCKFILE_SIZE; ++nIndex)
 431     {
 432         CPPUNIT_ASSERT_EQUAL(sal_Int32(0), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 433     }
 434
 435     // We have a fixed size lock file
 436     CPPUNIT_ASSERT_EQUAL(sal_Int32(MSO_WORD_LOCKFILE_SIZE), sLockFileContent.getLength());
 437 }
 438
 439 void LockfileTest::testExcelLockFileContent()
 440 {
 441     // Test the lockfile generated for the specified XLSX document
 442     OUString aTestFile = generateTestURL(u"testExcelLockFileContent.xlsx");
 443
 444     // Set user name
 445     SvtUserOptions aUserOpt;
 446     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 447     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 448
 449     // Write the lock file and check the content
 450     svt::MSODocumentLockFile aLockFile(aTestFile);
 451     aLockFile.CreateOwnLockFile();
 452     OUString sLockFileContent(readLockFile(aLockFile.GetURL()));
 453     aLockFile.RemoveFileDirectly();
 454
 455     // First character is the size of the user name
 456     OUString sUserName = aUserOpt.GetFirstName() + " " + aUserOpt.GetLastName();
 457     int nIndex = 0;
 458     CPPUNIT_ASSERT_EQUAL(sUserName.getLength(), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 459
 460     // Then we have the user name
 461     CPPUNIT_ASSERT_EQUAL(sUserName, sLockFileContent.copy(1, sUserName.getLength()));
 462
 463     // We have some filling 0x20 bytes after the user name
 464     for (nIndex = sUserName.getLength() + 1; nIndex < MSO_USERNAME_MAX_LENGTH + 3; ++nIndex)
 465     {
 466         CPPUNIT_ASSERT_EQUAL(sal_Int32(0x20), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 467     }
 468
 469     // Then we have the user name's length again
 470     CPPUNIT_ASSERT_EQUAL(sUserName.getLength(), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 471
 472     // Then we have the user name again with 16 bit coding
 473     for (int i = 0; i < sUserName.getLength(); ++i)
 474     {
 475         CPPUNIT_ASSERT_EQUAL(
 476             sUserName[i],
 477             static_cast<sal_Unicode>(static_cast<sal_Int16>(sLockFileContent[56 + i * 2])
 478                                      + static_cast<sal_Int16>(sLockFileContent[56 + i * 2 + 1])));
 479     }
 480
 481     // We have some filling 0 and 0x20 bytes after the user name
 482     for (nIndex += sUserName.getLength() * 2 + 2; nIndex < MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE;
 483          nIndex += 2)
 484     {
 485         CPPUNIT_ASSERT_EQUAL(sal_Int32(0x20), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 486         if (nIndex + 1 < MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE)
 487             CPPUNIT_ASSERT_EQUAL(sal_Int32(0),
 488                                  static_cast<sal_Int32>(sLockFileContent[nIndex + 1]));
 489     }
 490
 491     // We have a fixed size lock file
 492     CPPUNIT_ASSERT_EQUAL(sal_Int32(MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE),
 493                          sLockFileContent.getLength());
 494 }
 495
 496 void LockfileTest::testPowerPointLockFileContent()
 497 {
 498     // Test the lockfile generated for the specified PPTX document
 499     OUString aTestFile = generateTestURL(u"testPowerPointLockFileContent.pptx");
 500
 501     // Set user name
 502     SvtUserOptions aUserOpt;
 503     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 504     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 505
 506     // Write the lock file and check the content
 507     svt::MSODocumentLockFile aLockFile(aTestFile);
 508     aLockFile.CreateOwnLockFile();
 509     OUString sLockFileContent(readLockFile(aLockFile.GetURL()));
 510     aLockFile.RemoveFileDirectly();
 511
 512     // First character is the size of the user name
 513     OUString sUserName = aUserOpt.GetFirstName() + " " + aUserOpt.GetLastName();
 514     int nIndex = 0;
 515     CPPUNIT_ASSERT_EQUAL(sUserName.getLength(), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 516
 517     // Then we have the user name
 518     CPPUNIT_ASSERT_EQUAL(sUserName, sLockFileContent.copy(1, sUserName.getLength()));
 519
 520     // We have some filling bytes after the user name
 521     nIndex = sUserName.getLength() + 1;
 522     CPPUNIT_ASSERT_EQUAL(sal_Int32(0), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 523     for (nIndex += 1; nIndex < MSO_USERNAME_MAX_LENGTH + 3; ++nIndex)
 524     {
 525         CPPUNIT_ASSERT_EQUAL(sal_Int32(0x20), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 526     }
 527
 528     // Then we have the user name's length again
 529     CPPUNIT_ASSERT_EQUAL(sUserName.getLength(), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 530
 531     // Then we have the user name again with 16 bit coding
 532     for (int i = 0; i < sUserName.getLength(); ++i)
 533     {
 534         CPPUNIT_ASSERT_EQUAL(
 535             sUserName[i],
 536             static_cast<sal_Unicode>(static_cast<sal_Int16>(sLockFileContent[56 + i * 2])
 537                                      + static_cast<sal_Int16>(sLockFileContent[56 + i * 2 + 1])));
 538     }
 539
 540     // We have some filling 0 and 0x20 bytes after the user name
 541     for (nIndex += sUserName.getLength() * 2 + 2; nIndex < MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE;
 542          nIndex += 2)
 543     {
 544         CPPUNIT_ASSERT_EQUAL(sal_Int32(0x20), static_cast<sal_Int32>(sLockFileContent[nIndex]));
 545         if (nIndex + 1 < MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE)
 546             CPPUNIT_ASSERT_EQUAL(sal_Int32(0),
 547                                  static_cast<sal_Int32>(sLockFileContent[nIndex + 1]));
 548     }
 549
 550     // We have a fixed size lock file
 551     CPPUNIT_ASSERT_EQUAL(sal_Int32(MSO_EXCEL_AND_POWERPOINT_LOCKFILE_SIZE),
 552                          sLockFileContent.getLength());
 553 }
 554
 555 void LockfileTest::testWordLockFileRT()
 556 {
 557     OUString aTestODT = generateTestURL(u"testWordLockFileRT.docx");
 558
 559     // Set user name
 560     SvtUserOptions aUserOpt;
 561     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 562     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 563
 564     // Write the lock file and read it back
 565     svt::MSODocumentLockFile aLockFile(aTestODT);
 566     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 567     aLockFile.CreateOwnLockFile();
 568     LockFileEntry aRTEntry = aLockFile.GetLockData();
 569     aLockFile.RemoveFileDirectly();
 570
 571     // Check whether the lock file attributes are the same
 572     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 573                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 574 }
 575
 576 void LockfileTest::testExcelLockFileRT()
 577 {
 578     OUString aTestODT = generateTestURL(u"testExcelLockFileRT.xlsx");
 579
 580     // Set user name
 581     SvtUserOptions aUserOpt;
 582     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 583     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 584
 585     // Write the lock file and read it back
 586     svt::MSODocumentLockFile aLockFile(aTestODT);
 587     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 588     aLockFile.CreateOwnLockFile();
 589     LockFileEntry aRTEntry = aLockFile.GetLockData();
 590     aLockFile.RemoveFileDirectly();
 591
 592     // Check whether the lock file attributes are the same
 593     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 594                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 595 }
 596
 597 void LockfileTest::testPowerPointLockFileRT()
 598 {
 599     OUString aTestODT = generateTestURL(u"testPowerPointLockFileRT.pptx");
 600
 601     // Set user name
 602     SvtUserOptions aUserOpt;
 603     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 604     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 605
 606     // Write the lock file and read it back
 607     svt::MSODocumentLockFile aLockFile(aTestODT);
 608     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 609     aLockFile.CreateOwnLockFile();
 610     LockFileEntry aRTEntry = aLockFile.GetLockData();
 611     aLockFile.RemoveFileDirectly();
 612
 613     // Check whether the lock file attributes are the same
 614     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 615                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 616 }
 617
 618 void LockfileTest::testMSOLockFileLongUserName()
 619 {
 620     OUString aTestODT = generateTestURL(u"testMSOLockFileLongUserName.docx");
 621
 622     // Set user name
 623     SvtUserOptions aUserOpt;
 624     aUserOpt.SetToken(UserOptToken::FirstName,
 625                       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
 626     aUserOpt.SetToken(UserOptToken::LastName,
 627                       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
 628
 629     // Write the lock file and read it back
 630     svt::MSODocumentLockFile aLockFile(aTestODT);
 631     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 632     aLockFile.CreateOwnLockFile();
 633     LockFileEntry aRTEntry = aLockFile.GetLockData();
 634
 635     // Check whether the user name was cut to the maximum length
 636     CPPUNIT_ASSERT_EQUAL(
 637         aOrigEntry[LockFileComponent::OOOUSERNAME].copy(0, MSO_USERNAME_MAX_LENGTH),
 638         aRTEntry[LockFileComponent::OOOUSERNAME]);
 639
 640     aLockFile.RemoveFileDirectly();
 641 }
 642
 643 void LockfileTest::testMSOLockFileUnicodeUsername()
 644 {
 645     // Test the lockfile generated for the specified ODT document
 646     OUString aTestODT = generateTestURL(u"testMSOLockFileUnicodeUsername.docx");
 647
 648     // Set user name
 649     SvtUserOptions aUserOpt;
 650     sal_Unicode vFirstName[] = { 2351, 2676, 3117, 5279 };
 651     aUserOpt.SetToken(UserOptToken::FirstName, OUString(vFirstName, 4));
 652     sal_Unicode vLastName[] = { 671, 1245, 1422, 1822 };
 653     aUserOpt.SetToken(UserOptToken::LastName, OUString(vLastName, 4));
 654
 655     // Write the lock file and read it back
 656     svt::DocumentLockFile aLockFile(aTestODT);
 657     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 658     aLockFile.CreateOwnLockFile();
 659     LockFileEntry aRTEntry = aLockFile.GetLockData();
 660
 661     // Check whether the user name is the same
 662     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 663                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 664     CPPUNIT_ASSERT_EQUAL(OUString(aUserOpt.GetFirstName() + " " + aUserOpt.GetLastName()),
 665                          aOrigEntry[LockFileComponent::OOOUSERNAME]);
 666
 667     aLockFile.RemoveFileDirectly();
 668 }
 669
 670 void LockfileTest::testMSOLockFileOverwrite()
 671 {
 672     OUString aTestODT = generateTestURL(u"testMSOLockFileOverwrite.docx");
 673
 674     // Set user name
 675     SvtUserOptions aUserOpt;
 676     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile");
 677     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 678
 679     // Write the lock file and read it back
 680     svt::MSODocumentLockFile aLockFile(aTestODT);
 681     aLockFile.CreateOwnLockFile();
 682
 683     // Change user name
 684     aUserOpt.SetToken(UserOptToken::FirstName, "LockFile2");
 685     aUserOpt.SetToken(UserOptToken::LastName, "Test");
 686
 687     // Overwrite lockfile
 688     svt::MSODocumentLockFile aLockFile2(aTestODT);
 689     LockFileEntry aOrigEntry = svt::LockFileCommon::GenerateOwnEntry();
 690     aLockFile2.OverwriteOwnLockFile();
 691
 692     LockFileEntry aRTEntry = aLockFile.GetLockData();
 693
 694     // Check whether the lock file attributes are the same
 695     CPPUNIT_ASSERT_EQUAL(aOrigEntry[LockFileComponent::OOOUSERNAME],
 696                          aRTEntry[LockFileComponent::OOOUSERNAME]);
 697
 698     aLockFile2.RemoveFileDirectly();
 699 }
 700
 701 CPPUNIT_TEST_SUITE_REGISTRATION(LockfileTest);
 702 } // namespace
 703
 704 CPPUNIT_PLUGIN_IMPLEMENT();
 705
 706 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */