xref: /AOO41X/main/sal/qa/osl/socket/osl_StreamSocket.cxx (revision 87d2adbc9cadf14644c3679b041b9226f7630199)

/**************************************************************
 *
 * 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_sal.hxx"

/**  test coder preface:
     1. the BSD socket function will meet "unresolved external symbol error" on Windows platform
     if you are not including ws2_32.lib in makefile.mk,  the including format will be like this:

     .IF "$(GUI)" == "WNT"
     SHL1STDLIBS += $(SOLARLIBDIR)$/cppunit.lib
     SHL1STDLIBS +=  ws2_32.lib
     .ENDIF

     likewise on Solaris platform.
     .IF "$(GUI)" == "UNX"
     SHL1STDLIBS+=$(SOLARLIBDIR)$/libcppunit$(DLLPOSTFIX).a
     SHL1STDLIBS += -lsocket -ldl -lnsl
     .ENDIF

     2. since the Socket implementation of osl is only IPv4 oriented, our test are mainly focus on IPv4
     category.

     3. some fragment of Socket source implementation are lack of comment so it is hard for testers
     guess what the exact functionality or usage of a member.  Hope the Socket section's comment
     will be added.

     4. following functions are declared but not implemented:
     inline sal_Bool SAL_CALL operator== (const SocketAddr & Addr) const;
*/

//------------------------------------------------------------------------
// include files
//------------------------------------------------------------------------

#include <testshl/simpleheader.hxx>

//#include "osl_Socket_Const.h"
#include "sockethelper.hxx"
#include <osl/conditn.hxx>

using namespace osl;
using namespace rtl;

#define IP_PORT_MYPORT9  8897
#define IP_PORT_MYPORT10 18900

const char * pTestString1 = "test socket";
const char * pTestString2 = " Passed#OK";

//------------------------------------------------------------------------
// helper functions
//------------------------------------------------------------------------

// just used to test socket::close() when accepting
class AcceptorThread : public Thread
{
    ::osl::AcceptorSocket asAcceptorSocket;
    ::rtl::OUString aHostIP;
    sal_Bool bOK;
protected:
    void SAL_CALL run( )
        {
            ::osl::SocketAddr saLocalSocketAddr( aHostIP, IP_PORT_MYPORT9 );
            ::osl::StreamSocket ssStreamConnection;

            asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //integer not sal_Bool : sal_True);
            sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
            if  ( sal_True != bOK1 )
            {
                t_print("# AcceptorSocket bind address failed.\n" ) ;
                return;
            }
            sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
            if  ( sal_True != bOK2 )
            {
                t_print("# AcceptorSocket listen address failed.\n" ) ;
                return;
            }

            asAcceptorSocket.enableNonBlockingMode( sal_False );

            oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
            if (eResult != osl_Socket_Ok )
            {
                bOK = sal_True;
                t_print("AcceptorThread: acceptConnection failed! \n");
            }
        }
public:
    AcceptorThread(::osl::AcceptorSocket & asSocket, ::rtl::OUString const& aBindIP )
            : asAcceptorSocket( asSocket ), aHostIP( aBindIP )
        {
            bOK = sal_False;
        }

    sal_Bool isOK() { return bOK; }

    ~AcceptorThread( )
        {
            if ( isRunning( ) )
            {
                asAcceptorSocket.shutdown();
                t_print("# error: Acceptor thread not terminated.\n" );
            }
        }
};

/** Server Socket Thread, served as a temp little server to communicate with client.
 */
class ServerSocketThread : public Thread
{
    osl::Condition    &m_aCondition;
protected:
    oslThreadIdentifier m_id;

    void SAL_CALL run( )
        {
            ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
            ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 );
            ::osl::StreamSocket ssStreamConnection;

            //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
            asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //integer not sal_Bool : sal_True);
            while ( schedule( ) == sal_True )
            {
                sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
                if  ( sal_True != bOK1 )
                {
                    t_print("# ServerSocketThread: AcceptorSocket bind address failed.\n" ) ;
                    break;
                }
                sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
                if  ( sal_True != bOK2 )
                {
                    t_print("# ServerSocketThread: AcceptorSocket listen address failed.\n" ) ;
                    break;
                }

                asAcceptorSocket.enableNonBlockingMode( sal_False );
                m_aCondition.set();

                oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
                if (eResult != osl_Socket_Ok )
                {
                    t_print("ServerSocketThread: acceptConnection failed! \n");
                    break;
                }
                sal_Int32 nReadNumber1 = ssStreamConnection.recv( pReadBuffer, 11 );
                sal_Int32 nReadNumber2 = ssStreamConnection.recv( pReadBuffer + nReadNumber1, 11 );
                pReadBuffer[nReadNumber1 + nReadNumber2] = '\0';
                //t_print("# read buffer content: %s\n", pReadBuffer );
                break;
            }
            ssStreamConnection.close();
            asAcceptorSocket.close();

        }

    void SAL_CALL onTerminated( )
        {
            //t_print("# normally terminate this server thread %d!\n",  m_id );
        }

public:
    // public to check if data transmition is OK
    sal_Char pReadBuffer[30];
    ServerSocketThread( osl::Condition &_aCond  ):m_aCondition(_aCond)
        {
            m_aCondition.reset();
            t_print("#init ServerSocketThread\n");
            m_id = getIdentifier( );
            //t_print("# successfully creat this ServerSocketThread %d!\n",  m_id );
        }

    ~ServerSocketThread( )
        {
            if ( isRunning( ) )
                t_print("# error: ServerSocketThread has not terminated.\n" );
        }
};

/** Client Socket Thread, served as a temp little client to communicate with server.
 */
class ClientSocketThread : public Thread
{
protected:
    osl::Condition    &m_aCondition;
    oslThreadIdentifier m_id;
    ::osl::SocketAddr m_saTargetSocketAddr;
    ::osl::ConnectorSocket m_csConnectorSocket;

