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 12 import com.sun.star.embed.*; 13 14 import share.LogWriter; 15 import complex.storages.TestHelper; 16 import complex.storages.StorageTest; 17 18 public class Test05 implements StorageTest { 19 20 XMultiServiceFactory m_xMSF; 21 XSingleServiceFactory m_xStorageFactory; 22 TestHelper m_aTestHelper; 23 24 public Test05( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) 25 { 26 m_xMSF = xMSF; 27 m_xStorageFactory = xStorageFactory; 28 m_aTestHelper = new TestHelper( aLogWriter, "Test05: " ); 29 } 30 31 public boolean test() 32 { 33 try 34 { 35 String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); 36 if ( sTempFileURL == null || sTempFileURL == "" ) 37 { 38 m_aTestHelper.Error( "No valid temporary file was created!" ); 39 return false; 40 } 41 42 // create temporary storage based on a previously created temporary file 43 Object pArgs[] = new Object[2]; 44 pArgs[0] = (Object) sTempFileURL; 45 pArgs[1] = new Integer( ElementModes.WRITE ); 46 47 Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); 48 XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); 49 if ( xTempFileStorage == null ) 50 { 51 m_aTestHelper.Error( "Can't create storage based on temporary file!" ); 52 return false; 53 } 54 55 // open a new substorage 56 XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempFileStorage, 57 "SubStorage1", 58 ElementModes.WRITE ); 59 if ( xTempSubStorage == null ) 60 { 61 m_aTestHelper.Error( "Can't create substorage!" ); 62 return false; 63 } 64 65 // open a new substorage 66 XStorage xSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, 67 "SubSubStorage1", 68 ElementModes.WRITE ); 69 if ( xSubSubStorage == null ) 70 { 71 m_aTestHelper.Error( "Can't create substorage!" ); 72 return false; 73 } 74 75 byte pBigBytes[] = new byte[33000]; 76 for ( int nInd = 0; nInd < 33000; nInd++ ) 77 pBigBytes[nInd] = (byte)( nInd % 128 ); 78 79 // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes 80 if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) 81 return false; 82 83 // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes 84 if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) 85 return false; 86 87 byte pBytes1[] = { 1, 1, 1, 1, 1 }; 88 89 // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes 90 if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) 91 return false; 92 93 byte pBytes2[] = { 2, 2, 2, 2, 2 }; 94 95 // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes 96 if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) 97 return false; 98 99 // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly 100 if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempFileStorage, 101 "MediaType3", 102 true, 103 ElementModes.WRITE ) ) 104 return false; 105 106 // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly 107 if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, 108 "MediaType4", 109 false, 110 ElementModes.WRITE ) ) 111 return false; 112 113 // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly 114 if ( !m_aTestHelper.setStorageTypeAndCheckProps( xSubSubStorage, 115 "MediaType5", 116 false, 117 ElementModes.WRITE ) ) 118 return false; 119 120 121 // commit all the storages 122 if ( !m_aTestHelper.commitStorage( xSubSubStorage ) ) 123 return false; 124 125 if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) 126 return false; 127 128 if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) 129 return false; 130 131 // try to open an opened substorage, open call must fail 132 if ( !m_aTestHelper.cantOpenStorage( xTempFileStorage, "SubStorage1" ) ) 133 return false; 134 135 136 // reopen created streams 137 XStream xSubStream1 = m_aTestHelper.OpenStream( xSubSubStorage, 138 "SubStream1", 139 ElementModes.WRITE | ElementModes.NOCREATE ); 140 XStream xBigSubStream1 = m_aTestHelper.OpenStream( xSubSubStorage, 141 "BigSubStream1", 142 ElementModes.WRITE | ElementModes.NOCREATE ); 143 XStream xSubStream2 = m_aTestHelper.OpenStream( xSubSubStorage, 144 "SubStream2", 145 ElementModes.READ | ElementModes.NOCREATE ); 146 XStream xBigSubStream2 = m_aTestHelper.OpenStream( xSubSubStorage, 147 "BigSubStream2", 148 ElementModes.READ | ElementModes.NOCREATE ); 149 150 if ( xSubStream1 == null || xBigSubStream1 == null || xSubStream2 == null || xBigSubStream2 == null ) 151 return false; 152 153 // it should be possible to have more then one copy of stream for reading 154 XStream xSubStream2clone = m_aTestHelper.OpenStream( xSubSubStorage, 155 "SubStream2", 156 ElementModes.READ | ElementModes.NOCREATE ); 157 XStream xBigSubStream2clone = m_aTestHelper.OpenStream( xSubSubStorage, 158 "BigSubStream2", 159 ElementModes.READ | ElementModes.NOCREATE ); 160 if ( xSubStream2clone == null || xBigSubStream2clone == null ) 161 return false; 162 163 164 // so now the first streams can not be open neither for reading nor for writing 165 if ( !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream1", ElementModes.WRITE ) 166 || !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream1", ElementModes.READ ) 167 || !m_aTestHelper.cantOpenStream( xSubSubStorage, "BigSubStream1", ElementModes.WRITE ) 168 || !m_aTestHelper.cantOpenStream( xSubSubStorage, "BigSubStream1", ElementModes.READ ) ) 169 return false; 170 171 // the second streams can not be open for writing 172 if ( !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream2", ElementModes.WRITE ) 173 || !m_aTestHelper.cantOpenStream( xSubSubStorage, "BigSubStream2", ElementModes.WRITE ) ) 174 return false; 175 176 177 // dispose xTestSubStorage, all the subtree must be disposed 178 if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) 179 return false; 180 181 // check that subtree was disposed correctly 182 try 183 { 184 xSubSubStorage.isStreamElement( "SubStream1" ); 185 m_aTestHelper.Error( "Substorage was not disposed!" ); 186 return false; 187 } 188 catch ( com.sun.star.lang.DisposedException de ) 189 {} 190 catch ( Exception e ) 191 { 192 m_aTestHelper.Error( "Wrong exception is thrown by disposed storage: " + e ); 193 return false; 194 } 195 196 try 197 { 198 xSubStream1.getInputStream(); 199 m_aTestHelper.Error( "Writeable substream was not disposed!" ); 200 return false; 201 } 202 catch ( com.sun.star.lang.DisposedException de ) 203 {} 204 catch ( Exception e ) 205 { 206 m_aTestHelper.Error( "Wrong exception is thrown by disposed stream: " + e ); 207 return false; 208 } 209 210 try 211 { 212 xSubStream2.getInputStream(); 213 m_aTestHelper.Error( "Readonly substream was not disposed!" ); 214 return false; 215 } 216 catch ( com.sun.star.lang.DisposedException de ) 217 {} 218 catch ( Exception e ) 219 { 220 m_aTestHelper.Error( "Wrong exception is thrown by disposed stream: " + e ); 221 return false; 222 } 223 224 225 // dispose root storage 226 if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) 227 return false; 228 229 230 // ================================================ 231 // now check all the written and copied information 232 // ================================================ 233 234 pArgs[1] = new Integer( ElementModes.READ ); 235 Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); 236 XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); 237 if ( xResultStorage == null ) 238 { 239 m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); 240 return false; 241 } 242 243 if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.READ ) ) 244 return false; 245 246 // open existing substorage 247 XStorage xResSubStorage = m_aTestHelper.openSubStorage( xResultStorage, 248 "SubStorage1", 249 ElementModes.READ ); 250 if ( xResSubStorage == null ) 251 { 252 m_aTestHelper.Error( "Can't open existing substorage 'SubSubStorage'!" ); 253 return false; 254 } 255 256 if ( !m_aTestHelper.checkStorageProperties( xResSubStorage, "MediaType4", false, ElementModes.READ ) ) 257 return false; 258 259 // open existing substorage 260 XStorage xResSubSubStorage = m_aTestHelper.openSubStorage( xResSubStorage, 261 "SubSubStorage1", 262 ElementModes.READ ); 263 if ( xResSubSubStorage == null ) 264 { 265 m_aTestHelper.Error( "Can't open existing substorage 'SubSubStorage'!" ); 266 return false; 267 } 268 269 if ( !m_aTestHelper.checkStorageProperties( xResSubSubStorage, "MediaType5", false, ElementModes.READ ) ) 270 return false; 271 272 // check substreams 273 if ( !m_aTestHelper.checkStream( xResSubSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) 274 return false; 275 276 if ( !m_aTestHelper.checkStream( xResSubSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) 277 return false; 278 279 if ( !m_aTestHelper.checkStream( xResSubSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) 280 return false; 281 282 if ( !m_aTestHelper.checkStream( xResSubSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) 283 return false; 284 285 // dispose used storages to free resources 286 if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) 287 return false; 288 289 return true; 290 } 291 catch( Exception e ) 292 { 293 m_aTestHelper.Error( "Exception: " + e ); 294 return false; 295 } 296 } 297 298 } 299 300