package/qa/ofopxmlstorages/Test03.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package complex.ofopxmlstorages;
  20
  21 import com.sun.star.uno.XInterface;
  22 import com.sun.star.lang.XMultiServiceFactory;
  23 import com.sun.star.lang.XSingleServiceFactory;
  24
  25 import com.sun.star.bridge.XUnoUrlResolver;
  26 import com.sun.star.uno.UnoRuntime;
  27 import com.sun.star.uno.XInterface;
  28
  29 import com.sun.star.embed.*;
  30 import com.sun.star.container.XNameAccess;
  31 import com.sun.star.beans.StringPair;
  32
  33 import share.LogWriter;
  34 import complex.ofopxmlstorages.TestHelper;
  35 import complex.ofopxmlstorages.StorageTest;
  36
  37 public class Test03 implements StorageTest {
  38
  39     XMultiServiceFactory m_xMSF;
  40     XSingleServiceFactory m_xStorageFactory;
  41     TestHelper m_aTestHelper;
  42
  43     public Test03( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter )
  44     {
  45         m_xMSF = xMSF;
  46         m_xStorageFactory = xStorageFactory;
  47         m_aTestHelper = new TestHelper( aLogWriter, "Test03: " );
  48     }
  49
  50     public boolean test()
  51     {
  52         try
  53         {
  54             StringPair[][] aRelations =
  55                 { { new StringPair( "Id", "Num1" ) },
  56                   { new StringPair( "Target", "TargetURLValue" ), new StringPair( "Id", "Num6" ) },
  57                   { new StringPair( "Target", "" ), new StringPair( "Id", "Num7" ) },
  58                   { new StringPair( "Id", "Num2" ), new StringPair( "TargetMode", "Internal" ), new StringPair( "Type", "unknown" ), new StringPair( "Target", "URL value" ) },
  59                   { new StringPair( "Id", "Num3" ), new StringPair( "TargetMode", "Internal" ), new StringPair( "Type", "unknown" ), new StringPair( "Target", "URL value" ) },
  60                   { new StringPair( "Id", "Num4" ), new StringPair( "TargetMode", "Internal" ), new StringPair( "Type", "unknown" ), new StringPair( "Target", "URL value" ) },
  61                   { new StringPair( "Id", "Num5" ), new StringPair( "TargetMode", "" ), new StringPair( "Type", "unknown" ), new StringPair( "Target", "URL value" ) }
  62                 };
  63
  64             // create temporary storage based on arbitrary medium
  65             // after such a storage is closed it is lost
  66             XStorage xTempStorage = m_aTestHelper.createTempStorage( m_xMSF, m_xStorageFactory );
  67             if ( xTempStorage == null )
  68             {
  69                 m_aTestHelper.Error( "Can't create temporary storage representation!" );
  70                 return false;
  71             }
  72
  73             // open a new substorage
  74             XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage,
  75                                                                         "SubStorage1",
  76                                                                         ElementModes.WRITE );
  77             if ( xTempSubStorage == null )
  78             {
  79                 m_aTestHelper.Error( "Can't create substorage!" );
  80                 return false;
  81             }
  82
  83             byte pBytes1[] = { 1, 1, 1, 1, 1 };
  84
  85             // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes
  86             if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage,
  87                                                         "SubStream1",
  88                                                         "MediaType1",
  89                                                         true,
  90                                                         pBytes1,
  91                                                         aRelations ) )
  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( xTempSubStorage,
  98                                                         "SubStream2",
  99                                                         "MediaType2",
 100                                                         false,
 101                                                         pBytes2,
 102                                                         aRelations ) )
 103                 return false;
 104
 105             // set Relations for storages and check that "IsRoot" and "OpenMode" properties are set correctly
 106             if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage,
 107                                                             false,
 108                                                             ElementModes.WRITE,
 109                                                             aRelations ) )
 110                 return false;
 111
 112             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
 113                 return false;
 114
 115             if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
 116                 return false;
 117
 118             // ================================================
 119             // check storage hyerarchy tree
 120             // ================================================
 121
 122             // check that isStorageElement() and isStreamElement reacts to nonexisting object correctly
 123             try {
 124                 xTempStorage.isStorageElement( "does not exist" );
 125                 m_aTestHelper.Error( "Nonexisting element doesn't detected by isStorageElement() call!" );
 126                 return false;
 127             }
 128             catch( com.sun.star.container.NoSuchElementException ne )
 129             {
 130             }
 131             catch( Exception e )
 132             {
 133                 m_aTestHelper.Error( "Wrong exception is thrown by isStorageElement() call: " + e );
 134                 return false;
 135             }
 136
 137             try {
 138                 xTempStorage.isStreamElement( "does not exist" );
 139                 m_aTestHelper.Error( "Nonexisting element doesn't detected by isStreamElement() call!" );
 140                 return false;
 141             }
 142             catch( com.sun.star.container.NoSuchElementException ne )
 143             {
 144             }
 145             catch( Exception e )
 146             {
 147                 m_aTestHelper.Error( "Wrong exception is thrown by isStreamElement() call: " + e );
 148                 return false;
 149             }
 150
 151             XNameAccess xRootNameAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xTempStorage );
 152             if ( xRootNameAccess == null )
 153             {
 154                 m_aTestHelper.Error( "Root storage doesn't support XNameAccess!" );
 155                 return false;
 156             }
 157
 158             try {
 159                 if ( !xTempStorage.isStorageElement( "SubStorage1" ) || xTempStorage.isStreamElement( "SubStorage1" ) )
 160                 {
 161                     m_aTestHelper.Error( "Child 'SubStorage1' can not be detected as storage!" );
 162                     return false;
 163                 }
 164
 165                 if ( xTempStorage.isStorageElement( "SubStream1" ) || !xTempStorage.isStreamElement( "SubStream1" ) )
 166                 {
 167                     m_aTestHelper.Error( "Child 'SubStream1' can not be detected as stream!" );
 168                     return false;
 169                 }
 170             }
 171             catch( Exception e )
 172             {
 173                 m_aTestHelper.Error( "Child's type can not be detected, exception: " + e );
 174                 return false;
 175             }
 176
 177
 178             // check that root storage contents are represented correctly
 179             String sRootCont[] = xRootNameAccess.getElementNames();
 180
 181             if ( sRootCont.length != 2 )
 182             {
 183                 m_aTestHelper.Error( "Root storage contains wrong amount of children!" );
 184                 return false;
 185             }
 186
 187             if ( !( sRootCont[0].equals( "SubStorage1" ) && sRootCont[1].equals( "SubStream1" )
 188                  || sRootCont[0].equals( "SubStream1" ) && sRootCont[1].equals( "SubStorage1" ) )
 189               || !( xRootNameAccess.hasByName( "SubStream1" ) && xRootNameAccess.hasByName( "SubStorage1" ) ) )
 190             {
 191                 m_aTestHelper.Error( "Root storage contains wrong list of children!" );
 192                 return false;
 193             }
 194
 195             // get storage through XNameAccess
 196             XStorage xResultSubStorage = getStorageFromNameAccess( xRootNameAccess, "SubStorage1" );
 197             if ( xResultSubStorage == null )
 198                 return false;
 199
 200             if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage,
 201                                                         false,
 202                                                         ElementModes.READ,
 203                                                         aRelations ) )
 204                 return false;
 205
 206             XNameAccess xChildAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xResultSubStorage );
 207             if ( xChildAccess == null )
 208             {
 209                 m_aTestHelper.Error( "Child storage doesn't support XNameAccess!" );
 210                 return false;
 211             }
 212
 213             if ( !xChildAccess.hasByName( "SubStream2" )
 214               || !xResultSubStorage.isStreamElement( "SubStream2" )
 215               || xResultSubStorage.isStorageElement( "SubStream2" ) )
 216             {
 217                 m_aTestHelper.Error( "'SubStream2' can not be detected as child stream element of 'SubStorage1'!" );
 218                 return false;
 219             }
 220
 221             return true;
 222         }
 223         catch( Exception e )
 224         {
 225             m_aTestHelper.Error( "Exception: " + e );
 226             return false;
 227         }
 228     }
 229
 230     public XStorage getStorageFromNameAccess( XNameAccess xAccess, String sName )
 231     {
 232         try
 233         {
 234             Object oStorage = xAccess.getByName( sName );
 235             XStorage xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oStorage );
 236
 237             if ( xResult != null )
 238                 return xResult;
 239             else
 240                 m_aTestHelper.Error( "Can't retrieve substorage '" + sName + "' through XNameAccess!" );
 241         }
 242         catch( Exception e )
 243         {
 244             m_aTestHelper.Error( "Can't retrieve substorage '" + sName + "' through XNameAccess, exception: " + e );
 245         }
 246
 247         return null;
 248     }
 249
 250 }
 251