    void SAL_CALL run( )
        {
            TimeValue *pTimeout;
            pTimeout  = ( TimeValue* )malloc( sizeof( TimeValue ) );
            pTimeout->Seconds = 5;
            pTimeout->Nanosec = 0;

            /// if the thread should terminate, schedule return false
            //while ( schedule( ) == sal_True )
            //{
            if ( osl::Condition::result_ok != m_aCondition.wait( pTimeout ) )
            {
                free( pTimeout );
                return;
            }

            if ( osl_Socket_Ok == m_csConnectorSocket.connect( m_saTargetSocketAddr, pTimeout ))
            {
                m_csConnectorSocket.send( pTestString1, 11 ); // "test socket"
                m_csConnectorSocket.send( pTestString2, 10);
            }
            else
                t_print("# ClientSocketThread: connect failed! \n");
            //  terminate();
            //}
            m_csConnectorSocket.close();
            free( pTimeout );
        }

    void SAL_CALL onTerminated( )
        {
            //t_print("# normally terminate this thread %d!\n",  m_id );
        }

public:
    ClientSocketThread( osl::Condition &_aCond  ):
            m_aCondition(_aCond),
            m_saTargetSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 ),
            m_csConnectorSocket( )
        {
            m_id = getIdentifier( );
            //t_print("# successfully creat this client thread %d!\n",  m_id );
        }

    ~ClientSocketThread( )
        {
            if ( isRunning( ) )
                t_print("# error: client thread not terminated.\n" );
        }

};

// -----------------------------------------------------------------------------
// Helper functions, to create buffers, check buffers
class ValueCheckProvider
{
    bool m_bFoundFailure;
    char *m_pBuffer;
    sal_Int32 m_nBufferSize;

public:
    ValueCheckProvider()
            :m_bFoundFailure(false),
             m_pBuffer(NULL),
             m_nBufferSize(0)
        {
        }

    bool       isFailure() {return m_bFoundFailure;}

    const char* getBuffer() {return m_pBuffer;}
    char*       getWriteBuffer() {return m_pBuffer;}

    sal_Int32   getBufferSize() {return m_nBufferSize;}

    bool checkValues(sal_Int32 _nLength, int _nValue)
        {
            m_bFoundFailure = false;
            for(sal_Int32 i=0;i<_nLength;i++)
            {
                if (m_pBuffer[i] != _nValue)
                {
                    m_bFoundFailure = true;
                }
            }
            return m_bFoundFailure;
        }

    void createBuffer(sal_Int32 _nLength, int _nValue)
        {
            m_nBufferSize = _nLength;
            m_pBuffer = (char*) malloc(m_nBufferSize);
            if (m_pBuffer)
            {
                memset(m_pBuffer, _nValue, m_nBufferSize);
            }
        }

    void freeBuffer()
        {
            if (m_pBuffer) free(m_pBuffer);
        }

};

// -----------------------------------------------------------------------------
/** Client Socket Thread, served as a temp little client to communicate with server.
 */

class ReadSocketThread : public Thread
{
    ValueCheckProvider m_aValues;
    int m_nValue;
    osl::Condition    &m_aCondition;

protected:
    oslThreadIdentifier m_id;

    void SAL_CALL run( )
        {
            ::osl::SocketAddr      m_aTargetSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT10 );
            ::osl::ConnectorSocket m_aConnectorSocket;

            if (! m_aTargetSocketAddr.is())
            {
                t_print("# SocketAddr was NOT created successfully!\n");
            }
            else
            {
                t_print("start ReadSocketThread\n");

                TimeValue *pTimeout;
                pTimeout  = ( TimeValue* )malloc( sizeof( TimeValue ) );
                pTimeout->Seconds = 5;
                pTimeout->Nanosec = 0;

                m_aCondition.wait();

                t_print("connect()\n");

                oslSocketResult eResult = m_aConnectorSocket.connect( m_aTargetSocketAddr, pTimeout );
                if ( osl_Socket_Ok == eResult )
                {
                    sal_Int32 nReadCount = m_aConnectorSocket.read( m_aValues.getWriteBuffer(), m_aValues.getBufferSize() );
                    m_aValues.checkValues(nReadCount, m_nValue);
                }
                else
                {
                    t_print("# ReadSocketThread: connect failed! \n");
                    printSocketResult(eResult);
                }

                //remove this line for deadlock on solaris( margritte.germany )
                m_aConnectorSocket.close();
                free( pTimeout );
            }
        }

    void SAL_CALL onTerminated( )
        {
            //t_print("# normally terminate this thread %d!\n",  m_id );
        }

public:
    sal_Int32 getCount() {return m_aValues.getBufferSize();}
    bool       isOk() {return m_aValues.isFailure() == true ? false : true;}

    ReadSocketThread(sal_Int32 _nBufferSize, int _nValue, osl::Condition &_aCond )
            : m_nValue( _nValue ),
              m_aCondition(_aCond)
        {
            t_print("#init ReadSocketThread\n");
            m_id = getIdentifier( );

            //t_print("# successfully creat this client thread %d!\n",  m_id );
            m_aValues.createBuffer(_nBufferSize, 0);
        }

    ~ReadSocketThread( )
        {
            if ( isRunning( ) )
                t_print("# error: client thread not terminated.\n" );
            m_aValues.freeBuffer();
        }

};

/** Server Socket Thread, write a file which is large
 */
class WriteSocketThread : public Thread
{
    ValueCheckProvider m_aValues;
    osl::Condition    &m_aCondition;

protected:
    oslThreadIdentifier m_id;

    void SAL_CALL run( )
        {
            t_print("start WriteSocketThread\n");
            ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
            ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT10 );
            if (! saLocalSocketAddr.is())
            {
                t_print("LocalSocketAddr was NOT created successfully!\n");
            }

            ::osl::StreamSocket ssStreamConnection;

