/**************************************************************
 *
 * 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_io.hxx"
#include <com/sun/star/test/XSimpleTest.hpp>
#include <com/sun/star/io/XActiveDataSink.hpp>
#include <com/sun/star/io/XActiveDataSource.hpp>
#include <com/sun/star/io/XMarkableStream.hpp>
#include <com/sun/star/io/XConnectable.hpp>

#include <com/sun/star/lang/XServiceInfo.hpp>

#include <cppuhelper/factory.hxx>

#include <cppuhelper/implbase1.hxx>
#include <cppuhelper/implbase2.hxx>

#include <osl/conditn.hxx>
#include <osl/mutex.hxx>

using namespace ::rtl;
using namespace ::osl;
using namespace ::cppu;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::io;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::test;
// streams

#include "testfactreg.hxx"


class OMarkableOutputStreamTest : public WeakImplHelper1< XSimpleTest >
{
public:
	OMarkableOutputStreamTest( const Reference< XMultiServiceFactory > & rFactory );
	~OMarkableOutputStreamTest();

public: // implementation names
    static Sequence< OUString > 	getSupportedServiceNames_Static(void) throw ();
	static OUString 				getImplementationName_Static() throw ();

public:
    virtual void SAL_CALL testInvariant(
		const OUString& TestName,
		const Reference < XInterface >& TestObject)
		throw (	IllegalArgumentException,
				RuntimeException) ;

    virtual sal_Int32 SAL_CALL  test(	const OUString& TestName,
    					const Reference < XInterface >& TestObject,
    					sal_Int32 hTestHandle)
		throw (	IllegalArgumentException, RuntimeException);
    virtual sal_Bool SAL_CALL testPassed(void)
		throw (	RuntimeException);
    virtual Sequence< OUString > SAL_CALL getErrors(void)
		throw (RuntimeException);
    virtual Sequence< Any > SAL_CALL getErrorExceptions(void)
		throw (RuntimeException);
    virtual Sequence< OUString > SAL_CALL getWarnings(void)
		throw (RuntimeException);

private:
	void testSimple( const Reference< XOutputStream > &r, const Reference < XInputStream > &rInput );

private:
	Sequence<Any>  m_seqExceptions;
	Sequence<OUString> m_seqErrors;
	Sequence<OUString> m_seqWarnings;
	Reference< XMultiServiceFactory > m_rFactory;

};

OMarkableOutputStreamTest::OMarkableOutputStreamTest( const Reference< XMultiServiceFactory > &rFactory )
		: m_rFactory( rFactory )
{

}

OMarkableOutputStreamTest::~OMarkableOutputStreamTest()
{

}




void OMarkableOutputStreamTest::testInvariant( const OUString& TestName,
											   const Reference < XInterface >& TestObject )
	throw (	IllegalArgumentException, RuntimeException)
{
	Reference< XServiceInfo > info( TestObject, UNO_QUERY );
	ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
	if( info.is() )
	{
		ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
		ERROR_ASSERT( ! info->supportsService(
			OUString( RTL_CONSTASCII_USTRINGPARAM("bla bluzb")) ) , "XServiceInfo test failed" );
	}
}


sal_Int32 OMarkableOutputStreamTest::test(
	const OUString& TestName,
	const Reference < XInterface >& TestObject,
	sal_Int32 hTestHandle)
	throw (	IllegalArgumentException, RuntimeException)
{
	if( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.MarkableOutputStream") )
				  == TestName  )  {
		try
		{
			if( 0 == hTestHandle )
			{
				testInvariant( TestName , TestObject );
			}
			else
			{
				Reference < XInterface > x = m_rFactory->createInstance( OUString::createFromAscii("com.sun.star.io.Pipe"));
				Reference< XOutputStream >  rPipeOutput( x , UNO_QUERY );
				Reference < XInputStream >  rPipeInput( x , UNO_QUERY );

				Reference<  XActiveDataSource >  source( TestObject , UNO_QUERY );
				source->setOutputStream( rPipeOutput );

				Reference< XOutputStream > rOutput( TestObject , UNO_QUERY );

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

		}
		catch( Exception &e )
		{
			OString o = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
			BUILD_ERROR( 0 , o.getStr() );
		}
		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;
}



sal_Bool OMarkableOutputStreamTest::testPassed(void) 						throw (RuntimeException)
{
	return m_seqErrors.getLength() == 0;
}


Sequence< OUString > OMarkableOutputStreamTest::getErrors(void) 		throw (RuntimeException)
{
	return m_seqErrors;
}


Sequence< Any > OMarkableOutputStreamTest::getErrorExceptions(void) throw (RuntimeException)
{
	return m_seqExceptions;
}


Sequence< OUString > OMarkableOutputStreamTest::getWarnings(void) 		throw (RuntimeException)
{
	return m_seqWarnings;
}


void OMarkableOutputStreamTest::testSimple(  	const Reference< XOutputStream > &rOutput ,
												const Reference< XInputStream > &rInput )
{
	Reference < XMarkableStream > rMarkable( rOutput , UNO_QUERY );

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

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

	Sequence<sal_Int8> seqWrite( strlen( pcStr )+1 );
	memcpy( seqWrite.getArray() , pcStr , seqWrite.getLength() );

	Sequence<sal_Int8> seqRead( seqWrite.getLength() );

	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.getLength() );
		ERROR_ASSERT( ! strcmp( (char *) seqWrite.getArray() , (char * )seqRead.getArray() ) ,
		              "error during read/write" );
	}

	// Check creating marks !
	sal_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.getLength() == rMarkable->offsetToMark( nMark ) ,
											 "offsetToMark failure" );

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

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

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

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

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

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

		sal_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 == ((sal_uInt8*)(aByte.getArray()))[i] , "in between mark failure" );
		}
	}

	{
		// now a more extensive mark test !
		Sequence<sal_Int8> as[4];
		sal_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
*
*
**/
Reference < XInterface > SAL_CALL OMarkableOutputStreamTest_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw(Exception)
{
	OMarkableOutputStreamTest *p = new OMarkableOutputStreamTest( rSMgr );
	return Reference < XInterface > ( SAL_STATIC_CAST( OWeakObject * , p ) );
}



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

	return aRet;
}

