package/qa/storages/Test04.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 import com.sun.star.lang.DisposedException;
  25
  26 import com.sun.star.bridge.XUnoUrlResolver;
  27 import com.sun.star.uno.UnoRuntime;
  28 import com.sun.star.uno.XInterface;
  29
  30 import com.sun.star.container.XNameAccess;
  31
  32 import com.sun.star.embed.*;
  33
  34 import share.LogWriter;
  35 import complex.storages.TestHelper;
  36 import complex.storages.StorageTest;
  37
  38 public class Test04 implements StorageTest {
  39
  40     XMultiServiceFactory m_xMSF;
  41     XSingleServiceFactory m_xStorageFactory;
  42     TestHelper m_aTestHelper;
  43
  44     public Test04( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter )
  45     {
  46         m_xMSF = xMSF;
  47         m_xStorageFactory = xStorageFactory;
  48         m_aTestHelper = new TestHelper( aLogWriter, "Test04: " );
  49     }
  50
  51     public boolean test()
  52     {
  53         try
  54         {
  55             String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF );
  56             if ( sTempFileURL == null || sTempFileURL == "" )
  57             {
  58                 m_aTestHelper.Error( "No valid temporary file was created!" );
  59                 return false;
  60             }
  61
  62             // create temporary storage based on arbitrary medium
  63             // after such a storage is closed it is lost
  64             Object oTempStorage = m_xStorageFactory.createInstance();
  65             XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
  66             if ( xTempStorage == null )
  67             {
  68                 m_aTestHelper.Error( "Can't create temporary storage representation!" );
  69                 return false;
  70             }
  71
  72             // open substorages and create streams there
  73
  74             // first substorage of the root storage
  75             XStorage xTempSubStorage1 = m_aTestHelper.openSubStorage( xTempStorage,
  76                                                                         "SubStorage1",
  77                                                                         ElementModes.WRITE );
  78             if ( xTempSubStorage1 == null )
  79             {
  80                 m_aTestHelper.Error( "Can't create substorage!" );
  81                 return false;
  82             }
  83
  84             byte pBigBytes[] = new byte[33000];
  85             for ( int nInd = 0; nInd < 33000; nInd++ )
  86                 pBigBytes[nInd] = (byte)( nInd % 128 );
  87
  88             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  89             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage1, "BigSubStream1", "MediaType1", true, pBigBytes ) )
  90                 return false;
  91
  92             byte pBytes1[] = { 1, 1, 1, 1, 1 };
  93
  94             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  95             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage1, "SubStream1", "MediaType1", true, pBytes1 ) )
  96                 return false;
  97
  98             // second substorage of the root storage
  99             XStorage xTempSubStorage2 = m_aTestHelper.openSubStorage( xTempStorage,
 100                                                                         "SubStorage2",
 101                                                                         ElementModes.WRITE );
 102             if ( xTempSubStorage2 == null )
 103             {
 104                 m_aTestHelper.Error( "Can't create substorage!" );
 105                 return false;
 106             }
 107
 108             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
 109             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage2, "BigSubStream2", "MediaType2", false, pBigBytes ) )
 110                 return false;
 111
 112             byte pBytes2[] = { 2, 2, 2, 2, 2 };
 113
 114             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
 115             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage2, "SubStream2", "MediaType2", false, pBytes2 ) )
 116                 return false;
 117
 118             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 119             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage,
 120                                                             "MediaType3",
 121                                                             true,
 122                                                             ElementModes.WRITE ) )
 123                 return false;
 124
 125             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 126             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage1,
 127                                                             "MediaType4",
 128                                                             false,
 129                                                             ElementModes.WRITE ) )
 130                 return false;
 131
 132             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 133             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage2,
 134                                                             "MediaType5",
 135                                                             false,
 136                                                             ElementModes.WRITE ) )
 137                 return false;
 138
 139             // create temporary storage based on a previously created temporary file
 140             Object pArgs[] = new Object[2];
 141             pArgs[0] = (Object) sTempFileURL;
 142             pArgs[1] = Integer.valueOf( ElementModes.WRITE );
 143
 144             Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
 145             XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage );
 146             if ( xTempFileStorage == null )
 147             {
 148                 m_aTestHelper.Error( "Can't create storage based on temporary file!" );
 149                 return false;
 150             }
 151
 152             if ( !m_aTestHelper.copyElementTo( xTempStorage, "SubStorage1", xTempFileStorage ) )
 153                 return false;
 154
 155             // if storage is not committed before disposing all the changes will be lost
 156             if ( !m_aTestHelper.commitStorage( xTempSubStorage2 ) )
 157                 return false;
 158
 159             // a storage must be disposed before moving/removing otherwise the access will be denied
 160             if ( !m_aTestHelper.disposeStorage( xTempSubStorage2 ) )
 161                 return false;
 162
 163             if ( !m_aTestHelper.moveElementTo( xTempStorage, "SubStorage2", xTempFileStorage ) )
 164                 return false;
 165
 166             // SubStorage2 must be removed and disposed now
 167             try
 168             {
 169                 xTempSubStorage2.isStreamElement( "SubStream2" );
 170                 m_aTestHelper.Error( "SubStorage2 must be disposed already!" );
 171                 return false;
 172             }
 173             catch( com.sun.star.lang.DisposedException de )
 174             {
 175             }
 176             catch( Exception e )
 177             {
 178                 m_aTestHelper.Error( "Wrong exception in case of disposed storage, exception: " + e );
 179                 return false;
 180             }
 181
 182             if ( !m_aTestHelper.copyElementTo( xTempSubStorage1, "SubStream1", xTempFileStorage ) )
 183                 return false;
 184
 185             if ( !m_aTestHelper.renameElement( xTempFileStorage, "SubStream1", "SubStream1_copy" ) )
 186                 return false;
 187
 188             if ( !m_aTestHelper.moveElementTo( xTempSubStorage1, "SubStream1", xTempFileStorage ) )
 189                 return false;
 190
 191             if ( !m_aTestHelper.copyElementTo( xTempSubStorage1, "BigSubStream1", xTempFileStorage ) )
 192                 return false;
 193
 194             if ( !m_aTestHelper.renameElement( xTempFileStorage, "BigSubStream1", "BigSubStream1_copy" ) )
 195                 return false;
 196
 197             if ( !m_aTestHelper.moveElementTo( xTempSubStorage1, "BigSubStream1", xTempFileStorage ) )
 198                 return false;
 199
 200             if ( !m_aTestHelper.commitStorage( xTempFileStorage ) )
 201                 return false;
 202
 203             // dispose used storages to free resources
 204             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
 205                 return false;
 206
 207
 208             // now check all the written and copied information
 209
 210
 211             // the temporary file must not be locked any more after storage disposing
 212             pArgs[1] = Integer.valueOf( ElementModes.WRITE );
 213             Object oResStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
 214             XStorage xResStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResStorage );
 215             if ( xResStorage == null )
 216             {
 217                 m_aTestHelper.Error( "Can't reopen storage based on temporary file!" );
 218                 return false;
 219             }
 220
 221             // open and check SubStorage1
 222             XStorage xResSubStorage1 = m_aTestHelper.openSubStorage( xResStorage,
 223                                                                         "SubStorage1",
 224                                                                         ElementModes.READ );
 225             if ( xResSubStorage1 == null )
 226             {
 227                 m_aTestHelper.Error( "Can't open existing substorage!" );
 228                 return false;
 229             }
 230
 231             if ( !m_aTestHelper.checkStorageProperties( xResSubStorage1, "MediaType4", false, ElementModes.READ ) )
 232                 return false;
 233
 234
 235             // open and check SubStorage2
 236             XStorage xResSubStorage2 = m_aTestHelper.openSubStorage( xResStorage,
 237                                                                         "SubStorage2",
 238                                                                         ElementModes.READ );
 239             if ( xResSubStorage2 == null )
 240             {
 241                 m_aTestHelper.Error( "Can't open existing substorage!" );
 242                 return false;
 243             }
 244
 245             if ( !m_aTestHelper.checkStorageProperties( xResSubStorage2, "MediaType5", false, ElementModes.READ ) )
 246                 return false;
 247
 248
 249             // check all the result streams
 250
 251             if ( !m_aTestHelper.checkStream( xResStorage, "SubStream1", "MediaType1", true, pBytes1 ) )
 252                 return false;
 253
 254             if ( !m_aTestHelper.checkStream( xResStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) )
 255                 return false;
 256
 257             if ( !m_aTestHelper.checkStream( xResStorage, "SubStream1_copy", "MediaType1", true, pBytes1 ) )
 258                 return false;
 259
 260             if ( !m_aTestHelper.checkStream( xResStorage, "BigSubStream1_copy", "MediaType1", true, pBigBytes ) )
 261                 return false;
 262
 263             if ( !m_aTestHelper.checkStream( xResSubStorage1, "SubStream1", "MediaType1", true, pBytes1 ) )
 264                 return false;
 265
 266             if ( !m_aTestHelper.checkStream( xResSubStorage1, "BigSubStream1", "MediaType1", true, pBigBytes ) )
 267                 return false;
 268
 269             if ( !m_aTestHelper.checkStream( xResSubStorage2, "SubStream2", "MediaType2", false, pBytes2 ) )
 270                 return false;
 271
 272             if ( !m_aTestHelper.checkStream( xResSubStorage2, "BigSubStream2", "MediaType2", false, pBigBytes ) )
 273                 return false;
 274
 275             // the storage must be disposed before removing
 276             if ( !m_aTestHelper.disposeStorage( xResSubStorage2 ) )
 277                 return false;
 278
 279             // remove element and check that it was removed completely
 280             if ( !m_aTestHelper.removeElement( xResStorage, "SubStorage2" ) )
 281                 return false;
 282
 283             try
 284             {
 285                 XNameAccess xResAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xResStorage );
 286                 if ( xResAccess.hasByName( "SubStorage2" ) )
 287                     m_aTestHelper.Error( "SubStorage2 must be removed already!" );
 288             }
 289             catch( Exception e )
 290             {
 291                 m_aTestHelper.Error( "Can't get access to root storage, exception: " + e );
 292                 return false;
 293             }
 294
 295             try
 296             {
 297                 xResSubStorage2.isStreamElement( "SubStream2" );
 298
 299                 m_aTestHelper.Error( "SubStorage2 must be disposed already!" );
 300                 return false;
 301             }
 302             catch( com.sun.star.lang.DisposedException de )
 303             {
 304             }
 305             catch( Exception e )
 306             {
 307                 m_aTestHelper.Error( "Wrong exception in case of disposed storage, exception: " + e );
 308                 return false;
 309             }
 310
 311             // dispose used storages to free resources
 312             if ( !m_aTestHelper.disposeStorage( xResStorage ) )
 313                 return false;
 314
 315             return true;
 316         }
 317         catch( Exception e )
 318         {
 319             m_aTestHelper.Error( "Exception: " + e );
 320             return false;
 321         }
 322     }
 323
 324 }
 325