            //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
            asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 );    //sal_True);

            /// if the thread should terminate, schedule return false
            // while ( schedule( ) == sal_True )
            // {
            t_print("bind()\n");
            sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
            if  ( sal_True != bOK1 )
            {
                t_print("# WriteSocketThread: AcceptorSocket bind address failed. \n" ) ;
            }
            else
            {
                t_print("listen()\n");
                sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
                if  ( sal_True != bOK2 )
                {
                    t_print("# WriteSocketThread: AcceptorSocket listen address failed. \n" ) ;
                }
                else
                {

                    // blocking mode, if read/recv failed, block until success
                    asAcceptorSocket.enableNonBlockingMode( sal_False);
                    t_print("acceptConnection()\n");
                    m_aCondition.set();

                    oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
                    if (eResult != osl_Socket_Ok )
                    {
                        t_print("WriteSocketThread: acceptConnection failed! \n");
                    }
                    else
                    {

// LLA: removed, due to the fact, this is to error prone
// LLA:             char * pSrcRoot = getenv("SOURCE_ROOT");
// LLA:             // LLA: This is absolute wrong!
// LLA:             // strcat( pSrcRoot, "/sal/inc/osl/file.hxx");
// LLA:             rtl::OString sSrcRoot(pSrcRoot);
// LLA:             sSrcRoot += "/sal/inc/osl/file.hxx";
// LLA:
// LLA:             ::rtl::OUString sFilePath = ::rtl::OUString::createFromAscii( sSrcRoot.getStr() );
// LLA: #ifdef WNT
// LLA:             while (sFilePath.lastIndexOf('/') != -1)
// LLA:                 sFilePath = sFilePath.replace('/',(sal_Unicode)'\\');
// LLA: #endif
// LLA:             FILE *stream;
// LLA:             sal_uInt64     nCount_read;
// LLA:             sal_Char       buffer_read[FILE_READ];
// LLA:
// LLA:             if( (stream = fopen( oustring2char( sFilePath ), "r+t" )) != NULL )
// LLA:             {
// LLA:                 /* Attempt to read in 25 characters */
// LLA:                 nCount_read = fread( buffer_read, sizeof( char ), FILE_READ, stream );
// LLA:                 fclose( stream );
// LLA:             }
// LLA:             else
// LLA:                 t_print("# File $SRC_ROOT/sal/inc/osl/file.hxx could not be opened\n" );

                        t_print("write()\n");

                        ssStreamConnection.write( m_aValues.getBuffer(), m_aValues.getBufferSize() );
                        t_print("done written.\n");
                    }
                }
            }
            ssStreamConnection.close();
            asAcceptorSocket.close();
        }

    void SAL_CALL onTerminated( )
        {
            //t_print("# normally terminate this server thread %d!\n",  m_id );
        }

public:
    // public to check if data transmition is OK
    WriteSocketThread(sal_Int32 _nBufferSize, int _nValue, osl::Condition &_aCond )
            : m_aCondition(_aCond)
        {
            m_aCondition.reset();

            t_print("#init WriteSocketThread\n");
            m_id = getIdentifier( );
            //t_print("# successfully creat this server thread %d!\n",  m_id );

            m_aValues.createBuffer(_nBufferSize, _nValue);
        }

    ~WriteSocketThread( )
        {
            if ( isRunning( ) )
                t_print("# error: server thread not terminated.\n" );
            m_aValues.freeBuffer();
        }
};

// -----------------------------------------------------------------------------

namespace osl_StreamSocket
{

    /** testing the methods:
        inline StreamSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
        oslProtocol Protocol = osl_Socket_ProtocolIp,
        oslSocketType   Type = osl_Socket_TypeStream);

        inline StreamSocket( const StreamSocket & );

        inline StreamSocket( oslSocket Socket , __sal_NoAcquire noacquire );

        inline StreamSocket( oslSocket Socket );
    */

    class ctors : public CppUnit::TestFixture
    {
    public:
        oslSocket sHandle;
        // initialization
        void setUp( )
            {
                sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
            }

        void tearDown( )
            {
                sHandle = NULL;
            }


        void ctors_none()
            {
                /// Socket constructor.
                ::osl::StreamSocket ssSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );

                CPPUNIT_ASSERT_MESSAGE( "test for ctors_none constructor function: check if the stream socket was created successfully.",
                                        osl_Socket_TypeStream ==  ssSocket.getType( ) );
            }

        void ctors_acquire()
            {
                /// Socket constructor.
                ::osl::StreamSocket ssSocket( sHandle );

                CPPUNIT_ASSERT_MESSAGE( "test for ctors_acquire constructor function: check if the socket was created successfully",
                                        osl_Socket_TypeStream == ssSocket.getType( ) );
            }

        void ctors_no_acquire()
            {
                /// Socket constructor.
                ::osl::StreamSocket ssSocket( sHandle, SAL_NO_ACQUIRE );

                CPPUNIT_ASSERT_MESSAGE(" test for ctors_no_acquire constructor function: check if the socket was created successfully",
                                       osl_Socket_TypeStream == ssSocket.getType( ) );
            }

        void ctors_copy_ctor()
            {
                /// Socket constructor.
                ::osl::StreamSocket ssSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                /// Socket copy constructor.
                ::osl::StreamSocket copySocket( ssSocket );

                CPPUNIT_ASSERT_MESSAGE(" test for ctors_copy_ctor constructor function: create new Socket instance using copy constructor",
                                       osl_Socket_TypeStream == copySocket.getType( ) );
            }

