/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_extensions.hxx"
#include <smart/com/sun/star/test/XSimpleTest.hxx>
#include <smart/com/sun/star/io/XMarkableStream.hxx>
#include <smart/com/sun/star/io/XActiveDataSink.hxx>
#include <smart/com/sun/star/io/XActiveDataSource.hxx>
#include <smart/com/sun/star/io/XConnectable.hxx>

#include <smart/com/sun/star/lang/XServiceInfo.hxx>


#include <usr/factoryhlp.hxx>

#include <usr/reflserv.hxx>  // for EXTERN_SERVICE_CALLTYPE
#include <usr/weak.hxx>      // OWeakObject

#include <vos/conditn.hxx>
#include <vos/mutex.hxx>
#include <vos/thread.hxx>

#include <string.h>

#include "testfactreg.hxx"


using namespace vos;
using namespace usr;

class OMarkableOutputStreamTest :
		public XSimpleTest,
        public OWeakObject
{
public:
	OMarkableOutputStreamTest( const XMultiServiceFactoryRef & rFactory );
	~OMarkableOutputStreamTest();

public: // refcounting
	BOOL						queryInterface( Uik aUik, XInterfaceRef & rOut );
	void 						acquire() 						 { OWeakObject::acquire(); }
	void 						release() 						 { OWeakObject::release(); }
	void* 						getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }

public: // implementation names
    static Sequence< UString > 	getSupportedServiceNames_Static(void) THROWS( () );
	static UString 				getImplementationName_Static() THROWS( () );

public:
    virtual void testInvariant(const UString& TestName, const XInterfaceRef& TestObject)
    															THROWS( (	IllegalArgumentException,
    																		UsrSystemException) );

    virtual INT32 test(	const UString& TestName,
    					const XInterfaceRef& TestObject,
    					INT32 hTestHandle) 						THROWS( (	IllegalArgumentException,
    																		UsrSystemException) );

    virtual BOOL testPassed(void) 								THROWS( (	UsrSystemException) );
    virtual Sequence< UString > getErrors(void) 				THROWS( (UsrSystemException) );
    virtual Sequence< UsrAny > getErrorExceptions(void) 		THROWS( (UsrSystemException) );
    virtual Sequence< UString > getWarnings(void) 				THROWS( (UsrSystemException) );

private:
	void testSimple( const XOutputStreamRef &r, const XInputStreamRef &rInput );

private:
	Sequence<UsrAny>  m_seqExceptions;
	Sequence<UString> m_seqErrors;
	Sequence<UString> m_seqWarnings;
	XMultiServiceFactoryRef m_rFactory;

};

OMarkableOutputStreamTest::OMarkableOutputStreamTest( const XMultiServiceFactoryRef &rFactory )
		: m_rFactory( rFactory )
{

}

OMarkableOutputStreamTest::~OMarkableOutputStreamTest()
{

}


BOOL OMarkableOutputStreamTest::queryInterface( Uik uik , XInterfaceRef &rOut )
{
	if( XSimpleTest::getSmartUik() == uik ) {
		rOut = (XSimpleTest *) this;
	}
	else {
		return OWeakObject::queryInterface( uik , rOut );
	}
	return TRUE;
}


void OMarkableOutputStreamTest::testInvariant( const UString& TestName, const XInterfaceRef& TestObject )
    															THROWS( (	IllegalArgumentException,
    																		UsrSystemException) )
{
	XServiceInfoRef info( TestObject, USR_QUERY );
	ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
	if( info.is() )
	{
		ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
		ERROR_ASSERT( ! info->supportsService( L"bla bluzb" ) , "XServiceInfo test failed" );
	}
}


