1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_io.hxx"
26 #include <com/sun/star/test/XSimpleTest.hpp>
27 #include <com/sun/star/io/XActiveDataSink.hpp>
28 #include <com/sun/star/io/XActiveDataSource.hpp>
29 #include <com/sun/star/io/XMarkableStream.hpp>
30 #include <com/sun/star/io/XConnectable.hpp>
31
32 #include <com/sun/star/lang/XServiceInfo.hpp>
33
34 #include <cppuhelper/factory.hxx>
35
36 #include <cppuhelper/implbase1.hxx>
37 #include <cppuhelper/implbase2.hxx>
38
39 #include <osl/conditn.hxx>
40 #include <osl/mutex.hxx>
41
42 using namespace ::rtl;
43 using namespace ::osl;
44 using namespace ::cppu;
45 using namespace ::com::sun::star::uno;
46 using namespace ::com::sun::star::io;
47 using namespace ::com::sun::star::lang;
48 using namespace ::com::sun::star::test;
49 // streams
50
51 #include "testfactreg.hxx"
52
53
54 class OMarkableOutputStreamTest : public WeakImplHelper1< XSimpleTest >
55 {
56 public:
57 OMarkableOutputStreamTest( const Reference< XMultiServiceFactory > & rFactory );
58 ~OMarkableOutputStreamTest();
59
60 public: // implementation names
61 static Sequence< OUString > getSupportedServiceNames_Static(void) throw ();
62 static OUString getImplementationName_Static() throw ();
63
64 public:
65 virtual void SAL_CALL testInvariant(
66 const OUString& TestName,
67 const Reference < XInterface >& TestObject)
68 throw ( IllegalArgumentException,
69 RuntimeException) ;
70
71 virtual sal_Int32 SAL_CALL test( const OUString& TestName,
72 const Reference < XInterface >& TestObject,
73 sal_Int32 hTestHandle)
74 throw ( IllegalArgumentException, RuntimeException);
75 virtual sal_Bool SAL_CALL testPassed(void)
76 throw ( RuntimeException);
77 virtual Sequence< OUString > SAL_CALL getErrors(void)
78 throw (RuntimeException);
79 virtual Sequence< Any > SAL_CALL getErrorExceptions(void)
80 throw (RuntimeException);
81 virtual Sequence< OUString > SAL_CALL getWarnings(void)
82 throw (RuntimeException);
83
84 private:
85 void testSimple( const Reference< XOutputStream > &r, const Reference < XInputStream > &rInput );
86
87 private:
88 Sequence<Any> m_seqExceptions;
89 Sequence<OUString> m_seqErrors;
90 Sequence<OUString> m_seqWarnings;
91 Reference< XMultiServiceFactory > m_rFactory;
92
93 };
94
OMarkableOutputStreamTest(const Reference<XMultiServiceFactory> & rFactory)95 OMarkableOutputStreamTest::OMarkableOutputStreamTest( const Reference< XMultiServiceFactory > &rFactory )
96 : m_rFactory( rFactory )
97 {
98
99 }
100
~OMarkableOutputStreamTest()101 OMarkableOutputStreamTest::~OMarkableOutputStreamTest()
102 {
103
104 }
105
106
107
108
testInvariant(const OUString & TestName,const Reference<XInterface> & TestObject)109 void OMarkableOutputStreamTest::testInvariant( const OUString& TestName,
110 const Reference < XInterface >& TestObject )
111 throw ( IllegalArgumentException, RuntimeException)
112 {
113 Reference< XServiceInfo > info( TestObject, UNO_QUERY );
114 ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
115 if( info.is() )
116 {
117 ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
118 ERROR_ASSERT( ! info->supportsService(
119 OUString( RTL_CONSTASCII_USTRINGPARAM("bla bluzb")) ) , "XServiceInfo test failed" );
120 }
121 }
122
123
test(const OUString & TestName,const Reference<XInterface> & TestObject,sal_Int32 hTestHandle)124 sal_Int32 OMarkableOutputStreamTest::test(
125 const OUString& TestName,
126 const Reference < XInterface >& TestObject,
127 sal_Int32 hTestHandle)
128 throw ( IllegalArgumentException, RuntimeException)
129 {
130 if( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.MarkableOutputStream") )
131 == TestName ) {
132 try
133 {
134 if( 0 == hTestHandle )
135 {
136 testInvariant( TestName , TestObject );
137 }
138 else
139 {
140 Reference < XInterface > x = m_rFactory->createInstance( OUString::createFromAscii("com.sun.star.io.Pipe"));
141 Reference< XOutputStream > rPipeOutput( x , UNO_QUERY );
142 Reference < XInputStream > rPipeInput( x , UNO_QUERY );
143
144 Reference< XActiveDataSource > source( TestObject , UNO_QUERY );
145 source->setOutputStream( rPipeOutput );
146
147 Reference< XOutputStream > rOutput( TestObject , UNO_QUERY );
148
149 OSL_ASSERT( rPipeInput.is() );
150 OSL_ASSERT( rOutput.is() );
151 if( 1 == hTestHandle ) {
152 // checks usual streaming
153 testSimple( rOutput , rPipeInput );
154 }
155 }
156
157 }
158 catch( Exception &e )
159 {
160 OString o = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
161 BUILD_ERROR( 0 , o.getStr() );
162 }
163 catch( ... )
164 {
165 BUILD_ERROR( 0 , "unknown exception (Exception is not base class)" );
166 }
167
168 hTestHandle ++;
169
170 if( 2 == hTestHandle )
171 {
172 // all tests finished.
173 hTestHandle = -1;
174 }
175 }
176 else {
177 throw IllegalArgumentException();
178 }
179 return hTestHandle;
180 }
181
182
183
testPassed(void)184 sal_Bool OMarkableOutputStreamTest::testPassed(void) throw (RuntimeException)
185 {
186 return m_seqErrors.getLength() == 0;
187 }
188
189
getErrors(void)190 Sequence< OUString > OMarkableOutputStreamTest::getErrors(void) throw (RuntimeException)
191 {
192 return m_seqErrors;
193 }
194
195
getErrorExceptions(void)196 Sequence< Any > OMarkableOutputStreamTest::getErrorExceptions(void) throw (RuntimeException)
197 {
198 return m_seqExceptions;
199 }
200
201
getWarnings(void)202 Sequence< OUString > OMarkableOutputStreamTest::getWarnings(void) throw (RuntimeException)
203 {
204 return m_seqWarnings;
205 }
206
207
testSimple(const Reference<XOutputStream> & rOutput,const Reference<XInputStream> & rInput)208 void OMarkableOutputStreamTest::testSimple( const Reference< XOutputStream > &rOutput ,
209 const Reference< XInputStream > &rInput )
210 {
211 Reference < XMarkableStream > rMarkable( rOutput , UNO_QUERY );
212
213 ERROR_ASSERT( rMarkable.is() , "no MarkableStream implemented" );
214
215 // first check normal input/output facility
216 char pcStr[] = "Live long and prosper !";
217
218 Sequence<sal_Int8> seqWrite( strlen( pcStr )+1 );
219 memcpy( seqWrite.getArray() , pcStr , seqWrite.getLength() );
220
221 Sequence<sal_Int8> seqRead( seqWrite.getLength() );
222
223 int nMax = 10,i;
224
225 for( i = 0 ; i < nMax ; i ++ ) {
226 rOutput->writeBytes( seqWrite );
227 rInput->readBytes( seqRead , rInput->available() );
228 ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
229 "error during read/write/skip" );
230 }
231
232 // Check buffer resizing
233 nMax = 3000;
234 for( i = 0 ; i < nMax ; i ++ ) {
235 rOutput->writeBytes( seqWrite );
236 }
237
238 for( i = 0 ; i < nMax ; i ++ ) {
239 rInput->readBytes( seqRead , seqWrite.getLength() );
240 ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
241 "error during read/write" );
242 }
243
244 // Check creating marks !
245 sal_Int32 nMark = rMarkable->createMark();
246
247 for( i = 0 ; i < nMax ; i ++ ) {
248 rOutput->writeBytes( seqWrite );
249 }
250
251 ERROR_ASSERT( 0 == rInput->available() , "bytes available though mark is holded" );
252
253 ERROR_ASSERT( nMax*seqWrite.getLength() == rMarkable->offsetToMark( nMark ) ,
254 "offsetToMark failure" );
255
256 rMarkable->deleteMark( nMark );
257 ERROR_ASSERT( nMax*seqWrite.getLength() == rInput->available(),"bytes are not available though mark has been deleted" );
258
259 rInput->skipBytes( nMax*seqWrite.getLength() );
260 ERROR_ASSERT( 0 == rInput->available(), "skip bytes failure" );
261
262 try
263 {
264 rMarkable->jumpToMark( nMark );
265 ERROR_ASSERT( 0 , "jump to non existing mark possible !" );
266 }
267 catch ( IllegalArgumentException & )
268 {
269 // ok, exception was thrown
270 }
271
272 // test putting marks not at the end of the stream!
273 ERROR_ASSERT( 0 == rInput->available(), "stream isn't clean" );
274 {
275 Sequence< sal_Int8 > aByte(256);
276
277 for( i = 0 ; i < 256 ; i ++ )
278 {
279 aByte.getArray()[i] = i;
280 }
281 sal_Int32 nMark1 = rMarkable->createMark();
282
283 rOutput->writeBytes( aByte );
284 rMarkable->jumpToMark( nMark1 );
285 aByte.realloc( 10 );
286 rOutput->writeBytes( aByte );
287
288 sal_Int32 nMark2 = rMarkable->createMark( );
289
290 for( i = 0 ; i < 10 ; i ++ )
291 {
292 aByte.getArray()[i] = i+10;
293 }
294
295 rOutput->writeBytes( aByte );
296
297 // allow the bytes to be written !
298 rMarkable->jumpToFurthest();
299 rMarkable->deleteMark( nMark1 );
300 rMarkable->deleteMark( nMark2 );
301
302 ERROR_ASSERT( 256 == rInput->available(), "in between mark failure" );
303 rInput->readBytes( aByte ,256);
304 for( i = 0 ; i < 256 ; i ++ )
305 {
306 ERROR_ASSERT( i == ((sal_uInt8*)(aByte.getArray()))[i] , "in between mark failure" );
307 }
308 }
309
310 {
311 // now a more extensive mark test !
312 Sequence<sal_Int8> as[4];
313 sal_Int32 an[4];
314
315 for( i = 0 ; i < 4 ; i ++ ) {
316 as[i].realloc(1);
317 as[i].getArray()[0] = i;
318 an[i] = rMarkable->createMark();
319 rOutput->writeBytes( as[i] );
320 }
321
322 // check offset to mark
323 for( i = 0 ; i < 4 ; i ++ ) {
324 ERROR_ASSERT( rMarkable->offsetToMark( an[i] ) == 4-i , "offsetToMark failure" );
325 }
326
327 rMarkable->jumpToMark( an[1] );
328 ERROR_ASSERT( rMarkable->offsetToMark( an[3] ) == -2 , "offsetToMark failure" );
329
330 rMarkable->jumpToFurthest( );
331 ERROR_ASSERT( rMarkable->offsetToMark( an[0] ) == 4 , "offsetToMark failure" );
332
333 // now do a rewrite !
334 for( i = 0 ; i < 4 ; i ++ ) {
335 rMarkable->jumpToMark( an[3-i] );
336 rOutput->writeBytes( as[i] );
337 }
338 // NOTE : CursorPos 1
339
340 // now delete the marks !
341 for( i = 0 ; i < 4 ; i ++ ) {
342 rMarkable->deleteMark( an[i] );
343 }
344 ERROR_ASSERT( rInput->available() == 1 , "wrong number of bytes flushed" );
345
346 rMarkable->jumpToFurthest();
347
348 ERROR_ASSERT( rInput->available() == 4 , "wrong number of bytes flushed" );
349
350 rInput->readBytes( seqRead , 4 );
351
352 ERROR_ASSERT( 3 == seqRead.getArray()[0] , "rewrite didn't work" );
353 ERROR_ASSERT( 2 == seqRead.getArray()[1] , "rewrite didn't work" );
354 ERROR_ASSERT( 1 == seqRead.getArray()[2] , "rewrite didn't work" );
355 ERROR_ASSERT( 0 == seqRead.getArray()[3] , "rewrite didn't work" );
356
357 rOutput->closeOutput();
358 rInput->closeInput();
359 }
360
361 }
362
363 /***
364 * the test methods
365 *
366 ****/
367
368
369
370
371
372 /**
373 * for external binding
374 *
375 *
376 **/
OMarkableOutputStreamTest_CreateInstance(const Reference<XMultiServiceFactory> & rSMgr)377 Reference < XInterface > SAL_CALL OMarkableOutputStreamTest_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw(Exception)
378 {
379 OMarkableOutputStreamTest *p = new OMarkableOutputStreamTest( rSMgr );
380 return Reference < XInterface > ( SAL_STATIC_CAST( OWeakObject * , p ) );
381 }
382
383
384
OMarkableOutputStreamTest_getSupportedServiceNames(void)385 Sequence<OUString> OMarkableOutputStreamTest_getSupportedServiceNames(void) throw ()
386 {
387 Sequence<OUString> aRet(1);
388 aRet.getArray()[0] = OMarkableOutputStreamTest_getImplementationName();
389
390 return aRet;
391 }
392
OMarkableOutputStreamTest_getServiceName()393 OUString OMarkableOutputStreamTest_getServiceName() throw ()
394 {
395 return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.star.io.MarkableOutputStream"));
396 }
397
OMarkableOutputStreamTest_getImplementationName()398 OUString OMarkableOutputStreamTest_getImplementationName() throw ()
399 {
400 return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.starextensions.stm.MarkableOutputStream"));
401 }
402
403
404
405
406
407
408
409 //-----------------------------------------------------
410 // Input stream
411
412
413 class OMarkableInputStreamTest : public WeakImplHelper1< XSimpleTest >
414 {
415 public:
416 OMarkableInputStreamTest( const Reference< XMultiServiceFactory > & rFactory );
417 ~OMarkableInputStreamTest();
418
419 public: // implementation names
420 static Sequence< OUString > getSupportedServiceNames_Static(void) throw () ;
421 static OUString getImplementationName_Static() throw () ;
422
423 public:
424 virtual void SAL_CALL testInvariant(
425 const OUString& TestName,
426 const Reference < XInterface >& TestObject)
427 throw ( IllegalArgumentException, RuntimeException) ;
428
429 virtual sal_Int32 SAL_CALL test(
430 const OUString& TestName,
431 const Reference < XInterface >& TestObject,
432 sal_Int32 hTestHandle)
433 throw ( IllegalArgumentException,
434 RuntimeException) ;
435
436 virtual sal_Bool SAL_CALL testPassed(void)
437 throw ( RuntimeException);
438 virtual Sequence< OUString > SAL_CALL getErrors(void)
439 throw (RuntimeException);
440 virtual Sequence< Any > SAL_CALL getErrorExceptions(void)
441 throw (RuntimeException);
442 virtual Sequence< OUString > SAL_CALL getWarnings(void)
443 throw (RuntimeException);
444
445 private:
446 void testSimple( const Reference< XOutputStream > &r,
447 const Reference < XInputStream > &rInput );
448
449 private:
450 Sequence<Any> m_seqExceptions;
451 Sequence<OUString> m_seqErrors;
452 Sequence<OUString> m_seqWarnings;
453 Reference< XMultiServiceFactory > m_rFactory;
454
455 };
456
OMarkableInputStreamTest(const Reference<XMultiServiceFactory> & rFactory)457 OMarkableInputStreamTest::OMarkableInputStreamTest( const Reference< XMultiServiceFactory > &rFactory )
458 : m_rFactory( rFactory )
459 {
460
461 }
462
~OMarkableInputStreamTest()463 OMarkableInputStreamTest::~OMarkableInputStreamTest()
464 {
465
466 }
467
468
469
testInvariant(const OUString & TestName,const Reference<XInterface> & TestObject)470 void OMarkableInputStreamTest::testInvariant(
471 const OUString& TestName, const Reference < XInterface >& TestObject )
472 throw ( IllegalArgumentException, RuntimeException)
473 {
474 if( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.MarkableInputStream"))
475 == TestName ) {
476 Reference <XServiceInfo > info( TestObject, UNO_QUERY );
477 ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
478 if( info.is() )
479 {
480 ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
481 ERROR_ASSERT(
482 ! info->supportsService(
483 OUString(RTL_CONSTASCII_USTRINGPARAM("bla bluzb")) ) ,
484 "XServiceInfo test failed" );
485 }
486 }
487 else
488 {
489 throw IllegalArgumentException();
490 }
491 }
492
493
test(const OUString & TestName,const Reference<XInterface> & TestObject,sal_Int32 hTestHandle)494 sal_Int32 OMarkableInputStreamTest::test(
495 const OUString& TestName,
496 const Reference < XInterface >& TestObject,
497 sal_Int32 hTestHandle) throw ( IllegalArgumentException, RuntimeException)
498 {
499 if( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.MarkableInputStream")) == TestName )
500 {
501 try
502 {
503 if( 0 == hTestHandle ) {
504 testInvariant( TestName , TestObject );
505 }
506 else {
507 Reference < XInterface > x = m_rFactory->createInstance( OUString::createFromAscii("com.sun.star.io.Pipe"));
508 Reference< XOutputStream > rPipeOutput( x , UNO_QUERY );
509 Reference < XInputStream > rPipeInput( x , UNO_QUERY );
510
511 Reference < XActiveDataSink > sink( TestObject , UNO_QUERY );
512 sink->setInputStream( rPipeInput );
513
514 Reference < XInputStream > rInput( TestObject , UNO_QUERY );
515
516 OSL_ASSERT( rPipeOutput.is() );
517 OSL_ASSERT( rInput.is() );
518 if( 1 == hTestHandle ) {
519 // checks usual streaming
520 testSimple( rPipeOutput , rInput );
521 }
522 }
523
524 }
525 catch( Exception & e )
526 {
527 OString o = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
528 BUILD_ERROR( 0 , o.getStr() );
529 }
530 catch( ... )
531 {
532 BUILD_ERROR( 0 , "unknown exception (Exception is not base class)" );
533 }
534
535 hTestHandle ++;
536
537 if( 2 == hTestHandle ) {
538 // all tests finished.
539 hTestHandle = -1;
540 }
541 }
542 else
543 {
544 throw IllegalArgumentException();
545 }
546 return hTestHandle;
547 }
548
549
550
testPassed(void)551 sal_Bool OMarkableInputStreamTest::testPassed(void) throw (RuntimeException)
552 {
553 return m_seqErrors.getLength() == 0;
554 }
555
556
getErrors(void)557 Sequence< OUString > OMarkableInputStreamTest::getErrors(void) throw (RuntimeException)
558 {
559 return m_seqErrors;
560 }
561
562
getErrorExceptions(void)563 Sequence< Any > OMarkableInputStreamTest::getErrorExceptions(void) throw (RuntimeException)
564 {
565 return m_seqExceptions;
566 }
567
568
getWarnings(void)569 Sequence< OUString > OMarkableInputStreamTest::getWarnings(void) throw (RuntimeException)
570 {
571 return m_seqWarnings;
572 }
573
574
testSimple(const Reference<XOutputStream> & rOutput,const Reference<XInputStream> & rInput)575 void OMarkableInputStreamTest::testSimple( const Reference< XOutputStream > &rOutput ,
576 const Reference < XInputStream > &rInput )
577 {
578 Reference < XMarkableStream > rMarkable( rInput , UNO_QUERY );
579
580 Sequence<sal_Int8> seqWrite( 256 );
581 Sequence<sal_Int8> seqRead(10);
582
583 for( int i = 0 ; i < 256 ; i ++ )
584 {
585 seqWrite.getArray()[i] = i;
586 }
587
588 rOutput->writeBytes( seqWrite );
589 ERROR_ASSERT( 256 == rInput->available() , "basic read/write failure" );
590
591 rInput->readBytes( seqRead , 10 );
592 ERROR_ASSERT( 9 == seqRead.getArray()[9] , "basic read/write failure" );
593
594 sal_Int32 nMark = rMarkable->createMark();
595
596 rInput->skipBytes( 50 );
597 ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );
598 ERROR_ASSERT( 50 == rMarkable->offsetToMark( nMark ) , "marking error" );
599
600 rMarkable->jumpToMark( nMark );
601 ERROR_ASSERT( 256-10 == rInput->available() , "marking error" );
602
603 rInput->readBytes( seqRead , 10 );
604 ERROR_ASSERT( 10 == seqRead.getArray()[0] , "marking error" );
605
606 // pos 20
607 {
608 sal_Int32 nInBetweenMark = rMarkable->createMark( );
609 rMarkable->jumpToMark( nMark );
610 rMarkable->jumpToMark( nInBetweenMark );
611
612 rInput->readBytes( seqRead , 10 );
613 ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );
614
615 rMarkable->deleteMark( nMark );
616
617 // Check if releasing the first bytes works correct.
618 rMarkable->jumpToMark( nInBetweenMark);
619 rInput->readBytes( seqRead , 10 );
620 ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );
621
622 rMarkable->deleteMark( nInBetweenMark );
623 }
624
625 rMarkable->jumpToFurthest();
626 ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );
627
628
629 ERROR_ASSERT( 100 == rInput->readSomeBytes( seqRead , 100 ) , "wrong results using readSomeBytes" );
630 ERROR_ASSERT( 96 == rInput->readSomeBytes( seqRead , 1000) , "wrong results using readSomeBytes" );
631 rOutput->closeOutput();
632 rInput->closeInput();
633 }
634
635 /***
636 * the test methods
637 *
638 ****/
639
640
641
642
643
644 /**
645 * for external binding
646 *
647 *
648 **/
OMarkableInputStreamTest_CreateInstance(const Reference<XMultiServiceFactory> & rSMgr)649 Reference < XInterface > SAL_CALL OMarkableInputStreamTest_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw(Exception)
650 {
651 OMarkableInputStreamTest *p = new OMarkableInputStreamTest( rSMgr );
652 return Reference < XInterface > ( SAL_STATIC_CAST( OWeakObject * , p ) );
653 }
654
655
656
OMarkableInputStreamTest_getSupportedServiceNames(void)657 Sequence<OUString> OMarkableInputStreamTest_getSupportedServiceNames(void) throw ()
658 {
659 Sequence<OUString> aRet(1);
660 aRet.getArray()[0] = OMarkableInputStreamTest_getImplementationName();
661
662 return aRet;
663 }
664
OMarkableInputStreamTest_getServiceName()665 OUString OMarkableInputStreamTest_getServiceName() throw ()
666 {
667 return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.star.io.MarkableInputStream"));
668 }
669
OMarkableInputStreamTest_getImplementationName()670 OUString OMarkableInputStreamTest_getImplementationName() throw ()
671 {
672 return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.star.extensions.stm.MarkableInputStream" ));
673 }
674