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_extensions.hxx"
26 #include <smart/com/sun/star/test/XSimpleTest.hxx>
27 #include <smart/com/sun/star/io/XMarkableStream.hxx>
28 #include <smart/com/sun/star/io/XActiveDataSink.hxx>
29 #include <smart/com/sun/star/io/XActiveDataSource.hxx>
30 #include <smart/com/sun/star/io/XConnectable.hxx>
31
32 #include <smart/com/sun/star/lang/XServiceInfo.hxx>
33
34
35 #include <usr/factoryhlp.hxx>
36
37 #include <usr/reflserv.hxx> // for EXTERN_SERVICE_CALLTYPE
38 #include <usr/weak.hxx> // OWeakObject
39
40 #include <vos/conditn.hxx>
41 #include <vos/mutex.hxx>
42 #include <vos/thread.hxx>
43
44 #include <string.h>
45
46 #include "testfactreg.hxx"
47
48
49 using namespace vos;
50 using namespace usr;
51
52 class OMarkableOutputStreamTest :
53 public XSimpleTest,
54 public OWeakObject
55 {
56 public:
57 OMarkableOutputStreamTest( const XMultiServiceFactoryRef & rFactory );
58 ~OMarkableOutputStreamTest();
59
60 public: // refcounting
61 BOOL queryInterface( Uik aUik, XInterfaceRef & rOut );
acquire()62 void acquire() { OWeakObject::acquire(); }
release()63 void release() { OWeakObject::release(); }
getImplementation(Reflection * p)64 void* getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
65
66 public: // implementation names
67 static Sequence< UString > getSupportedServiceNames_Static(void) THROWS( () );
68 static UString getImplementationName_Static() THROWS( () );
69
70 public:
71 virtual void testInvariant(const UString& TestName, const XInterfaceRef& TestObject)
72 THROWS( ( IllegalArgumentException,
73 UsrSystemException) );
74
75 virtual INT32 test( const UString& TestName,
76 const XInterfaceRef& TestObject,
77 INT32 hTestHandle) THROWS( ( IllegalArgumentException,
78 UsrSystemException) );
79
80 virtual BOOL testPassed(void) THROWS( ( UsrSystemException) );
81 virtual Sequence< UString > getErrors(void) THROWS( (UsrSystemException) );
82 virtual Sequence< UsrAny > getErrorExceptions(void) THROWS( (UsrSystemException) );
83 virtual Sequence< UString > getWarnings(void) THROWS( (UsrSystemException) );
84
85 private:
86 void testSimple( const XOutputStreamRef &r, const XInputStreamRef &rInput );
87
88 private:
89 Sequence<UsrAny> m_seqExceptions;
90 Sequence<UString> m_seqErrors;
91 Sequence<UString> m_seqWarnings;
92 XMultiServiceFactoryRef m_rFactory;
93
94 };
95
OMarkableOutputStreamTest(const XMultiServiceFactoryRef & rFactory)96 OMarkableOutputStreamTest::OMarkableOutputStreamTest( const XMultiServiceFactoryRef &rFactory )
97 : m_rFactory( rFactory )
98 {
99
100 }
101
~OMarkableOutputStreamTest()102 OMarkableOutputStreamTest::~OMarkableOutputStreamTest()
103 {
104
105 }
106
107
queryInterface(Uik uik,XInterfaceRef & rOut)108 BOOL OMarkableOutputStreamTest::queryInterface( Uik uik , XInterfaceRef &rOut )
109 {
110 if( XSimpleTest::getSmartUik() == uik ) {
111 rOut = (XSimpleTest *) this;
112 }
113 else {
114 return OWeakObject::queryInterface( uik , rOut );
115 }
116 return TRUE;
117 }
118
119
testInvariant(const UString & TestName,const XInterfaceRef & TestObject)120 void OMarkableOutputStreamTest::testInvariant( const UString& TestName, const XInterfaceRef& TestObject )
121 THROWS( ( IllegalArgumentException,
122 UsrSystemException) )
123 {
124 XServiceInfoRef info( TestObject, USR_QUERY );
125 ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
126 if( info.is() )
127 {
128 ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
129 ERROR_ASSERT( ! info->supportsService( L"bla bluzb" ) , "XServiceInfo test failed" );
130 }
131 }
132
133
test(const UString & TestName,const XInterfaceRef & TestObject,INT32 hTestHandle)134 INT32 OMarkableOutputStreamTest::test( const UString& TestName,
135 const XInterfaceRef& TestObject,
136 INT32 hTestHandle) THROWS( ( IllegalArgumentException,
137 UsrSystemException) )
138 {
139 if( L"com.sun.star.io.MarkableOutputStream" == TestName ) {
140 try {
141 if( 0 == hTestHandle ) {
142 testInvariant( TestName , TestObject );
143 }
144 else {
145 XInterfaceRef x = m_rFactory->createInstance( L"com.sun.star.io.Pipe");
146 XOutputStreamRef rPipeOutput( x , USR_QUERY );
147 XInputStreamRef rPipeInput( x , USR_QUERY );
148
149 XActiveDataSourceRef source( TestObject , USR_QUERY );
150 source->setOutputStream( rPipeOutput );
151
152 XOutputStreamRef rOutput( TestObject , USR_QUERY );
153
154 OSL_ASSERT( rPipeInput.is() );
155 OSL_ASSERT( rOutput.is() );
156 if( 1 == hTestHandle ) {
157 // checks usual streaming
158 testSimple( rOutput , rPipeInput );
159 }
160 }
161
162 }
163 catch( Exception& e ) {
164 BUILD_ERROR( 0 , UStringToString( e.getName() , CHARSET_SYSTEM ).GetCharStr() );
165 }
166 catch(...) {
167 BUILD_ERROR( 0 , "unknown exception (Exception is not base class)" );
168 }
169
170 hTestHandle ++;
171
172 if( 2 == hTestHandle ) {
173 // all tests finished.
174 hTestHandle = -1;
175 }
176 }
177 else {
178 THROW( IllegalArgumentException() );
179 }
180 return hTestHandle;
181 }
182
183
184
testPassed(void)185 BOOL OMarkableOutputStreamTest::testPassed(void) THROWS( (UsrSystemException) )
186 {
187 return m_seqErrors.getLen() == 0;
188 }
189
190
getErrors(void)191 Sequence< UString > OMarkableOutputStreamTest::getErrors(void) THROWS( (UsrSystemException) )
192 {
193 return m_seqErrors;
194 }
195
196
getErrorExceptions(void)197 Sequence< UsrAny > OMarkableOutputStreamTest::getErrorExceptions(void) THROWS( (UsrSystemException) )
198 {
199 return m_seqExceptions;
200 }
201
202
getWarnings(void)203 Sequence< UString > OMarkableOutputStreamTest::getWarnings(void) THROWS( (UsrSystemException) )
204 {
205 return m_seqWarnings;
206 }
207
208
testSimple(const XOutputStreamRef & rOutput,const XInputStreamRef & rInput)209 void OMarkableOutputStreamTest::testSimple( const XOutputStreamRef &rOutput ,
210 const XInputStreamRef &rInput )
211 {
212 XMarkableStreamRef rMarkable( rOutput , USR_QUERY );
213
214 ERROR_ASSERT( rMarkable.is() , "no MarkableStream implemented" );
215
216 // first check normal input/output facility
217 char pcStr[] = "Live long and prosper !";
218
219 Sequence<BYTE> seqWrite( strlen( pcStr )+1 );
220 memcpy( seqWrite.getArray() , pcStr , seqWrite.getLen() );
221
222 Sequence<BYTE> seqRead( seqWrite.getLen() );
223
224 int nMax = 10,i;
225
226 for( i = 0 ; i < nMax ; i ++ ) {
227 rOutput->writeBytes( seqWrite );
228 rInput->readBytes( seqRead , rInput->available() );
229 ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
230 "error during read/write/skip" );
231 }
232
233 // Check buffer resizing
234 nMax = 3000;
235 for( i = 0 ; i < nMax ; i ++ ) {
236 rOutput->writeBytes( seqWrite );
237 }
238
239 for( i = 0 ; i < nMax ; i ++ ) {
240 rInput->readBytes( seqRead , seqWrite.getLen() );
241 ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
242 "error during read/write" );
243 }
244
245 // Check creating marks !
246 INT32 nMark = rMarkable->createMark();
247
248 for( i = 0 ; i < nMax ; i ++ ) {
249 rOutput->writeBytes( seqWrite );
250 }
251
252 ERROR_ASSERT( 0 == rInput->available() , "bytes available though mark is holded" );
253
254 ERROR_ASSERT( nMax*seqWrite.getLen() == rMarkable->offsetToMark( nMark ) ,
255 "offsetToMark failure" );
256
257 rMarkable->deleteMark( nMark );
258 ERROR_ASSERT( nMax*seqWrite.getLen() == rInput->available(),"bytes are not available though mark has been deleted" );
259
260 rInput->skipBytes( nMax*seqWrite.getLen() );
261 ERROR_ASSERT( 0 == rInput->available(), "skip bytes failure" );
262
263 try {
264 rMarkable->jumpToMark( nMark );
265 ERROR_ASSERT( 0 , "jump to non existing mark possible !" );
266 }
267 catch ( IllegalArgumentException& e )
268 {
269 e;// 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< BYTE > aByte(256);
276
277 for( i = 0 ; i < 256 ; i ++ )
278 {
279 aByte.getArray()[i] = i;
280 }
281 INT32 nMark1 = rMarkable->createMark();
282
283 rOutput->writeBytes( aByte );
284 rMarkable->jumpToMark( nMark1 );
285 aByte.realloc( 10 );
286 rOutput->writeBytes( aByte );
287
288 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 == aByte.getArray()[i] , "in between mark failure" );
307 }
308 }
309
310 {
311 // now a more extensive mark test !
312 Sequence<BYTE> as[4];
313 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 XMultiServiceFactoryRef & rSMgr)377 XInterfaceRef OMarkableOutputStreamTest_CreateInstance( const XMultiServiceFactoryRef & rSMgr ) THROWS((Exception))
378 {
379 OMarkableOutputStreamTest *p = new OMarkableOutputStreamTest( rSMgr );
380 XInterfaceRef xService = *p;
381 return xService;
382 }
383
384
385
OMarkableOutputStreamTest_getSupportedServiceNames(void)386 Sequence<UString> OMarkableOutputStreamTest_getSupportedServiceNames(void) THROWS( () )
387 {
388 Sequence<UString> aRet(1);
389 aRet.getArray()[0] = OMarkableOutputStreamTest_getImplementationName();
390
391 return aRet;
392 }
393
OMarkableOutputStreamTest_getServiceName()394 UString OMarkableOutputStreamTest_getServiceName() THROWS( () )
395 {
396 return L"test.com.sun.star.io.MarkableOutputStream";
397 }
398
OMarkableOutputStreamTest_getImplementationName()399 UString OMarkableOutputStreamTest_getImplementationName() THROWS( () )
400 {
401 return L"test.com.sun.starextensions.stm.MarkableOutputStream";
402 }
403
404
405
406
407
408
409
410 //-----------------------------------------------------
411 // Input stream
412
413
414 class OMarkableInputStreamTest :
415 public XSimpleTest,
416 public OWeakObject
417 {
418 public:
419 OMarkableInputStreamTest( const XMultiServiceFactoryRef & rFactory );
420 ~OMarkableInputStreamTest();
421
422 public: // refcounting
423 BOOL queryInterface( Uik aUik, XInterfaceRef & rOut );
acquire()424 void acquire() { OWeakObject::acquire(); }
release()425 void release() { OWeakObject::release(); }
getImplementation(Reflection * p)426 void* getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
427
428 public: // implementation names
429 static Sequence< UString > getSupportedServiceNames_Static(void) THROWS( () );
430 static UString getImplementationName_Static() THROWS( () );
431
432 public:
433 virtual void testInvariant(const UString& TestName, const XInterfaceRef& TestObject)
434 THROWS( ( IllegalArgumentException,
435 UsrSystemException) );
436
437 virtual INT32 test( const UString& TestName,
438 const XInterfaceRef& TestObject,
439 INT32 hTestHandle) THROWS( ( IllegalArgumentException,
440 UsrSystemException) );
441
442 virtual BOOL testPassed(void) THROWS( ( UsrSystemException) );
443 virtual Sequence< UString > getErrors(void) THROWS( (UsrSystemException) );
444 virtual Sequence< UsrAny > getErrorExceptions(void) THROWS( (UsrSystemException) );
445 virtual Sequence< UString > getWarnings(void) THROWS( (UsrSystemException) );
446
447 private:
448 void testSimple( const XOutputStreamRef &r, const XInputStreamRef &rInput );
449
450 private:
451 Sequence<UsrAny> m_seqExceptions;
452 Sequence<UString> m_seqErrors;
453 Sequence<UString> m_seqWarnings;
454 XMultiServiceFactoryRef m_rFactory;
455
456 };
457
OMarkableInputStreamTest(const XMultiServiceFactoryRef & rFactory)458 OMarkableInputStreamTest::OMarkableInputStreamTest( const XMultiServiceFactoryRef &rFactory )
459 : m_rFactory( rFactory )
460 {
461
462 }
463
~OMarkableInputStreamTest()464 OMarkableInputStreamTest::~OMarkableInputStreamTest()
465 {
466
467 }
468
469
queryInterface(Uik uik,XInterfaceRef & rOut)470 BOOL OMarkableInputStreamTest::queryInterface( Uik uik , XInterfaceRef &rOut )
471 {
472 if( XSimpleTest::getSmartUik() == uik ) {
473 rOut = (XSimpleTest *) this;
474 }
475 else {
476 return OWeakObject::queryInterface( uik , rOut );
477 }
478 return TRUE;
479 }
480
481
testInvariant(const UString & TestName,const XInterfaceRef & TestObject)482 void OMarkableInputStreamTest::testInvariant( const UString& TestName, const XInterfaceRef& TestObject )
483 THROWS( ( IllegalArgumentException,
484 UsrSystemException) )
485 {
486 if( L"com.sun.star.io.MarkableInputStream" == TestName ) {
487 XServiceInfoRef info( TestObject, USR_QUERY );
488 ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
489 if( info.is() )
490 {
491 ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
492 ERROR_ASSERT( ! info->supportsService( L"bla bluzb" ) , "XServiceInfo test failed" );
493 }
494 }
495 else {
496 THROW( IllegalArgumentException() );
497 }
498 }
499
500
test(const UString & TestName,const XInterfaceRef & TestObject,INT32 hTestHandle)501 INT32 OMarkableInputStreamTest::test( const UString& TestName,
502 const XInterfaceRef& TestObject,
503 INT32 hTestHandle) THROWS( ( IllegalArgumentException,
504 UsrSystemException) )
505 {
506 if( L"com.sun.star.io.MarkableInputStream" == TestName ) {
507 try {
508 if( 0 == hTestHandle ) {
509 testInvariant( TestName , TestObject );
510 }
511 else {
512 XInterfaceRef x = m_rFactory->createInstance( L"com.sun.star.io.Pipe");
513 XOutputStreamRef rPipeOutput( x , USR_QUERY );
514 XInputStreamRef rPipeInput( x , USR_QUERY );
515
516 XActiveDataSinkRef sink( TestObject , USR_QUERY );
517 sink->setInputStream( rPipeInput );
518
519 XInputStreamRef rInput( TestObject , USR_QUERY );
520
521 OSL_ASSERT( rPipeOutput.is() );
522 OSL_ASSERT( rInput.is() );
523 if( 1 == hTestHandle ) {
524 // checks usual streaming
525 testSimple( rPipeOutput , rInput );
526 }
527 }
528
529 }
530 catch( Exception& e ) {
531 BUILD_ERROR( 0 , UStringToString( e.getName() , CHARSET_SYSTEM ).GetCharStr() );
532 }
533 catch(...) {
534 BUILD_ERROR( 0 , "unknown exception (Exception is not base class)" );
535 }
536
537 hTestHandle ++;
538
539 if( 2 == hTestHandle ) {
540 // all tests finished.
541 hTestHandle = -1;
542 }
543 }
544 else {
545 THROW( IllegalArgumentException() );
546 }
547 return hTestHandle;
548 }
549
550
551
testPassed(void)552 BOOL OMarkableInputStreamTest::testPassed(void) THROWS( (UsrSystemException) )
553 {
554 return m_seqErrors.getLen() == 0;
555 }
556
557
getErrors(void)558 Sequence< UString > OMarkableInputStreamTest::getErrors(void) THROWS( (UsrSystemException) )
559 {
560 return m_seqErrors;
561 }
562
563
getErrorExceptions(void)564 Sequence< UsrAny > OMarkableInputStreamTest::getErrorExceptions(void) THROWS( (UsrSystemException) )
565 {
566 return m_seqExceptions;
567 }
568
569
getWarnings(void)570 Sequence< UString > OMarkableInputStreamTest::getWarnings(void) THROWS( (UsrSystemException) )
571 {
572 return m_seqWarnings;
573 }
574
575
testSimple(const XOutputStreamRef & rOutput,const XInputStreamRef & rInput)576 void OMarkableInputStreamTest::testSimple( const XOutputStreamRef &rOutput ,
577 const XInputStreamRef &rInput )
578 {
579 XMarkableStreamRef rMarkable( rInput , USR_QUERY );
580
581 Sequence<BYTE> seqWrite( 256 );
582 Sequence<BYTE> seqRead(10);
583
584 for( int i = 0 ; i < 256 ; i ++ )
585 {
586 seqWrite.getArray()[i] = i;
587 }
588
589 rOutput->writeBytes( seqWrite );
590 ERROR_ASSERT( 256 == rInput->available() , "basic read/write failure" );
591
592 rInput->readBytes( seqRead , 10 );
593 ERROR_ASSERT( 9 == seqRead.getArray()[9] , "basic read/write failure" );
594
595 INT32 nMark = rMarkable->createMark();
596
597 rInput->skipBytes( 50 );
598 ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );
599 ERROR_ASSERT( 50 == rMarkable->offsetToMark( nMark ) , "marking error" );
600
601 rMarkable->jumpToMark( nMark );
602 ERROR_ASSERT( 256-10 == rInput->available() , "marking error" );
603
604 rInput->readBytes( seqRead , 10 );
605 ERROR_ASSERT( 10 == seqRead.getArray()[0] , "marking error" );
606
607 // pos 20
608 {
609 INT32 nInBetweenMark = rMarkable->createMark( );
610 rMarkable->jumpToMark( nMark );
611 rMarkable->jumpToMark( nInBetweenMark );
612
613 rInput->readBytes( seqRead , 10 );
614 ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );
615
616 rMarkable->deleteMark( nMark );
617
618 // Check if releasing the first bytes works correct.
619 rMarkable->jumpToMark( nInBetweenMark);
620 rInput->readBytes( seqRead , 10 );
621 ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );
622
623 rMarkable->deleteMark( nInBetweenMark );
624 }
625
626 rMarkable->jumpToFurthest();
627 ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );
628
629
630 ERROR_ASSERT( 100 == rInput->readSomeBytes( seqRead , 100 ) , "wrong results using readSomeBytes" );
631 ERROR_ASSERT( 96 == rInput->readSomeBytes( seqRead , 1000) , "wrong results using readSomeBytes" );
632 rOutput->closeOutput();
633 rInput->closeInput();
634 }
635
636 /***
637 * the test methods
638 *
639 ****/
640
641
642
643
644
645 /**
646 * for external binding
647 *
648 *
649 **/
OMarkableInputStreamTest_CreateInstance(const XMultiServiceFactoryRef & rSMgr)650 XInterfaceRef OMarkableInputStreamTest_CreateInstance( const XMultiServiceFactoryRef & rSMgr ) THROWS((Exception))
651 {
652 OMarkableInputStreamTest *p = new OMarkableInputStreamTest( rSMgr );
653 XInterfaceRef xService = *p;
654 return xService;
655 }
656
657
658
OMarkableInputStreamTest_getSupportedServiceNames(void)659 Sequence<UString> OMarkableInputStreamTest_getSupportedServiceNames(void) THROWS( () )
660 {
661 Sequence<UString> aRet(1);
662 aRet.getArray()[0] = OMarkableInputStreamTest_getImplementationName();
663
664 return aRet;
665 }
666
OMarkableInputStreamTest_getServiceName()667 UString OMarkableInputStreamTest_getServiceName() THROWS( () )
668 {
669 return L"test.com.sun.star.io.MarkableInputStream";
670 }
671
OMarkableInputStreamTest_getImplementationName()672 UString OMarkableInputStreamTest_getImplementationName() THROWS( () )
673 {
674 return L"test.com.sun.star.extensions.stm.MarkableInputStream";
675 }
676