INT32 OMarkableOutputStreamTest::test(	const UString& TestName,
    					const XInterfaceRef& TestObject,
    					INT32 hTestHandle) 						THROWS( (	IllegalArgumentException,
    																		UsrSystemException) )
{
	if( L"com.sun.star.io.MarkableOutputStream" == TestName )  {
		try {
			if( 0 == hTestHandle ) {
				testInvariant( TestName , TestObject );
			}
			else  {
				XInterfaceRef x = m_rFactory->createInstance( L"com.sun.star.io.Pipe");
				XOutputStreamRef  rPipeOutput( x , USR_QUERY );
				XInputStreamRef  rPipeInput( x , USR_QUERY );

				XActiveDataSourceRef source( TestObject , USR_QUERY );
				source->setOutputStream( rPipeOutput );

				XOutputStreamRef rOutput( TestObject , USR_QUERY );

				OSL_ASSERT( rPipeInput.is() );
				OSL_ASSERT( rOutput.is() );
				if( 1 == hTestHandle ) {
					// checks usual streaming
					testSimple( rOutput , rPipeInput );
				}
			}

		}
		catch( Exception& e )  {
			BUILD_ERROR( 0 , UStringToString( e.getName() , CHARSET_SYSTEM ).GetCharStr() );
		}
		catch(...) {
			BUILD_ERROR( 0 , "unknown exception (Exception is  not base class)" );
		}

		hTestHandle ++;

		if( 2 == hTestHandle ) {
			// all tests finished.
			hTestHandle = -1;
		}
	}
	else {
		THROW( IllegalArgumentException() );
	}
	return hTestHandle;
}



BOOL OMarkableOutputStreamTest::testPassed(void) 						THROWS( (UsrSystemException) )
{
	return m_seqErrors.getLen() == 0;
}


Sequence< UString > OMarkableOutputStreamTest::getErrors(void) 		THROWS( (UsrSystemException) )
{
	return m_seqErrors;
}


Sequence< UsrAny > OMarkableOutputStreamTest::getErrorExceptions(void) THROWS( (UsrSystemException) )
{
	return m_seqExceptions;
}


Sequence< UString > OMarkableOutputStreamTest::getWarnings(void) 		THROWS( (UsrSystemException) )
{
	return m_seqWarnings;
}


