?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix toolbar import
[ooovba.git] / package / qa / storages / TestHelper.java
blob687b7b8df990b8203e2b939bc816fad3bab2ab47
1 package complex.storages;
2
3 import com.sun.star.uno.UnoRuntime;
4 import com.sun.star.uno.XInterface;
5 import com.sun.star.uno.AnyConverter;
6
7 import com.sun.star.lang.*;
8 import com.sun.star.embed.*;
9 import com.sun.star.packages.*;
10 import com.sun.star.io.*;
11 import com.sun.star.beans.*;
12
13 import share.LogWriter;
14
15 public class TestHelper {
16
17 LogWriter m_aLogWriter;
18 String m_sTestPrefix;
19
20 public TestHelper( LogWriter aLogWriter, String sTestPrefix )
21 {
22 m_aLogWriter = aLogWriter;
23 m_sTestPrefix = sTestPrefix;
24 }
25
26 public boolean WriteBytesToStream( XStream xStream,
27 String sStreamName,
28 String sMediaType,
29 boolean bCompressed,
30 byte[] pBytes )
31 {
32 // get output stream of substream
33 XOutputStream xOutput = xStream.getOutputStream();
34 if ( xOutput == null )
35 {
36 Error( "Can't get XOutputStream implementation from substream '" + sStreamName + "'!" );
37 return false;
38 }
39
40 // get XTrucate implementation from output stream
41 XTruncate xTruncate = (XTruncate) UnoRuntime.queryInterface( XTruncate.class, xOutput );
42 if ( xTruncate == null )
43 {
44 Error( "Can't get XTruncate implementation from substream '" + sStreamName + "'!" );
45 return false;
46 }
47
48 // write requested byte sequence
49 try
50 {
51 xTruncate.truncate();
52 xOutput.writeBytes( pBytes );
53 }
54 catch( Exception e )
55 {
56 Error( "Can't write to stream '" + sStreamName + "', exception: " + e );
57 return false;
58 }
59
60 // get access to the XPropertySet interface
61 XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStream );
62 if ( xPropSet == null )
63 {
64 Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" );
65 return false;
66 }
67
68 // set properties to the stream
69 try
70 {
71 xPropSet.setPropertyValue( "MediaType", sMediaType );
72 xPropSet.setPropertyValue( "Compressed", new Boolean( bCompressed ) );
73 }
74 catch( Exception e )
75 {
76 Error( "Can't set properties to substream '" + sStreamName + "', exception: " + e );
77 return false;
78 }
79
80 // check size property of the stream
81 try
82 {
83 int nSize = AnyConverter.toInt( xPropSet.getPropertyValue( "Size" ) );
84 if ( nSize != pBytes.length )
85 {
86 Error( "The 'Size' property of substream '" + sStreamName + "' contains wrong value!" );
87 return false;
88 }
89 }
90 catch( Exception e )
91 {
92 Error( "Can't get 'Size' property from substream '" + sStreamName + "', exception: " + e );
93 return false;
94 }
95
96 return true;
97 }
98
99
100 public boolean WriteBytesToSubstream( XStorage xStorage,
101 String sStreamName,
102 String sMediaType,
103 boolean bCompressed,
104 byte[] pBytes )
105 {
106 // open substream element
107 XStream xSubStream = null;
108 try
109 {
110 Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.WRITE );
111 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
112 if ( xSubStream == null )
113 {
114 Error( "Can't create substream '" + sStreamName + "'!" );
115 return false;
116 }
117 }
118 catch( Exception e )
119 {
120 Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
121 return false;
122 }
123
124 if ( !WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ) )
125 return false;
126
127 // free the stream resources, garbage collector may remove the object too late
128 if ( !disposeStream( xSubStream, sStreamName ) )
129 return false;
130
131 return true;
132 }
133
134 public boolean WriteBytesToEncrSubstream( XStorage xStorage,
135 String sStreamName,
136 String sMediaType,
137 boolean bCompressed,
138 byte[] pBytes,
139 String sPass )
140 {
141 // open substream element
142 XStream xSubStream = null;
143 try
144 {
145 Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.WRITE, sPass );
146 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
147 if ( xSubStream == null )
148 {
149 Error( "Can't create substream '" + sStreamName + "'!" );
150 return false;
151 }
152 }
153 catch( Exception e )
154 {
155 Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
156 return false;
157 }
158
159 if ( !WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ) )
160 return false;
161
162 // free the stream resources, garbage collector may remove the object too late
163 if ( !disposeStream( xSubStream, sStreamName ) )
164 return false;
165
166 return true;
167 }
168
169 public boolean WBToSubstrOfEncr( XStorage xStorage,
170 String sStreamName,
171 String sMediaType,
172 boolean bCompressed,
173 byte[] pBytes,
174 boolean bEncrypted )
175 {
176 // open substream element
177 XStream xSubStream = null;
178 try
179 {
180 Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.WRITE );
181 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
182 if ( xSubStream == null )
183 {
184 Error( "Can't create substream '" + sStreamName + "'!" );
185 return false;
186 }
187 }
188 catch( Exception e )
189 {
190 Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
191 return false;
192 }
193
194 // get access to the XPropertySet interface
195 XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xSubStream );
196 if ( xPropSet == null )
197 {
198 Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" );
199 return false;
200 }
201
202 // set properties to the stream
203 try
204 {
205 xPropSet.setPropertyValue( "UseCommonStoragePasswordEncryption", new Boolean( bEncrypted ) );
206 }
207 catch( Exception e )
208 {
209 Error( "Can't set 'UseCommonStoragePasswordEncryption' property to substream '" + sStreamName + "', exception: " + e );
210 return false;
211 }
212
213 if ( !WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ) )
214 return false;
215
216 // free the stream resources, garbage collector may remove the object too late
217 if ( !disposeStream( xSubStream, sStreamName ) )
218 return false;
219
220 return true;
221 }
222
223 public boolean WriteBytesToStreamH( XStorage xStorage,
224 String sStreamPath,
225 String sMediaType,
226 boolean bCompressed,
227 byte[] pBytes,
228 boolean bCommit )
229 {
230 // open substream element
231 XStream xSubStream = null;
232 try
233 {
234 XHierarchicalStorageAccess xHStorage =
235 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage );
236 if ( xHStorage == null )
237 {
238 Error( "The storage does not support hierarchical access!" );
239 return false;
240 }
241
242 Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sStreamPath, ElementModes.WRITE );
243 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
244 if ( xSubStream == null )
245 {
246 Error( "Can't create substream '" + sStreamPath + "'!" );
247 return false;
248 }
249 }
250 catch( Exception e )
251 {
252 Error( "Can't create substream '" + sStreamPath + "', exception : " + e + "!" );
253 return false;
254 }
255
256 if ( !WriteBytesToStream( xSubStream, sStreamPath, sMediaType, bCompressed, pBytes ) )
257 return false;
258
259 XTransactedObject xTransact =
260 (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream );
261 if ( xTransact == null )
262 {
263 Error( "Substream '" + sStreamPath + "', stream opened for writing must be transacted!" );
264 return false;
265 }
266
267 if ( bCommit )
268 {
269 try {
270 xTransact.commit();
271 } catch( Exception e )
272 {
273 Error( "Can't commit storage after substream '" + sStreamPath + "' change, exception : " + e + "!" );
274 return false;
275 }
276 }
277
278 // free the stream resources, garbage collector may remove the object too late
279 if ( !disposeStream( xSubStream, sStreamPath ) )
280 return false;
281
282 return true;
283 }
284
285 public boolean WriteBytesToEncrStreamH( XStorage xStorage,
286 String sStreamPath,
287 String sMediaType,
288 boolean bCompressed,
289 byte[] pBytes,
290 String sPass,
291 boolean bCommit )
292 {
293 // open substream element
294 XStream xSubStream = null;
295 try
296 {
297 XHierarchicalStorageAccess xHStorage =
298 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage );
299 if ( xHStorage == null )
300 {
301 Error( "The storage does not support hierarchical access!" );
302 return false;
303 }
304
305 Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sStreamPath,
306 ElementModes.WRITE,
307 sPass );
308 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
309 if ( xSubStream == null )
310 {
311 Error( "Can't create substream '" + sStreamPath + "'!" );
312 return false;
313 }
314 }
315 catch( Exception e )
316 {
317 Error( "Can't create substream '" + sStreamPath + "', exception : " + e + "!" );
318 return false;
319 }
320
321 if ( !WriteBytesToStream( xSubStream, sStreamPath, sMediaType, bCompressed, pBytes ) )
322 return false;
323
324 XTransactedObject xTransact =
325 (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream );
326 if ( xTransact == null )
327 {
328 Error( "Substream '" + sStreamPath + "', stream opened for writing must be transacted!" );
329 return false;
330 }
331
332 if ( bCommit )
333 {
334 try {
335 xTransact.commit();
336 } catch( Exception e )
337 {
338 Error( "Can't commit storage after substream '" + sStreamPath + "' change, exception : " + e + "!" );
339 return false;
340 }
341 }
342
343 // free the stream resources, garbage collector may remove the object too late
344 if ( !disposeStream( xSubStream, sStreamPath ) )
345 return false;
346
347 return true;
348 }
349
350 public boolean WBToSubstrOfEncrH( XStorage xStorage,
351 String sStreamPath,
352 String sMediaType,
353 boolean bCompressed,
354 byte[] pBytes,
355 boolean bEncrypted,
356 boolean bCommit )
357 {
358 // open substream element
359 XStream xSubStream = null;
360 try
361 {
362 XHierarchicalStorageAccess xHStorage =
363 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage );
364 if ( xHStorage == null )
365 {
366 Error( "The storage does not support hierarchical access!" );
367 return false;
368 }
369
370 Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sStreamPath, ElementModes.WRITE );
371 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
372 if ( xSubStream == null )
373 {
374 Error( "Can't create substream '" + sStreamPath + "'!" );
375 return false;
376 }
377 }
378 catch( Exception e )
379 {
380 Error( "Can't create substream '" + sStreamPath + "', exception : " + e + "!" );
381 return false;
382 }
383
384 // get access to the XPropertySet interface
385 XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xSubStream );
386 if ( xPropSet == null )
387 {
388 Error( "Can't get XPropertySet implementation from substream '" + sStreamPath + "'!" );
389 return false;
390 }
391
392 // set properties to the stream
393 try
394 {
395 xPropSet.setPropertyValue( "UseCommonStoragePasswordEncryption", new Boolean( bEncrypted ) );
396 }
397 catch( Exception e )
398 {
399 Error( "Can't set 'UseCommonStoragePasswordEncryption' property to substream '" + sStreamPath + "', exception: " + e );
400 return false;
401 }
402
403 if ( !WriteBytesToStream( xSubStream, sStreamPath, sMediaType, bCompressed, pBytes ) )
404 return false;
405
406 XTransactedObject xTransact =
407 (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream );
408 if ( xTransact == null )
409 {
410 Error( "Substream '" + sStreamPath + "', stream opened for writing must be transacted!" );
411 return false;
412 }
413
414 if ( bCommit )
415 {
416 try {
417 xTransact.commit();
418 } catch( Exception e )
419 {
420 Error( "Can't commit storage after substream '" + sStreamPath + "' change, exception : " + e + "!" );
421 return false;
422 }
423 }
424
425 // free the stream resources, garbage collector may remove the object too late
426 if ( !disposeStream( xSubStream, sStreamPath ) )
427 return false;
428
429 return true;
430 }
431
432 public int ChangeStreamPass( XStorage xStorage,
433 String sStreamName,
434 String sOldPass,
435 String sNewPass )
436 {
437 // open substream element
438 XStream xSubStream = null;
439 try
440 {
441 Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.WRITE, sOldPass );
442 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
443 if ( xSubStream == null )
444 {
445 Error( "Can't open substream '" + sStreamName + "'!" );
446 return 0;
447 }
448 }
449 catch( Exception e )
450 {
451 Error( "Can't open substream '" + sStreamName + "', exception : " + e + "!" );
452 return 0;
453 }
454
455
456 // change the password for the stream
457 XEncryptionProtectedSource xStreamEncryption =
458 (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xSubStream );
459
460 if ( xStreamEncryption == null )
461 {
462 Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" );
463 return -1;
464 }
465
466 try {
467 xStreamEncryption.setEncryptionPassword( sNewPass );
468 }
469 catch( Exception e )
470 {
471 Error( "Can't change encryption key of the substream '" + sStreamName + "', exception:" + e );
472 return 0;
473 }
474
475 // free the stream resources, garbage collector may remove the object too late
476 if ( !disposeStream( xSubStream, sStreamName ) )
477 return 0;
478
479 return 1;
480 }
481
482 public int ChangeStreamPassH( XStorage xStorage,
483 String sPath,
484 String sOldPass,
485 String sNewPass,
486 boolean bCommit )
487 {
488 // open substream element
489 XHierarchicalStorageAccess xHStorage =
490 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage );
491 if ( xHStorage == null )
492 {
493 Error( "The storage does not support hierarchical access!" );
494 return 0;
495 }
496
497 XStream xSubStream = null;
498 try
499 {
500 Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, ElementModes.WRITE, sOldPass );
501 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
502 if ( xSubStream == null )
503 {
504 Error( "Can't open encrypted substream '" + sPath + "'!" );
505 return 0;
506 }
507 }
508 catch( Exception e )
509 {
510 Error( "Can't open encrypted substream '" + sPath + "', exception : " + e + "!" );
511 return 0;
512 }
513
514 // change the password for the stream
515 XEncryptionProtectedSource xStreamEncryption =
516 (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xSubStream );
517
518 if ( xStreamEncryption == null )
519 {
520 Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" );
521 return -1;
522 }
523
524 try {
525 xStreamEncryption.setEncryptionPassword( sNewPass );
526 }
527 catch( Exception e )
528 {
529 Error( "Can't change encryption key of the substream '" + sPath + "', exception:" + e );
530 return 0;
531 }
532
533 XTransactedObject xTransact =
534 (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream );
535 if ( xTransact == null )
536 {
537 Error( "Substream '" + sPath + "', stream opened for writing must be transacted!" );
538 return 0;
539 }
540
541 if ( bCommit )
542 {
543 try {
544 xTransact.commit();
545 } catch( Exception e )
546 {
547 Error( "Can't commit storage after substream '" + sPath + "' change, exception : " + e + "!" );
548 return 0;
549 }
550 }
551
552 // free the stream resources, garbage collector may remove the object too late
553 if ( !disposeStream( xSubStream, sPath ) )
554 return 0;
555
556 return 1;
557 }
558
559 public boolean setStorageTypeAndCheckProps( XStorage xStorage, String sMediaType, boolean bIsRoot, int nMode )
560 {
561 boolean bOk = false;
562
563 // get access to the XPropertySet interface
564 XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStorage );
565 if ( xPropSet != null )
566 {
567 try
568 {
569 // set "MediaType" property to the stream
570 xPropSet.setPropertyValue( "MediaType", sMediaType );
571
572 // get "IsRoot" and "OpenMode" properties and control there values
573 boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) );
574 int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) );
575
576 bOk = true;
577 if ( bPropIsRoot != bIsRoot )
578 {
579 Error( "'IsRoot' property contains wrong value!" );
580 bOk = false;
581 }
582
583 if ( ( bIsRoot
584 && ( nPropMode | ElementModes.READ ) != ( nMode | ElementModes.READ ) )
585 || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) )
586 {
587 Error( "'OpenMode' property contains wrong value, expected " + nMode + ", in reality " + nPropMode + "!" );
588 bOk = false;
589 }
590 }
591 catch( Exception e )
592 {
593 Error( "Can't control properties of substorage, exception: " + e );
594 }
595 }
596 else
597 {
598 Error( "Can't get XPropertySet implementation from storage!" );
599 }
600
601 return bOk;
602 }
603
604 public boolean checkStorageProperties( XStorage xStorage, String sMediaType, boolean bIsRoot, int nMode )
605 {
606 boolean bOk = false;
607
608 // get access to the XPropertySet interface
609 XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStorage );
610 if ( xPropSet != null )
611 {
612 try
613 {
614 // get "MediaType", "IsRoot" and "OpenMode" properties and control there values
615 String sPropMediaType = AnyConverter.toString( xPropSet.getPropertyValue( "MediaType" ) );
616 boolean bPropIsRoot = AnyConverter.toBoolean( xPropSet.getPropertyValue( "IsRoot" ) );
617 int nPropMode = AnyConverter.toInt( xPropSet.getPropertyValue( "OpenMode" ) );
618
619 bOk = true;
620 if ( !sPropMediaType.equals( sMediaType ) )
621 {
622 Error( "'MediaType' property contains wrong value, expected '"
623 + sMediaType + "', set '" + sPropMediaType + "' !" );
624 bOk = false;
625 }
626
627 if ( bPropIsRoot != bIsRoot )
628 {
629 Error( "'IsRoot' property contains wrong value!" );
630 bOk = false;
631 }
632
633 if ( ( bIsRoot
634 && ( nPropMode | ElementModes.READ ) != ( nMode | ElementModes.READ ) )
635 || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) )
636 {
637 Error( "'OpenMode' property contains wrong value, expected " + nMode + ", in reality " + nPropMode + "!" );
638 bOk = false;
639 }
640 }
641 catch( Exception e )
642 {
643 Error( "Can't get properties of substorage, exception: " + e );
644 }
645 }
646 else
647 {
648 Error( "Can't get XPropertySet implementation from storage!" );
649 }
650
651 return bOk;
652 }
653
654 public boolean InternalCheckStream( XStream xStream,
655 String sName,
656 String sMediaType,
657 boolean bCompressed,
658 byte[] pBytes,
659 boolean bCheckCompressed )
660 {
661 // get input stream of substream
662 XInputStream xInput = xStream.getInputStream();
663 if ( xInput == null )
664 {
665 Error( "Can't get XInputStream implementation from substream '" + sName + "'!" );
666 return false;
667 }
668
669 byte pContents[][] = new byte[1][]; // ???
670
671 // read contents
672 try
673 {
674 xInput.readBytes( pContents, pBytes.length + 1 );
675 }
676 catch( Exception e )
677 {
678 Error( "Can't read from stream '" + sName + "', exception: " + e );
679 return false;
680 }
681
682 // check size of stream data
683 if ( pContents.length == 0 )
684 {
685 Error( "SubStream '" + sName + "' reading produced disaster!" );
686 return false;
687 }
688
689 if ( pBytes.length != pContents[0].length )
690 {
691 Error( "SubStream '" + sName + "' contains wrong amount of data! (" + pContents[0].length + "/" + pBytes.length + ")" );
692 return false;
693 }
694
695 // check stream data
696 for ( int ind = 0; ind < pBytes.length; ind++ )
697 {
698 if ( pBytes[ind] != pContents[0][ind] )
699 {
700 Error( "SubStream '" + sName + "' contains wrong data! ( byte num. "
701 + ind + " should be " + pBytes[ind] + " but it is " + pContents[0][ind] + ")" );
702 return false;
703 }
704 }
705
706 // check properties
707 boolean bOk = false;
708
709 // get access to the XPropertySet interface
710 XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xStream );
711 if ( xPropSet != null )
712 {
713 try
714 {
715 // get "MediaType" and "Size" properties and control there values
716 String sPropMediaType = AnyConverter.toString( xPropSet.getPropertyValue( "MediaType" ) );
717 int nPropSize = AnyConverter.toInt( xPropSet.getPropertyValue( "Size" ) );
718 boolean bPropCompress = AnyConverter.toBoolean( xPropSet.getPropertyValue( "Compressed" ) );
719
720 bOk = true;
721 if ( !sPropMediaType.equals( sMediaType ) )
722 {
723 Error( "'MediaType' property contains wrong value for stream '" + sName + "',\nexpected: '"
724 + sMediaType + "', set: '" + sPropMediaType + "'!" );
725 bOk = false;
726 }
727
728 if ( nPropSize != pBytes.length )
729 {
730 Error( "'Size' property contains wrong value for stream'" + sName + "'!" );
731 bOk = false;
732 }
733
734 if ( bCheckCompressed && bPropCompress != bCompressed )
735 {
736 Error( "'Compressed' property contains wrong value for stream'" + sName + "'!" );
737 bOk = false;
738 }
739 }
740 catch( Exception e )
741 {
742 Error( "Can't get properties of substream '" + sName + "', exception: " + e );
743 }
744 }
745 else
746 {
747 Error( "Can't get XPropertySet implementation from stream '" + sName + "'!" );
748 }
749
750 return bOk;
751 }
752
753 public boolean checkStream( XStorage xParentStorage,
754 String sName,
755 String sMediaType,
756 boolean bCompressed,
757 byte[] pBytes )
758 {
759 // open substream element first
760 XStream xSubStream = null;
761 try
762 {
763 Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.READ );
764 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
765 if ( xSubStream == null )
766 {
767 Error( "Can't open substream '" + sName + "'!" );
768 return false;
769 }
770 }
771 catch( Exception e )
772 {
773 Error( "Can't open substream '" + sName + "', exception : " + e + "!" );
774 return false;
775 }
776
777 boolean bResult = InternalCheckStream( xSubStream, sName, sMediaType, bCompressed, pBytes, true );
778
779 // free the stream resources, garbage collector may remove the object too late
780 if ( !disposeStream( xSubStream, sName ) )
781 return false;
782
783 return bResult;
784 }
785
786 public boolean checkEncrStream( XStorage xParentStorage,
787 String sName,
788 String sMediaType,
789 byte[] pBytes,
790 String sPass )
791 {
792 // Important: a common password for any of parent storage should not be set or
793 // should be different from sPass
794
795 try
796 {
797 Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.READ );
798 Error( "Encrypted stream '" + sName + "' was opened without password!" );
799 return false;
800 }
801 catch( WrongPasswordException wpe )
802 {}
803 catch( Exception e )
804 {
805 Error( "Unexpected exception in case of opening of encrypted stream '" + sName + "' without password: " + e + "!" );
806 return false;
807 }
808
809 String sWrongPass = "11";
810 sWrongPass += sPass;
811 try
812 {
813 Object oSubStream = xParentStorage.openEncryptedStreamElement( sName, ElementModes.READ, sWrongPass );
814 Error( "Encrypted stream '" + sName + "' was opened with wrong password!" );
815 return false;
816 }
817 catch( WrongPasswordException wpe )
818 {}
819 catch( Exception e )
820 {
821 Error( "Unexpected exception in case of opening of encrypted stream '" + sName + "' with wrong password: " + e + "!" );
822 return false;
823 }
824
825 XStream xSubStream = null;
826 try
827 {
828 Object oSubStream = xParentStorage.openEncryptedStreamElement( sName, ElementModes.READ, sPass );
829 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
830 if ( xSubStream == null )
831 {
832 Error( "Can't open encrypted substream '" + sName + "'!" );
833 return false;
834 }
835 }
836 catch( Exception e )
837 {
838 Error( "Can't open encrypted substream '" + sName + "', exception : " + e + "!" );
839 return false;
840 }
841
842 // encrypted streams will be compressed always, so after the storing this property is always true,
843 // although before the storing it can be set to false ( it is not always clear whether a stream is encrypted
844 // before the storing )
845 boolean bResult = InternalCheckStream( xSubStream, sName, sMediaType, true, pBytes, false );
846
847 // free the stream resources, garbage collector may remove the object too late
848 if ( !disposeStream( xSubStream, sName ) )
849 return false;
850
851 return bResult;
852 }
853
854 public boolean checkStreamH( XStorage xParentStorage,
855 String sPath,
856 String sMediaType,
857 boolean bCompressed,
858 byte[] pBytes )
859 {
860 // open substream element first
861 XStream xSubStream = null;
862 try
863 {
864 XHierarchicalStorageAccess xHStorage =
865 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xParentStorage );
866 if ( xHStorage == null )
867 {
868 Error( "The storage does not support hierarchical access!" );
869 return false;
870 }
871
872 Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sPath, ElementModes.READ );
873 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
874 if ( xSubStream == null )
875 {
876 Error( "Can't open substream '" + sPath + "'!" );
877 return false;
878 }
879 }
880 catch( Exception e )
881 {
882 Error( "Can't open substream '" + sPath + "', exception : " + e + "!" );
883 return false;
884 }
885
886 boolean bResult = InternalCheckStream( xSubStream, sPath, sMediaType, bCompressed, pBytes, true );
887
888 // free the stream resources, garbage collector may remove the object too late
889 if ( !disposeStream( xSubStream, sPath ) )
890 return false;
891
892 return bResult;
893 }
894
895 public boolean checkEncrStreamH( XStorage xParentStorage,
896 String sPath,
897 String sMediaType,
898 byte[] pBytes,
899 String sPass )
900 {
901 // Important: a common password for any of parent storage should not be set or
902 // should be different from sPass
903 XHierarchicalStorageAccess xHStorage =
904 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xParentStorage );
905 if ( xHStorage == null )
906 {
907 Error( "The storage does not support hierarchical access!" );
908 return false;
909 }
910
911 try
912 {
913 Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sPath, ElementModes.READ );
914 XStream xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
915 Error( "Encrypted substream '" + sPath + "' was opened without password!" );
916 return false;
917 }
918 catch( WrongPasswordException wpe )
919 {}
920 catch( Exception e )
921 {
922 Error( "Unexpected exception in case of opening of encrypted stream '" + sPath + "' without password: " + e + "!" );
923 return false;
924 }
925
926 String sWrongPass = "11";
927 sWrongPass += sPass;
928 try
929 {
930 Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, ElementModes.READ, sWrongPass );
931 XStream xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
932 Error( "Encrypted substream '" + sPath + "' was opened with wrong password!" );
933 return false;
934 }
935 catch( WrongPasswordException wpe )
936 {}
937 catch( Exception e )
938 {
939 Error( "Unexpected exception in case of opening of encrypted stream '" + sPath + "' with wrong password: " + e + "!" );
940 return false;
941 }
942
943 XStream xSubStream = null;
944 try
945 {
946 Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, ElementModes.READ, sPass );
947 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
948 if ( xSubStream == null )
949 {
950 Error( "Can't open encrypted substream '" + sPath + "'!" );
951 return false;
952 }
953 }
954 catch( Exception e )
955 {
956 Error( "Can't open encrypted substream '" + sPath + "', exception : " + e + "!" );
957 return false;
958 }
959
960 // encrypted streams will be compressed always, so after the storing this property is always true,
961 // although before the storing it can be set to false ( it is not always clear whether a stream is encrypted
962 // before the storing )
963 boolean bResult = InternalCheckStream( xSubStream, sPath, sMediaType, true, pBytes, false );
964
965 // free the stream resources, garbage collector may remove the object too late
966 if ( !disposeStream( xSubStream, sPath ) )
967 return false;
968
969 return bResult;
970 }
971
972 public boolean copyStorage( XStorage xSourceStorage, XStorage xDestStorage )
973 {
974 // copy xSourceStorage to xDestStorage
975 try
976 {
977 xSourceStorage.copyToStorage( xDestStorage );
978 }
979 catch( Exception e )
980 {
981 Error( "Storage copying failed, exception: " + e );
982 return false;
983 }
984
985 return true;
986 }
987
988 public boolean commitStorage( XStorage xStorage )
989 {
990 // XTransactedObject must be supported by storages
991 XTransactedObject xTransact = (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xStorage );
992 if ( xTransact == null )
993 {
994 Error( "Storage doesn't implement transacted access!" );
995 return false;
996 }
997
998 try
999 {
1000 xTransact.commit();
1001 }
1002 catch( Exception e )
1003 {
1004 Error( "Storage commit failed, exception:" + e );
1005 return false;
1006 }
1007
1008 return true;
1009 }
1010
1011 public boolean disposeStream( XStream xStream, String sStreamName )
1012 {
1013 XComponent xComponent = (XComponent) UnoRuntime.queryInterface( XComponent.class, xStream );
1014 if ( xComponent == null )
1015 {
1016 Error( "Can't get XComponent implementation from substream '" + sStreamName + "'!" );
1017 return false;
1018 }
1019
1020 try
1021 {
1022 xComponent.dispose();
1023 }
1024 catch( Exception e )
1025 {
1026 Error( "Substream '" + sStreamName + "' disposing throws exception: " + e );
1027 return false;
1028 }
1029
1030 return true;
1031 }
1032
1033 public boolean disposeStorage( XStorage xStorage )
1034 {
1035 // dispose the storage
1036 XComponent xComponent = (XComponent) UnoRuntime.queryInterface( XComponent.class, xStorage );
1037 if ( xComponent == null )
1038 {
1039 Error( "Can't retrieve XComponent implementation from storage!" );
1040 return false;
1041 }
1042
1043 try
1044 {
1045 xComponent.dispose();
1046 }
1047 catch( Exception e )
1048 {
1049 Error( "Storage disposing failed!" );
1050 return false;
1051 }
1052
1053 return true;
1054 }
1055
1056 public XInputStream getInputStream( XStream xStream )
1057 {
1058 XInputStream xInTemp = null;
1059 try
1060 {
1061 xInTemp = xStream.getInputStream();
1062 if ( xInTemp == null )
1063 Error( "Can't get the input part of a stream!" );
1064 }
1065 catch ( Exception e )
1066 {
1067 Error( "Can't get the input part of a stream, exception :" + e );
1068 }
1069
1070 return xInTemp;
1071 }
1072
1073 public boolean closeOutput( XStream xStream )
1074 {
1075 XOutputStream xOutTemp = null;
1076 try
1077 {
1078 xOutTemp = xStream.getOutputStream();
1079 if ( xOutTemp == null )
1080 {
1081 Error( "Can't get the output part of a stream!" );
1082 return false;
1083 }
1084 }
1085 catch ( Exception e )
1086 {
1087 Error( "Can't get the output part of a stream, exception :" + e );
1088 return false;
1089 }
1090
1091 try
1092 {
1093 xOutTemp.closeOutput();
1094 }
1095 catch ( Exception e )
1096 {
1097 Error( "Can't close output part of a stream, exception :" + e );
1098 return false;
1099 }
1100
1101 return true;
1102 }
1103
1104 public XStorage openSubStorage( XStorage xStorage, String sName, int nMode )
1105 {
1106 // open existing substorage
1107 try
1108 {
1109 Object oSubStorage = xStorage.openStorageElement( sName, nMode );
1110 XStorage xSubStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oSubStorage );
1111 return xSubStorage;
1112 }
1113 catch( Exception e )
1114 {
1115 Error( "Can't open substorage '" + sName + "', exception: " + e );
1116 }
1117
1118 return null;
1119 }
1120
1121 public XStream CreateTempFileStream( XMultiServiceFactory xMSF )
1122 {
1123 // try to get temporary file representation
1124 XStream xTempFileStream = null;
1125 try
1126 {
1127 Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" );
1128 xTempFileStream = (XStream)UnoRuntime.queryInterface( XStream.class, oTempFile );
1129 }
1130 catch( Exception e )
1131 {}
1132
1133 if ( xTempFileStream == null )
1134 Error( "Can't create temporary file!" );
1135
1136 return xTempFileStream;
1137 }
1138
1139 public String CreateTempFile( XMultiServiceFactory xMSF )
1140 {
1141 String sResult = null;
1142
1143 // try to get temporary file representation
1144 XPropertySet xTempFileProps = null;
1145 try
1146 {
1147 Object oTempFile = xMSF.createInstance( "com.sun.star.io.TempFile" );
1148 xTempFileProps = (XPropertySet)UnoRuntime.queryInterface( XPropertySet.class, oTempFile );
1149 }
1150 catch( Exception e )
1151 {}
1152
1153 if ( xTempFileProps != null )
1154 {
1155 try
1156 {
1157 xTempFileProps.setPropertyValue( "RemoveFile", new Boolean( false ) );
1158 sResult = AnyConverter.toString( xTempFileProps.getPropertyValue( "Uri" ) );
1159 }
1160 catch( Exception e )
1161 {
1162 Error( "Can't control TempFile properties, exception: " + e );
1163 }
1164 }
1165 else
1166 {
1167 Error( "Can't create temporary file representation!" );
1168 }
1169
1170 // close temporary file explicitly
1171 try
1172 {
1173 XStream xStream = (XStream)UnoRuntime.queryInterface( XStream.class, xTempFileProps );
1174 if ( xStream != null )
1175 {
1176 XOutputStream xOut = xStream.getOutputStream();
1177 if ( xOut != null )
1178 xOut.closeOutput();
1179
1180 XInputStream xIn = xStream.getInputStream();
1181 if ( xIn != null )
1182 xIn.closeInput();
1183 }
1184 else
1185 Error( "Can't close TempFile!" );
1186 }
1187 catch( Exception e )
1188 {
1189 Error( "Can't close TempFile, exception: " + e );
1190 }
1191
1192 return sResult;
1193 }
1194
1195 public boolean copyElementTo( XStorage xSource, String sName, XStorage xDest )
1196 {
1197 // copy element with name sName from xSource to xDest
1198 try
1199 {
1200 xSource.copyElementTo( sName, xDest, sName );
1201 }
1202 catch( Exception e )
1203 {
1204 Error( "Element copying failed, exception: " + e );
1205 return false;
1206 }
1207
1208 return true;
1209 }
1210
1211 public boolean copyElementTo( XStorage xSource, String sName, XStorage xDest, String sTargetName )
1212 {
1213 // copy element with name sName from xSource to xDest
1214 try
1215 {
1216 xSource.copyElementTo( sName, xDest, sTargetName );
1217 }
1218 catch( Exception e )
1219 {
1220 Error( "Element copying failed, exception: " + e );
1221 return false;
1222 }
1223
1224 return true;
1225 }
1226
1227 public boolean moveElementTo( XStorage xSource, String sName, XStorage xDest )
1228 {
1229 // move element with name sName from xSource to xDest
1230 try
1231 {
1232 xSource.moveElementTo( sName, xDest, sName );
1233 }
1234 catch( Exception e )
1235 {
1236 Error( "Element moving failed, exception: " + e );
1237 return false;
1238 }
1239
1240 return true;
1241 }
1242
1243 public boolean renameElement( XStorage xStorage, String sOldName, String sNewName )
1244 {
1245 // rename element with name sOldName to sNewName
1246 try
1247 {
1248 xStorage.renameElement( sOldName, sNewName );
1249 }
1250 catch( Exception e )
1251 {
1252 Error( "Element renaming failed, exception: " + e );
1253 return false;
1254 }
1255
1256 return true;
1257 }
1258
1259 public boolean removeElement( XStorage xStorage, String sName )
1260 {
1261 // remove element with name sName
1262 try
1263 {
1264 xStorage.removeElement( sName );
1265 }
1266 catch( Exception e )
1267 {
1268 Error( "Element removing failed, exception: " + e );
1269 return false;
1270 }
1271
1272 return true;
1273 }
1274
1275 public XStream OpenStream( XStorage xStorage,
1276 String sStreamName,
1277 int nMode )
1278 {
1279 // open substream element
1280 XStream xSubStream = null;
1281 try
1282 {
1283 Object oSubStream = xStorage.openStreamElement( sStreamName, nMode );
1284 xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream );
1285 if ( xSubStream == null )
1286 Error( "Can't create substream '" + sStreamName + "'!" );
1287 }
1288 catch( Exception e )
1289 {
1290 Error( "Can't create substream '" + sStreamName + "', exception : " + e + "!" );
1291 }
1292
1293 return xSubStream;
1294 }
1295
1296 public boolean compareRawMethodsOnEncrStream( XStorage xStorage, String sStreamName )
1297 {
1298
1299 XStorageRawAccess xRawStorage;
1300 try
1301 {
1302 xRawStorage = (XStorageRawAccess) UnoRuntime.queryInterface( XStorageRawAccess.class, xStorage );
1303 }
1304 catch( Exception e )
1305 {
1306 Error( "Can't get raw access to the storage, exception : " + e + "!" );
1307 return false;
1308 }
1309
1310 if ( xRawStorage == null )
1311 {
1312 Error( "Can't get raw access to the storage!" );
1313 return false;
1314 }
1315
1316 XInputStream xHeadRawStream = null;
1317 try
1318 {
1319 xHeadRawStream = xRawStorage.getRawEncrStreamElement( sStreamName );
1320 }
1321 catch( Exception e )
1322 {
1323 Error( "Can't open encrypted stream '" + sStreamName + "' in raw mode with header, exception : " + e + "!" );
1324 }
1325
1326 XInputStream xPlainRawStream = null;
1327 try
1328 {
1329 xPlainRawStream = xRawStorage.getPlainRawStreamElement( sStreamName );
1330 }
1331 catch( Exception e )
1332 {
1333 Error( "Can't open encrypted stream '" + sStreamName + "' in raw mode with header, exception : " + e + "!" );
1334 }
1335
1336 if ( xHeadRawStream == null || xPlainRawStream == null )
1337 {
1338 Error( "Can't open encrypted stream '" + sStreamName + "' in raw modes!" );
1339 return false;
1340 }
1341
1342 try
1343 {
1344 byte pData[][] = new byte[1][22];
1345 if ( xHeadRawStream.readBytes( pData, 22 ) != 22 )
1346 {
1347 Error( "Can't read header of encrypted stream '" + sStreamName + "' raw representations!" );
1348 return false;
1349 }
1350
1351 if ( pData[0][0] != 0x4d || pData[0][1] != 0x47 || pData[0][2] != 0x02 || pData[0][3] != 0x05 )
1352 {
1353 Error( "No signature in the header of encrypted stream '" + sStreamName + "' raw representations!" );
1354 return false;
1355 }
1356
1357 int nVariableHeaderLength =
1358 ( pData[0][14] + pData[0][15] * 0x100 ) // salt length
1359 + ( pData[0][16] + pData[0][17] * 0x100 ) // iv length
1360 + ( pData[0][18] + pData[0][19] * 0x100 ) // digest length
1361 + ( pData[0][20] + pData[0][21] * 0x100 ); // mediatype length
1362
1363 xHeadRawStream.skipBytes( nVariableHeaderLength );
1364
1365 byte pRawData1[][] = new byte[1][32000];
1366 byte pRawData2[][] = new byte[1][32000];
1367 int nRead1 = 0;
1368 int nRead2 = 0;
1369
1370 do
1371 {
1372 nRead1 = xHeadRawStream.readBytes( pRawData1, 32000 );
1373 nRead2 = xPlainRawStream.readBytes( pRawData2, 32000 );
1374
1375 if ( nRead1 != nRead2 )
1376 {
1377 Error( "The encrypted stream '" + sStreamName + "' raw representations have different size!" );
1378 return false;
1379 }
1380
1381 for ( int nInd = 0; nInd < nRead1; nInd++ )
1382 if ( pRawData1[0][nInd] != pRawData2[0][nInd] )
1383 {
1384 Error( "The encrypted stream '" + sStreamName + "' raw representations have different data!" );
1385 return false;
1386 }
1387 }
1388 while( nRead1 == 32000 );
1389 }
1390 catch ( Exception e )
1391 {
1392 Error( "Can't compare stream '" + sStreamName + "' raw representations, exception : " + e + "!" );
1393 return false;
1394 }
1395
1396 return true;
1397 }
1398
1399 public boolean cantOpenStorage( XStorage xStorage, String sName )
1400 {
1401 // try to open an opened substorage, open call must fail
1402 try
1403 {
1404 Object oDummyStorage = xStorage.openStorageElement( sName, ElementModes.READ );
1405 Error( "The trying to reopen opened substorage '" + sName + "' must fail!" );
1406 }
1407 catch( Exception e )
1408 {
1409 return true;
1410 }
1411
1412 return false;
1413 }
1414
1415 public boolean cantOpenStream( XStorage xStorage, String sName, int nMode )
1416 {
1417 // try to open the substream with specified mode must fail
1418 try
1419 {
1420 Object oDummyStream = xStorage.openStreamElement( sName, nMode );
1421 Error( "The trying to open substream '" + sName + "' must fail!" );
1422 }
1423 catch( Exception e )
1424 {
1425 return true;
1426 }
1427
1428 return false;
1429 }
1430
1431 public boolean cantOpenStreamH( XStorage xStorage, String sPath, int nMode )
1432 {
1433 // try to open the substream with specified mode must fail
1434
1435 XHierarchicalStorageAccess xHStorage =
1436 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage );
1437 if ( xHStorage == null )
1438 {
1439 Error( "The storage does not support hierarchical access!" );
1440 return false;
1441 }
1442
1443 try
1444 {
1445 Object oDummyStream = xHStorage.openStreamElementByHierarchicalName( sPath, nMode );
1446 Error( "The trying to open substream '" + sPath + "' must fail!" );
1447 }
1448 catch( Exception e )
1449 {
1450 return true;
1451 }
1452
1453 return false;
1454 }
1455
1456 public boolean cantOpenEncrStreamH( XStorage xStorage, String sPath, int nMode, String aPass )
1457 {
1458 // try to open the substream with specified mode must fail
1459
1460 XHierarchicalStorageAccess xHStorage =
1461 (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage );
1462 if ( xHStorage == null )
1463 {
1464 Error( "The storage does not support hierarchical access!" );
1465 return false;
1466 }
1467
1468 try
1469 {
1470 Object oDummyStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, nMode, aPass );
1471 Error( "The trying to open substream '" + sPath + "' must fail!" );
1472 }
1473 catch( WrongPasswordException wpe )
1474 {
1475 Error( "The substream '" + sPath + "' must not exist!" );
1476 return false;
1477 }
1478 catch( Exception e )
1479 {
1480 return true;
1481 }
1482
1483 return false;
1484 }
1485
1486 public XStorage cloneStorage( XSingleServiceFactory xFactory, XStorage xStorage )
1487 {
1488 // create a copy of a last commited version of specified storage
1489 XStorage xResult = null;
1490 try
1491 {
1492 Object oTempStorage = xFactory.createInstance();
1493 xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
1494 if ( xResult != null )
1495 xStorage.copyLastCommitTo( xResult );
1496 }
1497 catch( Exception e )
1498 {
1499 Error( "Can't clone storage, exception: " + e );
1500 return null;
1501 }
1502
1503 return xResult;
1504 }
1505
1506 public XStorage cloneSubStorage( XSingleServiceFactory xFactory, XStorage xStorage, String sName )
1507 {
1508 // create a copy of a last commited version of specified substorage
1509 XStorage xResult = null;
1510 try
1511 {
1512 Object oTempStorage = xFactory.createInstance();
1513 xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage );
1514 if ( xResult != null )
1515 xStorage.copyStorageElementLastCommitTo( sName, xResult );
1516 }
1517 catch( Exception e )
1518 {
1519 Error( "Can't clone substorage '" + sName + "', exception: " + e );
1520 return null;
1521 }
1522
1523 return xResult;
1524 }
1525
1526 public XStream cloneSubStream( XStorage xStorage, String sName )
1527 {
1528 // clone existing substream
1529 try
1530 {
1531 XStream xStream = xStorage.cloneStreamElement( sName );
1532 return xStream;
1533 }
1534 catch( Exception e )
1535 {
1536 Error( "Can't clone substream '" + sName + "', exception: " + e );
1537 }
1538
1539 return null;
1540 }
1541
1542 public XStream cloneEncrSubStream( XStorage xStorage, String sName, String sPass )
1543 {
1544 // clone existing substream
1545 try
1546 {
1547 XStream xStream = xStorage.cloneEncryptedStreamElement( sName, sPass );
1548 return xStream;
1549 }
1550 catch( Exception e )
1551 {
1552 Error( "Can't clone encrypted substream '" + sName + "', exception: " + e );
1553 }
1554
1555 return null;
1556 }
1557
1558 public void Error( String sError )
1559 {
1560 m_aLogWriter.println( m_sTestPrefix + "Error: " + sError );
1561 }
1562
1563 public void Message( String sMessage )
1564 {
1565 m_aLogWriter.println( m_sTestPrefix + sMessage );
1566 }
1567 }
1568
vba interoperability for OOo