        CPPUNIT_TEST_SUITE( ctors );
        CPPUNIT_TEST( ctors_none );
        CPPUNIT_TEST( ctors_acquire );
        CPPUNIT_TEST( ctors_no_acquire );
        CPPUNIT_TEST( ctors_copy_ctor );
        CPPUNIT_TEST_SUITE_END();

    }; // class ctors

    class send_recv: public CppUnit::TestFixture
    {
    public:
        // initialization
        void setUp( )
            {
            }

        void tearDown( )
            {

            }

        void send_recv1()
            {
                osl::Condition aCondition;
                //client sent two strings, and server received, check the order and value
                ServerSocketThread myServerThread( aCondition );
                ClientSocketThread myClientThread( aCondition );
                myServerThread.create( );
                myClientThread.create( );

                //wait until the thread terminate
                myClientThread.join( );
                myServerThread.join( );
                sal_Char myStr[30] = "";
                strcat( myStr, pTestString1 );
                strcat( myStr, pTestString2 );
                sal_Int32 nRes = strcmp( myServerThread.pReadBuffer, myStr );
                CPPUNIT_ASSERT_MESSAGE(" test for send/recv with two threads: launch Server/Client threads, send data from client, check received data in Server thread.",
                                       nRes == 0 );
            }

        // error when recv
        void send_recv2()
            {
                ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 );
                ::osl::StreamSocket ssStreamConnection;
                sal_Char pReadBuffer[30] = "";

                osl::Condition aCondition;
                aCondition.reset();
                ClientSocketThread myClientThread( aCondition );
                myClientThread.create( );

                asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 );

                asAcceptorSocket.bind( saLocalSocketAddr );
                asAcceptorSocket.listen( 1 );
                asAcceptorSocket.enableNonBlockingMode( sal_True );
                aCondition.set();

                asAcceptorSocket.acceptConnection( ssStreamConnection );
                sal_Int32 nReadNumber = ssStreamConnection.recv( pReadBuffer, 11 );

                myClientThread.join( ) ;
                ssStreamConnection.close();
                asAcceptorSocket.close();
                CPPUNIT_ASSERT_MESSAGE(" test for send/recv, recv error!", nReadNumber == -1 );
            }

        // LLA: This is a helper function, which create 2 threads, a server and a client.
        // the server writes the buffersize to the client.

        void write_read(sal_Int32 _nBufferSize, int _nValue)
            {
                //client sent two strings, and server received, check the order and value
                osl::Condition aCondition;
                WriteSocketThread myServerThread(_nBufferSize, _nValue, aCondition);
                ReadSocketThread myClientThread(_nBufferSize, _nValue, aCondition);
                myServerThread.create( );
//          thread_sleep( 1 );
                myClientThread.create( );

                //wait until the thread terminate
                myClientThread.join( );
                myServerThread.join( );

                //Maximum Packet Size is ( ARPANET, MILNET = 1007 Ethernet (10Mb) = 1500
                // Proteon PRONET  = 2046), so here test read 4000 bytes
                sal_Int32 nLength = myClientThread.getCount();
                bool       bIsOk   = myClientThread.isOk(); // check if the values are right.

                t_print("Length:=%d\n", nLength);
                t_print(" bIsOk:=%d\n", bIsOk);

                CPPUNIT_ASSERT_MESSAGE(" test for write/read values with two threads: send data from server, check readed data in client.",
                                       nLength == _nBufferSize && bIsOk == true);
            }

        // Tests with different values and sizes
        void write_read_001()
            {
                write_read(50, 10);
            }
        void write_read_002()
            {
                write_read(1024, 20);
            }
        void write_read_003()
            {
                write_read(4000, 1);
            }
        void write_read_004()
            {
                write_read(8192, 3);
            }
        void write_read_005()
            {
                write_read(32768, 3);
            }

        CPPUNIT_TEST_SUITE( send_recv );
        CPPUNIT_TEST( write_read_001 );
        CPPUNIT_TEST( write_read_002 );
        CPPUNIT_TEST( write_read_003 );
        CPPUNIT_TEST( write_read_004 );
        CPPUNIT_TEST( write_read_005 );
        CPPUNIT_TEST( send_recv1 );
        CPPUNIT_TEST( send_recv2 );
//      CPPUNIT_TEST( write_read );
        CPPUNIT_TEST_SUITE_END();
    }; // class send_recv

