qadevOOo/runner/helper/StreamSimulator.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 helper;
  20
  21 import com.sun.star.uno.UnoRuntime;
  22
  23
  24 import com.sun.star.ucb.XSimpleFileAccess;
  25
  26 /**
  27  * It simulates an input and output stream and
  28  * implements the interfaces XInputStream, XOutputStream.
  29  * So it can be used for testing loading/saving of documents
  30  * using streams instead of URLs.
  31  *
  32  */
  33 public class StreamSimulator implements com.sun.star.io.XInputStream    ,
  34                                         com.sun.star.io.XOutputStream   ,
  35                                         com.sun.star.io.XSeekable
  36 {
  37
  38     /**
  39      * @member  m_sFileName     name of the corresponding file on disk
  40      * @member  m_xInStream     the internal input stream for reading
  41      * @member  m_xOutStream    the internal input stream for writing
  42      * @member  m_xSeek         points at runtime to m_xInStream or m_xOutStream and make it seekable
  43      *
  44      * @member  //m_aProtocol     the external set protocol object for logging messages
  45      * @member  m_bInWasUsed    indicates, that the input stream interface was used
  46      * @member  m_bOutWasUsed   indicates, that the output stream interface was used
  47      */
  48
  49     private com.sun.star.io.XInputStream    m_xInStream     ;
  50     private com.sun.star.io.XOutputStream   m_xOutStream    ;
  51     private com.sun.star.io.XSeekable       m_xSeek         ;
  52
  53
  54
  55
  56
  57     /**
  58      * construct a new instance of this class
  59      * It set the name of the corresponding file on disk, which
  60      * should be source or target for the following operations on
  61      * this object. And it regulate if it should function as
  62      * input or output stream.
  63      *
  64      * @param   sFileName
  65      *              name of the file on disk
  66      *              Will be used as source (if param bInput==true)
  67      *              or as target (if param bInput==false).
  68      *
  69      * @param   bInput
  70      *              it specify, which interface should work at this object.
  71      *              <TRUE/>  => we simulate an input stream
  72      *              <FALSE/> => we simulate an output stream
  73      *
  74      * @throw   com.sun.star.io.NotConnectedException
  75      *              in case the internal streams to the file on disk couldn't established.
  76      *              They are necessary. Otherwise this simulator can't really work.
  77      */
  78     public StreamSimulator( String  sFileName , boolean bInput ,
  79         lib.TestParameters param   ) throws com.sun.star.io.NotConnectedException
  80     {
  81         try
  82         {
  83             XSimpleFileAccess xHelper = UnoRuntime.queryInterface(XSimpleFileAccess.class,
  84                 param.getMSF().createInstance("com.sun.star.ucb.SimpleFileAccess"));
  85
  86             if (xHelper == null)
  87                 throw new com.sun.star.io.NotConnectedException("ucb helper not available. Can't create streams.");
  88
  89             if (bInput)
  90             {
  91                 m_xInStream = xHelper.openFileRead(sFileName);
  92                 m_xSeek = UnoRuntime.queryInterface(
  93                             com.sun.star.io.XSeekable.class,
  94                             m_xInStream);
  95             }
  96             else
  97             {
  98                 m_xOutStream = xHelper.openFileWrite(sFileName);
  99                 m_xSeek = UnoRuntime.queryInterface(
 100                             com.sun.star.io.XSeekable.class,
 101                             m_xOutStream);
 102             }
 103         }
 104         catch(com.sun.star.uno.Exception exUno)
 105         {
 106             throw new com.sun.star.io.NotConnectedException(exUno);
 107         }
 108     }
 109
 110     /**
 111      * following methods simulates the XInputStream.
 112      * The notice all actions inside the internal protocol
 113      * and try to map all necessary functions to the internal
 114      * open in-stream.
 115      */
 116     public int readBytes( /*OUT*/ byte[][] lData        ,
 117                           /*IN*/  int      nBytesToRead ) throws com.sun.star.io.NotConnectedException      ,
 118                                                                  com.sun.star.io.BufferSizeExceededException,
 119                                                                  com.sun.star.io.IOException
 120     {
 121         if (m_xInStream == null)
 122         {
 123             throw new com.sun.star.io.NotConnectedException("stream not open");
 124         }
 125
 126         int nRead = 0;
 127         try
 128         {
 129             nRead = m_xInStream.readBytes(lData,nBytesToRead);
 130         }
 131         catch (com.sun.star.io.NotConnectedException       exConnect) {
 132         }
 133         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 134         }
 135         catch (com.sun.star.io.IOException                 exIO     ) {
 136         }
 137         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 138         }
 139
 140         return nRead;
 141     }
 142
 143
 144
 145     public int readSomeBytes( /*OUT*/ byte[][] lData           ,
 146                               /*IN*/  int      nMaxBytesToRead ) throws com.sun.star.io.NotConnectedException       ,
 147                                                                         com.sun.star.io.BufferSizeExceededException ,
 148                                                                         com.sun.star.io.IOException
 149     {
 150         if (m_xInStream == null)
 151         {
 152             throw new com.sun.star.io.NotConnectedException("stream not open");
 153         }
 154
 155         int nRead = 0;
 156         try
 157         {
 158             nRead = m_xInStream.readSomeBytes(lData,nMaxBytesToRead);
 159         }
 160         catch (com.sun.star.io.NotConnectedException       exConnect) {
 161         }
 162         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 163         }
 164         catch (com.sun.star.io.IOException                 exIO     ) {
 165         }
 166         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 167         }
 168
 169         return nRead;
 170     }
 171
 172
 173
 174     public void skipBytes( /*IN*/ int nBytesToSkip ) throws com.sun.star.io.NotConnectedException       ,
 175                                                             com.sun.star.io.BufferSizeExceededException ,
 176                                                             com.sun.star.io.IOException
 177     {
 178         if (m_xInStream == null)
 179         {
 180             throw new com.sun.star.io.NotConnectedException("stream not open");
 181         }
 182
 183         try
 184         {
 185             m_xInStream.skipBytes(nBytesToSkip);
 186         }
 187         catch (com.sun.star.io.NotConnectedException       exConnect) {
 188         }
 189         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 190         }
 191         catch (com.sun.star.io.IOException                 exIO     ) {
 192         }
 193         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 194         }
 195     }
 196
 197
 198
 199     public int available() throws com.sun.star.io.NotConnectedException,
 200                                   com.sun.star.io.IOException
 201     {
 202         if (m_xInStream == null)
 203         {
 204             throw new com.sun.star.io.NotConnectedException("stream not open");
 205         }
 206
 207         int nAvailable = 0;
 208         try
 209         {
 210             nAvailable = m_xInStream.available();
 211         }
 212         catch (com.sun.star.io.NotConnectedException exConnect) {
 213         }
 214         catch (com.sun.star.io.IOException           exIO     ) {
 215         }
 216         catch (com.sun.star.uno.RuntimeException     exRuntime) {
 217         }
 218
 219         return nAvailable;
 220     }
 221
 222
 223
 224     public void closeInput() throws com.sun.star.io.NotConnectedException,
 225                                     com.sun.star.io.IOException
 226     {
 227         if (m_xInStream == null)
 228         {
 229             throw new com.sun.star.io.NotConnectedException("stream not open");
 230         }
 231
 232         try
 233         {
 234             m_xInStream.closeInput();
 235         }
 236         catch (com.sun.star.io.NotConnectedException exConnect) {
 237         }
 238         catch (com.sun.star.io.IOException           exIO     ) {
 239         }
 240         catch (com.sun.star.uno.RuntimeException     exRuntime) {
 241         }
 242     }
 243
 244
 245     /**
 246      * following methods simulates the XOutputStream.
 247      * The notice all actions inside the internal protocol
 248      * and try to map all necessary functions to the internal
 249      * open out-stream.
 250      */
 251     public void writeBytes( /*IN*/byte[] lData ) throws com.sun.star.io.NotConnectedException       ,
 252                                                         com.sun.star.io.BufferSizeExceededException ,
 253                                                         com.sun.star.io.IOException
 254     {
 255         if (m_xOutStream == null)
 256         {
 257             throw new com.sun.star.io.NotConnectedException("stream not open");
 258         }
 259
 260         try
 261         {
 262             m_xOutStream.writeBytes(lData);
 263         }
 264         catch (com.sun.star.io.NotConnectedException       exConnect) {
 265         }
 266         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 267         }
 268         catch (com.sun.star.io.IOException                 exIO     ) {
 269         }
 270         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 271         }
 272     }
 273
 274
 275
 276     public void flush() throws com.sun.star.io.NotConnectedException        ,
 277                                com.sun.star.io.BufferSizeExceededException  ,
 278                                com.sun.star.io.IOException
 279     {
 280         if (m_xOutStream == null)
 281         {
 282             throw new com.sun.star.io.NotConnectedException("stream not open");
 283         }
 284
 285         try
 286         {
 287             m_xOutStream.flush();
 288         }
 289         catch (com.sun.star.io.NotConnectedException       exConnect) {
 290         }
 291         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 292         }
 293         catch (com.sun.star.io.IOException                 exIO     ) {
 294         }
 295         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 296         }
 297     }
 298
 299
 300
 301     public void closeOutput() throws com.sun.star.io.NotConnectedException      ,
 302                                      com.sun.star.io.BufferSizeExceededException,
 303                                      com.sun.star.io.IOException
 304     {
 305         if (m_xOutStream == null)
 306         {
 307             throw new com.sun.star.io.NotConnectedException("stream not open");
 308         }
 309
 310         try
 311         {
 312             m_xOutStream.closeOutput();
 313         }
 314         catch (com.sun.star.io.NotConnectedException       exConnect) {
 315         }
 316         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 317         }
 318         catch (com.sun.star.io.IOException                 exIO     ) {
 319         }
 320         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 321         }
 322     }
 323
 324
 325     /**
 326      * following methods simulates the XSeekable.
 327      * The notice all actions inside the internal protocol
 328      * and try to map all necessary functions to the internal
 329      * open stream.
 330      */
 331     public void seek( /*IN*/long nLocation ) throws com.sun.star.lang.IllegalArgumentException,
 332                                                     com.sun.star.io.IOException
 333     {
 334         if (m_xSeek == null)
 335         {
 336             throw new com.sun.star.io.IOException("stream not seekable");
 337         }
 338
 339         try
 340         {
 341             m_xSeek.seek(nLocation);
 342         }
 343         catch (com.sun.star.lang.IllegalArgumentException exArg    ) {
 344         }
 345         catch (com.sun.star.io.IOException                exIO     ) {
 346         }
 347         catch (com.sun.star.uno.RuntimeException          exRuntime) {
 348         }
 349     }
 350
 351
 352
 353     public long getPosition() throws com.sun.star.io.IOException
 354     {
 355         if (m_xSeek == null)
 356         {
 357             throw new com.sun.star.io.IOException("stream not seekable");
 358         }
 359
 360         long nPos = 0;
 361         try
 362         {
 363             nPos = m_xSeek.getPosition();
 364         }
 365         catch (com.sun.star.io.IOException       exIO     ) {
 366         }
 367         catch (com.sun.star.uno.RuntimeException exRuntime) {
 368         }
 369
 370         return nPos;
 371     }
 372
 373
 374
 375     public long getLength() throws com.sun.star.io.IOException
 376     {
 377         if (m_xSeek == null)
 378         {
 379             throw new com.sun.star.io.IOException("stream not seekable");
 380         }
 381
 382         long nLen = 0;
 383         try
 384         {
 385             nLen = m_xSeek.getLength();
 386         }
 387         catch (com.sun.star.io.IOException       exIO     ) {
 388         }
 389         catch (com.sun.star.uno.RuntimeException exRuntime) {
 390         }
 391
 392         return nLen;
 393     }
 394 }