void OMarkableOutputStreamTest::testSimple(  	const XOutputStreamRef &rOutput ,
												const XInputStreamRef &rInput )
{
	XMarkableStreamRef rMarkable( rOutput , USR_QUERY );

	ERROR_ASSERT( rMarkable.is() , "no MarkableStream implemented" );

	// first check normal input/output facility
	char pcStr[] = "Live long and prosper !";

	Sequence<BYTE> seqWrite( strlen( pcStr )+1 );
	memcpy( seqWrite.getArray() , pcStr , seqWrite.getLen() );

	Sequence<BYTE> seqRead( seqWrite.getLen() );

	int nMax = 10,i;

	for( i = 0 ; i < nMax ; i ++ ) {
		rOutput->writeBytes( seqWrite );
		rInput->readBytes( seqRead , rInput->available() );
		ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
		              "error during read/write/skip" );
	}

	// Check buffer resizing
	nMax = 3000;
	for( i = 0 ; i < nMax ; i ++ ) {
		rOutput->writeBytes( seqWrite );
	}

	for( i = 0 ; i < nMax ; i ++ ) {
		rInput->readBytes( seqRead , seqWrite.getLen() );
		ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
		              "error during read/write" );
	}

	// Check creating marks !
	INT32 nMark = rMarkable->createMark();

	for( i = 0 ; i < nMax ; i ++ ) {
		rOutput->writeBytes( seqWrite );
	}

	ERROR_ASSERT( 0 == rInput->available() , "bytes available though mark is holded" );

	ERROR_ASSERT( nMax*seqWrite.getLen() == rMarkable->offsetToMark( nMark ) ,
											 "offsetToMark failure" );

	rMarkable->deleteMark( nMark );
	ERROR_ASSERT( nMax*seqWrite.getLen() == rInput->available(),"bytes are not available though mark has been deleted" );

	rInput->skipBytes( nMax*seqWrite.getLen() );
	ERROR_ASSERT( 0 == rInput->available(), "skip bytes failure" );

	try {
		rMarkable->jumpToMark( nMark );
		ERROR_ASSERT( 0 , "jump to non existing mark possible !" );
	}
	catch ( IllegalArgumentException& e )
	{
		e;// ok, exception was thrown
	}

	// test putting marks not at the end of the stream!
	ERROR_ASSERT( 0 == rInput->available(), "stream isn't clean" );
	{
		Sequence< BYTE > aByte(256);

		for( i = 0 ; i < 256 ; i ++ )
		{
			aByte.getArray()[i] = i;
		}
		INT32 nMark1 = rMarkable->createMark();

		rOutput->writeBytes( aByte );
		rMarkable->jumpToMark( nMark1 );
		aByte.realloc( 10 );
		rOutput->writeBytes( aByte );

		INT32 nMark2 = rMarkable->createMark( );

		for( i = 0 ; i < 10 ; i ++ )
		{
			aByte.getArray()[i] = i+10;
		}

		rOutput->writeBytes( aByte );

		// allow the bytes to be written !
		rMarkable->jumpToFurthest();
		rMarkable->deleteMark( nMark1 );
		rMarkable->deleteMark( nMark2 );

		ERROR_ASSERT( 256 == rInput->available(), "in between mark failure" );
		rInput->readBytes( aByte ,256);
		for( i = 0 ; i < 256 ; i ++ )
		{
			ERROR_ASSERT( i == aByte.getArray()[i] , "in between mark failure" );
		}
	}

	{
		// now a more extensive mark test !
		Sequence<BYTE> as[4];
		INT32 an[4];

		for( i = 0 ; i < 4 ; i ++ ) {
			as[i].realloc(1);
			as[i].getArray()[0] = i;
			an[i] = rMarkable->createMark();
			rOutput->writeBytes( as[i] );
		}

		// check offset to mark
		for( i = 0 ; i < 4 ; i ++ ) {
			ERROR_ASSERT( rMarkable->offsetToMark( an[i] ) == 4-i , "offsetToMark failure" );
		}

		rMarkable->jumpToMark( an[1] );
		ERROR_ASSERT( rMarkable->offsetToMark( an[3] ) == -2 , "offsetToMark failure" );

		rMarkable->jumpToFurthest( );
		ERROR_ASSERT( rMarkable->offsetToMark( an[0] ) == 4 , "offsetToMark failure" );

		// now do a rewrite !
		for( i = 0 ; i < 4 ; i ++ ) {
			rMarkable->jumpToMark( an[3-i] );
			rOutput->writeBytes( as[i] );
		}
		// NOTE : CursorPos 1

		// now delete the marks !
		for( i = 0 ; i < 4 ; i ++ ) {
			rMarkable->deleteMark( an[i] );
		}
		ERROR_ASSERT( rInput->available() == 1 , "wrong number of bytes flushed" );

		rMarkable->jumpToFurthest();

		ERROR_ASSERT( rInput->available() == 4 , "wrong number of bytes flushed" );

		rInput->readBytes( seqRead , 4 );

		ERROR_ASSERT( 3 == seqRead.getArray()[0] , "rewrite didn't work" );
		ERROR_ASSERT( 2 == seqRead.getArray()[1] , "rewrite didn't work" );
		ERROR_ASSERT( 1 == seqRead.getArray()[2] , "rewrite didn't work" );
		ERROR_ASSERT( 0 == seqRead.getArray()[3] , "rewrite didn't work" );

		rOutput->closeOutput();
		rInput->closeInput();
	}

}

/***
* the test methods
*
****/





/**
* for external binding
*
*
**/
XInterfaceRef OMarkableOutputStreamTest_CreateInstance( const XMultiServiceFactoryRef & rSMgr ) THROWS((Exception))
{
	OMarkableOutputStreamTest *p = new OMarkableOutputStreamTest( rSMgr );
	XInterfaceRef xService = *p;
	return xService;
}



Sequence<UString> OMarkableOutputStreamTest_getSupportedServiceNames(void) THROWS( () )
{
	Sequence<UString> aRet(1);
	aRet.getArray()[0] = OMarkableOutputStreamTest_getImplementationName();

	return aRet;
}

UString     OMarkableOutputStreamTest_getServiceName() THROWS( () )
{
	return L"test.com.sun.star.io.MarkableOutputStream";
}

UString 	OMarkableOutputStreamTest_getImplementationName() THROWS( () )
{
	return L"test.com.sun.starextensions.stm.MarkableOutputStream";
}







//-----------------------------------------------------
// Input stream