// -----------------------------------------------------------------------------

    class SendClientThread : public Thread
    {
    protected:
        ::osl::SocketAddr m_saTargetSocketAddr;
        ::osl::ConnectorSocket m_csConnectorSocket;
        void SAL_CALL run( )
            {
                TimeValue *pTimeout;
                pTimeout  = ( TimeValue* )malloc( sizeof( TimeValue ) );
                pTimeout->Seconds = 5;
                pTimeout->Nanosec = 0;

                if ( osl_Socket_Ok == m_csConnectorSocket.connect( m_saTargetSocketAddr, pTimeout ))
                {
                    sal_Int32 nWrite1 = m_csConnectorSocket.write( pTestString1, 11 ); // "test socket"

                    sal_Int32 nWrite2 = m_csConnectorSocket.write( pTestString2, strlen( pTestString2 ) + 1 );
                    thread_sleep( 2 );
                    m_csConnectorSocket.write( pTestString2, strlen( pTestString2 ) + 1 );
                    t_print("nWrite1 is %d, nWrite2 is %d\n", nWrite1, nWrite2 );
                    //thread_sleep( 1 );
                }
                else
                    t_print("# SendClientThread: connect failed! \n");

                m_csConnectorSocket.close();
                free( pTimeout );
            }
    public:
        SendClientThread(  ):
                m_saTargetSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9 ),
                m_csConnectorSocket( )
            {
                //t_print("# successfully creat this SendClientThread %d!\n",  m_id );
            }

        ~SendClientThread( )
            {
                if ( isRunning( ) )
                    t_print("# error: SendClientThread has not terminated.\n" );
            }

    };

    class shutdown: public CppUnit::TestFixture
    {
    public:
        // initialization
        void setUp( )
            {
            }

        void tearDown( )
            {

            }

        // similar to close_002
        void shutdown_001()
            {
#if defined(LINUX)
                ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                AcceptorThread myAcceptorThread( asSocket, rtl::OUString::createFromAscii("127.0.0.1") );
                myAcceptorThread.create();

                thread_sleep( 1 );

                //when accepting, shutdown the socket, the thread will not block for accepting
                asSocket.shutdown();
                myAcceptorThread.join();

                CPPUNIT_ASSERT_MESSAGE( "test for close when is accepting: the socket will quit accepting status.",
                                        myAcceptorThread.isOK( ) == sal_True );
#endif
            }

        void shutdown_002()
            {
                ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9);
                asSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
                CPPUNIT_ASSERT_MESSAGE("shutdown_002: bind fail", asSocket.bind( saLocalSocketAddr ) == sal_True);
                CPPUNIT_ASSERT_MESSAGE("shutdown_002: listen fail", asSocket.listen( 1 ) == sal_True );
                sal_Char pReadBuffer[40];
//          osl::Condition aCondition;
                SendClientThread mySendThread;
                mySendThread.create();

                asSocket.enableNonBlockingMode( sal_False );
                ::osl::StreamSocket ssConnectionSocket;
                oslSocketResult eResult = asSocket.acceptConnection( ssConnectionSocket );
                CPPUNIT_ASSERT_MESSAGE("shutdown_002: acceptConnection fail", eResult == osl_Socket_Ok );

                /* set socket option SO_LINGER 0, so close immediatly */
                linger aLingerSet;
                sal_Int32 nBufferLen = sizeof( struct linger );
                aLingerSet.l_onoff = 0;
                aLingerSet.l_linger = 0;

                ssConnectionSocket.setOption( osl_Socket_OptionLinger,  &aLingerSet, nBufferLen );
                thread_sleep( 1 );
                //sal_uInt32 nRecv1 = 0;
                sal_Int32 nRead1 = ssConnectionSocket.read( pReadBuffer, 11 );

                //shutdown read after client the first send complete
                ssConnectionSocket.shutdown( osl_Socket_DirRead );

                sal_Int32 nRead2 = ssConnectionSocket.read( pReadBuffer + nRead1, 12 );
                sal_Int32 nRead3 = ssConnectionSocket.read( pReadBuffer + nRead1 + nRead2, 12 );
                t_print("after read 2, nRead1 is %d, nRead2 is %d, nRead3 is %d \n", nRead1, nRead2, nRead3 );
                mySendThread.join();

                ssConnectionSocket.close();
                asSocket.close();

                /* on Linux, if send is before shutdown(DirRead), can read, nRecv2 still > 0,
                   http://dbforums.com/arch/186/2002/12/586417
                   While on Solaris, after shutdown(DirRead), all read will return 0
                */
#ifdef LINUX
                CPPUNIT_ASSERT_MESSAGE( "test for shutdown read direction: the socket can not read(recv).",
                                        nRead1 > 0  && nRead3 == 0 );
#else
                CPPUNIT_ASSERT_MESSAGE( "test for shutdown read direction: the socket can not read(recv).",
                                        nRead1 > 0  && nRead2 == 0 && nRead3 == 0 );
#endif

            }

        void shutdown_003()
            {
                ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("127.0.0.1"), IP_PORT_MYPORT9);
                asSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
                CPPUNIT_ASSERT_MESSAGE("shutdown_002: bind fail", asSocket.bind( saLocalSocketAddr ) == sal_True);
                CPPUNIT_ASSERT_MESSAGE("shutdown_002: listen fail", asSocket.listen( 1 ) == sal_True );
                sal_Char pReadBuffer[40];
                osl::Condition aCondition;
                SendClientThread mySendThread;
                mySendThread.create();

                asSocket.enableNonBlockingMode( sal_False );
                ::osl::StreamSocket ssConnectionSocket;
                oslSocketResult eResult = asSocket.acceptConnection( ssConnectionSocket );
                CPPUNIT_ASSERT_MESSAGE("shutdown_002: acceptConnection fail", eResult == osl_Socket_Ok );

                thread_sleep( 1 );
                //shutdown write after client the first send complete
                ssConnectionSocket.shutdown( osl_Socket_DirWrite );

                // recv should not shutdown
                sal_Int32 nRead1 = ssConnectionSocket.read( pReadBuffer, 11 );

                sal_Int32 nWrite = ssConnectionSocket.write( pReadBuffer, 11 );
                // still can read
                sal_Int32 nRead3 = ssConnectionSocket.read( pReadBuffer + nRead1 , 12 );
                t_print("after read 2, nRead1 is %d, nWrite is %d, nRead3 is %d\n", nRead1, nWrite, nRead3 );
                mySendThread.join();
                ssConnectionSocket.close();
                asSocket.close();

                CPPUNIT_ASSERT_MESSAGE( "test for shutdown read direction: the socket can not send(write).",
                                        nRead1  > 0  && nWrite == 0 && nRead3 > 0);

            }

        CPPUNIT_TEST_SUITE( shutdown );
        CPPUNIT_TEST( shutdown_001 );
        CPPUNIT_TEST( shutdown_002 );
        CPPUNIT_TEST( shutdown_003 );
        CPPUNIT_TEST_SUITE_END();
    }; // class shutdown

    class isExceptionPending: public CppUnit::TestFixture
    {
    public:
        void isExPending_001()
            {
                ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                TimeValue *pTimeout;
                pTimeout  = ( TimeValue* )malloc( sizeof( TimeValue ) );
                pTimeout->Seconds = 3;
                pTimeout->Nanosec = 0;
                sal_Bool bOk = asSocket.isExceptionPending( pTimeout );
                free( pTimeout );

                CPPUNIT_ASSERT_MESSAGE( "test for isExceptionPending.",
                                        bOk == sal_False );
            }

        /**tester's comments: lack of a case that return sal_True, do not know when it will return sal_True*/


        CPPUNIT_TEST_SUITE( isExceptionPending );
        CPPUNIT_TEST( isExPending_001 );
        CPPUNIT_TEST_SUITE_END();
    }; // class isExceptionPending

// -----------------------------------------------------------------------------
/** Server Socket Thread, write a file which is large
 */