OUString     OMarkableOutputStreamTest_getServiceName() throw ()
{
	return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.star.io.MarkableOutputStream"));
}

OUString 	OMarkableOutputStreamTest_getImplementationName() throw ()
{
	return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.starextensions.stm.MarkableOutputStream"));
}







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


class OMarkableInputStreamTest : public WeakImplHelper1< XSimpleTest >
{
public:
	OMarkableInputStreamTest( const Reference< XMultiServiceFactory > & rFactory );
	~OMarkableInputStreamTest();

public: // implementation names
    static Sequence< OUString > 	getSupportedServiceNames_Static(void) throw () ;
	static OUString 				getImplementationName_Static() throw () ;

public:
    virtual void SAL_CALL testInvariant(
		const OUString& TestName,
		const Reference < XInterface >& TestObject)
		throw (	IllegalArgumentException, RuntimeException) ;

    virtual sal_Int32 SAL_CALL test(
		const OUString& TestName,
		const Reference < XInterface >& TestObject,
		sal_Int32 hTestHandle)
		throw (	IllegalArgumentException,
				RuntimeException) ;

    virtual sal_Bool SAL_CALL testPassed(void)
		throw (	RuntimeException);
    virtual Sequence< OUString > SAL_CALL getErrors(void)
		throw (RuntimeException);
    virtual Sequence< Any > SAL_CALL getErrorExceptions(void)
		throw (RuntimeException);
    virtual Sequence< OUString > SAL_CALL getWarnings(void)
		throw (RuntimeException);

private:
	void testSimple( const Reference< XOutputStream > &r,
					 const Reference < XInputStream > &rInput );

private:
	Sequence<Any>  m_seqExceptions;
	Sequence<OUString> m_seqErrors;
	Sequence<OUString> m_seqWarnings;
	Reference< XMultiServiceFactory > m_rFactory;

};