class OMarkableInputStreamTest :
		public XSimpleTest,
        public OWeakObject
{
public:
	OMarkableInputStreamTest( const XMultiServiceFactoryRef & rFactory );
	~OMarkableInputStreamTest();

public: // refcounting
	BOOL						queryInterface( Uik aUik, XInterfaceRef & rOut );
	void 						acquire() 						 { OWeakObject::acquire(); }
	void 						release() 						 { OWeakObject::release(); }
	void* 						getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }

public: // implementation names
    static Sequence< UString > 	getSupportedServiceNames_Static(void) THROWS( () );
	static UString 				getImplementationName_Static() THROWS( () );

public:
    virtual void testInvariant(const UString& TestName, const XInterfaceRef& TestObject)
    															THROWS( (	IllegalArgumentException,
    																		UsrSystemException) );

    virtual INT32 test(	const UString& TestName,
    					const XInterfaceRef& TestObject,
    					INT32 hTestHandle) 						THROWS( (	IllegalArgumentException,
    																		UsrSystemException) );

    virtual BOOL testPassed(void) 								THROWS( (	UsrSystemException) );
    virtual Sequence< UString > getErrors(void) 				THROWS( (UsrSystemException) );
    virtual Sequence< UsrAny > getErrorExceptions(void) 		THROWS( (UsrSystemException) );
    virtual Sequence< UString > getWarnings(void) 				THROWS( (UsrSystemException) );

private:
	void testSimple( const XOutputStreamRef &r, const XInputStreamRef &rInput );

private:
	Sequence<UsrAny>  m_seqExceptions;
	Sequence<UString> m_seqErrors;
	Sequence<UString> m_seqWarnings;
	XMultiServiceFactoryRef m_rFactory;

};

OMarkableInputStreamTest::OMarkableInputStreamTest( const XMultiServiceFactoryRef &rFactory )
		: m_rFactory( rFactory )
{

}

OMarkableInputStreamTest::~OMarkableInputStreamTest()
{

}


BOOL OMarkableInputStreamTest::queryInterface( Uik uik , XInterfaceRef &rOut )
{
	if( XSimpleTest::getSmartUik() == uik ) {
		rOut = (XSimpleTest *) this;
	}
	else {
		return OWeakObject::queryInterface( uik , rOut );
	}
	return TRUE;
}


void OMarkableInputStreamTest::testInvariant( const UString& TestName, const XInterfaceRef& TestObject )
    															THROWS( (	IllegalArgumentException,
    																		UsrSystemException) )
{
	if( L"com.sun.star.io.MarkableInputStream" == TestName )  {
		XServiceInfoRef info( TestObject, USR_QUERY );
		ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
		if( info.is() )
		{
			ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
			ERROR_ASSERT( ! info->supportsService( L"bla bluzb" ) , "XServiceInfo test failed" );
		}
	}
	else {
		THROW( IllegalArgumentException() );
	}
}


INT32 OMarkableInputStreamTest::test(	const UString& TestName,
    					const XInterfaceRef& TestObject,
    					INT32 hTestHandle) 						THROWS( (	IllegalArgumentException,
    																		UsrSystemException) )
{
	if( L"com.sun.star.io.MarkableInputStream" == TestName )  {
		try {
			if( 0 == hTestHandle ) {
				testInvariant( TestName , TestObject );
			}
			else  {
				XInterfaceRef x = m_rFactory->createInstance( L"com.sun.star.io.Pipe");
				XOutputStreamRef  rPipeOutput( x , USR_QUERY );
				XInputStreamRef  rPipeInput( x , USR_QUERY );

				XActiveDataSinkRef sink( TestObject , USR_QUERY );
				sink->setInputStream( rPipeInput );

				XInputStreamRef rInput( TestObject , USR_QUERY );

				OSL_ASSERT( rPipeOutput.is() );
				OSL_ASSERT( rInput.is() );
				if( 1 == hTestHandle ) {
					// checks usual streaming
					testSimple( rPipeOutput , rInput );
				}
			}

		}
		catch( Exception& e )  {
			BUILD_ERROR( 0 , UStringToString( e.getName() , CHARSET_SYSTEM ).GetCharStr() );
		}
		catch(...) {
			BUILD_ERROR( 0 , "unknown exception (Exception is  not base class)" );
		}

		hTestHandle ++;

		if( 2 == hTestHandle ) {
			// all tests finished.
			hTestHandle = -1;
		}
	}
	else {
		THROW( IllegalArgumentException() );
	}
	return hTestHandle;
}



