package/qa/storages/Test04.java

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