package/qa/storages/RegressionTest_i30400.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package complex.storages;
  20
  21 import com.sun.star.uno.XInterface;
  22 import com.sun.star.lang.XMultiServiceFactory;
  23 import com.sun.star.lang.XSingleServiceFactory;
  24
  25 import com.sun.star.bridge.XUnoUrlResolver;
  26 import com.sun.star.uno.UnoRuntime;
  27 import com.sun.star.uno.XInterface;
  28 import com.sun.star.io.XStream;
  29 import com.sun.star.io.XInputStream;
  30
  31 import com.sun.star.embed.*;
  32
  33 import share.LogWriter;
  34 import complex.storages.TestHelper;
  35 import complex.storages.StorageTest;
  36
  37 public class RegressionTest_i30400 implements StorageTest {
  38
  39     XMultiServiceFactory m_xMSF;
  40     XSingleServiceFactory m_xStorageFactory;
  41     TestHelper m_aTestHelper;
  42
  43     public RegressionTest_i30400( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter )
  44     {
  45         m_xMSF = xMSF;
  46         m_xStorageFactory = xStorageFactory;
  47         m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i30400: " );
  48     }
  49
  50     public boolean test()
  51     {
  52         try
  53         {
  54
  55             // create a temporary stream and a storage based on it
  56             // fill the storage with the data that will be used for testing
  57
  58
  59             XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF );
  60             if ( xTempFileStream == null )
  61                 return false;
  62
  63             // create storage based on the temporary stream
  64             Object pArgs[] = new Object[2];
  65             pArgs[0] = (Object) xTempFileStream;
  66             pArgs[1] = Integer.valueOf( ElementModes.WRITE );
  67             byte pBytes1[] = { 1, 1, 1, 1, 1 };
  68             String pPass1 = "1, 2, 3, 4, 5";
  69
  70             Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
  71             XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
  72             if ( xTempStorage == null )
  73             {
  74                 m_aTestHelper.Error( "Can't create temporary storage representation!" );
  75                 return false;
  76             }
  77
  78             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  79             if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "Stream1", "MediaType1", true, pBytes1 ) )
  80                 return false;
  81
  82             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  83             if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "EncrStream1", "MediaType2", true, pBytes1, pPass1 ) )
  84                 return false;
  85
  86
  87             // open a new substorage
  88             XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage,
  89                                                                     "SubStorage1",
  90                                                                     ElementModes.WRITE );
  91             if ( xTempSubStorage == null )
  92             {
  93                 m_aTestHelper.Error( "Can't create substorage!" );
  94                 return false;
  95             }
  96
  97             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  98             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType3", true, pBytes1 ) )
  99                 return false;
 100
 101             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
 102             if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "SubEncrStream1", "MediaType4", true, pBytes1, pPass1 ) )
 103                 return false;
 104
 105             // open a new substorage in the existing substorage
 106             XStorage xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage,
 107                                                                         "SubSubStorage1",
 108                                                                         ElementModes.WRITE );
 109             if ( xTempSubStorage == null )
 110             {
 111                 m_aTestHelper.Error( "Can't create substorage!" );
 112                 return false;
 113             }
 114
 115             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
 116             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubSubStream1", "MediaType5", true, pBytes1 ) )
 117                 return false;
 118
 119             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 120             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubSubStorage,
 121                                                             "MediaType6",
 122                                                             false,
 123                                                             ElementModes.WRITE ) )
 124                 return false;
 125
 126
 127             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 128             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage,
 129                                                             "MediaType7",
 130                                                             false,
 131                                                             ElementModes.WRITE ) )
 132                 return false;
 133
 134             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 135             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage,
 136                                                             "MediaType8",
 137                                                             true,
 138                                                             ElementModes.WRITE ) )
 139                 return false;
 140
 141
 142             // check the copying with renaming
 143
 144
 145             if ( !TestCopyWithRenaming( xTempStorage, xTempSubStorage, xTempSubSubStorage ) )
 146                 return false;
 147
 148
 149             // commit the storages
 150
 151
 152             // commit lowlevel substorage
 153             if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) )
 154                 return false;
 155
 156             // commit substorage
 157             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
 158                 return false;
 159
 160             // commit the root storage so the contents must be stored now
 161             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
 162                 return false;
 163
 164
 165             // dispose the storages
 166
 167
 168             // dispose lowerest substorage
 169             if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) )
 170                 return false;
 171
 172             // dispose substorage
 173             if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
 174                 return false;
 175
 176             // dispose the temporary storage
 177             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
 178                 return false;
 179
 180
 181             // reopen the target storage readonly, and check the copying with renaming
 182
 183
 184             pArgs[1] = Integer.valueOf( ElementModes.READ );
 185             oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
 186             xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
 187             if ( xTempStorage == null )
 188             {
 189                 m_aTestHelper.Error( "Can't create temporary storage representation!" );
 190                 return false;
 191             }
 192
 193             // open the substorages
 194
 195             xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage,
 196                                                             "SubStorage1",
 197                                                             ElementModes.READ );
 198             if ( xTempSubStorage == null )
 199             {
 200                 m_aTestHelper.Error( "Can't create substorage!" );
 201                 return false;
 202             }
 203
 204             // open the lowlevel substorages
 205
 206             xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage,
 207                                                                 "SubSubStorage1",
 208                                                                 ElementModes.READ );
 209             if ( xTempSubSubStorage == null )
 210             {
 211                 m_aTestHelper.Error( "Can't create substorage!" );
 212                 return false;
 213             }
 214
 215             // test the copying with renaming
 216             if ( !TestCopyWithRenaming( xTempStorage, xTempSubStorage, xTempSubSubStorage ) )
 217                 return false;
 218
 219
 220             // the storage is based on the temporary stream so it can be left undisposed, since it does not lock
 221             // any resource, later the garbage collector will release the object and it must die by refcount
 222
 223             return true;
 224         }
 225         catch( Exception e )
 226         {
 227             m_aTestHelper.Error( "Exception: " + e );
 228             return false;
 229         }
 230     }
 231
 232
 233     public boolean TestCopyWithRenaming( XStorage xTempStorage, XStorage xTempSubStorage, XStorage xTempSubSubStorage )
 234         throws com.sun.star.uno.Exception
 235     {
 236
 237         // create a second temporary stream and copy all the staff there
 238         // with renaming, check the success
 239
 240
 241         XStream xTempFileStream2 = m_aTestHelper.CreateTempFileStream( m_xMSF );
 242         if ( xTempFileStream2 == null )
 243             return false;
 244
 245         Object pArgs[] = new Object[2];
 246         pArgs[0] = (Object) xTempFileStream2;
 247         pArgs[1] = Integer.valueOf( ElementModes.WRITE );
 248         byte pBytes1[] = { 1, 1, 1, 1, 1 };
 249         String pPass1 = "1, 2, 3, 4, 5";
 250
 251         Object oTempStorage2 = m_xStorageFactory.createInstanceWithArguments( pArgs );
 252         XStorage xTempStorage2 = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage2 );
 253         if ( xTempStorage2 == null )
 254         {
 255             m_aTestHelper.Error( "Can't create temporary storage representation!" );
 256             return false;
 257         }
 258
 259         // open a new substorage
 260         XStorage xTempSubStorage2 = m_aTestHelper.openSubStorage( xTempStorage2,
 261                                                                 "SubStorage1_target",
 262                                                                 ElementModes.WRITE );
 263         if ( xTempSubStorage2 == null )
 264         {
 265             m_aTestHelper.Error( "Can't create substorage!" );
 266             return false;
 267         }
 268
 269         // open a new substorage in the existing substorage
 270         XStorage xTempSubSubStorage2 = m_aTestHelper.openSubStorage( xTempSubStorage2,
 271                                                                     "SubSubStorage1_target",
 272                                                                     ElementModes.WRITE );
 273         if ( xTempSubSubStorage2 == null )
 274         {
 275             m_aTestHelper.Error( "Can't create substorage!" );
 276             return false;
 277         }
 278
 279         // make a copy with renaming on lowerest level
 280         if ( !m_aTestHelper.copyElementTo( xTempSubSubStorage, "SubSubStream1", xTempSubSubStorage2, "SubSubStream1_renamed" ) )
 281             return false;
 282
 283         // make a copy with renaming on the next level
 284
 285         if ( !m_aTestHelper.copyElementTo( xTempSubStorage, "SubStream1", xTempSubStorage2, "SubStream1_renamed" ) )
 286             return false;
 287
 288         if ( !m_aTestHelper.copyElementTo( xTempSubStorage, "SubEncrStream1", xTempSubStorage2, "SubEncrStream1_renamed" ) )
 289             return false;
 290
 291         if ( !m_aTestHelper.copyElementTo( xTempSubStorage, "SubSubStorage1", xTempSubStorage2, "SubSubStorage1_renamed" ) )
 292             return false;
 293
 294         // make a copy with renaming of subelements of the root storage
 295
 296         if ( !m_aTestHelper.copyElementTo( xTempStorage, "Stream1", xTempStorage2, "Stream1_renamed" ) )
 297             return false;
 298
 299         if ( !m_aTestHelper.copyElementTo( xTempStorage, "EncrStream1", xTempStorage2, "EncrStream1_renamed" ) )
 300             return false;
 301
 302         if ( !m_aTestHelper.copyElementTo( xTempStorage, "SubStorage1", xTempStorage2, "SubStorage1_renamed" ) )
 303             return false;
 304
 305
 306         // commit the storages, and check the renaming in all stages
 307
 308
 309         // commit substorage to let the renaming take place
 310         if ( !m_aTestHelper.commitStorage( xTempSubSubStorage2 ) )
 311             return false;
 312
 313         // commit substorage to let the renaming take place
 314         if ( !m_aTestHelper.commitStorage( xTempSubStorage2 ) )
 315             return false;
 316
 317         // commit the root storage so the contents must be stored now
 318         if ( !m_aTestHelper.commitStorage( xTempStorage2 ) )
 319             return false;
 320
 321
 322         // dispose the storages
 323
 324
 325         // dispose lowerest substorage
 326         if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage2 ) )
 327             return false;
 328
 329         // dispose substorage
 330         if ( !m_aTestHelper.disposeStorage( xTempSubStorage2 ) )
 331             return false;
 332
 333         // dispose the temporary storage
 334         if ( !m_aTestHelper.disposeStorage( xTempStorage2 ) )
 335             return false;
 336
 337
 338         // reopen the target storage readonly, and check the contents
 339
 340
 341         pArgs[1] = Integer.valueOf( ElementModes.READ );
 342         oTempStorage2 = m_xStorageFactory.createInstanceWithArguments( pArgs );
 343         xTempStorage2 = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage2 );
 344         if ( xTempStorage2 == null )
 345         {
 346             m_aTestHelper.Error( "Can't create temporary storage representation!" );
 347             return false;
 348         }
 349
 350         // open the substorages
 351
 352         XStorage xTempSubStorage2_target = m_aTestHelper.openSubStorage( xTempStorage2,
 353                                                                 "SubStorage1_target",
 354                                                                 ElementModes.READ );
 355         if ( xTempSubStorage2_target == null )
 356         {
 357             m_aTestHelper.Error( "Can't create substorage!" );
 358             return false;
 359         }
 360
 361         XStorage xTempSubStorage2_renamed = m_aTestHelper.openSubStorage( xTempStorage2,
 362                                                                 "SubStorage1_renamed",
 363                                                                 ElementModes.READ );
 364         if ( xTempSubStorage2_renamed == null )
 365         {
 366             m_aTestHelper.Error( "Can't create substorage!" );
 367             return false;
 368         }
 369
 370         // open the lowlevel substorages
 371
 372         XStorage xTempSubSubStorage2_inRenamed = m_aTestHelper.openSubStorage( xTempSubStorage2_renamed,
 373                                                                                 "SubSubStorage1",
 374                                                                                 ElementModes.READ );
 375         if ( xTempSubSubStorage2_inRenamed == null )
 376         {
 377             m_aTestHelper.Error( "Can't create substorage!" );
 378             return false;
 379         }
 380
 381         XStorage xTempSubSubStorage2_renamed = m_aTestHelper.openSubStorage( xTempSubStorage2_target,
 382                                                                             "SubSubStorage1_renamed",
 383                                                                             ElementModes.READ );
 384         if ( xTempSubSubStorage2_renamed == null )
 385         {
 386             m_aTestHelper.Error( "Can't create substorage!" );
 387             return false;
 388         }
 389
 390         XStorage xTempSubSubStorage2_target = m_aTestHelper.openSubStorage( xTempSubStorage2_target,
 391                                                                             "SubSubStorage1_target",
 392                                                                             ElementModes.READ );
 393         if ( xTempSubSubStorage2_target == null )
 394         {
 395             m_aTestHelper.Error( "Can't create substorage!" );
 396             return false;
 397         }
 398
 399         // check the storages
 400
 401         if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage2_inRenamed, "MediaType6", false, ElementModes.READ ) )
 402             return false;
 403
 404         if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage2_renamed, "MediaType6", false, ElementModes.READ ) )
 405             return false;
 406
 407         if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage2_renamed, "MediaType7", false, ElementModes.READ ) )
 408             return false;
 409
 410
 411         // check the streams
 412
 413
 414         // sub sub level
 415
 416         if ( !m_aTestHelper.checkStream( xTempSubSubStorage2_inRenamed, "SubSubStream1", "MediaType5", true, pBytes1 ) )
 417             return false;
 418
 419         if ( !m_aTestHelper.checkStream( xTempSubSubStorage2_renamed, "SubSubStream1", "MediaType5", true, pBytes1 ) )
 420             return false;
 421
 422         if ( !m_aTestHelper.checkStream( xTempSubSubStorage2_target, "SubSubStream1_renamed", "MediaType5", true, pBytes1 ) )
 423             return false;
 424
 425         // sub level
 426
 427         if ( !m_aTestHelper.checkStream( xTempSubStorage2_renamed, "SubStream1", "MediaType3", true, pBytes1 ) )
 428             return false;
 429
 430         if ( !m_aTestHelper.checkEncrStream( xTempSubStorage2_renamed, "SubEncrStream1", "MediaType4", pBytes1, pPass1 ) )
 431             return false;
 432
 433         if ( !m_aTestHelper.checkStream( xTempSubStorage2_target, "SubStream1_renamed", "MediaType3", true, pBytes1 ) )
 434             return false;
 435
 436         if ( !m_aTestHelper.checkEncrStream( xTempSubStorage2_target, "SubEncrStream1_renamed", "MediaType4", pBytes1, pPass1 ) )
 437             return false;
 438
 439         // root storage level
 440
 441         if ( !m_aTestHelper.checkStream( xTempStorage2, "Stream1_renamed", "MediaType1", true, pBytes1 ) )
 442             return false;
 443
 444         if ( !m_aTestHelper.checkEncrStream( xTempStorage2, "EncrStream1_renamed", "MediaType2", pBytes1, pPass1 ) )
 445             return false;
 446
 447         // the storage is based on the temporary stream so it can be left undisposed, since it does not lock
 448         // any resource, later the garbage collector will release the object and it must die by refcount
 449
 450         return true;
 451     }
 452 }
 453