BOOL OMarkableInputStreamTest::testPassed(void) 										THROWS( (UsrSystemException) )
{
	return m_seqErrors.getLen() == 0;
}


Sequence< UString > OMarkableInputStreamTest::getErrors(void) 							THROWS( (UsrSystemException) )
{
	return m_seqErrors;
}


Sequence< UsrAny > OMarkableInputStreamTest::getErrorExceptions(void) 					THROWS( (UsrSystemException) )
{
	return m_seqExceptions;
}


Sequence< UString > OMarkableInputStreamTest::getWarnings(void) 						THROWS( (UsrSystemException) )
{
	return m_seqWarnings;
}


void OMarkableInputStreamTest::testSimple(  	const XOutputStreamRef &rOutput ,
												const XInputStreamRef &rInput )
{
	XMarkableStreamRef rMarkable( rInput , USR_QUERY );

	Sequence<BYTE> seqWrite( 256 );
	Sequence<BYTE> seqRead(10);

	for( int i = 0 ; i < 256 ; i ++ )
	{
		seqWrite.getArray()[i] = i;
	}

	rOutput->writeBytes( seqWrite );
	ERROR_ASSERT( 256 == rInput->available() , "basic read/write failure" );

	rInput->readBytes( seqRead , 10 );
	ERROR_ASSERT( 9 == seqRead.getArray()[9] , "basic read/write failure" );

	INT32 nMark = rMarkable->createMark();

	rInput->skipBytes( 50 );
	ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );
	ERROR_ASSERT( 50 == rMarkable->offsetToMark( nMark ) , "marking error" );

	rMarkable->jumpToMark( nMark );
	ERROR_ASSERT( 256-10 == rInput->available() , "marking error" );

	rInput->readBytes( seqRead , 10 );
	ERROR_ASSERT( 10 == seqRead.getArray()[0] , "marking error" );

	// pos 20
	{
		INT32 nInBetweenMark = rMarkable->createMark( );
		rMarkable->jumpToMark( nMark );
		rMarkable->jumpToMark( nInBetweenMark );

		rInput->readBytes( seqRead , 10 );
		ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );

		rMarkable->deleteMark( nMark );

		// Check if releasing the first bytes works correct.
		rMarkable->jumpToMark( nInBetweenMark);
		rInput->readBytes( seqRead , 10 );
		ERROR_ASSERT( 20 == seqRead.getArray()[0] , "Inbetween mark failed!\n" );

		rMarkable->deleteMark( nInBetweenMark );
	}

	rMarkable->jumpToFurthest();
	ERROR_ASSERT( 256-10-50 == rInput->available() , "marking error" );


	ERROR_ASSERT( 100 == rInput->readSomeBytes( seqRead , 100	) , "wrong results using readSomeBytes" );
	ERROR_ASSERT( 96 == rInput->readSomeBytes( seqRead , 1000) , "wrong results using readSomeBytes" );
	rOutput->closeOutput();
	rInput->closeInput();
}

/***
* the test methods
*
****/





/**
* for external binding
*
*
**/
XInterfaceRef OMarkableInputStreamTest_CreateInstance( const XMultiServiceFactoryRef & rSMgr ) THROWS((Exception))
{
	OMarkableInputStreamTest *p = new OMarkableInputStreamTest( rSMgr );
	XInterfaceRef xService = *p;
	return xService;
}



Sequence<UString> OMarkableInputStreamTest_getSupportedServiceNames(void) THROWS( () )
{
	Sequence<UString> aRet(1);
	aRet.getArray()[0] = OMarkableInputStreamTest_getImplementationName();
	
	return aRet;
}

UString     OMarkableInputStreamTest_getServiceName() THROWS( () )
{
	return L"test.com.sun.star.io.MarkableInputStream";
}

UString 	OMarkableInputStreamTest_getImplementationName() THROWS( () )
{
	return L"test.com.sun.star.extensions.stm.MarkableInputStream";
}