// LLA: class WriteSocketThread : public Thread
// LLA: {
// LLA:     ValueCheckProvider m_aValues;
// LLA:
// LLA: protected:
// LLA:     oslThreadIdentifier m_id;
// LLA:
// LLA:     void SAL_CALL run( )
// LLA:     {
// LLA:         ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
// LLA:         ::osl::SocketAddr saLocalSocketAddr( rtl::OUString::createFromAscii("10.16.66.252"), 8888 );
// LLA:         ::osl::StreamSocket ssStreamConnection;
// LLA:
// LLA:         //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
// LLA:         asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 );    //sal_True);
// LLA:
// LLA:         /// if the thread should terminate, schedule return false
// LLA:         while ( schedule( ) == sal_True )
// LLA:         {
// LLA:             sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
// LLA:             if  ( sal_True != bOK1 )
// LLA:             {
// LLA:                 t_print("# WriteSocketThread: AcceptorSocket bind address failed. \n" ) ;
// LLA:                 break;
// LLA:             }
// LLA:             sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
// LLA:             if  ( sal_True != bOK2 )
// LLA:             {
// LLA:                 t_print("# WriteSocketThread: AcceptorSocket listen address failed. \n" ) ;
// LLA:                 break;
// LLA:             }
// LLA:             // blocking mode, if read/recv failed, block until success
// LLA:             asAcceptorSocket.enableNonBlockingMode( sal_False);
// LLA:
// LLA:             oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
// LLA:             if (eResult != osl_Socket_Ok )
// LLA:             {
// LLA:                 t_print("WriteSocketThread: acceptConnection failed! \n");
// LLA:                 break;
// LLA:             }
// LLA:
// LLA:
// LLA:             sal_Int32 nReadNumber1 = ssStreamConnection.write( m_aValues.getBuffer(), m_aValues.getBufferSize() );
// LLA:             break;
// LLA:         }
// LLA:         ssStreamConnection.close();
// LLA:         asAcceptorSocket.close();
// LLA:     }
// LLA: }
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
/** Client Socket Thread, served as a temp little client to communicate with server.
 */

#define IP_PORT_TEST 8900

    class ReadSocket2Thread : public Thread
    {
        osl::Condition &m_aCondition;
        char*        m_pBuffer;
        sal_Int32    m_nBufferSize;
        sal_Int32    m_nReadCount;
        rtl::OString m_sAddr;

        bool         m_bOk;

        void setFailed()
            {
                m_bOk = false;
            }

    protected:
        oslThreadIdentifier m_id;

        void read()
            {
                if (m_sAddr.getLength() == 0)
                {
                    setFailed();
                    return;
                }

                // 10.16.66.252
                ::osl::SocketAddr aSocketAddr( rtl::OUString::createFromAscii(m_sAddr.getStr()), IP_PORT_TEST );
                ::osl::ConnectorSocket aSocket; // ( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );

                aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;

                m_aCondition.wait();
                t_print("wait done\n");

                TimeValue *pTimeout;
                pTimeout  = ( TimeValue* )malloc( sizeof( TimeValue ) );
                pTimeout->Seconds = 20;
                pTimeout->Nanosec = 0;


                // blocking mode, if read/recv failed, block until success
                t_print("enableNonBlockingMode(false)\n");
                aSocket.enableNonBlockingMode( sal_False );


                t_print("connect()\n");
                oslSocketResult eResult = aSocket.connect( aSocketAddr, pTimeout );
                if ( osl_Socket_Ok == eResult)
                {
                    if (m_pBuffer)
                    {
                        t_print("read()\n");
                        m_nReadCount = aSocket.read( m_pBuffer, m_nBufferSize );
                        t_print("%d bytes recived.\n", m_nReadCount);
                    }
                }
                else
                {
                    t_print("# ReadSocket2Thread: connect failed! \n");
                    printSocketResult(eResult);
                    setFailed();
                }

                //remove this line for deadlock on solaris( margritte.germany )
                aSocket.close();
                free( pTimeout );
            }

        void SAL_CALL run( )
            {
                read();
            }

        void SAL_CALL onTerminated( )
            {
                //t_print("# normally terminate this thread %d!\n",  m_id );
            }

    public:
        sal_Int32 getCount() {return m_nReadCount;}
        bool       isOk() {return m_nReadCount == 0 ? false : true;}
        bool       getFailed() {return m_bOk == false ? true : false;}

        ReadSocket2Thread(osl::Condition &_aCondition)
                :m_aCondition(_aCondition),
                 m_nReadCount(0),
                 m_bOk( true )
            {
                m_aCondition.reset();
                m_pBuffer = (char*) malloc(1024);
                if (m_pBuffer)
                {
                    m_nBufferSize = 1024;
                }

                m_id = getIdentifier( );
                //t_print("# successfully creat this client thread %d!\n",  m_id );
            }

        void setAddr(rtl::OString const& _sAddr)
            {
                m_sAddr = _sAddr;
            }

        ~ReadSocket2Thread( )
            {
                if ( isRunning( ) )
                    t_print("# error: client thread not terminated.\n" );
                free(m_pBuffer);
            }

    };

    // -----------------------------------------------------------------------------

    class justtest : public CppUnit::TestFixture
    {
        void send_Acceptor(rtl::OString const& _sAddr, osl::Condition &)
            {
                ::osl::AcceptorSocket aSocket; // ( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                ::osl::SocketAddr aSocketAddr;

                if (! aSocketAddr.setPort(IP_PORT_TEST))
                {
                    t_print("# cant set port\n" );
                }

                if (! aSocketAddr.setHostname(rtl::OUString::createFromAscii(_sAddr.getStr())))
                {
                    t_print("# cant set hostname/ip\n" );
                }

                rtl::OUString aHostname = aSocketAddr.getHostname();
                aSocketAddr.getPort();


                //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
                aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);

                /// if the thread should terminate, schedule return false
                // while ( schedule( ) == sal_True )
                // {
                if (! aSocket.bind( aSocketAddr ))
                {
                    t_print("# can't bind.\n" );
                }
                if (! aSocket.listen( ))
                {
                    t_print("# can't listen. \n" );
                }

                // blocking mode, if read/recv failed, block until success
                aSocket.enableNonBlockingMode( sal_False);
                ::osl::StreamSocket ssStreamConnection;

                oslSocketResult eResult = aSocket.acceptConnection( ssStreamConnection );
                if (eResult != osl_Socket_Ok )
                {
                    t_print("WriteSocketThread: acceptConnection failed! \n");
                    // break;
                }
                char const * pBuffer = "Test String\n";
                sal_Int32 nBufferSize = strlen(pBuffer);
                ssStreamConnection.write( pBuffer, nBufferSize );
                // break;
                // }

                // ssStreamConnection.close();
                aSocket.close();
            }

        // -----------------------------------------------------------------------------

        void send_Connector(rtl::OString const& _sAddr, osl::Condition &/*_aCondition*/ )
            {
                ::osl::ConnectorSocket aSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                ::osl::SocketAddr aSocketAddr( rtl::OUString::createFromAscii(_sAddr.getStr()), IP_PORT_TEST );

                if (! aSocketAddr.is())
                {
                    t_print("is failed.\n");
                    return;
                }

                //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
                aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;

                oslSocketResult aResult = aSocket.connect( aSocketAddr );
                if  ( aResult != osl_Socket_Ok )
                {
                    t_print("# send_Connector: connect failed. \n" );
                }
                else
                {
                    // blocking mode, if read/recv failed, block until success
//                    aSocket.enableNonBlockingMode( sal_False );

//                     _aCondition.set();

                    ::osl::StreamSocket ssStreamConnection(aSocket);

                    char const * pBuffer = "GET / HTTP/1.0\015\012\015\012";
                    sal_Int32 nBufferSize = strlen(pBuffer);
                    ssStreamConnection.write( pBuffer, nBufferSize );

                    char *pBufferPeek = (char*) malloc(1024);
                    sal_Int32 nReadNumber = ssStreamConnection.recv( pBufferPeek, 1024, osl_Socket_MsgPeek);
                    free(pBufferPeek);

                    char *pBuffer2 = (char*) malloc(nReadNumber + 1);
                    sal_Int32 nReadNumberReal = ssStreamConnection.read( pBuffer2, nReadNumber );
                    pBuffer2[nReadNumberReal] = '\0';

                    t_print("received: %s\n", pBuffer2);

                    // char * pBuffer3 = "quit\n";
                    // nBufferSize = strlen(pBuffer3);
                    // nWriteNumber = ssStreamConnection.write( pBuffer3, nBufferSize );

                    rtl::OUString suError = ssStreamConnection.getErrorAsString();
                    free(pBuffer2);
                    // ssStreamConnection.close();

                    // ssStreamConnection.close();
                }
                aSocket.shutdown(osl_Socket_DirReadWrite);
                aSocket.close();
            }


    public:
