package/qa/storages/RegressionTest_i49755.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
   7 import com.sun.star.bridge.XUnoUrlResolver;
   8 import com.sun.star.uno.UnoRuntime;
   9 import com.sun.star.uno.XInterface;
  10 import com.sun.star.io.XStream;
  11 import com.sun.star.io.XInputStream;
  12
  13 import com.sun.star.embed.*;
  14
  15 import share.LogWriter;
  16 import complex.storages.TestHelper;
  17 import complex.storages.StorageTest;
  18
  19 public class RegressionTest_i49755 implements StorageTest {
  20
  21     XMultiServiceFactory m_xMSF;
  22     XSingleServiceFactory m_xStorageFactory;
  23     TestHelper m_aTestHelper;
  24
  25     public RegressionTest_i49755( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter )
  26     {
  27         m_xMSF = xMSF;
  28         m_xStorageFactory = xStorageFactory;
  29         m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i49755: " );
  30     }
  31
  32     public boolean test()
  33     {
  34         try
  35         {
  36             XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF );
  37             if ( xTempFileStream == null )
  38                 return false;
  39
  40             // create storage based on the temporary stream
  41             Object pArgs[] = new Object[2];
  42             pArgs[0] = (Object) xTempFileStream;
  43             pArgs[1] = new Integer( ElementModes.WRITE );
  44
  45             Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
  46             XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
  47             if ( xTempStorage == null )
  48             {
  49                 m_aTestHelper.Error( "Can't create temporary storage representation!" );
  50                 return false;
  51             }
  52
  53             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
  54             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage,
  55                                                             "MediaType1",
  56                                                             true,
  57                                                             ElementModes.WRITE ) )
  58                 return false;
  59
  60
  61             byte pBytes[] = new byte[36000];
  62             for ( int nInd = 0; nInd < 36000; nInd++ )
  63                 pBytes[nInd] = (byte)( nInd % 128 );
  64
  65             // open a new substorage
  66             XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage,
  67                                                                         "SubStorage1",
  68                                                                         ElementModes.WRITE );
  69             if ( xTempSubStorage == null )
  70             {
  71                 m_aTestHelper.Error( "Can't create substorage!" );
  72                 return false;
  73             }
  74
  75             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
  76             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage,
  77                                                             "MediaType2",
  78                                                             false,
  79                                                             ElementModes.WRITE ) )
  80                 return false;
  81
  82             // open a new substorage
  83             XStorage xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage,
  84                                                                         "SubStorage2",
  85                                                                         ElementModes.WRITE );
  86             if ( xTempSubStorage == null )
  87             {
  88                 m_aTestHelper.Error( "Can't create substorage!" );
  89                 return false;
  90             }
  91
  92             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
  93             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubSubStorage,
  94                                                             "MediaType3",
  95                                                             false,
  96                                                             ElementModes.WRITE ) )
  97                 return false;
  98
  99             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
 100             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubStream1", "MediaType4", true, pBytes ) )
 101                 return false;
 102
 103             // open a new substorage
 104             XStorage xTempSubStorage1 = m_aTestHelper.openSubStorage( xTempStorage,
 105                                                                         "SubStorage3",
 106                                                                         ElementModes.WRITE );
 107             if ( xTempSubStorage1 == null )
 108             {
 109                 m_aTestHelper.Error( "Can't create substorage!" );
 110                 return false;
 111             }
 112
 113             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 114             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage1,
 115                                                             "MediaType5",
 116                                                             false,
 117                                                             ElementModes.WRITE ) )
 118                 return false;
 119
 120             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
 121             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage1, "SubStream2", "MediaType4", false, pBytes ) )
 122                 return false;
 123
 124
 125             // commit substorages first
 126             if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) )
 127                 return false;
 128
 129             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
 130                 return false;
 131
 132             if ( !m_aTestHelper.commitStorage( xTempSubStorage1 ) )
 133                 return false;
 134
 135             // commit the root storage so the contents must be stored now
 136             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
 137                 return false;
 138
 139             // dispose used storage to free resources
 140             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
 141                 return false;
 142
 143             // ================================================
 144             // now change the contents of the second substorage
 145             // without changing of the contents of the first substorage
 146             // ================================================
 147
 148             Object oStep2TempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
 149             XStorage xStep2TempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oStep2TempStorage );
 150             if ( xStep2TempStorage == null )
 151             {
 152                 m_aTestHelper.Error( "Can't create temporary storage representation!" );
 153                 return false;
 154             }
 155
 156             XStorage xStep2TempSubStorage1 = m_aTestHelper.openSubStorage( xStep2TempStorage,
 157                                                                             "SubStorage3",
 158                                                                             ElementModes.WRITE );
 159             if ( xStep2TempSubStorage1 == null )
 160             {
 161                 m_aTestHelper.Error( "Can't create substorage!" );
 162                 return false;
 163             }
 164
 165             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
 166             if ( !m_aTestHelper.WriteBytesToSubstream( xStep2TempSubStorage1, "SubStream2", "MediaType4", false, pBytes ) )
 167                 return false;
 168
 169             if ( !m_aTestHelper.commitStorage( xStep2TempSubStorage1 ) )
 170                 return false;
 171
 172             // commit the root storage so the contents must be stored now
 173             if ( !m_aTestHelper.commitStorage( xStep2TempStorage ) )
 174                 return false;
 175
 176             // dispose used storage to free resources
 177             if ( !m_aTestHelper.disposeStorage( xStep2TempStorage ) )
 178                 return false;
 179
 180
 181             // ================================================
 182             // now check all the written information
 183             // and the raw stream contents
 184             // ================================================
 185
 186             // close the output part of the temporary stream
 187             // the output part must present since we already wrote to the stream
 188             if ( !m_aTestHelper.closeOutput( xTempFileStream ) )
 189                 return false;
 190
 191             XInputStream xTempInStream = m_aTestHelper.getInputStream( xTempFileStream );
 192             if ( xTempInStream == null )
 193                 return false;
 194
 195             // open input stream
 196             // since no mode is provided the result storage must be opened readonly
 197             Object pOneArg[] = new Object[1];
 198             pOneArg[0] = (Object) xTempInStream;
 199
 200             Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pOneArg );
 201             XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage );
 202             if ( xResultStorage == null )
 203             {
 204                 m_aTestHelper.Error( "Can't open storage based on input stream!" );
 205                 return false;
 206             }
 207
 208             if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType1", true, ElementModes.READ ) )
 209                 return false;
 210
 211             // open existing substorage
 212             XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage,
 213                                                                         "SubStorage1",
 214                                                                         ElementModes.READ );
 215             if ( xResultSubStorage == null )
 216             {
 217                 m_aTestHelper.Error( "Can't open existing substorage!" );
 218                 return false;
 219             }
 220
 221             if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType2", false, ElementModes.READ ) )
 222                 return false;
 223
 224             // open existing substorage
 225             XStorage xResultSubSubStorage = m_aTestHelper.openSubStorage( xResultSubStorage,
 226                                                                             "SubStorage2",
 227                                                                             ElementModes.READ );
 228             if ( xResultSubSubStorage == null )
 229             {
 230                 m_aTestHelper.Error( "Can't open existing substorage!" );
 231                 return false;
 232             }
 233
 234             if ( !m_aTestHelper.checkStorageProperties( xResultSubSubStorage, "MediaType3", false, ElementModes.READ ) )
 235                 return false;
 236
 237             if ( !m_aTestHelper.checkStream( xResultSubSubStorage, "SubStream1", "MediaType4", true, pBytes ) )
 238                 return false;
 239
 240
 241
 242             XStorage xResultSubStorage1 = m_aTestHelper.openSubStorage( xResultStorage,
 243                                                                         "SubStorage3",
 244                                                                         ElementModes.READ );
 245             if ( xResultSubStorage1 == null )
 246             {
 247                 m_aTestHelper.Error( "Can't open existing substorage!" );
 248                 return false;
 249             }
 250
 251             if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage1, "MediaType5", false, ElementModes.READ ) )
 252                 return false;
 253
 254             if ( !m_aTestHelper.checkStream( xResultSubStorage1, "SubStream2", "MediaType4", false, pBytes ) )
 255                 return false;
 256
 257
 258             // dispose used storages to free resources
 259             if ( !m_aTestHelper.disposeStorage( xResultStorage ) )
 260                 return false;
 261
 262             return true;
 263         }
 264         catch( Exception e )
 265         {
 266             m_aTestHelper.Error( "Exception: " + e );
 267             return false;
 268         }
 269     }
 270
 271 }
 272