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 pBytes1[] = { 1, 1, 1, 1, 1 };
  67
  68                         // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  69                         if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage1, "SubStream1", "MediaType1", true, pBytes1 ) )
  70                                 return false;
  71
  72                         // second substorage of the root storage
  73                         XStorage xTempSubStorage2 = m_aTestHelper.openSubStorage( xTempStorage,
  74                                                                                                                                                 "SubStorage2",
  75                                                                                                                                                 ElementModes.WRITE );
  76                         if ( xTempSubStorage2 == null )
  77                         {
  78                                 m_aTestHelper.Error( "Can't create substorage!" );
  79                                 return false;
  80                         }
  81
  82                         byte pBytes2[] = { 2, 2, 2, 2, 2 };
  83
  84                         // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  85                         if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage2, "SubStream2", "MediaType2", false, pBytes2 ) )
  86                                 return false;
  87
  88                         // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
  89                         if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage,
  90                                                                                                                         "MediaType3",
  91                                                                                                                         true,
  92                                                                                                                         ElementModes.WRITE ) )
  93                                 return false;
  94
  95                         // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
  96                         if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage1,
  97                                                                                                                         "MediaType4",
  98                                                                                                                         false,
  99                                                                                                                         ElementModes.WRITE ) )
 100                                 return false;
 101
 102                         // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 103                         if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage2,
 104                                                                                                                         "MediaType5",
 105                                                                                                                         false,
 106                                                                                                                         ElementModes.WRITE ) )
 107                                 return false;
 108
 109                         // create temporary storage based on a previously created temporary file
 110                         Object pArgs[] = new Object[2];
 111                         pArgs[0] = (Object) sTempFileURL;
 112                         pArgs[1] = new Integer( ElementModes.WRITE );
 113
 114                         Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
 115                         XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage );
 116                         if ( xTempFileStorage == null )
 117                         {
 118                                 m_aTestHelper.Error( "Can't create storage based on temporary file!" );
 119                                 return false;
 120                         }
 121
 122                         if ( !m_aTestHelper.copyElementTo( xTempStorage, "SubStorage1", xTempFileStorage ) )
 123                                 return false;
 124
 125                         // if storage is not commited before disposing all the changes will be lost
 126                         if ( !m_aTestHelper.commitStorage( xTempSubStorage2 ) )
 127                                 return false;
 128
 129                         // a storage must be disposed before moving/removing otherwise the access will be denied
 130                         if ( !m_aTestHelper.disposeStorage( xTempSubStorage2 ) )
 131                                 return false;
 132
 133                         if ( !m_aTestHelper.moveElementTo( xTempStorage, "SubStorage2", xTempFileStorage ) )
 134                                 return false;
 135
 136                         // SubStorage2 must be removed and disposed now
 137                         try
 138                         {
 139                                 xTempSubStorage2.isStreamElement( "SubStream2" );
 140                                 m_aTestHelper.Error( "SubStorage2 must be disposed already!" );
 141                                 return false;
 142                         }
 143                         catch( com.sun.star.lang.DisposedException de )
 144                         {
 145                         }
 146                         catch( Exception e )
 147                         {
 148                                 m_aTestHelper.Error( "Wrong exception in case of disposed storage, exception: " + e );
 149                                 return false;
 150                         }
 151
 152                         if ( !m_aTestHelper.copyElementTo( xTempSubStorage1, "SubStream1", xTempFileStorage ) )
 153                                 return false;
 154
 155                         if ( !m_aTestHelper.renameElement( xTempFileStorage, "SubStream1", "SubStream1_copy" ) )
 156                                 return false;
 157
 158                         if ( !m_aTestHelper.moveElementTo( xTempSubStorage1, "SubStream1", xTempFileStorage ) )
 159                                 return false;
 160
 161                         if ( !m_aTestHelper.commitStorage( xTempFileStorage ) )
 162                                 return false;
 163
 164                         // dispose used storages to free resources
 165                         if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
 166                                 return false;
 167
 168                         // ================================================
 169                         // now check all the written and copied information
 170                         // ================================================
 171
 172                         // the temporary file must not be locked any more after storage disposing
 173                         pArgs[1] = new Integer( ElementModes.WRITE );
 174                         Object oResStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
 175                         XStorage xResStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResStorage );
 176                         if ( xResStorage == null )
 177                         {
 178                                 m_aTestHelper.Error( "Can't reopen storage based on temporary file!" );
 179                                 return false;
 180                         }
 181
 182                         // open and check SubStorage1
 183                         XStorage xResSubStorage1 = m_aTestHelper.openSubStorage( xResStorage,
 184                                                                                                                                                 "SubStorage1",
 185                                                                                                                                                 ElementModes.READ );
 186                         if ( xResSubStorage1 == null )
 187                         {
 188                                 m_aTestHelper.Error( "Can't open existing substorage!" );
 189                                 return false;
 190                         }
 191
 192                         if ( !m_aTestHelper.checkStorageProperties( xResSubStorage1, "MediaType4", false, ElementModes.READ ) )
 193                                 return false;
 194
 195
 196                         // open and check SubStorage2
 197                         XStorage xResSubStorage2 = m_aTestHelper.openSubStorage( xResStorage,
 198                                                                                                                                                 "SubStorage2",
 199                                                                                                                                                 ElementModes.READ );
 200                         if ( xResSubStorage2 == null )
 201                         {
 202                                 m_aTestHelper.Error( "Can't open existing substorage!" );
 203                                 return false;
 204                         }
 205
 206                         if ( !m_aTestHelper.checkStorageProperties( xResSubStorage2, "MediaType5", false, ElementModes.READ ) )
 207                                 return false;
 208
 209
 210                         // check all the result streams
 211
 212                         if ( !m_aTestHelper.checkStream( xResStorage, "SubStream1", "MediaType1", true, pBytes1 ) )
 213                                 return false;
 214
 215                         if ( !m_aTestHelper.checkStream( xResStorage, "SubStream1_copy", "MediaType1", true, pBytes1 ) )
 216                                 return false;
 217
 218                         if ( !m_aTestHelper.checkStream( xResSubStorage1, "SubStream1", "MediaType1", true, pBytes1 ) )
 219                                 return false;
 220
 221                         if ( !m_aTestHelper.checkStream( xResSubStorage2, "SubStream2", "MediaType2", false, pBytes2 ) )
 222                                 return false;
 223
 224                         // the storage must be disposed before removing
 225                         if ( !m_aTestHelper.disposeStorage( xResSubStorage2 ) )
 226                                 return false;
 227
 228                         // remove element and check that it was removed completelly
 229                         if ( !m_aTestHelper.removeElement( xResStorage, "SubStorage2" ) )
 230                                 return false;
 231
 232                         try
 233                         {
 234                                 XNameAccess xResAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xResStorage );
 235                                 if ( xResAccess.hasByName( "SubStorage2" ) )
 236                                         m_aTestHelper.Error( "SubStorage2 must be removed already!" );
 237                         }
 238                         catch( Exception e )
 239                         {
 240                                 m_aTestHelper.Error( "Can't get access to root storage, exception: " + e );
 241                                 return false;
 242                         }
 243
 244                         try
 245                         {
 246                                 xResSubStorage2.isStreamElement( "SubStream2" );
 247
 248                                 m_aTestHelper.Error( "SubStorage2 must be disposed already!" );
 249                                 return false;
 250                         }
 251                         catch( com.sun.star.lang.DisposedException de )
 252                         {
 253                         }
 254                         catch( Exception e )
 255                         {
 256                                 m_aTestHelper.Error( "Wrong exception in case of disposed storage, exception: " + e );
 257                                 return false;
 258                         }
 259
 260                         // dispose used storages to free resources
 261                         if ( !m_aTestHelper.disposeStorage( xResStorage ) )
 262                                 return false;
 263
 264                         return true;
 265                 }
 266                 catch( Exception e )
 267                 {
 268                         m_aTestHelper.Error( "Exception: " + e );
 269                         return false;
 270                 }
 271     }
 272
 273 }
 274