// LLA: orig        void send_recv()
// LLA: orig             {
// LLA: orig                if ( ifAvailable(rtl::OUString::createFromAscii("margritte.germany")) == sal_True )
// LLA: orig                    t_print("margritte is alive ! \n");
// LLA: orig                if ( ifAvailable(rtl::OUString::createFromAscii("10.16.66.252")) == sal_False )
// LLA: orig                {
// LLA: orig            t_print("ip 10.16.66.252 is not alive! \n");
// LLA: orig            return;
// LLA: orig        }
// LLA: orig                 ReadSocket2Thread myReadThread;
// LLA: orig                 myReadThread.create();
// LLA: orig
// LLA: orig                 thread_sleep( 2 );
// LLA: orig                 // send_Acceptor();
// LLA: orig                 send_Connector();
// LLA: orig
// LLA: orig                 myReadThread.join();
// LLA: orig
// LLA: orig                 // statistics
// LLA: orig                 sal_uInt32 nLength = myReadThread.getCount();
// LLA: orig                 bool       bIsOk   = myReadThread.isOk(); // check if the values are right.
// LLA: orig
// LLA: orig                 t_print("Length:=%d\n", nLength);
// LLA: orig                 t_print(" bIsOk:=%d\n", bIsOk);
// LLA: orig             }

        // -----------------------------------------------------------------------------

        // LLA: send_Connector_2_margritte works, it send strings to echo server on margritte
        //      but can not receive anything

        void send_Connector_2_margritte(rtl::OString const& _sAddr)
            {
                ::osl::ConnectorSocket aSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                ::osl::SocketAddr aSocketAddr( rtl::OUString::createFromAscii(_sAddr.getStr()), IP_PORT_TEST );

                //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
                aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;

                oslSocketResult aResult = aSocket.connect( aSocketAddr );
                if  ( aResult != osl_Socket_Ok )
                {
                    t_print("# connect failed. \n" );
                }
                else
                {
                    // blocking mode, if read/recv failed, block until success
                    aSocket.enableNonBlockingMode( sal_False );

                    ::osl::StreamSocket ssStreamConnection(aSocket);

                    char const * pBuffer = "Test String\n";
                    sal_Int32 nBufferSize = strlen(pBuffer);
                    sal_Int32 nWriteNumber = ssStreamConnection.write( pBuffer, nBufferSize );

                    // char * pBuffer2 = "                                                                                                 ";
                    // sal_Int32 nReadNumber = ssStreamConnection.read( pBuffer2, strlen(pBuffer2) );

                    char const * pBuffer3 = "quit\n";
                    nBufferSize = strlen(pBuffer3);
                    nWriteNumber = ssStreamConnection.write( pBuffer3, nBufferSize );

                    ssStreamConnection.close();
                }
                aSocket.close();
            }

        void send_recv_2_margritte()
            {
                rtl::OString sAddr;
                sAddr = "margritte.germany.sun.com";
            	if ( ifAvailable(rtl::OUString::createFromAscii(sAddr.getStr())) == sal_True )
                {
                    t_print("found %s!\n", sAddr.getStr());
                }
                send_Connector_2_margritte(sAddr);
            }

        // -----------------------------------------------------------------------------

        void send_recv()
            {
                rtl::OString sAddr;
                // if ( ifAvailable(rtl::OUString::createFromAscii("margritte.germany")) == sal_True )
                // {
                //     t_print("margritte is alive ! \n");
                //     sAddr = "margritte.germany";
                // }

                sAddr = "margritte.germany.sun.com";
            	if ( ifAvailable(rtl::OUString::createFromAscii(sAddr.getStr())) == sal_True )
                {
                    t_print("found %s!\n", sAddr.getStr());
                }
//                 else
//                 {
//                     if ( ifAvailable(rtl::OUString::createFromAscii("192.168.7.2")) == sal_True )
//                     {
//                         sAddr = "192.168.7.2";
//                         t_print("moon found ! \n");
//                     }
//                     else
//                     {
//                         if ( ifAvailable(rtl::OUString::createFromAscii("moon.linux.bogus")) == sal_True )
//                         {
//                             sAddr = "moon.linux.bogus";
//                             t_print("moon found ! \n");
//                         }
//                         else
//                         {
//                             if ( ifAvailable(rtl::OUString::createFromAscii("moon")) == sal_True )
//                             {
//                                 sAddr = "moon";
//                                 t_print("moon found ! \n");
//                             }
//                         }
//                     }
//                 }

                // if ( ifAvailable(rtl::OUString::createFromAscii("10.16.64.196")) == sal_False )
                // {
                //     t_print("ip 10.16.64.196 is not alive! \n");
                //     return;
                // }

                osl::Condition aCondition;
                ReadSocket2Thread myReadThread(aCondition);
                myReadThread.setAddr(sAddr);
//                myReadThread.create();

                thread_sleep( 2 );
                if (! myReadThread.getFailed())
                {
                    // send_Acceptor(sAddr, aCondition);
                    send_Connector(sAddr, aCondition);

                    thread_sleep( 2 );
                    if (myReadThread.isRunning())
                    {
                        myReadThread.join();
                    }
                    // termAndJoinThread(&myReadThread);

                    // statistics
                    sal_uInt32 nLength = myReadThread.getCount();
                    bool       bIsOk   = myReadThread.isOk(); // check if the values are right.

                    t_print("Length:=%d\n", nLength);
                    t_print(" bIsOk:=%d\n", bIsOk);
                }
                else
                {
                    t_print("ERROR: No echo Server on %s found.\n", sAddr.getStr());
                }
            }


        void getPage(rtl::OString const& _sAddr);
        void test_getPage()
            {
                // rtl::OString sPage("lla-1.germany.sun.com");
                // getPage(sPage);

                rtl::OString sPage("lla-1");
                getPage(sPage);
            }

        CPPUNIT_TEST_SUITE( justtest );
        CPPUNIT_TEST( send_recv );
        CPPUNIT_TEST( test_getPage );
        CPPUNIT_TEST_SUITE_END();
    }; // class isExceptionPending


    void justtest::getPage(rtl::OString const& _sAddr)
            {
                rtl::OUString suAddr = rtl::OUString::createFromAscii(_sAddr.getStr());
                ::osl::ConnectorSocket aSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
                ::osl::SocketAddr aSocketAddr( suAddr, 80 );

            {
                // some checks
                aSocketAddr.getPort();
                oslSocketResult aResult;
                rtl::ByteSequence aSeq = aSocketAddr.getAddr(&aResult);
                if (aResult != osl_Socket_Ok)
                {
                    t_print("problem with getAddr: ");
                    printSocketResult(aResult);
                }

                rtl::OUString sStr = aSocketAddr.getHostname(&aResult);
                if (aResult != osl_Socket_Ok)
                {
                    t_print("problem with hostname: ");
                    printSocketResult(aResult);
                }
            }

                oslSocketResult aResult;

                // SocketAddr::resolveHostname(suAddr, aSocketAddr);
                // if (! aSocketAddr.is())
                // {
                //     t_print("Can't resolve Hostname.\n");
                //     return;
                // }
                // rtl::OUString sStr = aSocketAddr.getHostname(&aResult);
                // if (aResult != osl_Socket_Ok)
                // {
                //     t_print("problem with hostname: ");
                //     printSocketResult(aResult);
                //
                // }

                if (! aSocketAddr.is())
                {
                    t_print("SocketAddr::is() failed.\n");
                    return;
                }

                //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
                aSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True;

                aResult = aSocket.connect( aSocketAddr );
                if  ( aResult != osl_Socket_Ok )
                {
                    t_print("# send_Connector: connect failed. \n" );
                }
                else
                {
                    // blocking mode, if read/recv failed, block until success
//                    aSocket.enableNonBlockingMode( sal_False );

//                     _aCondition.set();

                    ::osl::StreamSocket ssStreamConnection(aSocket);

                    char const * pBuffer = "GET / HTTP/1.0\015\012\015\012";
                    sal_Int32 nBufferSize = strlen(pBuffer);
                    ssStreamConnection.write( pBuffer, nBufferSize );


                    char *pBufferPeek = (char*) malloc(1024);
                    sal_Int32 nReadNumber = 1;
                    while ( nReadNumber != 0)
                    {
                        nReadNumber = ssStreamConnection.recv( pBufferPeek, 1024, osl_Socket_MsgPeek);
                        if (nReadNumber > 0)
                        {
                            char *pBuffer2 = (char*) malloc(nReadNumber + 1);
                            sal_Int32 nReadNumberReal = ssStreamConnection.read( pBuffer2, nReadNumber );
                            pBuffer2[nReadNumberReal] = '\0';
                            t_print("%s", pBuffer2);
                            free(pBuffer2);
                        }
                    }
                    free(pBufferPeek);

                    // char * pBuffer3 = "quit\n";
                    // nBufferSize = strlen(pBuffer3);
                    // nWriteNumber = ssStreamConnection.write( pBuffer3, nBufferSize );

                    rtl::OUString suError = ssStreamConnection.getErrorAsString();
                }
                aSocket.shutdown(osl_Socket_DirReadWrite);
                aSocket.close();
            }

// -----------------------------------------------------------------------------

    CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_StreamSocket::ctors, "osl_StreamSocket");
    CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_StreamSocket::send_recv, "osl_StreamSocket");
    CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_StreamSocket::shutdown, "osl_StreamSocket");
    CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_StreamSocket::isExceptionPending, "osl_StreamSocket");

    CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(osl_StreamSocket::justtest, "osl_StreamSocket");

} // namespace osl_StreamSocket

// -----------------------------------------------------------------------------

// this macro creates an empty function, which will called by the RegisterAllFunctions()
// to let the user the possibility to also register some functions by hand.
NOADDITIONAL;