odk/examples/java/Storage/Test05.java

   1 /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 import com.sun.star.lang.XMultiServiceFactory;
  21 import com.sun.star.lang.XSingleServiceFactory;
  22
  23 import com.sun.star.uno.UnoRuntime;
  24 import com.sun.star.io.XStream;
  25
  26 import com.sun.star.embed.*;
  27
  28 public class Test05 implements StorageTest {
  29
  30     XMultiServiceFactory m_xMSF;
  31     XSingleServiceFactory m_xStorageFactory;
  32     TestHelper m_aTestHelper;
  33
  34     public Test05( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory )
  35     {
  36         m_xMSF = xMSF;
  37         m_xStorageFactory = xStorageFactory;
  38         m_aTestHelper = new TestHelper( "Test05: " );
  39     }
  40
  41     public boolean test()
  42     {
  43         try
  44         {
  45             String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF );
  46             if ( sTempFileURL == null || sTempFileURL.equals("") )
  47             {
  48                 m_aTestHelper.Error( "No valid temporary file was created!" );
  49                 return false;
  50             }
  51
  52             // create temporary storage based on a previously created temporary file
  53             Object pArgs[] = new Object[2];
  54             pArgs[0] = sTempFileURL;
  55             pArgs[1] = Integer.valueOf( ElementModes.WRITE );
  56
  57             Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
  58             XStorage xTempFileStorage = UnoRuntime.queryInterface( XStorage.class, oTempFileStorage );
  59             if ( xTempFileStorage == null )
  60             {
  61                 m_aTestHelper.Error( "Can't create storage based on temporary file!" );
  62                 return false;
  63             }
  64
  65             // open a new substorage
  66             XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempFileStorage,
  67                                                                         "SubStorage1",
  68                                                                         ElementModes.WRITE );
  69             if ( xTempSubStorage == null )
  70             {
  71                 m_aTestHelper.Error( "Can't create substorage!" );
  72                 return false;
  73             }
  74
  75             // open a new substorage
  76             XStorage xSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage,
  77                                                                         "SubSubStorage1",
  78                                                                         ElementModes.WRITE );
  79             if ( xSubSubStorage == null )
  80             {
  81                 m_aTestHelper.Error( "Can't create substorage!" );
  82                 return false;
  83             }
  84
  85
  86             byte pBytes1[] = { 1, 1, 1, 1, 1 };
  87
  88             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  89             if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) )
  90                 return false;
  91
  92             byte pBytes2[] = { 2, 2, 2, 2, 2 };
  93
  94             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  95             if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) )
  96                 return false;
  97
  98             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
  99             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempFileStorage,
 100                                                             "MediaType3",
 101                                                             true,
 102                                                             ElementModes.WRITE ) )
 103                 return false;
 104
 105             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 106             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage,
 107                                                             "MediaType4",
 108                                                             false,
 109                                                             ElementModes.WRITE ) )
 110                 return false;
 111
 112             // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 113             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xSubSubStorage,
 114                                                             "MediaType5",
 115                                                             false,
 116                                                             ElementModes.WRITE ) )
 117                 return false;
 118
 119
 120             // commit all the storages
 121             if ( !m_aTestHelper.commitStorage( xSubSubStorage ) )
 122                 return false;
 123
 124             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
 125                 return false;
 126
 127             if ( !m_aTestHelper.commitStorage( xTempFileStorage ) )
 128                 return false;
 129
 130             // try to open an opened substorage, open call must fail
 131             if ( !m_aTestHelper.cantOpenStorage( xTempFileStorage, "SubStorage1" ) )
 132                 return false;
 133
 134
 135             // reopen created streams
 136             XStream xSubStream1 = m_aTestHelper.OpenStream( xSubSubStorage,
 137                                                             "SubStream1",
 138                                                             ElementModes.READWRITE | ElementModes.NOCREATE );
 139             XStream xSubStream2 = m_aTestHelper.OpenStream( xSubSubStorage,
 140                                                             "SubStream2",
 141                                                             ElementModes.READ | ElementModes.NOCREATE );
 142             if ( xSubStream1 == null || xSubStream2 == null )
 143                 return false;
 144
 145             // it should be possible to have more than one copy of stream for reading
 146             XStream xSubStream2clone = m_aTestHelper.OpenStream( xSubSubStorage,
 147                                                                 "SubStream2",
 148                                                                 ElementModes.READ | ElementModes.NOCREATE );
 149
 150
 151             // so now the first stream can not be open neither for reading nor for writing
 152             if ( !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream1", ElementModes.WRITE )
 153               || !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream1", ElementModes.READ ) )
 154                 return false;
 155
 156             // the second stream can not be open for writing
 157             if ( !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream2", ElementModes.WRITE ) )
 158                 return false;
 159
 160
 161             // dispose xTestSubStorage, all the subtree must be disposed
 162             if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
 163                 return false;
 164
 165             // check that subtree was disposed correctly
 166             try
 167             {
 168                 xSubSubStorage.isStreamElement( "SubStream1" );
 169                 m_aTestHelper.Error( "Substorage was not disposed!" );
 170                 return false;
 171             }
 172             catch ( com.sun.star.lang.DisposedException de )
 173             {}
 174             catch ( Exception e )
 175             {
 176                 m_aTestHelper.Error( "Wrong exception is thrown by disposed storage: " + e );
 177                 return false;
 178             }
 179
 180             try
 181             {
 182                 xSubStream1.getInputStream();
 183                 m_aTestHelper.Error( "Writeable substream was not disposed!" );
 184                 return false;
 185             }
 186             catch ( com.sun.star.lang.DisposedException de )
 187             {}
 188             catch ( Exception e )
 189             {
 190                 m_aTestHelper.Error( "Wrong exception is thrown by disposed stream: " + e );
 191                 return false;
 192             }
 193
 194             try
 195             {
 196                 xSubStream2.getInputStream();
 197                 m_aTestHelper.Error( "Readonly substream was not disposed!" );
 198                 return false;
 199             }
 200             catch ( com.sun.star.lang.DisposedException de )
 201             {}
 202             catch ( Exception e )
 203             {
 204                 m_aTestHelper.Error( "Wrong exception is thrown by disposed stream: " + e );
 205                 return false;
 206             }
 207
 208
 209             // dispose root storage
 210             if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) )
 211                 return false;
 212
 213
 214
 215             // now check all the written and copied information
 216
 217
 218             pArgs[1] = Integer.valueOf( ElementModes.READ );
 219             Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
 220             XStorage xResultStorage = UnoRuntime.queryInterface( XStorage.class, oResultStorage );
 221             if ( xResultStorage == null )
 222             {
 223                 m_aTestHelper.Error( "Can't reopen storage based on temporary file!" );
 224                 return false;
 225             }
 226
 227             if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.READ ) )
 228                 return false;
 229
 230             // open existing substorage
 231             XStorage xResSubStorage = m_aTestHelper.openSubStorage( xResultStorage,
 232                                                                     "SubStorage1",
 233                                                                     ElementModes.READ );
 234             if ( xResSubStorage == null )
 235             {
 236                 m_aTestHelper.Error( "Can't open existing substorage 'SubSubStorage'!" );
 237                 return false;
 238             }
 239
 240             if ( !m_aTestHelper.checkStorageProperties( xResSubStorage, "MediaType4", false, ElementModes.READ ) )
 241                 return false;
 242
 243             // open existing substorage
 244             XStorage xResSubSubStorage = m_aTestHelper.openSubStorage( xResSubStorage,
 245                                                                         "SubSubStorage1",
 246                                                                         ElementModes.READ );
 247             if ( xResSubSubStorage == null )
 248             {
 249                 m_aTestHelper.Error( "Can't open existing substorage 'SubSubStorage'!" );
 250                 return false;
 251             }
 252
 253             if ( !m_aTestHelper.checkStorageProperties( xResSubSubStorage, "MediaType5", false, ElementModes.READ ) )
 254                 return false;
 255
 256             // check substreams
 257             if ( !m_aTestHelper.checkStream( xResSubSubStorage, "SubStream1", "MediaType1", pBytes1 ) )
 258                 return false;
 259
 260             if ( !m_aTestHelper.checkStream( xResSubSubStorage, "SubStream2", "MediaType2", pBytes2 ) )
 261                 return false;
 262
 263             // dispose used storages to free resources
 264             if ( !m_aTestHelper.disposeStorage( xResultStorage ) )
 265                 return false;
 266
 267             return true;
 268         }
 269         catch( Exception e )
 270         {
 271             m_aTestHelper.Error( "Exception: " + e );
 272             return false;
 273         }
 274     }
 275
 276 }
 277
 278 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */