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