OMarkableInputStreamTest::OMarkableInputStreamTest( const Reference< XMultiServiceFactory > &rFactory )
		: m_rFactory( rFactory )
{

}

OMarkableInputStreamTest::~OMarkableInputStreamTest()
{

}



void OMarkableInputStreamTest::testInvariant(
	const OUString& TestName, const Reference < XInterface >& TestObject )
	throw (	IllegalArgumentException, RuntimeException)
{
	if( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.MarkableInputStream"))
		== TestName )  {
		Reference <XServiceInfo >  info( TestObject, UNO_QUERY );
		ERROR_ASSERT( info.is() , "XServiceInfo not supported !" );
		if( info.is() )
		{
			ERROR_ASSERT( info->supportsService( TestName ), "XServiceInfo test failed" );
			ERROR_ASSERT(
				! info->supportsService(
					OUString(RTL_CONSTASCII_USTRINGPARAM("bla bluzb")) ) ,
				"XServiceInfo test failed" );
		}
	}
	else
	{
		throw IllegalArgumentException();
	}
}


sal_Int32 OMarkableInputStreamTest::test(
	const OUString& TestName,
	const Reference < XInterface >& TestObject,
	sal_Int32 hTestHandle) 	throw (	IllegalArgumentException, RuntimeException)
{
	if( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.MarkableInputStream")) == TestName )
	{
		try
		{
			if( 0 == hTestHandle ) {
				testInvariant( TestName , TestObject );
			}
			else  {
				Reference < XInterface > x = m_rFactory->createInstance( OUString::createFromAscii("com.sun.star.io.Pipe"));
				Reference< XOutputStream >  rPipeOutput( x , UNO_QUERY );
				Reference < XInputStream >  rPipeInput( x , UNO_QUERY );

				Reference < XActiveDataSink >  sink( TestObject , UNO_QUERY );
				sink->setInputStream( rPipeInput );

				Reference < XInputStream > rInput( TestObject , UNO_QUERY );

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

		}
		catch( Exception & e )
		{
			OString o = OUStringToOString( e.Message , RTL_TEXTENCODING_ASCII_US );
			BUILD_ERROR( 0 , o.getStr() );
		}
		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;
}



sal_Bool OMarkableInputStreamTest::testPassed(void) 										throw (RuntimeException)
{
	return m_seqErrors.getLength() == 0;
}


Sequence< OUString > OMarkableInputStreamTest::getErrors(void) 							throw (RuntimeException)
{
	return m_seqErrors;
}


Sequence< Any > OMarkableInputStreamTest::getErrorExceptions(void) 					throw (RuntimeException)
{
	return m_seqExceptions;
}


Sequence< OUString > OMarkableInputStreamTest::getWarnings(void) 						throw (RuntimeException)
{
	return m_seqWarnings;
}


void OMarkableInputStreamTest::testSimple(  	const Reference< XOutputStream > &rOutput ,
												const Reference < XInputStream > &rInput )
{
	Reference < XMarkableStream > rMarkable( rInput , UNO_QUERY );

	Sequence<sal_Int8> seqWrite( 256 );
	Sequence<sal_Int8> 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" );

	sal_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
	{
		sal_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
*
*
**/
Reference < XInterface > SAL_CALL OMarkableInputStreamTest_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr ) throw(Exception)
{
	OMarkableInputStreamTest *p = new OMarkableInputStreamTest( rSMgr );
	return Reference < XInterface > ( SAL_STATIC_CAST( OWeakObject * , p ) );
}



Sequence<OUString> OMarkableInputStreamTest_getSupportedServiceNames(void) throw ()
{
	Sequence<OUString> aRet(1);
	aRet.getArray()[0] = OMarkableInputStreamTest_getImplementationName();

	return aRet;
}

OUString     OMarkableInputStreamTest_getServiceName() throw ()
{
	return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.star.io.MarkableInputStream"));
}

OUString 	OMarkableInputStreamTest_getImplementationName() throw ()
{
	return OUString( RTL_CONSTASCII_USTRINGPARAM("test.com.sun.star.extensions.stm.MarkableInputStream" ));
}