187d2adbcSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
387d2adbcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
487d2adbcSAndrew Rist * or more contributor license agreements. See the NOTICE file
587d2adbcSAndrew Rist * distributed with this work for additional information
687d2adbcSAndrew Rist * regarding copyright ownership. The ASF licenses this file
787d2adbcSAndrew Rist * to you under the Apache License, Version 2.0 (the
887d2adbcSAndrew Rist * "License"); you may not use this file except in compliance
987d2adbcSAndrew Rist * with the License. You may obtain a copy of the License at
1087d2adbcSAndrew Rist *
1187d2adbcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
1287d2adbcSAndrew Rist *
1387d2adbcSAndrew Rist * Unless required by applicable law or agreed to in writing,
1487d2adbcSAndrew Rist * software distributed under the License is distributed on an
1587d2adbcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
1687d2adbcSAndrew Rist * KIND, either express or implied. See the License for the
1787d2adbcSAndrew Rist * specific language governing permissions and limitations
1887d2adbcSAndrew Rist * under the License.
1987d2adbcSAndrew Rist *
2087d2adbcSAndrew Rist *************************************************************/
2187d2adbcSAndrew Rist
2287d2adbcSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sal.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir /** test coder preface:
28cdf0e10cSrcweir 1. the BSD socket function will meet "unresolved external symbol error" on Windows platform
29cdf0e10cSrcweir if you are not including ws2_32.lib in makefile.mk, the including format will be like this:
30cdf0e10cSrcweir
31cdf0e10cSrcweir .IF "$(GUI)" == "WNT"
32cdf0e10cSrcweir SHL1STDLIBS += $(SOLARLIBDIR)$/cppunit.lib
33cdf0e10cSrcweir SHL1STDLIBS += ws2_32.lib
34cdf0e10cSrcweir .ENDIF
35cdf0e10cSrcweir
36cdf0e10cSrcweir likewise on Solaris platform.
37cdf0e10cSrcweir .IF "$(GUI)" == "UNX"
38cdf0e10cSrcweir SHL1STDLIBS+=$(SOLARLIBDIR)$/libcppunit$(DLLPOSTFIX).a
39cdf0e10cSrcweir SHL1STDLIBS += -lsocket -ldl -lnsl
40cdf0e10cSrcweir .ENDIF
41cdf0e10cSrcweir
42cdf0e10cSrcweir 2. since the Socket implementation of osl is only IPv4 oriented, our test are mainly focus on IPv4
43cdf0e10cSrcweir category.
44cdf0e10cSrcweir
45cdf0e10cSrcweir 3. some fragment of Socket source implementation are lack of comment so it is hard for testers
46cdf0e10cSrcweir guess what the exact functionality or usage of a member. Hope the Socket section's comment
47cdf0e10cSrcweir will be added.
48cdf0e10cSrcweir
49cdf0e10cSrcweir 4. following functions are declared but not implemented:
50cdf0e10cSrcweir inline sal_Bool SAL_CALL operator== (const SocketAddr & Addr) const;
51cdf0e10cSrcweir */
52cdf0e10cSrcweir
53cdf0e10cSrcweir
54cdf0e10cSrcweir //------------------------------------------------------------------------
55cdf0e10cSrcweir // include files
56cdf0e10cSrcweir //------------------------------------------------------------------------
57cdf0e10cSrcweir
58cdf0e10cSrcweir #ifndef _OSL_SOCKET_CONST_H_
59cdf0e10cSrcweir #include <osl_Socket_Const_orig.h>
60cdf0e10cSrcweir #endif
61cdf0e10cSrcweir
6263d99982SDamjan Jovanovic #include <osl/signal.h>
6363d99982SDamjan Jovanovic #include "gtest/gtest.h"
64cdf0e10cSrcweir
65cdf0e10cSrcweir using namespace osl;
66cdf0e10cSrcweir using namespace rtl;
67cdf0e10cSrcweir
68cdf0e10cSrcweir //------------------------------------------------------------------------
69cdf0e10cSrcweir // helper functions
70cdf0e10cSrcweir //------------------------------------------------------------------------
71cdf0e10cSrcweir
72cdf0e10cSrcweir /** compare two OUString.
73cdf0e10cSrcweir */
compareUString(const::rtl::OUString & ustr1,const::rtl::OUString & ustr2)74cdf0e10cSrcweir inline sal_Bool compareUString( const ::rtl::OUString & ustr1, const ::rtl::OUString & ustr2 )
75cdf0e10cSrcweir {
76cdf0e10cSrcweir sal_Bool bOk = ustr1.equalsIgnoreAsciiCase( ustr2 );
77cdf0e10cSrcweir
78cdf0e10cSrcweir return bOk;
79cdf0e10cSrcweir }
80cdf0e10cSrcweir
81cdf0e10cSrcweir /** compare a OUString and an ASCII string.
82cdf0e10cSrcweir */
compareUString(const::rtl::OUString & ustr,const sal_Char * astr)83cdf0e10cSrcweir inline sal_Bool compareUString( const ::rtl::OUString & ustr, const sal_Char *astr )
84cdf0e10cSrcweir {
85cdf0e10cSrcweir ::rtl::OUString ustr2 = rtl::OUString::createFromAscii( astr );
86cdf0e10cSrcweir sal_Bool bOk = ustr.equalsIgnoreAsciiCase( ustr2 );
87cdf0e10cSrcweir
88cdf0e10cSrcweir return bOk;
89cdf0e10cSrcweir }
90cdf0e10cSrcweir
91cdf0e10cSrcweir /** compare two socket address.
92cdf0e10cSrcweir */
compareSocketAddr(const::osl::SocketAddr & addr1,const::osl::SocketAddr & addr2)93cdf0e10cSrcweir inline sal_Bool compareSocketAddr( const ::osl::SocketAddr & addr1 , const ::osl::SocketAddr & addr2 )
94cdf0e10cSrcweir {
95cdf0e10cSrcweir return ( ( sal_True == compareUString( addr1.getHostname( 0 ), addr2.getHostname( 0 ) ) ) && ( addr2.getPort( ) == addr2.getPort( ) ) );
96cdf0e10cSrcweir }
97cdf0e10cSrcweir
oustring2char(const::rtl::OUString & str)98cdf0e10cSrcweir inline char * oustring2char( const ::rtl::OUString & str )
99cdf0e10cSrcweir {
100cdf0e10cSrcweir rtl::OString aString;
101cdf0e10cSrcweir aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
102cdf0e10cSrcweir return (char *)aString.getStr( );
103cdf0e10cSrcweir }
104cdf0e10cSrcweir
105cdf0e10cSrcweir /** print a UNI_CODE String. And also print some comments of the string.
106cdf0e10cSrcweir */
printUString(const::rtl::OUString & str,const sal_Char * msg="")107cdf0e10cSrcweir inline void printUString( const ::rtl::OUString & str, const sal_Char * msg = "" )
108cdf0e10cSrcweir {
10963d99982SDamjan Jovanovic printf("#%s #printUString_u# ", msg );
11063d99982SDamjan Jovanovic printf("%s\n", oustring2char( str ) );
111cdf0e10cSrcweir }
112cdf0e10cSrcweir
113cdf0e10cSrcweir /** get the local host name.
114cdf0e10cSrcweir mindy: gethostbyname( "localhost" ), on Linux, it returns the hostname in /etc/hosts + domain name,
115cdf0e10cSrcweir if no entry in /etc/hosts, it returns "localhost" + domain name
116cdf0e10cSrcweir */
getHost(void)117cdf0e10cSrcweir inline ::rtl::OUString getHost( void )
118cdf0e10cSrcweir {
119cdf0e10cSrcweir struct hostent *hptr;
120cdf0e10cSrcweir
121cdf0e10cSrcweir hptr = gethostbyname( "localhost" );
12263d99982SDamjan Jovanovic EXPECT_TRUE(hptr != NULL) << "#In getHostname function, error on gethostbyname()";
123cdf0e10cSrcweir ::rtl::OUString aUString = ::rtl::OUString::createFromAscii( (const sal_Char *) hptr->h_name );
124cdf0e10cSrcweir
125cdf0e10cSrcweir return aUString;
126cdf0e10cSrcweir }
127cdf0e10cSrcweir
128cdf0e10cSrcweir /** get the full host name of the current processor, such as "aegean.prc.sun.com" --mindyliu
129cdf0e10cSrcweir */
getThisHostname(void)130cdf0e10cSrcweir inline ::rtl::OUString getThisHostname( void )
131cdf0e10cSrcweir {
132cdf0e10cSrcweir ::rtl::OUString aUString;
133cdf0e10cSrcweir #ifdef WNT
134cdf0e10cSrcweir struct hostent *hptr;
135cdf0e10cSrcweir hptr = gethostbyname( "localhost" );
13663d99982SDamjan Jovanovic EXPECT_TRUE(hptr != NULL) << "#In getHostname function, error on gethostbyname()";
137cdf0e10cSrcweir aUString = ::rtl::OUString::createFromAscii( (const sal_Char *) hptr->h_name );
138cdf0e10cSrcweir #else
139cdf0e10cSrcweir char hostname[255];
14063d99982SDamjan Jovanovic EXPECT_TRUE(gethostname(hostname, 255) == 0) << "#Error: gethostname failed.";
141cdf0e10cSrcweir
142cdf0e10cSrcweir struct hostent *hptr;
143cdf0e10cSrcweir //first search /ets/hosts, then search from dns
144cdf0e10cSrcweir hptr = gethostbyname( hostname);
145cdf0e10cSrcweir if ( hptr != NULL )
146cdf0e10cSrcweir {
147cdf0e10cSrcweir strcpy( hostname, hptr->h_name );
148cdf0e10cSrcweir }
149cdf0e10cSrcweir
15063d99982SDamjan Jovanovic printf("hostname is %s \n", hostname );
151cdf0e10cSrcweir aUString = ::rtl::OUString::createFromAscii( (const sal_Char *) hostname );
152cdf0e10cSrcweir #endif
153cdf0e10cSrcweir return aUString;
154cdf0e10cSrcweir }
155cdf0e10cSrcweir
156cdf0e10cSrcweir /** get IP by name, search /etc/hosts first, then search from dns, fail return OUString("")
157cdf0e10cSrcweir */
getIPbyName(rtl::OString const & str_name)158cdf0e10cSrcweir inline ::rtl::OUString getIPbyName( rtl::OString const& str_name )
159cdf0e10cSrcweir {
160cdf0e10cSrcweir ::rtl::OUString aUString;
161cdf0e10cSrcweir struct hostent *hptr;
162cdf0e10cSrcweir //first search /ets/hosts, then search from dns
163cdf0e10cSrcweir hptr = gethostbyname( str_name.getStr());
164cdf0e10cSrcweir if ( hptr != NULL )
165cdf0e10cSrcweir {
166cdf0e10cSrcweir struct in_addr ** addrptr;
167cdf0e10cSrcweir addrptr = (struct in_addr **) hptr->h_addr_list ;
168cdf0e10cSrcweir //if there are more than one IPs on the same machine, we select one
169cdf0e10cSrcweir for (; *addrptr; addrptr++)
170cdf0e10cSrcweir {
17163d99982SDamjan Jovanovic printf("#Local IP Address: %s\n", inet_ntoa(**addrptr));
172cdf0e10cSrcweir aUString = ::rtl::OUString::createFromAscii( (sal_Char *) (inet_ntoa(**addrptr)) );
173cdf0e10cSrcweir }
174cdf0e10cSrcweir }
175cdf0e10cSrcweir return aUString;
176cdf0e10cSrcweir }
177cdf0e10cSrcweir
178cdf0e10cSrcweir /** get local ethernet IP
179cdf0e10cSrcweir */
getLocalIP()180cdf0e10cSrcweir inline ::rtl::OUString getLocalIP( )
181cdf0e10cSrcweir {
182cdf0e10cSrcweir char hostname[255];
183cdf0e10cSrcweir gethostname(hostname, 255);
184cdf0e10cSrcweir
185cdf0e10cSrcweir return getIPbyName( hostname );
186cdf0e10cSrcweir }
187cdf0e10cSrcweir
188cdf0e10cSrcweir /** construct error message
189cdf0e10cSrcweir */
outputError(const::rtl::OUString & returnVal,const::rtl::OUString & rightVal,const sal_Char * msg="")190cdf0e10cSrcweir inline ::rtl::OUString outputError( const ::rtl::OUString & returnVal, const ::rtl::OUString & rightVal, const sal_Char * msg = "")
191cdf0e10cSrcweir {
192cdf0e10cSrcweir ::rtl::OUString aUString;
193cdf0e10cSrcweir if ( returnVal.equals( rightVal ) )
194cdf0e10cSrcweir return aUString;
195cdf0e10cSrcweir aUString += ::rtl::OUString::createFromAscii(msg);
196cdf0e10cSrcweir aUString += ::rtl::OUString::createFromAscii(": the returned value is '");
197cdf0e10cSrcweir aUString += returnVal;
198cdf0e10cSrcweir aUString += ::rtl::OUString::createFromAscii("', but the value should be '");
199cdf0e10cSrcweir aUString += rightVal;
200cdf0e10cSrcweir aUString += ::rtl::OUString::createFromAscii("'.");
201cdf0e10cSrcweir return aUString;
202cdf0e10cSrcweir }
203cdf0e10cSrcweir
204cdf0e10cSrcweir /** wait _nSec seconds.
205cdf0e10cSrcweir */
thread_sleep(sal_Int32 _nSec)206cdf0e10cSrcweir void thread_sleep( sal_Int32 _nSec )
207cdf0e10cSrcweir {
208cdf0e10cSrcweir /// print statement in thread process must use fflush() to force display.
20963d99982SDamjan Jovanovic printf("# wait %d seconds. ", _nSec );
210cdf0e10cSrcweir fflush(stdout);
211cdf0e10cSrcweir
212cdf0e10cSrcweir #ifdef WNT //Windows
213cdf0e10cSrcweir Sleep( _nSec * 100 );
214cdf0e10cSrcweir #endif
215cdf0e10cSrcweir #if ( defined UNX ) || ( defined OS2 ) //Unix
216cdf0e10cSrcweir usleep(_nSec * 100000);
217cdf0e10cSrcweir #endif
21863d99982SDamjan Jovanovic printf("# done\n" );
219cdf0e10cSrcweir }
220cdf0e10cSrcweir
221cdf0e10cSrcweir /** print Boolean value.
222cdf0e10cSrcweir */
printBool(sal_Bool bOk)223cdf0e10cSrcweir inline void printBool( sal_Bool bOk )
224cdf0e10cSrcweir {
22563d99982SDamjan Jovanovic printf("#printBool# " );
22663d99982SDamjan Jovanovic ( sal_True == bOk ) ? printf("YES!\n" ): printf("NO!\n" );
227cdf0e10cSrcweir }
228cdf0e10cSrcweir
229cdf0e10cSrcweir /** print content of a ByteSequence.
230cdf0e10cSrcweir */
printByteSequence_IP(const::rtl::ByteSequence & bsByteSeq,sal_Int32 nLen)231cdf0e10cSrcweir inline void printByteSequence_IP( const ::rtl::ByteSequence & bsByteSeq, sal_Int32 nLen )
232cdf0e10cSrcweir {
23363d99982SDamjan Jovanovic printf("#ByteSequence is: " );
234cdf0e10cSrcweir for ( int i = 0; i < nLen; i++ ){
235cdf0e10cSrcweir if ( bsByteSeq[i] < 0 )
23663d99982SDamjan Jovanovic printf("%d ", 256 + bsByteSeq[i] );
237cdf0e10cSrcweir else
23863d99982SDamjan Jovanovic printf("%d ", bsByteSeq[i] );
239cdf0e10cSrcweir }
24063d99982SDamjan Jovanovic printf(" .\n" );
241cdf0e10cSrcweir }
242cdf0e10cSrcweir
243cdf0e10cSrcweir /** convert an IP which is stored as a UString format to a ByteSequence array for later use.
244cdf0e10cSrcweir */
UStringIPToByteSequence(::rtl::OUString aUStr)245cdf0e10cSrcweir inline ::rtl::ByteSequence UStringIPToByteSequence( ::rtl::OUString aUStr )
246cdf0e10cSrcweir {
247cdf0e10cSrcweir
248cdf0e10cSrcweir rtl::OString aString = ::rtl::OUStringToOString( aUStr, RTL_TEXTENCODING_ASCII_US );
249cdf0e10cSrcweir const sal_Char *pChar = aString.getStr( ) ;
250cdf0e10cSrcweir sal_Char tmpBuffer[4];
251cdf0e10cSrcweir sal_Int32 nCharCounter = 0;
252cdf0e10cSrcweir ::rtl::ByteSequence bsByteSequence( IP_VER );
253cdf0e10cSrcweir sal_Int32 nByteSeqCounter = 0;
254cdf0e10cSrcweir
255cdf0e10cSrcweir for ( int i = 0; i < aString.getLength( ) + 1 ; i++ )
256cdf0e10cSrcweir {
257cdf0e10cSrcweir if ( ( *pChar != '.' ) && ( i !=aString.getLength( ) ) )
258cdf0e10cSrcweir tmpBuffer[nCharCounter++] = *pChar;
259cdf0e10cSrcweir else
260cdf0e10cSrcweir {
261cdf0e10cSrcweir tmpBuffer[nCharCounter] = '\0';
262cdf0e10cSrcweir nCharCounter = 0;
263cdf0e10cSrcweir bsByteSequence[nByteSeqCounter++] = static_cast<sal_Int8>( atoi( tmpBuffer ) );
264cdf0e10cSrcweir }
265cdf0e10cSrcweir pChar++;
266cdf0e10cSrcweir }
267cdf0e10cSrcweir return bsByteSequence;
268cdf0e10cSrcweir }
269cdf0e10cSrcweir
270cdf0e10cSrcweir /** print a socket result name.
271cdf0e10cSrcweir */
printSocketResult(oslSocketResult eResult)272cdf0e10cSrcweir inline void printSocketResult( oslSocketResult eResult )
273cdf0e10cSrcweir {
27463d99982SDamjan Jovanovic printf("#printSocketResult# " );
275cdf0e10cSrcweir if (!eResult)
276cdf0e10cSrcweir switch (eResult)
277cdf0e10cSrcweir {
278cdf0e10cSrcweir case osl_Socket_Ok:
27963d99982SDamjan Jovanovic printf("client connected\n");
280cdf0e10cSrcweir break;
281cdf0e10cSrcweir case osl_Socket_Error:
28263d99982SDamjan Jovanovic printf("got an error ... exiting\r\n\r\n" );
283cdf0e10cSrcweir break;
284cdf0e10cSrcweir case osl_Socket_TimedOut:
28563d99982SDamjan Jovanovic printf("timeout\n");
286cdf0e10cSrcweir break;
287cdf0e10cSrcweir
288cdf0e10cSrcweir case osl_Socket_FORCE_EQUAL_SIZE:
28963d99982SDamjan Jovanovic printf("FORCE EQUAL SIZE\n");
290cdf0e10cSrcweir break;
291cdf0e10cSrcweir case osl_Socket_InProgress:
29263d99982SDamjan Jovanovic printf("In Progress\n");
293cdf0e10cSrcweir break;
294cdf0e10cSrcweir case osl_Socket_Interrupted:
29563d99982SDamjan Jovanovic printf("Interrupted\n");
296cdf0e10cSrcweir break;
297cdf0e10cSrcweir }
298cdf0e10cSrcweir }
299cdf0e10cSrcweir
300cdf0e10cSrcweir /** Client Socket Thread, served as a temp little client to communicate with server.
301cdf0e10cSrcweir */
302cdf0e10cSrcweir class ClientSocketThread : public Thread
303cdf0e10cSrcweir {
304cdf0e10cSrcweir protected:
305cdf0e10cSrcweir oslThreadIdentifier m_id;
306cdf0e10cSrcweir ::osl::SocketAddr saTargetSocketAddr;
307cdf0e10cSrcweir ::osl::ConnectorSocket csConnectorSocket;
308cdf0e10cSrcweir
run()309cdf0e10cSrcweir void SAL_CALL run( )
310cdf0e10cSrcweir {
311cdf0e10cSrcweir TimeValue *pTimeout;
312cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
313cdf0e10cSrcweir pTimeout->Seconds = 5;
314cdf0e10cSrcweir pTimeout->Nanosec = 0;
315cdf0e10cSrcweir
316cdf0e10cSrcweir /// if the thread should terminate, schedule return false
317cdf0e10cSrcweir //while ( schedule( ) == sal_True )
318cdf0e10cSrcweir //{
319cdf0e10cSrcweir if ( osl_Socket_Ok == csConnectorSocket.connect( saTargetSocketAddr, pTimeout ))
320cdf0e10cSrcweir {
321cdf0e10cSrcweir csConnectorSocket.send( pTestString1, 11 ); // "test socket"
322cdf0e10cSrcweir csConnectorSocket.send( pTestString2, 10);
323cdf0e10cSrcweir }
324cdf0e10cSrcweir else
32563d99982SDamjan Jovanovic printf("# ClientSocketThread: connect failed! \n");
326cdf0e10cSrcweir // terminate();
327cdf0e10cSrcweir //}
328cdf0e10cSrcweir csConnectorSocket.close();
329cdf0e10cSrcweir free( pTimeout );
330cdf0e10cSrcweir }
331cdf0e10cSrcweir
onTerminated()332cdf0e10cSrcweir void SAL_CALL onTerminated( )
333cdf0e10cSrcweir {
33463d99982SDamjan Jovanovic //printf("# normally terminate this thread %d!\n", m_id );
335cdf0e10cSrcweir }
336cdf0e10cSrcweir
337cdf0e10cSrcweir public:
ClientSocketThread()338cdf0e10cSrcweir ClientSocketThread( ):
339cdf0e10cSrcweir saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT9 ),
340cdf0e10cSrcweir csConnectorSocket( )
341cdf0e10cSrcweir {
342cdf0e10cSrcweir m_id = getIdentifier( );
34363d99982SDamjan Jovanovic //printf("# successfully creat this client thread %d!\n", m_id );
344cdf0e10cSrcweir }
345cdf0e10cSrcweir
~ClientSocketThread()346cdf0e10cSrcweir ~ClientSocketThread( )
347cdf0e10cSrcweir {
348cdf0e10cSrcweir if ( isRunning( ) )
34963d99982SDamjan Jovanovic printf("# error: client thread not terminated.\n" );
350cdf0e10cSrcweir }
351cdf0e10cSrcweir
352cdf0e10cSrcweir };
353cdf0e10cSrcweir
354cdf0e10cSrcweir
355cdf0e10cSrcweir /** Server Socket Thread, served as a temp little server to communicate with client.
356cdf0e10cSrcweir */
357cdf0e10cSrcweir class ServerSocketThread : public Thread
358cdf0e10cSrcweir {
359cdf0e10cSrcweir protected:
360cdf0e10cSrcweir oslThreadIdentifier m_id;
361cdf0e10cSrcweir
run()362cdf0e10cSrcweir void SAL_CALL run( )
363cdf0e10cSrcweir {
364cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
365cdf0e10cSrcweir ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT9 );
366cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection;
367cdf0e10cSrcweir
368cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
369cdf0e10cSrcweir asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //integer not sal_Bool : sal_True);
370cdf0e10cSrcweir while ( schedule( ) == sal_True )
371cdf0e10cSrcweir {
372cdf0e10cSrcweir sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
373cdf0e10cSrcweir if ( sal_True != bOK1 )
374cdf0e10cSrcweir {
37563d99982SDamjan Jovanovic printf("# ServerSocketThread: AcceptorSocket bind address failed.\n" ) ;
376cdf0e10cSrcweir break;
377cdf0e10cSrcweir }
378cdf0e10cSrcweir sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
379cdf0e10cSrcweir if ( sal_True != bOK2 )
380cdf0e10cSrcweir {
38163d99982SDamjan Jovanovic printf("# ServerSocketThread: AcceptorSocket listen address failed.\n" ) ;
382cdf0e10cSrcweir break;
383cdf0e10cSrcweir }
384cdf0e10cSrcweir
385cdf0e10cSrcweir asAcceptorSocket.enableNonBlockingMode( sal_False );
386cdf0e10cSrcweir
387cdf0e10cSrcweir oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
388cdf0e10cSrcweir if (eResult != osl_Socket_Ok )
389cdf0e10cSrcweir {
39063d99982SDamjan Jovanovic printf("ServerSocketThread: acceptConnection failed! \n");
391cdf0e10cSrcweir break;
392cdf0e10cSrcweir }
393cdf0e10cSrcweir sal_Int32 nReadNumber1 = ssStreamConnection.recv( pReadBuffer, 11 );
394cdf0e10cSrcweir sal_Int32 nReadNumber2 = ssStreamConnection.recv( pReadBuffer + nReadNumber1, 11 );
395cdf0e10cSrcweir pReadBuffer[nReadNumber1 + nReadNumber2] = '\0';
39663d99982SDamjan Jovanovic //printf("# read buffer content: %s\n", pReadBuffer );
397cdf0e10cSrcweir break;
398cdf0e10cSrcweir }
399cdf0e10cSrcweir ssStreamConnection.close();
400cdf0e10cSrcweir asAcceptorSocket.close();
401cdf0e10cSrcweir
402cdf0e10cSrcweir }
403cdf0e10cSrcweir
onTerminated()404cdf0e10cSrcweir void SAL_CALL onTerminated( )
405cdf0e10cSrcweir {
40663d99982SDamjan Jovanovic //printf("# normally terminate this server thread %d!\n", m_id );
407cdf0e10cSrcweir }
408cdf0e10cSrcweir
409cdf0e10cSrcweir public:
410*1fb1d6b8SJohn Bampton // public to check if data transmission is OK
411cdf0e10cSrcweir sal_Char pReadBuffer[30];
ServerSocketThread()412cdf0e10cSrcweir ServerSocketThread( )
413cdf0e10cSrcweir {
414cdf0e10cSrcweir m_id = getIdentifier( );
415*1fb1d6b8SJohn Bampton //printf("# successfully create this server thread %d!\n", m_id );
416cdf0e10cSrcweir }
417cdf0e10cSrcweir
~ServerSocketThread()418cdf0e10cSrcweir ~ServerSocketThread( )
419cdf0e10cSrcweir {
420cdf0e10cSrcweir if ( isRunning( ) )
42163d99982SDamjan Jovanovic printf("# error: server thread not terminated.\n" );
422cdf0e10cSrcweir }
423cdf0e10cSrcweir };
424cdf0e10cSrcweir
425cdf0e10cSrcweir // -----------------------------------------------------------------------------
426cdf0e10cSrcweir // Helper functions, to create buffers, check buffers
427cdf0e10cSrcweir class ValueCheckProvider
428cdf0e10cSrcweir {
429cdf0e10cSrcweir bool m_bFoundFailure;
430cdf0e10cSrcweir char *m_pBuffer;
431cdf0e10cSrcweir sal_Int32 m_nBufferSize;
432cdf0e10cSrcweir
433cdf0e10cSrcweir public:
ValueCheckProvider()434cdf0e10cSrcweir ValueCheckProvider()
435cdf0e10cSrcweir :
436cdf0e10cSrcweir m_bFoundFailure(false),
437cdf0e10cSrcweir m_pBuffer(NULL),
438cdf0e10cSrcweir m_nBufferSize(0)
439cdf0e10cSrcweir {
440cdf0e10cSrcweir }
441cdf0e10cSrcweir
isFailure()442cdf0e10cSrcweir bool isFailure() {return m_bFoundFailure;}
443cdf0e10cSrcweir
getBuffer()444cdf0e10cSrcweir const char* getBuffer() {return m_pBuffer;}
getWriteBuffer()445cdf0e10cSrcweir char* getWriteBuffer() {return m_pBuffer;}
446cdf0e10cSrcweir
getBufferSize()447cdf0e10cSrcweir sal_Int32 getBufferSize() {return m_nBufferSize;}
448cdf0e10cSrcweir
checkValues(sal_Int32 _nLength,int _nValue)449cdf0e10cSrcweir bool checkValues(sal_Int32 _nLength, int _nValue)
450cdf0e10cSrcweir {
451cdf0e10cSrcweir m_bFoundFailure = false;
452cdf0e10cSrcweir for(sal_Int32 i=0;i<_nLength;i++)
453cdf0e10cSrcweir {
454cdf0e10cSrcweir if (m_pBuffer[i] != _nValue)
455cdf0e10cSrcweir {
456cdf0e10cSrcweir m_bFoundFailure = true;
457cdf0e10cSrcweir }
458cdf0e10cSrcweir }
459cdf0e10cSrcweir return m_bFoundFailure;
460cdf0e10cSrcweir }
461cdf0e10cSrcweir
createBuffer(sal_Int32 _nLength,int _nValue)462cdf0e10cSrcweir void createBuffer(sal_Int32 _nLength, int _nValue)
463cdf0e10cSrcweir {
464cdf0e10cSrcweir m_nBufferSize = _nLength;
465cdf0e10cSrcweir m_pBuffer = (char*) malloc(m_nBufferSize);
466cdf0e10cSrcweir if (m_pBuffer)
467cdf0e10cSrcweir {
468cdf0e10cSrcweir memset(m_pBuffer, _nValue, m_nBufferSize);
469cdf0e10cSrcweir }
470cdf0e10cSrcweir }
471cdf0e10cSrcweir
freeBuffer()472cdf0e10cSrcweir void freeBuffer()
473cdf0e10cSrcweir {
474cdf0e10cSrcweir if (m_pBuffer) free(m_pBuffer);
475cdf0e10cSrcweir }
476cdf0e10cSrcweir
477cdf0e10cSrcweir };
478cdf0e10cSrcweir
479cdf0e10cSrcweir // -----------------------------------------------------------------------------
480cdf0e10cSrcweir /** Client Socket Thread, served as a temp little client to communicate with server.
481cdf0e10cSrcweir */
482cdf0e10cSrcweir
483cdf0e10cSrcweir class ReadSocketThread : public Thread
484cdf0e10cSrcweir {
485cdf0e10cSrcweir int m_nValue;
486cdf0e10cSrcweir ValueCheckProvider m_aValues;
487cdf0e10cSrcweir
488cdf0e10cSrcweir protected:
489cdf0e10cSrcweir oslThreadIdentifier m_id;
490cdf0e10cSrcweir ::osl::SocketAddr saTargetSocketAddr;
491cdf0e10cSrcweir ::osl::ConnectorSocket csConnectorSocket;
492cdf0e10cSrcweir
run()493cdf0e10cSrcweir void SAL_CALL run( )
494cdf0e10cSrcweir {
495cdf0e10cSrcweir TimeValue *pTimeout;
496cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
497cdf0e10cSrcweir pTimeout->Seconds = 5;
498cdf0e10cSrcweir pTimeout->Nanosec = 0;
499cdf0e10cSrcweir
500cdf0e10cSrcweir /// if the thread should terminate, schedule return false
501cdf0e10cSrcweir //while ( schedule( ) == sal_True )
502cdf0e10cSrcweir //{
503cdf0e10cSrcweir if ( osl_Socket_Ok == csConnectorSocket.connect( saTargetSocketAddr, pTimeout ))
504cdf0e10cSrcweir {
505cdf0e10cSrcweir sal_Int32 nReadCount = csConnectorSocket.read( m_aValues.getWriteBuffer(), m_aValues.getBufferSize() );
506cdf0e10cSrcweir m_aValues.checkValues(nReadCount, m_nValue);
507cdf0e10cSrcweir }
508cdf0e10cSrcweir else
509cdf0e10cSrcweir {
51063d99982SDamjan Jovanovic printf("# ReadSocketThread: connect failed! \n");
511cdf0e10cSrcweir }
512cdf0e10cSrcweir // terminate();
513cdf0e10cSrcweir //}
514cdf0e10cSrcweir //remove this line for deadlock on solaris( margritte.germany )
515cdf0e10cSrcweir csConnectorSocket.close();
516cdf0e10cSrcweir free( pTimeout );
517cdf0e10cSrcweir }
518cdf0e10cSrcweir
onTerminated()519cdf0e10cSrcweir void SAL_CALL onTerminated( )
520cdf0e10cSrcweir {
52163d99982SDamjan Jovanovic //printf("# normally terminate this thread %d!\n", m_id );
522cdf0e10cSrcweir }
523cdf0e10cSrcweir
524cdf0e10cSrcweir public:
getCount()525cdf0e10cSrcweir sal_Int32 getCount() {return m_aValues.getBufferSize();}
isOk()526cdf0e10cSrcweir bool isOk() {return m_aValues.isFailure() == true ? false : true;}
527cdf0e10cSrcweir
ReadSocketThread(sal_Int32 _nBufferSize,int _nValue)528cdf0e10cSrcweir ReadSocketThread(sal_Int32 _nBufferSize, int _nValue )
529cdf0e10cSrcweir :
530cdf0e10cSrcweir m_nValue( _nValue ),
531cdf0e10cSrcweir saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT10 ),
532cdf0e10cSrcweir csConnectorSocket( )
533cdf0e10cSrcweir {
534cdf0e10cSrcweir m_id = getIdentifier( );
53563d99982SDamjan Jovanovic //printf("# successfully creat this client thread %d!\n", m_id );
536cdf0e10cSrcweir m_aValues.createBuffer(_nBufferSize, 0);
537cdf0e10cSrcweir }
538cdf0e10cSrcweir
~ReadSocketThread()539cdf0e10cSrcweir ~ReadSocketThread( )
540cdf0e10cSrcweir {
541cdf0e10cSrcweir if ( isRunning( ) )
54263d99982SDamjan Jovanovic printf("# error: client thread not terminated.\n" );
543cdf0e10cSrcweir m_aValues.freeBuffer();
544cdf0e10cSrcweir }
545cdf0e10cSrcweir
546cdf0e10cSrcweir };
547cdf0e10cSrcweir
548cdf0e10cSrcweir /** Server Socket Thread, write a file which is large
549cdf0e10cSrcweir */
550cdf0e10cSrcweir class WriteSocketThread : public Thread
551cdf0e10cSrcweir {
552cdf0e10cSrcweir ValueCheckProvider m_aValues;
553cdf0e10cSrcweir
554cdf0e10cSrcweir protected:
555cdf0e10cSrcweir oslThreadIdentifier m_id;
556cdf0e10cSrcweir
run()557cdf0e10cSrcweir void SAL_CALL run( )
558cdf0e10cSrcweir {
559cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
560cdf0e10cSrcweir ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT10 );
561cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection;
562cdf0e10cSrcweir
563cdf0e10cSrcweir //if has not set this option, socket addr can not be binded in some time(maybe 2 minutes) by another socket
564cdf0e10cSrcweir asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
565cdf0e10cSrcweir
566cdf0e10cSrcweir /// if the thread should terminate, schedule return false
567cdf0e10cSrcweir while ( schedule( ) == sal_True )
568cdf0e10cSrcweir {
569cdf0e10cSrcweir sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
570cdf0e10cSrcweir if ( sal_True != bOK1 )
571cdf0e10cSrcweir {
57263d99982SDamjan Jovanovic printf("# WriteSocketThread: AcceptorSocket bind address failed. \n" ) ;
573cdf0e10cSrcweir break;
574cdf0e10cSrcweir }
575cdf0e10cSrcweir sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
576cdf0e10cSrcweir if ( sal_True != bOK2 )
577cdf0e10cSrcweir {
57863d99982SDamjan Jovanovic printf("# WriteSocketThread: AcceptorSocket listen address failed. \n" ) ;
579cdf0e10cSrcweir break;
580cdf0e10cSrcweir }
581cdf0e10cSrcweir // blocking mode, if read/recv failed, block until success
582cdf0e10cSrcweir asAcceptorSocket.enableNonBlockingMode( sal_False);
583cdf0e10cSrcweir
584cdf0e10cSrcweir oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
585cdf0e10cSrcweir if (eResult != osl_Socket_Ok )
586cdf0e10cSrcweir {
58763d99982SDamjan Jovanovic printf("WriteSocketThread: acceptConnection failed! \n");
588cdf0e10cSrcweir break;
589cdf0e10cSrcweir }
590cdf0e10cSrcweir
591cdf0e10cSrcweir ssStreamConnection.write( m_aValues.getBuffer(), m_aValues.getBufferSize() );
592cdf0e10cSrcweir break;
593cdf0e10cSrcweir }
594cdf0e10cSrcweir ssStreamConnection.close();
595cdf0e10cSrcweir asAcceptorSocket.close();
596cdf0e10cSrcweir }
597cdf0e10cSrcweir
onTerminated()598cdf0e10cSrcweir void SAL_CALL onTerminated( )
599cdf0e10cSrcweir {
60063d99982SDamjan Jovanovic //printf("# normally terminate this server thread %d!\n", m_id );
601cdf0e10cSrcweir }
602cdf0e10cSrcweir
603cdf0e10cSrcweir public:
604*1fb1d6b8SJohn Bampton // public to check if data transmission is OK
WriteSocketThread(sal_Int32 _nBufferSize,int _nValue)605cdf0e10cSrcweir WriteSocketThread(sal_Int32 _nBufferSize, int _nValue )
606cdf0e10cSrcweir {
607cdf0e10cSrcweir m_id = getIdentifier( );
608*1fb1d6b8SJohn Bampton //printf("# successfully create this server thread %d!\n", m_id );
609cdf0e10cSrcweir
610cdf0e10cSrcweir m_aValues.createBuffer(_nBufferSize, _nValue);
611cdf0e10cSrcweir }
612cdf0e10cSrcweir
~WriteSocketThread()613cdf0e10cSrcweir ~WriteSocketThread( )
614cdf0e10cSrcweir {
615cdf0e10cSrcweir if ( isRunning( ) )
61663d99982SDamjan Jovanovic printf("# error: server thread not terminated.\n" );
617cdf0e10cSrcweir m_aValues.freeBuffer();
618cdf0e10cSrcweir }
619cdf0e10cSrcweir
620cdf0e10cSrcweir };
621cdf0e10cSrcweir
622cdf0e10cSrcweir // -----------------------------------------------------------------------------
623cdf0e10cSrcweir // just used to test socket::close() when accepting
624cdf0e10cSrcweir class AcceptorThread : public Thread
625cdf0e10cSrcweir {
626cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
627cdf0e10cSrcweir ::rtl::OUString aHostIP;
628cdf0e10cSrcweir sal_Bool bOK;
629cdf0e10cSrcweir protected:
run()630cdf0e10cSrcweir void SAL_CALL run( )
631cdf0e10cSrcweir {
632cdf0e10cSrcweir ::osl::SocketAddr saLocalSocketAddr( aHostIP, IP_PORT_MYPORT9 );
633cdf0e10cSrcweir ::osl::StreamSocket ssStreamConnection;
634cdf0e10cSrcweir
635cdf0e10cSrcweir asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //integer not sal_Bool : sal_True);
636cdf0e10cSrcweir sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
637cdf0e10cSrcweir if ( sal_True != bOK1 )
638cdf0e10cSrcweir {
63963d99982SDamjan Jovanovic printf("# AcceptorSocket bind address failed.\n" ) ;
640cdf0e10cSrcweir return;
641cdf0e10cSrcweir }
642cdf0e10cSrcweir sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
643cdf0e10cSrcweir if ( sal_True != bOK2 )
644cdf0e10cSrcweir {
64563d99982SDamjan Jovanovic printf("# AcceptorSocket listen address failed.\n" ) ;
646cdf0e10cSrcweir return;
647cdf0e10cSrcweir }
648cdf0e10cSrcweir
649cdf0e10cSrcweir asAcceptorSocket.enableNonBlockingMode( sal_False );
650cdf0e10cSrcweir
651cdf0e10cSrcweir oslSocketResult eResult = asAcceptorSocket.acceptConnection( ssStreamConnection );
652cdf0e10cSrcweir if (eResult != osl_Socket_Ok )
653cdf0e10cSrcweir {
654cdf0e10cSrcweir bOK = sal_True;
65563d99982SDamjan Jovanovic printf("AcceptorThread: acceptConnection failed! \n");
656cdf0e10cSrcweir }
657cdf0e10cSrcweir }
658cdf0e10cSrcweir public:
AcceptorThread(::osl::AcceptorSocket & asSocket,::rtl::OUString & aBindIP)659cdf0e10cSrcweir AcceptorThread(::osl::AcceptorSocket & asSocket, ::rtl::OUString & aBindIP )
660cdf0e10cSrcweir : asAcceptorSocket( asSocket ), aHostIP( aBindIP )
661cdf0e10cSrcweir {
662cdf0e10cSrcweir bOK = sal_False;
663cdf0e10cSrcweir }
664cdf0e10cSrcweir
isOK()665cdf0e10cSrcweir sal_Bool isOK() { return bOK; }
666cdf0e10cSrcweir
~AcceptorThread()667cdf0e10cSrcweir ~AcceptorThread( )
668cdf0e10cSrcweir {
669cdf0e10cSrcweir if ( isRunning( ) )
670cdf0e10cSrcweir {
671cdf0e10cSrcweir asAcceptorSocket.shutdown();
67263d99982SDamjan Jovanovic printf("# error: Acceptor thread not terminated.\n" );
673cdf0e10cSrcweir }
674cdf0e10cSrcweir }
675cdf0e10cSrcweir };
676cdf0e10cSrcweir
677cdf0e10cSrcweir class CloseSocketThread : public Thread
678cdf0e10cSrcweir {
679cdf0e10cSrcweir ::osl::Socket m_sSocket;
680cdf0e10cSrcweir protected:
run()681cdf0e10cSrcweir void SAL_CALL run( )
682cdf0e10cSrcweir {
683cdf0e10cSrcweir thread_sleep( 1 );
684cdf0e10cSrcweir m_sSocket.close( );
685cdf0e10cSrcweir }
686cdf0e10cSrcweir public:
CloseSocketThread(::osl::Socket & sSocket)687cdf0e10cSrcweir CloseSocketThread(::osl::Socket & sSocket )
688cdf0e10cSrcweir : m_sSocket( sSocket )
689cdf0e10cSrcweir {
690cdf0e10cSrcweir }
691cdf0e10cSrcweir
~CloseSocketThread()692cdf0e10cSrcweir ~CloseSocketThread( )
693cdf0e10cSrcweir {
694cdf0e10cSrcweir if ( isRunning( ) )
695cdf0e10cSrcweir {
69663d99982SDamjan Jovanovic printf("# error: CloseSocketThread not terminated.\n" );
697cdf0e10cSrcweir }
698cdf0e10cSrcweir }
699cdf0e10cSrcweir };
700cdf0e10cSrcweir
701cdf0e10cSrcweir //------------------------------------------------------------------------
702cdf0e10cSrcweir // tests cases begins here
703cdf0e10cSrcweir //------------------------------------------------------------------------
704cdf0e10cSrcweir
705cdf0e10cSrcweir namespace osl_SocketAddr
706cdf0e10cSrcweir {
707cdf0e10cSrcweir
708cdf0e10cSrcweir /** testing the methods:
709cdf0e10cSrcweir inline SocketAddr();
710cdf0e10cSrcweir inline SocketAddr(const SocketAddr& Addr);
711cdf0e10cSrcweir inline SocketAddr(const oslSocketAddr , __osl_socket_NoCopy nocopy );
712cdf0e10cSrcweir inline SocketAddr(oslSocketAddr Addr);
713cdf0e10cSrcweir inline SocketAddr( const ::rtl::OUString& strAddrOrHostName, sal_Int32 nPort );
714cdf0e10cSrcweir */
715cdf0e10cSrcweir
71663d99982SDamjan Jovanovic class SocketAddrCtors : public ::testing::Test
717cdf0e10cSrcweir {
718cdf0e10cSrcweir public:
71963d99982SDamjan Jovanovic }; // class ctors
720cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_none)72163d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_none)
72263d99982SDamjan Jovanovic {
72363d99982SDamjan Jovanovic /// SocketAddr constructor.
72463d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr;
725cdf0e10cSrcweir
72663d99982SDamjan Jovanovic // oslSocketResult aResult;
72763d99982SDamjan Jovanovic // rtl::OUString suHost = saSocketAddr.getLocalHostname( &aResult);
728cdf0e10cSrcweir
72963d99982SDamjan Jovanovic // rtl::OUString suHost2 = getThisHostname();
730cdf0e10cSrcweir
73163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == saSocketAddr.is( )) << "test for none parameter constructor function: check if the socket address was created successfully";
73263d99982SDamjan Jovanovic }
733cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_none_000)73463d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_none_000)
73563d99982SDamjan Jovanovic {
73663d99982SDamjan Jovanovic /// SocketAddr constructor.
73763d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr;
738cdf0e10cSrcweir
73963d99982SDamjan Jovanovic oslSocketResult aResult;
74063d99982SDamjan Jovanovic rtl::OUString suHost = saSocketAddr.getLocalHostname( &aResult);
74163d99982SDamjan Jovanovic rtl::OUString suHost2 = getThisHostname();
742cdf0e10cSrcweir
74363d99982SDamjan Jovanovic sal_Bool bOk = compareUString(suHost, suHost2);
744cdf0e10cSrcweir
74563d99982SDamjan Jovanovic rtl::OUString suError = rtl::OUString::createFromAscii("Host names should be the same. From SocketAddr.getLocalHostname() it is'");
74663d99982SDamjan Jovanovic suError += suHost;
74763d99982SDamjan Jovanovic suError += rtl::OUString::createFromAscii("', from getThisHostname() it is '");
74863d99982SDamjan Jovanovic suError += suHost2;
74963d99982SDamjan Jovanovic suError += rtl::OUString::createFromAscii("'.");
750cdf0e10cSrcweir
75163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOk) << suError.pData;
75263d99982SDamjan Jovanovic }
753cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_copy)75463d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_copy)
75563d99982SDamjan Jovanovic {
75663d99982SDamjan Jovanovic /// SocketAddr copy constructor.
75763d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostName1, IP_PORT_HTTP1 );
75863d99982SDamjan Jovanovic ::osl::SocketAddr saCopySocketAddr( saSocketAddr );
759cdf0e10cSrcweir
76063d99982SDamjan Jovanovic sal_Int32 nPort = saCopySocketAddr.getPort( );
761cdf0e10cSrcweir
76263d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == saCopySocketAddr.is( ) ) && ( nPort == IP_PORT_HTTP1 )) << "test for SocketAddr copy constructor function: copy constructor, do an action of copy construction then check the port with original set.";
76363d99982SDamjan Jovanovic }
764cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_copy_no_001)76563d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_copy_no_001)
76663d99982SDamjan Jovanovic {
767cdf0e10cSrcweir #if 0
76863d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostName1, IP_PORT_HTTP1 );
76963d99982SDamjan Jovanovic oslSocketAddr psaOSLSocketAddr = saSocketAddr.getHandle( );
770cdf0e10cSrcweir
77163d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrCopy( psaOSLSocketAddr, SAL_NO_COPY );
77263d99982SDamjan Jovanovic saSocketAddrCopy.setPort( IP_PORT_HTTP2 );
773cdf0e10cSrcweir
77463d99982SDamjan Jovanovic ASSERT_TRUE(saSocketAddr.getPort( ) == IP_PORT_HTTP2) << "test for SocketAddr no copy constructor function: do a no copy constructor on a given SocketAddr instance, modify the new instance's port, check the original one.";
775cdf0e10cSrcweir #endif
77663d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddr = new ::osl::SocketAddr( aHostName1, IP_PORT_HTTP1 );
77763d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddr != NULL) << "check for new SocketAddr";
778cdf0e10cSrcweir
77963d99982SDamjan Jovanovic oslSocketAddr psaOSLSocketAddr = pSocketAddr->getHandle( );
780cdf0e10cSrcweir
78163d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddrCopy = new ::osl::SocketAddr( psaOSLSocketAddr, SAL_NO_COPY );
782cdf0e10cSrcweir
78363d99982SDamjan Jovanovic pSocketAddrCopy->setPort( IP_PORT_HTTP2 );
78463d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddr->getPort( ) == IP_PORT_HTTP2) << "test for SocketAddr no copy constructor function: do a no copy constructor on a given SocketAddr instance, modify the new instance's port, check the original one.";
785cdf0e10cSrcweir
78663d99982SDamjan Jovanovic delete pSocketAddrCopy;
78763d99982SDamjan Jovanovic // LLA: don't do this also: delete pSocketAddr;
78863d99982SDamjan Jovanovic }
789cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_copy_no_002)79063d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_copy_no_002)
79163d99982SDamjan Jovanovic {
79263d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddr = new ::osl::SocketAddr( aHostName1, IP_PORT_HTTP1 );
79363d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddr != NULL) << "check for new SocketAddr";
79463d99982SDamjan Jovanovic oslSocketAddr psaOSLSocketAddr = pSocketAddr->getHandle( );
79563d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddrCopy = new ::osl::SocketAddr( psaOSLSocketAddr, SAL_NO_COPY );
796cdf0e10cSrcweir
79763d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddr->getHandle( ) == pSocketAddrCopy->getHandle( )) << "test for SocketAddr no copy constructor function: do a no copy constructor on a given SocketAddr instance, modify the new instance's port, check the original one.";
798cdf0e10cSrcweir
79963d99982SDamjan Jovanovic delete pSocketAddrCopy;
80063d99982SDamjan Jovanovic }
801cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_copy_handle_001)80263d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_copy_handle_001)
80363d99982SDamjan Jovanovic {
80463d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostName1, IP_PORT_HTTP1 );
80563d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrCopy( saSocketAddr.getHandle( ) );
806cdf0e10cSrcweir
80763d99982SDamjan Jovanovic ASSERT_TRUE(saSocketAddrCopy.getPort( ) == IP_PORT_HTTP1) << "test for SocketAddr copy handle constructor function: copy another Socket's handle, get its port to check copy effect.";
80863d99982SDamjan Jovanovic }
809cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_copy_handle_002)81063d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_copy_handle_002)
81163d99982SDamjan Jovanovic {
81263d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostName1, IP_PORT_HTTP1 );
81363d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrCopy( saSocketAddr.getHandle( ) );
81463d99982SDamjan Jovanovic saSocketAddrCopy.setPort( IP_PORT_HTTP2 );
815cdf0e10cSrcweir
81663d99982SDamjan Jovanovic ASSERT_TRUE(saSocketAddr.getPort( ) != IP_PORT_HTTP2) << "test for SocketAddr copy handle constructor function: copy another Socket's handle, the original one should not be changed.";
81763d99982SDamjan Jovanovic }
818cdf0e10cSrcweir
TEST_F(SocketAddrCtors,ctors_hostname_port_001)81963d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_hostname_port_001)
82063d99982SDamjan Jovanovic {
82163d99982SDamjan Jovanovic /// tcpip-specif constructor.
82263d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_FTP );
82363d99982SDamjan Jovanovic printUString(saSocketAddr.getHostname( ), "ctors_hostname_port_001:getHostname");
824cdf0e10cSrcweir
82563d99982SDamjan Jovanovic ASSERT_TRUE(saSocketAddr.is( ) == sal_True &&
82663d99982SDamjan Jovanovic ( saSocketAddr.getPort( ) == IP_PORT_FTP )/*&&
82730acf5e8Spfg ( sal_True == compareUString( saSocketAddr.getHostname( ), aHostName1 ) ) */) << "test for SocketAddr tcpip specific constructor function: do a constructor using tcpip spec, check the result.";
82863d99982SDamjan Jovanovic }
829cdf0e10cSrcweir
83063d99982SDamjan Jovanovic //same as is_002
TEST_F(SocketAddrCtors,ctors_hostname_port_002)83163d99982SDamjan Jovanovic TEST_F(SocketAddrCtors, ctors_hostname_port_002)
83263d99982SDamjan Jovanovic {
83363d99982SDamjan Jovanovic /// tcpip-specif constructor.
83463d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIpInval1, IP_PORT_MYPORT2 );
835cdf0e10cSrcweir
83630acf5e8Spfg ASSERT_TRUE(sal_False == saSocketAddr.is( )) << "test for SocketAddr tcpip specific constructor function: using an invalid IP address, the socketaddr ctors should fail";
83763d99982SDamjan Jovanovic }
838cdf0e10cSrcweir
839cdf0e10cSrcweir /** testing the method:
840cdf0e10cSrcweir inline sal_Bool is() const;
841cdf0e10cSrcweir */
842cdf0e10cSrcweir
84363d99982SDamjan Jovanovic class is : public ::testing::Test
844cdf0e10cSrcweir {
845cdf0e10cSrcweir public:
84663d99982SDamjan Jovanovic }; // class is
847cdf0e10cSrcweir
TEST_F(is,is_001)84863d99982SDamjan Jovanovic TEST_F(is, is_001)
84963d99982SDamjan Jovanovic {
85063d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr;
851cdf0e10cSrcweir
85263d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == saSocketAddr.is( )) << "test for is() function: create an unknown type socket, it should be True when call is.";
85363d99982SDamjan Jovanovic }
85463d99982SDamjan Jovanovic // refer to setPort_003()
TEST_F(is,is_002)85563d99982SDamjan Jovanovic TEST_F(is, is_002)
85663d99982SDamjan Jovanovic {
85763d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_INVAL );
858cdf0e10cSrcweir
85963d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == saSocketAddr.is( )) << "test for is() function: create a tcp-ip socket using invalid port number";
86063d99982SDamjan Jovanovic }
861cdf0e10cSrcweir
TEST_F(is,is_003)86263d99982SDamjan Jovanovic TEST_F(is, is_003)
86363d99982SDamjan Jovanovic {
86463d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIpInval1, IP_PORT_MYPORT );
865cdf0e10cSrcweir
86663d99982SDamjan Jovanovic ASSERT_TRUE(sal_True != saSocketAddr.is( )) << "test for is() function: create a tcp-ip socket using invalid Ip number";
86763d99982SDamjan Jovanovic }
868cdf0e10cSrcweir
869cdf0e10cSrcweir /** testing the method:
870cdf0e10cSrcweir inline ::rtl::OUString SAL_CALL getHostname( oslSocketResult *pResult = 0 ) const;
871cdf0e10cSrcweir */
872cdf0e10cSrcweir
87363d99982SDamjan Jovanovic class getHostname : public ::testing::Test
874cdf0e10cSrcweir {
875cdf0e10cSrcweir public:
SetUp()87663d99982SDamjan Jovanovic void SetUp()
877cdf0e10cSrcweir {
878cdf0e10cSrcweir }
879cdf0e10cSrcweir
TearDown()88063d99982SDamjan Jovanovic void TearDown()
881cdf0e10cSrcweir {
882cdf0e10cSrcweir }
88363d99982SDamjan Jovanovic }; // class getHostname
884cdf0e10cSrcweir
TEST_F(getHostname,getHostname_000)88563d99982SDamjan Jovanovic TEST_F(getHostname, getHostname_000)
88663d99982SDamjan Jovanovic {
88763d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp4, IP_PORT_FTP );
888cdf0e10cSrcweir
88963d99982SDamjan Jovanovic }
890cdf0e10cSrcweir
89163d99982SDamjan Jovanovic /** it will search the Ip in current machine's /etc/hosts at first, if find, then return the
89263d99982SDamjan Jovanovic mapped hostname, otherwise, it will search via DNS server, and often return hostname+ Domain name
89363d99982SDamjan Jovanovic like "sceri.PRC.Sun.COM"
89463d99982SDamjan Jovanovic The process is same as Socket::getLocalHost(), but getLocalHost can only return hostname of the current machine.
89563d99982SDamjan Jovanovic */
TEST_F(getHostname,getHostname_001)89663d99982SDamjan Jovanovic TEST_F(getHostname, getHostname_001)
89763d99982SDamjan Jovanovic {
89863d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp4, IP_PORT_FTP );
89963d99982SDamjan Jovanovic rtl::OUString suResult = saSocketAddr.getHostname( 0 );
90063d99982SDamjan Jovanovic rtl::OUString suError = outputError(suResult, aHostName4, "test for getHostname(0)");
90163d99982SDamjan Jovanovic sal_Bool bOK = compareUString( suResult, aHostName4 );
90263d99982SDamjan Jovanovic // search the returned hostname in /etc/hosts, if find, and the IP in the row is same as IP
90363d99982SDamjan Jovanovic // in the Addr, it's right also.
90463d99982SDamjan Jovanovic if ( bOK == sal_False)
90563d99982SDamjan Jovanovic {
90663d99982SDamjan Jovanovic if ( compareUString( getIPbyName( oustring2char( suResult ) ), aHostIp4 ) == sal_True )
90763d99982SDamjan Jovanovic bOK = sal_True;
90863d99982SDamjan Jovanovic }
90963d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << suError.pData;
91063d99982SDamjan Jovanovic }
911cdf0e10cSrcweir
91263d99982SDamjan Jovanovic // LLA: now we have to control, if this behaviour is right.
91363d99982SDamjan Jovanovic // LLA: this function does not work in company (Linux, Windows) but at home
TEST_F(getHostname,getHostname_002)91463d99982SDamjan Jovanovic TEST_F(getHostname, getHostname_002)
91563d99982SDamjan Jovanovic {
91663d99982SDamjan Jovanovic rtl::OUString suHostname = rtl::OUString::createFromAscii("cn-1.germany.sun.com");
91763d99982SDamjan Jovanovic rtl::OUString aHostIP = getIPbyName( oustring2char( suHostname ) );
91863d99982SDamjan Jovanovic
91963d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostName1, IP_PORT_FTP );
92063d99982SDamjan Jovanovic sal_Bool bOK = saSocketAddr.setHostname( suHostname );
92163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "#SocketAddr.setHostname failed";
92263d99982SDamjan Jovanovic oslSocketResult aResult;
92363d99982SDamjan Jovanovic rtl::OUString suResult = saSocketAddr.getHostname( &aResult );
92463d99982SDamjan Jovanovic ASSERT_TRUE(aResult == osl_Socket_Ok) << "SocketAddr.getHostname failed.";
92563d99982SDamjan Jovanovic
92663d99982SDamjan Jovanovic rtl::OUString suError = outputError(suResult, suHostname, "test for getHostname(0)");
92763d99982SDamjan Jovanovic bOK = compareUString( suResult, suHostname );
92863d99982SDamjan Jovanovic if ( bOK == sal_False)
92963d99982SDamjan Jovanovic {
93063d99982SDamjan Jovanovic rtl::OString aString = ::rtl::OUStringToOString( suResult, RTL_TEXTENCODING_ASCII_US );
93163d99982SDamjan Jovanovic if ( compareUString( getIPbyName( aString) , aHostIp6 ) == sal_True )
93263d99982SDamjan Jovanovic {
93363d99982SDamjan Jovanovic bOK = sal_True;
934cdf0e10cSrcweir }
93563d99982SDamjan Jovanovic }
936cdf0e10cSrcweir
93763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << suError.pData;
93863d99982SDamjan Jovanovic }
939cdf0e10cSrcweir
940cdf0e10cSrcweir /** testing the method:
941cdf0e10cSrcweir inline sal_Int32 SAL_CALL getPort() const;
942cdf0e10cSrcweir */
943cdf0e10cSrcweir
94463d99982SDamjan Jovanovic class getPort : public ::testing::Test
945cdf0e10cSrcweir {
946cdf0e10cSrcweir public:
94763d99982SDamjan Jovanovic }; // class getPort
948cdf0e10cSrcweir
TEST_F(getPort,getPort_001)94963d99982SDamjan Jovanovic TEST_F(getPort, getPort_001)
95063d99982SDamjan Jovanovic {
95163d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_FTP );
952cdf0e10cSrcweir
95363d99982SDamjan Jovanovic ASSERT_TRUE(IP_PORT_FTP == saSocketAddr.getPort( )) << "test for getPort() function: get a normal port number.";
95463d99982SDamjan Jovanovic }
955cdf0e10cSrcweir
TEST_F(getPort,getPort_002)95663d99982SDamjan Jovanovic TEST_F(getPort, getPort_002)
95763d99982SDamjan Jovanovic {
95863d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp2, IP_PORT_INVAL );
959cdf0e10cSrcweir
96063d99982SDamjan Jovanovic //printf("#getPort_002: Port number is %d \n", saSocketAddr.getPort( ));
961cdf0e10cSrcweir
96263d99982SDamjan Jovanovic ASSERT_TRUE(saSocketAddr.getPort( )>=1 && saSocketAddr.getPort( ) <= 65535) << "test for getPort( ) function: give an invalid port to a SocketAddr, get the port to see if it can detect. it did not pass in (W32).";
96363d99982SDamjan Jovanovic }
96463d99982SDamjan Jovanovic //two cases will return OSL_INVALID_PORT: 1. not valid SocketAddr
96563d99982SDamjan Jovanovic //2. SocketAddr family is not osl_Socket_FamilyInet, but case 2 could not be constructed
TEST_F(getPort,getPort_003)96663d99982SDamjan Jovanovic TEST_F(getPort, getPort_003)
96763d99982SDamjan Jovanovic {
96863d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIpInval1, IP_PORT_MYPORT );
969cdf0e10cSrcweir
97063d99982SDamjan Jovanovic ASSERT_TRUE(saSocketAddr.getPort( ) == OSL_INVALID_PORT) << "test for getPort( ) function: give an invalid IP to a SocketAddr, get the port to see returned value. ";
97163d99982SDamjan Jovanovic }
972cdf0e10cSrcweir
973cdf0e10cSrcweir /** testing the method:
974cdf0e10cSrcweir inline sal_Bool SAL_CALL setPort( sal_Int32 nPort );
975cdf0e10cSrcweir rfc1413.txt: TCP port numbers are from 1-65535
976cdf0e10cSrcweir rfc1700.txt: 0/tcp Reserved ; 0/udp Reserved
977cdf0e10cSrcweir */
978cdf0e10cSrcweir
97963d99982SDamjan Jovanovic class setPort : public ::testing::Test
980cdf0e10cSrcweir {
981cdf0e10cSrcweir public:
98263d99982SDamjan Jovanovic }; // class setPort
983cdf0e10cSrcweir
TEST_F(setPort,setPort_001)98463d99982SDamjan Jovanovic TEST_F(setPort, setPort_001)
98563d99982SDamjan Jovanovic {
98663d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_FTP );
98763d99982SDamjan Jovanovic sal_Bool bOK = saSocketAddr.setPort( IP_PORT_TELNET );
988cdf0e10cSrcweir
98963d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == bOK ) &&
99063d99982SDamjan Jovanovic ( IP_PORT_TELNET == saSocketAddr.getPort( ) )) << "test for setPort() function: modify a port number setting, and check it.";
99163d99982SDamjan Jovanovic }
992cdf0e10cSrcweir
99363d99982SDamjan Jovanovic /** 0 to 1024 is known as the reserved port range (traditionally only root can assign programs to ports in
99463d99982SDamjan Jovanovic this range) and the ephemeral port range from 1025 to 65535.
99563d99982SDamjan Jovanovic As many of you programmers will know, when you specify the source port of 0 when you connect to a host,
99663d99982SDamjan Jovanovic the OS automatically reassigns the port number to high numbered ephemeral port. The same happens if you
99763d99982SDamjan Jovanovic try to bind a listening socket to port 0.
99863d99982SDamjan Jovanovic http://www.securiteam.com/securityreviews/5XP0Q2AAKS.html
99963d99982SDamjan Jovanovic another: http://www.muq.org/~cynbe/muq/mufref_564.html
100063d99982SDamjan Jovanovic */
TEST_F(setPort,setPort_002)100163d99982SDamjan Jovanovic TEST_F(setPort, setPort_002)
100263d99982SDamjan Jovanovic {
100363d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_FTP );
100463d99982SDamjan Jovanovic sal_Bool bOK = saSocketAddr.setPort( IP_PORT_ZERO );
1005cdf0e10cSrcweir
100663d99982SDamjan Jovanovic oslSocket sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
100763d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
100863d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 );//sal_True);
100963d99982SDamjan Jovanovic sal_Bool bOK1 = sSocket.bind( saSocketAddr );
101063d99982SDamjan Jovanovic ASSERT_TRUE(bOK1 == sal_True) << "bind SocketAddr failed";
1011cdf0e10cSrcweir
101263d99982SDamjan Jovanovic sal_Int32 newPort = sSocket.getLocalPort();
101363d99982SDamjan Jovanovic //printf("#new port is %d\n", newPort );
1014cdf0e10cSrcweir
101563d99982SDamjan Jovanovic ASSERT_TRUE(( 1024 <= newPort ) && ( 65535 >= newPort ) && ( bOK == sal_True )) << "test for setPort() function: port number should be in 1 ~ 65535, set port 0, it should be converted to a port number between 1024~65535.";
1016cdf0e10cSrcweir
101763d99982SDamjan Jovanovic }
1018cdf0e10cSrcweir
TEST_F(setPort,setPort_003)101963d99982SDamjan Jovanovic TEST_F(setPort, setPort_003)
102063d99982SDamjan Jovanovic {
102163d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_FTP);
102263d99982SDamjan Jovanovic sal_Bool bOK = saSocketAddr.setPort( IP_PORT_INVAL );
102363d99982SDamjan Jovanovic //on Linux, getPort return 34463
102463d99982SDamjan Jovanovic //printf("#Port number is %d \n", saSocketAddr.getPort( ));
1025cdf0e10cSrcweir
102663d99982SDamjan Jovanovic ASSERT_TRUE(( ( 1 <= saSocketAddr.getPort( ) ) && ( 65535 >= saSocketAddr.getPort( ) ) &&( bOK == sal_True ) ) ||
102763d99982SDamjan Jovanovic bOK == sal_False) << "test for setPort( ) function: set an address with invalid port. it should return error or convert it to a valid port.";
102863d99982SDamjan Jovanovic }
1029cdf0e10cSrcweir
103063d99982SDamjan Jovanovic /* this is not a inet-addr => can't set port */
TEST_F(setPort,setPort_004)103163d99982SDamjan Jovanovic TEST_F(setPort, setPort_004)
103263d99982SDamjan Jovanovic {
103363d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIpInval1, IP_PORT_FTP);
103463d99982SDamjan Jovanovic sal_Bool bOK = saSocketAddr.setPort( IP_PORT_MYPORT );
1035cdf0e10cSrcweir
103663d99982SDamjan Jovanovic ASSERT_TRUE(bOK == sal_False) << "test for setPort( ) function: set an invalid address with valid port. it should return error.";
103763d99982SDamjan Jovanovic }
1038cdf0e10cSrcweir
1039cdf0e10cSrcweir /** tester comment:
1040cdf0e10cSrcweir
1041cdf0e10cSrcweir In the following two functions, it use ::rtl::ByteSequence as an intermediate storage for address,
1042cdf0e10cSrcweir the ByteSequence object can hold sal_Int8 arrays, which is raged [-127, 127], in case of IP addr
1043cdf0e10cSrcweir that is greater than 127, say 129.158.217.202, it will stored as -127, -98, -39, -54, it is unique
1044cdf0e10cSrcweir in the range of sal_Int8, but lack of readability.
1045cdf0e10cSrcweir so may be a sal_uInt8 array is better.
1046cdf0e10cSrcweir */
1047cdf0e10cSrcweir
1048cdf0e10cSrcweir
1049cdf0e10cSrcweir /** testing the method:
1050cdf0e10cSrcweir inline sal_Bool SAL_CALL setAddr( const ::rtl::ByteSequence & address );
1051cdf0e10cSrcweir */
1052cdf0e10cSrcweir
105363d99982SDamjan Jovanovic class setAddr : public ::testing::Test
1054cdf0e10cSrcweir {
1055cdf0e10cSrcweir public:
105663d99982SDamjan Jovanovic }; // class setAddr
1057cdf0e10cSrcweir
TEST_F(setAddr,setAddr_001)105863d99982SDamjan Jovanovic TEST_F(setAddr, setAddr_001)
105963d99982SDamjan Jovanovic {
106063d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp2, IP_PORT_FTP );
106163d99982SDamjan Jovanovic saSocketAddr.setAddr( UStringIPToByteSequence( aHostIp1 ) );
106263d99982SDamjan Jovanovic ::rtl::ByteSequence bsSocketAddr = saSocketAddr.getAddr( 0 );
106363d99982SDamjan Jovanovic sal_Bool bOK = sal_False;
1064cdf0e10cSrcweir
106563d99982SDamjan Jovanovic if ( ( bsSocketAddr[0] == 127 ) && ( bsSocketAddr[1] == 0 ) && ( bsSocketAddr[2] == 0 ) && ( bsSocketAddr[3] == 1 ) )
106663d99982SDamjan Jovanovic bOK = sal_True;
1067cdf0e10cSrcweir
106863d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for setAddr() function: construct Addr with \"129.158.217.202\", set it to \"127.0.0.1\", and check the correctness ";
106963d99982SDamjan Jovanovic }
1070cdf0e10cSrcweir
1071cdf0e10cSrcweir /** testing the method:
1072cdf0e10cSrcweir inline ::rtl::ByteSequence SAL_CALL getAddr( oslSocketResult *pResult = 0 ) const;
1073cdf0e10cSrcweir */
1074cdf0e10cSrcweir
107563d99982SDamjan Jovanovic class getAddr : public ::testing::Test
1076cdf0e10cSrcweir {
1077cdf0e10cSrcweir public:
107863d99982SDamjan Jovanovic }; // class getAddr
1079cdf0e10cSrcweir
TEST_F(getAddr,getAddr_001)108063d99982SDamjan Jovanovic TEST_F(getAddr, getAddr_001)
108163d99982SDamjan Jovanovic {
108263d99982SDamjan Jovanovic oslSocketResult SocketResult;
108363d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_FTP );
108463d99982SDamjan Jovanovic ::rtl::ByteSequence bsSocketAddr = saSocketAddr.getAddr( &SocketResult );
1085cdf0e10cSrcweir
108663d99982SDamjan Jovanovic sal_Bool bOK = sal_False;
1087cdf0e10cSrcweir
108863d99982SDamjan Jovanovic if ( ( osl_Socket_Ok == SocketResult ) &&( bsSocketAddr[0] == 127 ) && ( bsSocketAddr[1] == 0 ) &&( bsSocketAddr[2] == 0 ) && ( bsSocketAddr[3] == 1 ) )
108963d99982SDamjan Jovanovic bOK = sal_True;
1090cdf0e10cSrcweir
109163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK && SocketResult == osl_Socket_Ok) << "test for getAddr() function: construct a socketaddr with IP assigned, get the address to check correctness.Caught unknown exception on (Win32)";
109263d99982SDamjan Jovanovic }
1093cdf0e10cSrcweir
1094cdf0e10cSrcweir /** testing the methods:
1095cdf0e10cSrcweir inline SocketAddr & SAL_CALL operator= (oslSocketAddr Addr);
1096cdf0e10cSrcweir inline SocketAddr & SAL_CALL operator= (const SocketAddr& Addr);
1097cdf0e10cSrcweir inline SocketAddr & SAL_CALL assign( oslSocketAddr Addr, __osl_socket_NoCopy nocopy );
1098cdf0e10cSrcweir inline sal_Bool SAL_CALL operator== (oslSocketAddr Addr) const;
1099cdf0e10cSrcweir inline sal_Bool SAL_CALL operator== (const SocketAddr & Addr) const; /// not implemented.
1100cdf0e10cSrcweir */
1101cdf0e10cSrcweir
110263d99982SDamjan Jovanovic class operator_equal : public ::testing::Test
1103cdf0e10cSrcweir {
1104cdf0e10cSrcweir public:
110563d99982SDamjan Jovanovic }; // class operator_equal
1106cdf0e10cSrcweir
TEST_F(operator_equal,operator_equal_001)110763d99982SDamjan Jovanovic TEST_F(operator_equal, operator_equal_001)
110863d99982SDamjan Jovanovic {
110963d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_TELNET);
111063d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrEqual( aHostIp2, IP_PORT_FTP );
1111cdf0e10cSrcweir
111263d99982SDamjan Jovanovic saSocketAddrEqual = saSocketAddr;
111363d99982SDamjan Jovanovic sal_Bool bOK = sal_False;
111463d99982SDamjan Jovanovic ::rtl::ByteSequence bsSocketAddr = saSocketAddrEqual.getAddr( 0 );
1115cdf0e10cSrcweir
111663d99982SDamjan Jovanovic if ( ( IP_PORT_TELNET == saSocketAddrEqual.getPort( ) ) &&( bsSocketAddr[0] == 127 ) && ( bsSocketAddr[1] == 0 ) &&( bsSocketAddr[2] == 0 ) && ( bsSocketAddr[3] == 1 ) )
111763d99982SDamjan Jovanovic bOK = sal_True;
1118cdf0e10cSrcweir
111963d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for operator_equal() function: use operator= to assign Ip1 to Ip2, check its modification.";
112063d99982SDamjan Jovanovic }
1121cdf0e10cSrcweir
1122cdf0e10cSrcweir
TEST_F(operator_equal,operator_equal_002)112363d99982SDamjan Jovanovic TEST_F(operator_equal, operator_equal_002)
112463d99982SDamjan Jovanovic {
112563d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp3, IP_PORT_TELNET);
112663d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrEqual( aHostIp2, IP_PORT_FTP );
1127cdf0e10cSrcweir
112863d99982SDamjan Jovanovic saSocketAddrEqual = saSocketAddr;
112963d99982SDamjan Jovanovic ASSERT_TRUE(IP_PORT_TELNET == saSocketAddrEqual.getPort( )) << "after assign, the assigned SocketAddr is not same as the original Addr";
113063d99982SDamjan Jovanovic saSocketAddrEqual.setPort( IP_PORT_MYPORT3 );
113163d99982SDamjan Jovanovic saSocketAddr.setPort( IP_PORT_HTTP2 );
1132cdf0e10cSrcweir
113363d99982SDamjan Jovanovic ASSERT_TRUE(IP_PORT_MYPORT3 == saSocketAddrEqual.getPort( )) << "test for operator_equal() function: perform an equal action, then try to change the original address's port. it should not be changed ( handle released), it did not pass in (W32), this is under discussion.";
113463d99982SDamjan Jovanovic }
1135cdf0e10cSrcweir
TEST_F(operator_equal,operator_equal_const_001)113663d99982SDamjan Jovanovic TEST_F(operator_equal, operator_equal_const_001)
113763d99982SDamjan Jovanovic {
113863d99982SDamjan Jovanovic const ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_TELNET);
113963d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrEqual( aHostIp2, IP_PORT_FTP );
1140cdf0e10cSrcweir
114163d99982SDamjan Jovanovic saSocketAddrEqual = saSocketAddr;
114263d99982SDamjan Jovanovic sal_Bool bOK = sal_False;
114363d99982SDamjan Jovanovic ::rtl::ByteSequence bsSocketAddr = saSocketAddrEqual.getAddr( 0 );
1144cdf0e10cSrcweir
114563d99982SDamjan Jovanovic if ( ( IP_PORT_TELNET == saSocketAddrEqual.getPort( ) ) &&( bsSocketAddr[0] == 127 ) && ( bsSocketAddr[1] == 0 ) &&( bsSocketAddr[2] == 0 ) && ( bsSocketAddr[3] == 1 ) )
114663d99982SDamjan Jovanovic bOK = sal_True;
1147cdf0e10cSrcweir
114863d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for operator_equal_const() function: use operator= const to assign Ip1 to Ip2, verify the change on the second one.";
114963d99982SDamjan Jovanovic }
1150cdf0e10cSrcweir
TEST_F(operator_equal,operator_equal_const_002)115163d99982SDamjan Jovanovic TEST_F(operator_equal, operator_equal_const_002)
115263d99982SDamjan Jovanovic {
115363d99982SDamjan Jovanovic const ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_TELNET);
115463d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrEqual( aHostIp2, IP_PORT_FTP );
1155cdf0e10cSrcweir
115663d99982SDamjan Jovanovic saSocketAddrEqual = saSocketAddr;
115763d99982SDamjan Jovanovic saSocketAddrEqual.setPort( IP_PORT_HTTP1 );
1158cdf0e10cSrcweir
115963d99982SDamjan Jovanovic ASSERT_TRUE(IP_PORT_HTTP1 != saSocketAddr.getPort( )) << "test for operator_equal_const() function: change the second instance, the first one should not be altered, since it does not released the handle.";
116063d99982SDamjan Jovanovic }
1161cdf0e10cSrcweir
TEST_F(operator_equal,operator_equal_assign_001)116263d99982SDamjan Jovanovic TEST_F(operator_equal, operator_equal_assign_001)
116363d99982SDamjan Jovanovic {
116463d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddr = new ::osl::SocketAddr( aHostIp1, IP_PORT_TELNET );
116563d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddr != NULL) << "check for new SocketAddr";
116663d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddrAssign = new ::osl::SocketAddr( aHostIp2, IP_PORT_FTP );
116763d99982SDamjan Jovanovic oslSocketAddr poslSocketAddr = pSocketAddr->getHandle( );
116863d99982SDamjan Jovanovic //if( m_handle ) osl_destroySocketAddr( m_handle ); so pSocketAddrAssign had been destroyed and then point to pSocketAddr
116963d99982SDamjan Jovanovic pSocketAddrAssign->assign(poslSocketAddr, SAL_NO_COPY);
1170cdf0e10cSrcweir
117163d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddrAssign->getPort( ) == IP_PORT_TELNET) << "test for SocketAddr no copy constructor function: do a no copy constructor on a given SocketAddr instance, modify the new instance's port, check the original one.";
1172cdf0e10cSrcweir
117363d99982SDamjan Jovanovic delete pSocketAddrAssign;
117463d99982SDamjan Jovanovic }
1175cdf0e10cSrcweir
TEST_F(operator_equal,operator_is_equal_001)117663d99982SDamjan Jovanovic TEST_F(operator_equal, operator_is_equal_001)
117763d99982SDamjan Jovanovic {
117863d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_TELNET);
117963d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrequal( aHostIp1, IP_PORT_TELNET );
1180cdf0e10cSrcweir
118163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == ( saSocketAddrequal == saSocketAddr.getHandle( ) )) << "test for operator_equal_equal() function: check two identical Address.";
118263d99982SDamjan Jovanovic }
1183cdf0e10cSrcweir
TEST_F(operator_equal,operator_is_equal_002)118463d99982SDamjan Jovanovic TEST_F(operator_equal, operator_is_equal_002)
118563d99982SDamjan Jovanovic {
118663d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp2, IP_PORT_FTP);
118763d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddrequal( aHostIp1, IP_PORT_TELNET );
1188cdf0e10cSrcweir
118963d99982SDamjan Jovanovic ASSERT_TRUE(sal_False == ( saSocketAddrequal == saSocketAddr.getHandle( ) )) << "test for operator_equal_equal() function: check two different Address.";
119063d99982SDamjan Jovanovic }
1191cdf0e10cSrcweir
1192cdf0e10cSrcweir
1193cdf0e10cSrcweir /** testing the method:
1194cdf0e10cSrcweir inline oslSocketAddr SAL_CALL getHandle() const;
1195cdf0e10cSrcweir */
1196cdf0e10cSrcweir
119763d99982SDamjan Jovanovic class getSocketAddrHandle : public ::testing::Test
1198cdf0e10cSrcweir {
1199cdf0e10cSrcweir public:
120063d99982SDamjan Jovanovic }; // class getSocketAddrHandle
1201cdf0e10cSrcweir
TEST_F(getSocketAddrHandle,getSocketAddrHandle_001)120263d99982SDamjan Jovanovic TEST_F(getSocketAddrHandle, getSocketAddrHandle_001)
120363d99982SDamjan Jovanovic {
120463d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddr = new ::osl::SocketAddr( aHostName1, IP_PORT_HTTP1 );
120563d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddr != NULL) << "check for new SocketAddr";
120663d99982SDamjan Jovanovic oslSocketAddr psaOSLSocketAddr = pSocketAddr->getHandle( );
120763d99982SDamjan Jovanovic ::osl::SocketAddr* pSocketAddrCopy = new ::osl::SocketAddr( psaOSLSocketAddr, SAL_NO_COPY );
1208cdf0e10cSrcweir
120963d99982SDamjan Jovanovic ASSERT_TRUE(pSocketAddr->getHandle( ) == pSocketAddrCopy->getHandle( )) << "test for SocketAddr no copy constructor function: do a no copy constructor on a given SocketAddr instance, modify the new instance's port, check the original one.";
1210cdf0e10cSrcweir
121163d99982SDamjan Jovanovic delete pSocketAddrCopy;
121263d99982SDamjan Jovanovic }
1213cdf0e10cSrcweir
TEST_F(getSocketAddrHandle,getSocketAddrHandle_002)121463d99982SDamjan Jovanovic TEST_F(getSocketAddrHandle, getSocketAddrHandle_002)
121563d99982SDamjan Jovanovic {
121663d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostName3, IP_PORT_MYPORT4 );
121763d99982SDamjan Jovanovic oslSocketAddr poslSocketAddr = saSocketAddr.getHandle( );
1218cdf0e10cSrcweir
121963d99982SDamjan Jovanovic sal_Bool bOK = ( saSocketAddr == poslSocketAddr );
122063d99982SDamjan Jovanovic //printf("getSocketAddrHandle_002\n");
122163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for getHandle() function: use getHandle() function as an intermediate way to create identical address.";
122263d99982SDamjan Jovanovic }
1223cdf0e10cSrcweir
1224cdf0e10cSrcweir /** testing the method:
1225cdf0e10cSrcweir static inline ::rtl::OUString SAL_CALL getLocalHostname( oslSocketResult *pResult = 0);
1226cdf0e10cSrcweir */
1227cdf0e10cSrcweir
122863d99982SDamjan Jovanovic class getLocalHostname : public ::testing::Test
1229cdf0e10cSrcweir {
1230cdf0e10cSrcweir public:
123163d99982SDamjan Jovanovic }; // class getLocalHostname
1232cdf0e10cSrcweir
123363d99982SDamjan Jovanovic /* the process of getLocalHostname: 1.gethostname (same as /bin/hostname) returned name A
123463d99982SDamjan Jovanovic 2. search A in /etc/hosts, if there is an alias name is A, return the name in the same row
123563d99982SDamjan Jovanovic */
1236cdf0e10cSrcweir
TEST_F(getLocalHostname,getLocalHostname_000)123763d99982SDamjan Jovanovic TEST_F(getLocalHostname, getLocalHostname_000)
123863d99982SDamjan Jovanovic {
123963d99982SDamjan Jovanovic // _osl_getFullQualifiedDomainName( );
124063d99982SDamjan Jovanovic oslSocketResult aResult = osl_Socket_Error;
124163d99982SDamjan Jovanovic rtl::OUString suHostname = osl::SocketAddr::getLocalHostname(&aResult);
124263d99982SDamjan Jovanovic ASSERT_TRUE(aResult == osl_Socket_Ok) << "getLocalHostname failed";
124363d99982SDamjan Jovanovic }
124463d99982SDamjan Jovanovic
TEST_F(getLocalHostname,getLocalHostname_001)124563d99982SDamjan Jovanovic TEST_F(getLocalHostname, getLocalHostname_001)
124663d99982SDamjan Jovanovic {
124763d99982SDamjan Jovanovic oslSocketResult *pResult = NULL;
124863d99982SDamjan Jovanovic //printSocketResult(*pResult);
124963d99982SDamjan Jovanovic ::rtl::OUString suResult = ::osl::SocketAddr::getLocalHostname( pResult );
125063d99982SDamjan Jovanovic
125163d99982SDamjan Jovanovic // LLA: IMHO localhost, or hostname by itself should be ok.
125263d99982SDamjan Jovanovic rtl::OUString suThisHost = getThisHostname( );
125363d99982SDamjan Jovanovic bool bOk = false;
125463d99982SDamjan Jovanovic if (suThisHost.equals(rtl::OUString::createFromAscii("localhost")))
125563d99982SDamjan Jovanovic {
125663d99982SDamjan Jovanovic bOk = true;
125763d99982SDamjan Jovanovic }
125863d99982SDamjan Jovanovic else
125963d99982SDamjan Jovanovic {
126063d99982SDamjan Jovanovic if (suThisHost.equals(suResult))
1261cdf0e10cSrcweir {
1262cdf0e10cSrcweir bOk = true;
1263cdf0e10cSrcweir }
126463d99982SDamjan Jovanovic }
1265cdf0e10cSrcweir
126663d99982SDamjan Jovanovic ::rtl::OUString suError;
126763d99982SDamjan Jovanovic suError = outputError(suResult, getThisHostname( ), "test for getLocalHostname() function");
1268cdf0e10cSrcweir
126963d99982SDamjan Jovanovic ASSERT_TRUE(bOk == true) << suError.pData;
127063d99982SDamjan Jovanovic }
1271cdf0e10cSrcweir
1272cdf0e10cSrcweir /** testing the method:
1273cdf0e10cSrcweir static inline void SAL_CALL resolveHostname( const ::rtl::OUString & strHostName , SocketAddr & Addr );
1274cdf0e10cSrcweir */
1275cdf0e10cSrcweir
127663d99982SDamjan Jovanovic class resolveHostname : public ::testing::Test
1277cdf0e10cSrcweir {
1278cdf0e10cSrcweir public:
127963d99982SDamjan Jovanovic }; // class resolveHostname
1280cdf0e10cSrcweir
TEST_F(resolveHostname,resolveHostname_001)128163d99982SDamjan Jovanovic TEST_F(resolveHostname, resolveHostname_001)
128263d99982SDamjan Jovanovic {
128363d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr;
128463d99982SDamjan Jovanovic ::osl::SocketAddr::resolveHostname( aHostIp1, saSocketAddr );
128563d99982SDamjan Jovanovic ::rtl::ByteSequence bsSocketAddr = saSocketAddr.getAddr( 0 );
128663d99982SDamjan Jovanovic sal_Bool bOK = sal_False;
1287cdf0e10cSrcweir
128863d99982SDamjan Jovanovic if ( ( bsSocketAddr[0] == 127 ) && ( bsSocketAddr[1] == 0 ) &&( bsSocketAddr[2] == 0 ) && ( bsSocketAddr[3] == 1 ) )
128963d99982SDamjan Jovanovic bOK = sal_True;
1290cdf0e10cSrcweir
129163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for resolveHostname() function: try to resolve localhost to 127.0.0.1.";
129263d99982SDamjan Jovanovic }
1293cdf0e10cSrcweir
1294cdf0e10cSrcweir /** testing the method:
1295cdf0e10cSrcweir static inline sal_Int32 SAL_CALL getServicePort(
1296cdf0e10cSrcweir const ::rtl::OUString& strServiceName,
1297cdf0e10cSrcweir const ::rtl::OUString & strProtocolName= ::rtl::OUString::createFromAscii( "tcp" ) );
1298cdf0e10cSrcweir */
1299cdf0e10cSrcweir
130063d99982SDamjan Jovanovic class gettheServicePort : public ::testing::Test
1301cdf0e10cSrcweir {
1302cdf0e10cSrcweir public:
1303cdf0e10cSrcweir }; // class gettheServicePort
1304cdf0e10cSrcweir
TEST_F(gettheServicePort,gettheServicePort_001)130563d99982SDamjan Jovanovic TEST_F(gettheServicePort, gettheServicePort_001)
130663d99982SDamjan Jovanovic {
130763d99982SDamjan Jovanovic ASSERT_TRUE(IP_PORT_FTP== ::osl::SocketAddr::getServicePort( aServiceFTP, aProtocolTCP )) << "test for getServicePort() function: try to get ftp service port on TCP protocol.";
130863d99982SDamjan Jovanovic }
1309cdf0e10cSrcweir
TEST_F(gettheServicePort,gettheServicePort_002)131063d99982SDamjan Jovanovic TEST_F(gettheServicePort, gettheServicePort_002)
131163d99982SDamjan Jovanovic {
131263d99982SDamjan Jovanovic ASSERT_TRUE(IP_PORT_TELNET== ::osl::SocketAddr::getServicePort( aServiceTELNET, aProtocolTCP )) << "test for getServicePort() function: try to get telnet service port on TCP protocol.";
131363d99982SDamjan Jovanovic }
1314cdf0e10cSrcweir
TEST_F(gettheServicePort,gettheServicePort_003)131563d99982SDamjan Jovanovic TEST_F(gettheServicePort, gettheServicePort_003)
131663d99982SDamjan Jovanovic {
131763d99982SDamjan Jovanovic //Solaris has no service called "https", please see /etc/services
131863d99982SDamjan Jovanovic ASSERT_TRUE(IP_PORT_NETBIOS_DGM == ::osl::SocketAddr::getServicePort( aServiceNETBIOS, aProtocolUDP )) << "test for getServicePort() function: try to get netbios-ssn service port on UDP protocol.";
131963d99982SDamjan Jovanovic }
132063d99982SDamjan Jovanovic
TEST_F(gettheServicePort,gettheServicePort_004)132163d99982SDamjan Jovanovic TEST_F(gettheServicePort, gettheServicePort_004)
132263d99982SDamjan Jovanovic {
132363d99982SDamjan Jovanovic ASSERT_TRUE(OSL_INVALID_PORT == ::osl::SocketAddr::getServicePort( ::rtl::OUString::createFromAscii( "notexist" ), aProtocolUDP )) << "test for getServicePort() function: try to get a service port which is not exist.";
132463d99982SDamjan Jovanovic }
1325cdf0e10cSrcweir
1326cdf0e10cSrcweir
1327cdf0e10cSrcweir } // namespace osl_SocketAddr
1328cdf0e10cSrcweir
1329cdf0e10cSrcweir
1330cdf0e10cSrcweir
1331cdf0e10cSrcweir namespace osl_Socket
1332cdf0e10cSrcweir {
1333cdf0e10cSrcweir
1334cdf0e10cSrcweir /** testing the methods:
1335cdf0e10cSrcweir inline Socket( );
1336cdf0e10cSrcweir inline Socket( const Socket & socket );
1337cdf0e10cSrcweir inline Socket( oslSocket socketHandle );
1338cdf0e10cSrcweir inline Socket( oslSocket socketHandle, __sal_NoAcquire noacquire );
1339cdf0e10cSrcweir */
1340cdf0e10cSrcweir
1341cdf0e10cSrcweir /** test writer's comment:
1342cdf0e10cSrcweir
1343cdf0e10cSrcweir class Socket can not be initialized by its protected constructor, though the protected
1344cdf0e10cSrcweir constructor is the most convenient way to create a new socket.
1345cdf0e10cSrcweir it only allow the method of C function osl_createSocket like:
1346cdf0e10cSrcweir ::osl::Socket sSocket( osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream,
1347cdf0e10cSrcweir osl_Socket_ProtocolIp ) );
1348cdf0e10cSrcweir the use of C method lost some of the transparent of tester using C++ wrapper.
1349cdf0e10cSrcweir */
1350cdf0e10cSrcweir
1351cdf0e10cSrcweir
135263d99982SDamjan Jovanovic class OslSocketCtors : public ::testing::Test
1353cdf0e10cSrcweir {
1354cdf0e10cSrcweir public:
135563d99982SDamjan Jovanovic oslSocket sHandle;
135663d99982SDamjan Jovanovic // initialization
SetUp()135763d99982SDamjan Jovanovic void SetUp()
135863d99982SDamjan Jovanovic {
135963d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
136063d99982SDamjan Jovanovic }
1361cdf0e10cSrcweir
TearDown()136263d99982SDamjan Jovanovic void TearDown()
136363d99982SDamjan Jovanovic {
136463d99982SDamjan Jovanovic sHandle = NULL;
136563d99982SDamjan Jovanovic }
136663d99982SDamjan Jovanovic };
1367cdf0e10cSrcweir
TEST_F(OslSocketCtors,ctors_none)136863d99982SDamjan Jovanovic TEST_F(OslSocketCtors, ctors_none)
136963d99982SDamjan Jovanovic {
137063d99982SDamjan Jovanovic /// Socket constructor.
137163d99982SDamjan Jovanovic // ::osl::Socket sSocket;
1372cdf0e10cSrcweir
137363d99982SDamjan Jovanovic ASSERT_TRUE(1 == 1) << "test for ctors_none constructor function: check if the socket was created successfully, if no exception occurred";
137463d99982SDamjan Jovanovic }
1375cdf0e10cSrcweir
TEST_F(OslSocketCtors,ctors_acquire)137663d99982SDamjan Jovanovic TEST_F(OslSocketCtors, ctors_acquire)
137763d99982SDamjan Jovanovic {
137863d99982SDamjan Jovanovic /// Socket constructor.
137963d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle );
1380cdf0e10cSrcweir
138163d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == sSocket.getType( )) << "test for ctors_acquire constructor function: check if the socket was created successfully";
138263d99982SDamjan Jovanovic }
1383cdf0e10cSrcweir
TEST_F(OslSocketCtors,ctors_no_acquire)138463d99982SDamjan Jovanovic TEST_F(OslSocketCtors, ctors_no_acquire)
138563d99982SDamjan Jovanovic {
138663d99982SDamjan Jovanovic /// Socket constructor.
138763d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle, SAL_NO_ACQUIRE );
1388cdf0e10cSrcweir
138963d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == sSocket.getType( )) << " test for ctors_no_acquire constructor function: check if the socket was created successfully";
139063d99982SDamjan Jovanovic }
1391cdf0e10cSrcweir
TEST_F(OslSocketCtors,ctors_copy_ctor)139263d99982SDamjan Jovanovic TEST_F(OslSocketCtors, ctors_copy_ctor)
139363d99982SDamjan Jovanovic {
139463d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle );
139563d99982SDamjan Jovanovic /// Socket copy constructor.
139663d99982SDamjan Jovanovic ::osl::Socket copySocket( sSocket );
1397cdf0e10cSrcweir
139863d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == copySocket.getType( )) << " test for ctors_copy_ctor constructor function: create new Socket instance using copy constructor";
139963d99982SDamjan Jovanovic }
1400cdf0e10cSrcweir
TEST_F(OslSocketCtors,ctors_TypeRaw)140163d99982SDamjan Jovanovic TEST_F(OslSocketCtors, ctors_TypeRaw)
140263d99982SDamjan Jovanovic {
1403cdf0e10cSrcweir #ifdef WNT
140463d99982SDamjan Jovanovic oslSocket sHandleRaw = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeRaw, osl_Socket_ProtocolIp );
140563d99982SDamjan Jovanovic // LLA: ? ::osl::Socket sSocket( sHandleRaw );
140663d99982SDamjan Jovanovic ASSERT_TRUE(sHandleRaw != NULL) << " type osl_Socket_TypeRaw socket create failed on UNX ";
1407cdf0e10cSrcweir #else
140863d99982SDamjan Jovanovic oslSocket sHandleRaw = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeRaw, osl_Socket_ProtocolIp );
140963d99982SDamjan Jovanovic ASSERT_TRUE(sHandleRaw == NULL) << " can't create socket with type osl_Socket_TypeRaw within UNX is ok.";
1410cdf0e10cSrcweir #endif
141163d99982SDamjan Jovanovic }
1412cdf0e10cSrcweir
TEST_F(OslSocketCtors,ctors_family_Ipx)141363d99982SDamjan Jovanovic TEST_F(OslSocketCtors, ctors_family_Ipx)
141463d99982SDamjan Jovanovic {
141563d99982SDamjan Jovanovic oslSocket sHandleIpx = osl_createSocket( osl_Socket_FamilyIpx, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
141663d99982SDamjan Jovanovic ASSERT_TRUE(sHandleIpx != NULL) << " family osl_Socket_FamilyIpx socket create failed! ";
141763d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandleIpx ); //, SAL_NO_ACQUIRE );
141863d99982SDamjan Jovanovic printf("#Type is %d \n", sSocket.getType( ) );
1419cdf0e10cSrcweir
142063d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == sSocket.getType( )) << " test for create new Socket instance that family is osl_Socket_FamilyIpx";
142163d99982SDamjan Jovanovic }
1422cdf0e10cSrcweir
1423cdf0e10cSrcweir
1424cdf0e10cSrcweir /** testing the methods:
1425cdf0e10cSrcweir inline Socket& SAL_CALL operator= ( oslSocket socketHandle);
1426cdf0e10cSrcweir inline Socket& SAL_CALL operator= (const Socket& sock);
1427cdf0e10cSrcweir inline sal_Bool SAL_CALL operator==( const Socket& rSocket ) const ;
1428cdf0e10cSrcweir inline sal_Bool SAL_CALL operator==( const oslSocket socketHandle ) const;
1429cdf0e10cSrcweir */
1430cdf0e10cSrcweir
143163d99982SDamjan Jovanovic class operators : public ::testing::Test
1432cdf0e10cSrcweir {
1433cdf0e10cSrcweir public:
1434cdf0e10cSrcweir oslSocket sHandle;
1435cdf0e10cSrcweir // initialization
SetUp()143663d99982SDamjan Jovanovic void SetUp( )
1437cdf0e10cSrcweir {
1438cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1439cdf0e10cSrcweir }
1440cdf0e10cSrcweir
TearDown()144163d99982SDamjan Jovanovic void TearDown( )
1442cdf0e10cSrcweir {
1443cdf0e10cSrcweir sHandle = NULL;
1444cdf0e10cSrcweir }
144563d99982SDamjan Jovanovic }; // class operators
144663d99982SDamjan Jovanovic
1447cdf0e10cSrcweir
1448cdf0e10cSrcweir
1449cdf0e10cSrcweir /** test writer's comment:
1450cdf0e10cSrcweir
1451*1fb1d6b8SJohn Bampton the assignment operator does not support direct assignment like:
145263d99982SDamjan Jovanovic ::osl::Socket sSocket = sHandle.
1453cdf0e10cSrcweir */
TEST_F(operators,operators_assignment_handle)145463d99982SDamjan Jovanovic TEST_F(operators, operators_assignment_handle)
145563d99982SDamjan Jovanovic {
145663d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
145763d99982SDamjan Jovanovic ::osl::Socket assignSocket = sSocket.getHandle();
1458cdf0e10cSrcweir
145963d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == assignSocket.getType( )) << "test for operators_assignment_handle function: test the assignment operator.";
146063d99982SDamjan Jovanovic }
1461cdf0e10cSrcweir
TEST_F(operators,operators_assignment)146263d99982SDamjan Jovanovic TEST_F(operators, operators_assignment)
146363d99982SDamjan Jovanovic {
146463d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle );
146563d99982SDamjan Jovanovic ::osl::Socket assignSocket = sSocket;
1466cdf0e10cSrcweir
146763d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == assignSocket.getType( )) << "test for operators_assignment function: assignment operator";
146863d99982SDamjan Jovanovic }
1469cdf0e10cSrcweir
TEST_F(operators,operators_equal_handle_001)147063d99982SDamjan Jovanovic TEST_F(operators, operators_equal_handle_001)
147163d99982SDamjan Jovanovic {
147263d99982SDamjan Jovanovic /// Socket constructor.
147363d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle );
147463d99982SDamjan Jovanovic ::osl::Socket equalSocket = sSocket;
1475cdf0e10cSrcweir
147663d99982SDamjan Jovanovic ASSERT_TRUE(equalSocket == sHandle) << " test for operators_equal_handle_001 function: check equal.";
147763d99982SDamjan Jovanovic }
1478cdf0e10cSrcweir
TEST_F(operators,operators_equal_handle_002)147963d99982SDamjan Jovanovic TEST_F(operators, operators_equal_handle_002)
148063d99982SDamjan Jovanovic {
148163d99982SDamjan Jovanovic /// Socket constructor.
148263d99982SDamjan Jovanovic ::osl::Socket equalSocket( osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeDgram, osl_Socket_ProtocolIp ) );
1483cdf0e10cSrcweir
148463d99982SDamjan Jovanovic ASSERT_TRUE(!( equalSocket == sHandle )) << " test for operators_equal_handle_001 function: check unequal.";
148563d99982SDamjan Jovanovic }
1486cdf0e10cSrcweir
TEST_F(operators,operators_equal_001)148763d99982SDamjan Jovanovic TEST_F(operators, operators_equal_001)
148863d99982SDamjan Jovanovic {
148963d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle );
149063d99982SDamjan Jovanovic /// Socket copy constructor.
149163d99982SDamjan Jovanovic ::osl::Socket equalSocket( sSocket );
1492cdf0e10cSrcweir
149363d99982SDamjan Jovanovic ASSERT_TRUE(equalSocket == sSocket) << " test for operators_equal function: check equal.";
149463d99982SDamjan Jovanovic }
1495cdf0e10cSrcweir
TEST_F(operators,operators_equal_002)149663d99982SDamjan Jovanovic TEST_F(operators, operators_equal_002)
149763d99982SDamjan Jovanovic {
149863d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle );
149963d99982SDamjan Jovanovic /// Socket copy constructor.
150063d99982SDamjan Jovanovic ::osl::Socket equalSocket( osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeDgram, osl_Socket_ProtocolIp ) );
1501cdf0e10cSrcweir
150263d99982SDamjan Jovanovic ASSERT_TRUE(!( equalSocket == sSocket )) << " test for operators_equal_002 function: check unequal.";
150363d99982SDamjan Jovanovic }
1504cdf0e10cSrcweir
1505cdf0e10cSrcweir /** testing the methods:
1506cdf0e10cSrcweir inline void SAL_CALL shutdown( oslSocketDirection Direction = osl_Socket_DirReadWrite );
1507cdf0e10cSrcweir inline void SAL_CALL close();
1508cdf0e10cSrcweir */
1509cdf0e10cSrcweir
151063d99982SDamjan Jovanovic class close : public ::testing::Test
1511cdf0e10cSrcweir {
1512cdf0e10cSrcweir public:
1513cdf0e10cSrcweir oslSocket sHandle;
1514cdf0e10cSrcweir // initialization
SetUp()151563d99982SDamjan Jovanovic void SetUp( )
1516cdf0e10cSrcweir {
1517cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1518cdf0e10cSrcweir }
1519cdf0e10cSrcweir
TearDown()152063d99982SDamjan Jovanovic void TearDown( )
1521cdf0e10cSrcweir {
1522cdf0e10cSrcweir sHandle = NULL;
1523cdf0e10cSrcweir }
152463d99982SDamjan Jovanovic }; // class close
1525cdf0e10cSrcweir
TEST_F(close,close_001)152663d99982SDamjan Jovanovic TEST_F(close, close_001)
152763d99982SDamjan Jovanovic {
152863d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
152963d99982SDamjan Jovanovic sSocket.close();
1530cdf0e10cSrcweir
153163d99982SDamjan Jovanovic ASSERT_TRUE(sSocket.getHandle() == sHandle) << "test for close_001 function: this function is reserved for test.";
153263d99982SDamjan Jovanovic }
1533cdf0e10cSrcweir
TEST_F(close,close_002)153463d99982SDamjan Jovanovic TEST_F(close, close_002)
153563d99982SDamjan Jovanovic {
153663d99982SDamjan Jovanovic // This blocks forever on FreeBSD
153763d99982SDamjan Jovanovic #if defined(LINUX)
153863d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
153963d99982SDamjan Jovanovic AcceptorThread myAcceptorThread( asSocket, aHostIp1 );
154063d99982SDamjan Jovanovic myAcceptorThread.create();
154163d99982SDamjan Jovanovic
154263d99982SDamjan Jovanovic thread_sleep( 1 );
154363d99982SDamjan Jovanovic //when accepting, close the socket, the thread will not block for accepting
154463d99982SDamjan Jovanovic //man close:Any locks held on the file it was associated with, and owned by the process, are removed
154563d99982SDamjan Jovanovic asSocket.close();
154663d99982SDamjan Jovanovic //thread_sleep( 2 );
154763d99982SDamjan Jovanovic myAcceptorThread.join();
154863d99982SDamjan Jovanovic
154963d99982SDamjan Jovanovic ASSERT_TRUE(myAcceptorThread.isOK() == sal_True) << "test for close when is accepting: the socket will quit accepting status.";
155063d99982SDamjan Jovanovic #endif
155163d99982SDamjan Jovanovic }
1552cdf0e10cSrcweir
155363d99982SDamjan Jovanovic // to cover "if ( pSockAddrIn->sin_addr.s_addr == htonl(INADDR_ANY) )" in osl_closeSocket( )
TEST_F(close,close_003)155463d99982SDamjan Jovanovic TEST_F(close, close_003)
155563d99982SDamjan Jovanovic {
155663d99982SDamjan Jovanovic // This blocks forever on FreeBSD
155763d99982SDamjan Jovanovic #if defined(LINUX)
155863d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
155963d99982SDamjan Jovanovic AcceptorThread myAcceptorThread( asSocket, aHostIpZero );
156063d99982SDamjan Jovanovic myAcceptorThread.create();
1561cdf0e10cSrcweir
156263d99982SDamjan Jovanovic thread_sleep( 1 );
156363d99982SDamjan Jovanovic asSocket.close();
156463d99982SDamjan Jovanovic myAcceptorThread.join();
1565cdf0e10cSrcweir
156663d99982SDamjan Jovanovic ASSERT_TRUE(myAcceptorThread.isOK() == sal_True) << "test for close when is accepting: the socket will quit accepting status.";
156763d99982SDamjan Jovanovic #endif
156863d99982SDamjan Jovanovic }
1569cdf0e10cSrcweir
1570cdf0e10cSrcweir /** testing the method:
1571cdf0e10cSrcweir inline void SAL_CALL getLocalAddr( SocketAddr &Addr ) const;
1572cdf0e10cSrcweir */
1573cdf0e10cSrcweir
157463d99982SDamjan Jovanovic class getLocalAddr : public ::testing::Test
1575cdf0e10cSrcweir {
1576cdf0e10cSrcweir public:
1577cdf0e10cSrcweir oslSocket sHandle;
1578cdf0e10cSrcweir // initialization
SetUp()157963d99982SDamjan Jovanovic void SetUp( )
1580cdf0e10cSrcweir {
1581cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1582cdf0e10cSrcweir }
1583cdf0e10cSrcweir
TearDown()158463d99982SDamjan Jovanovic void TearDown( )
1585cdf0e10cSrcweir {
1586cdf0e10cSrcweir sHandle = NULL;
1587cdf0e10cSrcweir }
158863d99982SDamjan Jovanovic }; // class getLocalAddr
1589cdf0e10cSrcweir
159063d99982SDamjan Jovanovic // get the Address of the local end of the socket
TEST_F(getLocalAddr,getLocalAddr_001)159163d99982SDamjan Jovanovic TEST_F(getLocalAddr, getLocalAddr_001)
159263d99982SDamjan Jovanovic {
159363d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
159463d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIp1, IP_PORT_MYPORT8 );
159563d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr;
1596cdf0e10cSrcweir
159763d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
1598cdf0e10cSrcweir
159963d99982SDamjan Jovanovic sal_Bool bOK1 = sSocket.bind( saBindSocketAddr );
160063d99982SDamjan Jovanovic ::rtl::OUString suError1 = ::rtl::OUString::createFromAscii("Socket bind fail:") + sSocket.getErrorAsString();
160163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << suError1.pData;
1602cdf0e10cSrcweir
160363d99982SDamjan Jovanovic sSocket.getLocalAddr( saLocalSocketAddr );
1604cdf0e10cSrcweir
160563d99982SDamjan Jovanovic sal_Bool bOK = compareUString( saLocalSocketAddr.getHostname( 0 ), sSocket.getLocalHost() ) ;
1606cdf0e10cSrcweir
160763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for getLocalAddr function: first create a new socket, then a socket address, bind them, and check the address.";
160863d99982SDamjan Jovanovic }
1609cdf0e10cSrcweir
1610cdf0e10cSrcweir
1611cdf0e10cSrcweir /** testing the method:
1612cdf0e10cSrcweir inline sal_Int32 SAL_CALL getLocalPort() const;
1613cdf0e10cSrcweir */
1614cdf0e10cSrcweir
161563d99982SDamjan Jovanovic class getLocalPort : public ::testing::Test
1616cdf0e10cSrcweir {
1617cdf0e10cSrcweir public:
1618cdf0e10cSrcweir oslSocket sHandle;
1619cdf0e10cSrcweir // initialization
SetUp()162063d99982SDamjan Jovanovic void SetUp( )
1621cdf0e10cSrcweir {
1622cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1623cdf0e10cSrcweir }
1624cdf0e10cSrcweir
TearDown()162563d99982SDamjan Jovanovic void TearDown( )
1626cdf0e10cSrcweir {
1627cdf0e10cSrcweir sHandle = NULL;
1628cdf0e10cSrcweir }
162963d99982SDamjan Jovanovic }; // class getLocalPort
1630cdf0e10cSrcweir
TEST_F(getLocalPort,getLocalPort_001)163163d99982SDamjan Jovanovic TEST_F(getLocalPort, getLocalPort_001)
163263d99982SDamjan Jovanovic {
163363d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
163463d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIp1, IP_PORT_MYPORT7 ); // aHostIp1 localhost
163563d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr;
1636cdf0e10cSrcweir
163763d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
1638cdf0e10cSrcweir
163963d99982SDamjan Jovanovic sal_Bool bOK1 = sSocket.bind( saBindSocketAddr );
164063d99982SDamjan Jovanovic ::rtl::OUString suError1 = ::rtl::OUString::createFromAscii("Socket bind fail:") + sSocket.getErrorAsString();
164163d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << suError1.pData;
164263d99982SDamjan Jovanovic sal_Bool bOK = ( IP_PORT_MYPORT7 == sSocket.getLocalPort( ) );
1643cdf0e10cSrcweir
164463d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for getLocalPort function: first create a new socket, then a socket address, bind them, and check the port.";
164563d99982SDamjan Jovanovic }
1646cdf0e10cSrcweir
164763d99982SDamjan Jovanovic /** test writer's comment:
1648cdf0e10cSrcweir
164963d99982SDamjan Jovanovic the invalid port number can not be set by giving invalid port number
165063d99982SDamjan Jovanovic such as 99999 or -1, it will convert to ( x mod 65535 ), so it will always be
165163d99982SDamjan Jovanovic valid, the only instance that the getLocalPort returns OSL_INVALID_PORT
165263d99982SDamjan Jovanovic is when saSocketAddr itself is an invalid one, that is , the IP or host name
165363d99982SDamjan Jovanovic can not be found, then the created socket address is not valid.
165463d99982SDamjan Jovanovic */
165563d99982SDamjan Jovanovic #if 0
165663d99982SDamjan Jovanovic TEST_F(getLocalPort, getLocalPort_002)
165763d99982SDamjan Jovanovic {
165863d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIpInval, IP_PORT_TELNET);
1659cdf0e10cSrcweir #ifdef WNT
166063d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
166163d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); // sal_True);
166263d99982SDamjan Jovanovic sSocket.bind( saBindSocketAddr );
166363d99982SDamjan Jovanovic //Invalid IP, so bind should fail
166463d99982SDamjan Jovanovic ::rtl::OUString suError = outputError(::rtl::OUString::valueOf(sSocket.getLocalPort( )),
166563d99982SDamjan Jovanovic ::rtl::OUString::valueOf((sal_Int32)OSL_INVALID_PORT),
166663d99982SDamjan Jovanovic "test for getLocalPort function: first create a new socket, then an invalid socket address, bind them, and check the port assigned.");
166763d99982SDamjan Jovanovic sal_Bool bOK = ( OSL_INVALID_PORT == sSocket.getLocalPort( ) );
166863d99982SDamjan Jovanovic (void)bOK;
1669cdf0e10cSrcweir #else
167063d99982SDamjan Jovanovic //on Unix, if Addr is not an address of type osl_Socket_FamilyInet, it returns OSL_INVALID_PORT
167163d99982SDamjan Jovanovic ::rtl::OUString suError = ::rtl::OUString::createFromAscii( "on Unix, if Addr is not an address of type osl_Socket_FamilyInet, it returns OSL_INVALID_PORT, but can not create Addr of that case");
1672cdf0e10cSrcweir #endif
167363d99982SDamjan Jovanovic ASSERT_TRUE(sal_False) << suError;
1674cdf0e10cSrcweir
167563d99982SDamjan Jovanovic }
167663d99982SDamjan Jovanovic #endif
1677cdf0e10cSrcweir
TEST_F(getLocalPort,getLocalPort_003)167863d99982SDamjan Jovanovic TEST_F(getLocalPort, getLocalPort_003)
167963d99982SDamjan Jovanovic {
168063d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
168163d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( getLocalIP(), IP_PORT_INVAL);
1682cdf0e10cSrcweir
168363d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
1684cdf0e10cSrcweir
168563d99982SDamjan Jovanovic sal_Bool bOK1 = sSocket.bind( saBindSocketAddr );
168663d99982SDamjan Jovanovic ::rtl::OUString suError1 = ::rtl::OUString::createFromAscii("Socket bind fail:") + sSocket.getErrorAsString();
168763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << suError1.pData;
168863d99982SDamjan Jovanovic ::rtl::OUString suError = outputError(::rtl::OUString::valueOf(sSocket.getLocalPort( )),
168963d99982SDamjan Jovanovic ::rtl::OUString::createFromAscii("34463"),
169063d99982SDamjan Jovanovic "test for getLocalPort function: first create a new socket, then an invalid socket address, bind them, and check the port assigned");
169163d99982SDamjan Jovanovic sal_Bool bOK = ( sSocket.getLocalPort( ) >= 1 && sSocket.getLocalPort( ) <= 65535);
1692cdf0e10cSrcweir
169363d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << suError.pData;
169463d99982SDamjan Jovanovic }
1695cdf0e10cSrcweir
1696cdf0e10cSrcweir /** testing the method:
1697cdf0e10cSrcweir inline ::rtl::OUString SAL_CALL getLocalHost() const;
1698cdf0e10cSrcweir
1699cdf0e10cSrcweir Mindyliu: on Linux, at first it will check the binded in /etc/hosts, if it has the binded IP, it will return the hostname in it;
1700cdf0e10cSrcweir else if the binded IP is "127.0.0.1", it will return "localhost", if it's the machine's ethernet ip such as "129.158.217.90", it
1701cdf0e10cSrcweir will return hostname of current processor such as "aegean.PRC.Sun.COM"
1702cdf0e10cSrcweir */
1703cdf0e10cSrcweir
170463d99982SDamjan Jovanovic class getLocalHost : public ::testing::Test
1705cdf0e10cSrcweir {
1706cdf0e10cSrcweir public:
1707cdf0e10cSrcweir oslSocket sHandle;
1708cdf0e10cSrcweir // initialization
SetUp()170963d99982SDamjan Jovanovic void SetUp( )
1710cdf0e10cSrcweir {
1711cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1712cdf0e10cSrcweir }
1713cdf0e10cSrcweir
TearDown()171463d99982SDamjan Jovanovic void TearDown( )
1715cdf0e10cSrcweir {
1716cdf0e10cSrcweir sHandle = NULL;
1717cdf0e10cSrcweir }
171863d99982SDamjan Jovanovic }; // class getLocalHost
1719cdf0e10cSrcweir
TEST_F(getLocalHost,getLocalHost_001)172063d99982SDamjan Jovanovic TEST_F(getLocalHost, getLocalHost_001)
172163d99982SDamjan Jovanovic {
172263d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
172363d99982SDamjan Jovanovic //port number from IP_PORT_HTTP1 to IP_PORT_MYPORT6, mindyliu
172463d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIp1, IP_PORT_MYPORT6 );
1725cdf0e10cSrcweir
172663d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
1727cdf0e10cSrcweir
172863d99982SDamjan Jovanovic sal_Bool bOK1 = sSocket.bind( saBindSocketAddr );
172963d99982SDamjan Jovanovic ::rtl::OUString suError1 = ::rtl::OUString::createFromAscii("Socket bind fail:") + sSocket.getErrorAsString();
173063d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << suError1.pData;
173163d99982SDamjan Jovanovic sal_Bool bOK;
173263d99982SDamjan Jovanovic ::rtl::OUString suError;
1733cdf0e10cSrcweir #ifdef WNT
173463d99982SDamjan Jovanovic bOK = compareUString( sSocket.getLocalHost( ), getThisHostname( ) ) ;
173563d99982SDamjan Jovanovic suError = outputError(sSocket.getLocalHost( ), getThisHostname( ),
1736cdf0e10cSrcweir "test for getLocalHost function: create localhost socket and check name");
1737cdf0e10cSrcweir #else
173863d99982SDamjan Jovanovic ::rtl::OUString aUString = ::rtl::OUString::createFromAscii( (const sal_Char *) "localhost" );
173963d99982SDamjan Jovanovic sal_Bool bRes1, bRes2;
174063d99982SDamjan Jovanovic bRes1 = compareUString( sSocket.getLocalHost( ), aUString ) ;
174163d99982SDamjan Jovanovic bRes2 = compareUString( sSocket.getLocalHost( ), saBindSocketAddr.getHostname(0) ) ;
174263d99982SDamjan Jovanovic bOK = bRes1 || bRes2;
174363d99982SDamjan Jovanovic suError = outputError(sSocket.getLocalHost( ), aUString, "test for getLocalHost function: create localhost socket and check name");
1744cdf0e10cSrcweir #endif
174563d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << suError.pData;
174663d99982SDamjan Jovanovic }
1747cdf0e10cSrcweir
TEST_F(getLocalHost,getLocalHost_002)174863d99982SDamjan Jovanovic TEST_F(getLocalHost, getLocalHost_002)
174963d99982SDamjan Jovanovic {
175063d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
175163d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIpInval, IP_PORT_POP3);
175263d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr;
1753cdf0e10cSrcweir
175463d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
175563d99982SDamjan Jovanovic sSocket.bind( saBindSocketAddr );
175663d99982SDamjan Jovanovic //Invalid IP, so bind should fail
175763d99982SDamjan Jovanovic sal_Bool bOK = compareUString( sSocket.getLocalHost( ), aNullURL ) ;
175863d99982SDamjan Jovanovic ::rtl::OUString suError = outputError(sSocket.getLocalHost( ), aNullURL, "test for getLocalHost function: getLocalHost with invalid SocketAddr");
1759cdf0e10cSrcweir
176063d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << suError.pData;
176163d99982SDamjan Jovanovic }
1762cdf0e10cSrcweir
1763cdf0e10cSrcweir /** testing the methods:
1764cdf0e10cSrcweir inline void SAL_CALL getPeerAddr( SocketAddr & Addr) const;
1765cdf0e10cSrcweir inline sal_Int32 SAL_CALL getPeerPort() const;
1766cdf0e10cSrcweir inline ::rtl::OUString SAL_CALL getPeerHost() const;
1767cdf0e10cSrcweir */
176863d99982SDamjan Jovanovic class getPeer : public ::testing::Test
1769cdf0e10cSrcweir {
1770cdf0e10cSrcweir public:
1771cdf0e10cSrcweir oslSocket sHandle;
1772cdf0e10cSrcweir TimeValue *pTimeout;
1773cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
1774cdf0e10cSrcweir ::osl::ConnectorSocket csConnectorSocket;
1775cdf0e10cSrcweir
1776cdf0e10cSrcweir
1777cdf0e10cSrcweir // initialization
SetUp()177863d99982SDamjan Jovanovic void SetUp( )
1779cdf0e10cSrcweir {
1780cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
1781cdf0e10cSrcweir pTimeout->Seconds = 3;
1782cdf0e10cSrcweir pTimeout->Nanosec = 0;
1783cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1784cdf0e10cSrcweir }
1785cdf0e10cSrcweir
TearDown()178663d99982SDamjan Jovanovic void TearDown( )
1787cdf0e10cSrcweir {
1788cdf0e10cSrcweir free( pTimeout );
1789cdf0e10cSrcweir sHandle = NULL;
1790cdf0e10cSrcweir asAcceptorSocket.close( );
1791cdf0e10cSrcweir csConnectorSocket.close( );
1792cdf0e10cSrcweir }
1793cdf0e10cSrcweir }; // class getPeer
1794cdf0e10cSrcweir
TEST_F(getPeer,getPeer_001)179563d99982SDamjan Jovanovic TEST_F(getPeer, getPeer_001)
179663d99982SDamjan Jovanovic {
179763d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT );
179863d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT );
179963d99982SDamjan Jovanovic ::osl::SocketAddr saPeerSocketAddr( aHostIp2, IP_PORT_FTP );
180063d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
180163d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
180263d99982SDamjan Jovanovic /// launch server socket
180363d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
180463d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind '127.0.0.1' address failed.";
180563d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
180663d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
180763d99982SDamjan Jovanovic
180863d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
180963d99982SDamjan Jovanovic asAcceptorSocket.acceptConnection(ssConnection); /// waiting for incoming connection...
181063d99982SDamjan Jovanovic
181163d99982SDamjan Jovanovic /// launch client socket
181263d99982SDamjan Jovanovic csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
181363d99982SDamjan Jovanovic
181463d99982SDamjan Jovanovic /// get peer information
181563d99982SDamjan Jovanovic csConnectorSocket.getPeerAddr( saPeerSocketAddr );/// connected.
181663d99982SDamjan Jovanovic sal_Int32 peerPort = csConnectorSocket.getPeerPort( );
181763d99982SDamjan Jovanovic ::rtl::OUString peerHost = csConnectorSocket.getPeerHost( );
181863d99982SDamjan Jovanovic
181963d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == compareSocketAddr( saPeerSocketAddr, saLocalSocketAddr ) )&&
182063d99982SDamjan Jovanovic ( sal_True == compareUString( peerHost, saLocalSocketAddr.getHostname( 0 ) ) ) &&
182163d99982SDamjan Jovanovic ( peerPort == saLocalSocketAddr.getPort( ) )) << "test for getPeer function: setup a connection and then get the peer address, port and host from client side.";
182263d99982SDamjan Jovanovic }
1823cdf0e10cSrcweir
1824cdf0e10cSrcweir /** testing the methods:
1825cdf0e10cSrcweir inline sal_Bool SAL_CALL bind(const SocketAddr& LocalInterface);
1826cdf0e10cSrcweir */
1827cdf0e10cSrcweir
1828cdf0e10cSrcweir
182963d99982SDamjan Jovanovic class bind : public ::testing::Test
1830cdf0e10cSrcweir {
1831cdf0e10cSrcweir public:
1832cdf0e10cSrcweir oslSocket sHandle;
1833cdf0e10cSrcweir // initialization
SetUp()183463d99982SDamjan Jovanovic void SetUp( )
1835cdf0e10cSrcweir {
1836cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1837cdf0e10cSrcweir }
1838cdf0e10cSrcweir
TearDown()183963d99982SDamjan Jovanovic void TearDown( )
1840cdf0e10cSrcweir {
1841cdf0e10cSrcweir sHandle = NULL;
1842cdf0e10cSrcweir }
184363d99982SDamjan Jovanovic }; // class bind
1844cdf0e10cSrcweir
TEST_F(bind,bind_001)184563d99982SDamjan Jovanovic TEST_F(bind, bind_001)
184663d99982SDamjan Jovanovic {
184763d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
184863d99982SDamjan Jovanovic //bind must use local IP address ---mindyliu
184963d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( getLocalIP(), IP_PORT_MYPORT5 );
1850cdf0e10cSrcweir
185163d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
185263d99982SDamjan Jovanovic sal_Bool bOK1 = sSocket.bind( saBindSocketAddr );
185363d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "Socket bind fail.";
1854cdf0e10cSrcweir
185563d99982SDamjan Jovanovic sal_Bool bOK2 = compareUString( sSocket.getLocalHost( ), saBindSocketAddr.getHostname( ) ) ;
1856cdf0e10cSrcweir
185763d99982SDamjan Jovanovic sSocket.close();
185863d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "test for bind function: bind a valid address.";
185963d99982SDamjan Jovanovic }
1860cdf0e10cSrcweir
TEST_F(bind,bind_002)186163d99982SDamjan Jovanovic TEST_F(bind, bind_002)
186263d99982SDamjan Jovanovic {
186363d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
186463d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIpInval, IP_PORT_NETBIOS );
186563d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr;
1866cdf0e10cSrcweir
186763d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1); // sal_True);
186863d99982SDamjan Jovanovic sal_Bool bOK1 = sSocket.bind( saBindSocketAddr );
186963d99982SDamjan Jovanovic sal_Bool bOK2 = compareUString( sSocket.getLocalHost( ), getThisHostname( ) ) ;
1870cdf0e10cSrcweir
187163d99982SDamjan Jovanovic ASSERT_TRUE(( sal_False == bOK1 ) && ( sal_False == bOK2 )) << "test for bind function: bind a valid address.";
187263d99982SDamjan Jovanovic }
1873cdf0e10cSrcweir
1874cdf0e10cSrcweir
1875cdf0e10cSrcweir /** testing the methods:
1876cdf0e10cSrcweir inline sal_Bool SAL_CALL isRecvReady(const TimeValue *pTimeout = 0) const;
1877cdf0e10cSrcweir
1878cdf0e10cSrcweir */
187963d99982SDamjan Jovanovic class isRecvReady : public ::testing::Test
1880cdf0e10cSrcweir {
1881cdf0e10cSrcweir public:
1882cdf0e10cSrcweir oslSocket sHandle;
1883cdf0e10cSrcweir TimeValue *pTimeout;
1884cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
1885cdf0e10cSrcweir ::osl::ConnectorSocket csConnectorSocket;
1886cdf0e10cSrcweir
1887cdf0e10cSrcweir
1888cdf0e10cSrcweir // initialization
SetUp()188963d99982SDamjan Jovanovic void SetUp( )
1890cdf0e10cSrcweir {
1891cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
1892cdf0e10cSrcweir pTimeout->Seconds = 3;
1893cdf0e10cSrcweir pTimeout->Nanosec = 0;
1894cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1895cdf0e10cSrcweir }
1896cdf0e10cSrcweir
TearDown()189763d99982SDamjan Jovanovic void TearDown( )
1898cdf0e10cSrcweir {
1899cdf0e10cSrcweir free( pTimeout );
1900cdf0e10cSrcweir sHandle = NULL;
1901cdf0e10cSrcweir asAcceptorSocket.close( );
1902cdf0e10cSrcweir csConnectorSocket.close( );
1903cdf0e10cSrcweir }
1904cdf0e10cSrcweir }; // class isRecvReady
1905cdf0e10cSrcweir
TEST_F(isRecvReady,isRecvReady_001)190663d99982SDamjan Jovanovic TEST_F(isRecvReady, isRecvReady_001)
190763d99982SDamjan Jovanovic {
190863d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT1 );
190963d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT1 );
191063d99982SDamjan Jovanovic ::osl::SocketAddr saPeerSocketAddr( aHostIp2, IP_PORT_FTP );
191163d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
191263d99982SDamjan Jovanovic /// launch server socket
191363d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); // sal_True);
191463d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
191563d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
191663d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
191763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
191863d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
191963d99982SDamjan Jovanovic asAcceptorSocket.acceptConnection(ssConnection); /// waiting for incoming connection...
192063d99982SDamjan Jovanovic
192163d99982SDamjan Jovanovic /// launch client socket
192263d99982SDamjan Jovanovic csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
192363d99982SDamjan Jovanovic
192463d99982SDamjan Jovanovic /// is receive ready?
192563d99982SDamjan Jovanovic sal_Bool bOK3 = asAcceptorSocket.isRecvReady( pTimeout );
192663d99982SDamjan Jovanovic
192763d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == bOK3 )) << "test for isRecvReady function: setup a connection and then check if it can transmit data.";
192863d99982SDamjan Jovanovic }
1929cdf0e10cSrcweir
1930cdf0e10cSrcweir /** testing the methods:
1931cdf0e10cSrcweir inline sal_Bool SAL_CALL isSendReady(const TimeValue *pTimeout = 0) const;
1932cdf0e10cSrcweir */
193363d99982SDamjan Jovanovic class isSendReady : public ::testing::Test
1934cdf0e10cSrcweir {
1935cdf0e10cSrcweir public:
1936cdf0e10cSrcweir oslSocket sHandle;
1937cdf0e10cSrcweir TimeValue *pTimeout;
1938cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
1939cdf0e10cSrcweir ::osl::ConnectorSocket csConnectorSocket;
1940cdf0e10cSrcweir
1941cdf0e10cSrcweir
1942cdf0e10cSrcweir // initialization
SetUp()194363d99982SDamjan Jovanovic void SetUp( )
1944cdf0e10cSrcweir {
1945cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
1946cdf0e10cSrcweir pTimeout->Seconds = 3;
1947cdf0e10cSrcweir pTimeout->Nanosec = 0;
1948cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
1949cdf0e10cSrcweir }
1950cdf0e10cSrcweir
TearDown()195163d99982SDamjan Jovanovic void TearDown( )
1952cdf0e10cSrcweir {
1953cdf0e10cSrcweir free( pTimeout );
1954cdf0e10cSrcweir sHandle = NULL;
1955cdf0e10cSrcweir asAcceptorSocket.close( );
1956cdf0e10cSrcweir csConnectorSocket.close( );
1957cdf0e10cSrcweir }
1958cdf0e10cSrcweir }; // class isSendReady
1959cdf0e10cSrcweir
TEST_F(isSendReady,isSendReady_001)196063d99982SDamjan Jovanovic TEST_F(isSendReady, isSendReady_001)
196163d99982SDamjan Jovanovic {
196263d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT );
196363d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT );
196463d99982SDamjan Jovanovic ::osl::SocketAddr saPeerSocketAddr( aHostIp2, IP_PORT_FTP );
196563d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
196663d99982SDamjan Jovanovic
196763d99982SDamjan Jovanovic /// launch server socket
196863d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
196963d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
197063d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
197163d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
197263d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
197363d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
197463d99982SDamjan Jovanovic asAcceptorSocket.acceptConnection(ssConnection); /// waiting for incoming connection...
197563d99982SDamjan Jovanovic
197663d99982SDamjan Jovanovic /// launch client socket
197763d99982SDamjan Jovanovic csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
197863d99982SDamjan Jovanovic
197963d99982SDamjan Jovanovic /// is send ready?
198063d99982SDamjan Jovanovic sal_Bool bOK3 = csConnectorSocket.isSendReady( pTimeout );
198163d99982SDamjan Jovanovic
198263d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == bOK3 )) << "test for isSendReady function: setup a connection and then check if it can transmit data.";
198363d99982SDamjan Jovanovic }
1984cdf0e10cSrcweir
1985cdf0e10cSrcweir /** testing the methods:
1986cdf0e10cSrcweir inline oslSocketType SAL_CALL getType() const;
1987cdf0e10cSrcweir
1988cdf0e10cSrcweir */
1989cdf0e10cSrcweir
199063d99982SDamjan Jovanovic class getType : public ::testing::Test
1991cdf0e10cSrcweir {
1992cdf0e10cSrcweir public:
1993cdf0e10cSrcweir oslSocket sHandle;
1994cdf0e10cSrcweir // initialization
SetUp()199563d99982SDamjan Jovanovic void SetUp( )
1996cdf0e10cSrcweir {
1997cdf0e10cSrcweir
1998cdf0e10cSrcweir }
1999cdf0e10cSrcweir
TearDown()200063d99982SDamjan Jovanovic void TearDown( )
2001cdf0e10cSrcweir {
2002cdf0e10cSrcweir sHandle = NULL;
2003cdf0e10cSrcweir }
200463d99982SDamjan Jovanovic }; // class getType
2005cdf0e10cSrcweir
TEST_F(getType,getType_001)200663d99982SDamjan Jovanovic TEST_F(getType, getType_001)
200763d99982SDamjan Jovanovic {
200863d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
200963d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
2010cdf0e10cSrcweir
201163d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == sSocket.getType( )) << "test for getType function: get type of socket.";
201263d99982SDamjan Jovanovic }
2013cdf0e10cSrcweir
TEST_F(getType,getType_002)201463d99982SDamjan Jovanovic TEST_F(getType, getType_002)
201563d99982SDamjan Jovanovic {
201663d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeDgram, osl_Socket_ProtocolIp );
201763d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
2018cdf0e10cSrcweir
201963d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeDgram == sSocket.getType( )) << "test for getType function: get type of socket.";
202063d99982SDamjan Jovanovic }
2021cdf0e10cSrcweir
2022cdf0e10cSrcweir #ifdef UNX
202363d99982SDamjan Jovanovic // mindy: since on LINUX and SOLARIS, Raw type socket can not be created, so do not test getType() here
202463d99982SDamjan Jovanovic // mindy: and add one test case to test creating Raw type socket--> ctors_TypeRaw()
TEST_F(getType,getType_003)202563d99982SDamjan Jovanovic TEST_F(getType, getType_003)
202663d99982SDamjan Jovanovic {
202763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True) << "test for getType function: get type of socket.this is not passed in (LINUX, SOLARIS), the osl_Socket_TypeRaw, type socket can not be created.";
202863d99982SDamjan Jovanovic }
2029cdf0e10cSrcweir #else
TEST_F(getType,getType_003)203063d99982SDamjan Jovanovic TEST_F(getType, getType_003)
203163d99982SDamjan Jovanovic {
203263d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeRaw, osl_Socket_ProtocolIp );
203363d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
2034cdf0e10cSrcweir
203563d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeRaw == sSocket.getType( )) << "test for getType function: get type of socket.";
203663d99982SDamjan Jovanovic }
2037cdf0e10cSrcweir #endif
2038cdf0e10cSrcweir
2039cdf0e10cSrcweir
2040cdf0e10cSrcweir /** testing the methods:
2041cdf0e10cSrcweir inline sal_Int32 SAL_CALL getOption(
2042cdf0e10cSrcweir oslSocketOption Option,
2043cdf0e10cSrcweir void* pBuffer,
2044cdf0e10cSrcweir sal_uInt32 BufferLen,
2045cdf0e10cSrcweir oslSocketOptionLevel Level= osl_Socket_LevelSocket) const;
2046cdf0e10cSrcweir
2047cdf0e10cSrcweir inline sal_Int32 getOption( oslSocketOption option ) const;
2048cdf0e10cSrcweir
2049cdf0e10cSrcweir */
2050cdf0e10cSrcweir
205163d99982SDamjan Jovanovic class getOption : public ::testing::Test
2052cdf0e10cSrcweir {
2053cdf0e10cSrcweir public:
2054cdf0e10cSrcweir oslSocket sHandle;
2055cdf0e10cSrcweir // initialization
SetUp()205663d99982SDamjan Jovanovic void SetUp( )
2057cdf0e10cSrcweir {
2058cdf0e10cSrcweir
2059cdf0e10cSrcweir }
2060cdf0e10cSrcweir
TearDown()206163d99982SDamjan Jovanovic void TearDown( )
2062cdf0e10cSrcweir {
2063cdf0e10cSrcweir sHandle = NULL;
2064cdf0e10cSrcweir }
206563d99982SDamjan Jovanovic }; // class getOption
2066cdf0e10cSrcweir
206763d99982SDamjan Jovanovic /** test writer's comment:
2068cdf0e10cSrcweir
206963d99982SDamjan Jovanovic in oslSocketOption, the osl_Socket_OptionType denote 1 as osl_Socket_TypeStream.
207063d99982SDamjan Jovanovic 2 as osl_Socket_TypeDgram, etc which is not mapping the oslSocketType enum. differ
207163d99982SDamjan Jovanovic in 1.
207263d99982SDamjan Jovanovic */
2073cdf0e10cSrcweir
TEST_F(getOption,getOption_001)207463d99982SDamjan Jovanovic TEST_F(getOption, getOption_001)
207563d99982SDamjan Jovanovic {
207663d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
207763d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
207863d99982SDamjan Jovanovic sal_Int32 * pType = ( sal_Int32 * )malloc( sizeof ( sal_Int32 ) );
207963d99982SDamjan Jovanovic *pType = 0;
208063d99982SDamjan Jovanovic sSocket.getOption( osl_Socket_OptionType, pType, sizeof ( sal_Int32 ) );
208163d99982SDamjan Jovanovic sal_Bool bOK = ( SOCK_STREAM == *pType );
208263d99982SDamjan Jovanovic // there is a TypeMap(socket.c) which map osl_Socket_TypeStream to SOCK_STREAM on UNX, and SOCK_STREAM != osl_Socket_TypeStream
208363d99982SDamjan Jovanovic //sal_Bool bOK = ( TYPE_TO_NATIVE(osl_Socket_TypeStream) == *pType );
208463d99982SDamjan Jovanovic free( pType );
208563d99982SDamjan Jovanovic
208663d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for getOption function: get type option of socket.";
208763d99982SDamjan Jovanovic }
2088cdf0e10cSrcweir
208963d99982SDamjan Jovanovic // getsockopt error
TEST_F(getOption,getOption_004)209063d99982SDamjan Jovanovic TEST_F(getOption, getOption_004)
209163d99982SDamjan Jovanovic {
209263d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeDgram, osl_Socket_ProtocolIp );
209363d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
2094cdf0e10cSrcweir
209563d99982SDamjan Jovanovic sal_Bool * pbDontRoute = ( sal_Bool * )malloc( sizeof ( sal_Bool ) );
209663d99982SDamjan Jovanovic sal_Int32 nRes = sSocket.getOption( osl_Socket_OptionInvalid, pbDontRoute, sizeof ( sal_Bool ) );
209763d99982SDamjan Jovanovic free( pbDontRoute );
2098cdf0e10cSrcweir
209963d99982SDamjan Jovanovic ASSERT_TRUE(nRes == -1) << "test for getOption function: get invalid option of socket, should return -1.";
210063d99982SDamjan Jovanovic }
2101cdf0e10cSrcweir
TEST_F(getOption,getOption_simple_001)210263d99982SDamjan Jovanovic TEST_F(getOption, getOption_simple_001)
210363d99982SDamjan Jovanovic {
210463d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeDgram, osl_Socket_ProtocolIp );
210563d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
2106cdf0e10cSrcweir
210763d99982SDamjan Jovanovic sal_Bool bOK = ( sal_False == sSocket.getOption( osl_Socket_OptionDontRoute ) );
2108cdf0e10cSrcweir
210963d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for getOption function: get debug option of socket.";
211063d99982SDamjan Jovanovic }
2111cdf0e10cSrcweir
TEST_F(getOption,getOption_simple_002)211263d99982SDamjan Jovanovic TEST_F(getOption, getOption_simple_002)
211363d99982SDamjan Jovanovic {
211463d99982SDamjan Jovanovic sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeDgram, osl_Socket_ProtocolIp );
211563d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
2116cdf0e10cSrcweir
211763d99982SDamjan Jovanovic sal_Bool bOK = ( sal_False == sSocket.getOption( osl_Socket_OptionDebug ) );
2118cdf0e10cSrcweir
211963d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for getOption function: get debug option of socket.";
212063d99982SDamjan Jovanovic }
2121cdf0e10cSrcweir
2122cdf0e10cSrcweir /** testing the methods:
2123cdf0e10cSrcweir inline sal_Bool SAL_CALL setOption( oslSocketOption Option,
2124cdf0e10cSrcweir void* pBuffer,
2125cdf0e10cSrcweir sal_uInt32 BufferLen,
2126cdf0e10cSrcweir oslSocketOptionLevel Level= osl_Socket_LevelSocket ) const;
2127cdf0e10cSrcweir */
2128cdf0e10cSrcweir
212963d99982SDamjan Jovanovic class setOption : public ::testing::Test
2130cdf0e10cSrcweir {
2131cdf0e10cSrcweir public:
2132cdf0e10cSrcweir TimeValue *pTimeout;
2133cdf0e10cSrcweir // LLA: maybe there is an error in the source,
2134cdf0e10cSrcweir // as long as I remember, if a derived class do not overload all ctors there is a problem.
2135cdf0e10cSrcweir
2136cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
2137cdf0e10cSrcweir
SetUp()213863d99982SDamjan Jovanovic void SetUp( )
2139cdf0e10cSrcweir {
2140cdf0e10cSrcweir
2141cdf0e10cSrcweir }
2142cdf0e10cSrcweir
TearDown()214363d99982SDamjan Jovanovic void TearDown( )
2144cdf0e10cSrcweir {
2145cdf0e10cSrcweir asAcceptorSocket.close( );
2146cdf0e10cSrcweir }
214763d99982SDamjan Jovanovic }; // class setOption
2148cdf0e10cSrcweir
214963d99982SDamjan Jovanovic // LLA:
215063d99982SDamjan Jovanovic // getSocketOption returns BufferLen, or -1 if something failed
2151cdf0e10cSrcweir
215263d99982SDamjan Jovanovic // setSocketOption returns sal_True, if option could stored
215363d99982SDamjan Jovanovic // else sal_False
2154cdf0e10cSrcweir
TEST_F(setOption,setOption_001)215563d99982SDamjan Jovanovic TEST_F(setOption, setOption_001)
215663d99982SDamjan Jovanovic {
215763d99982SDamjan Jovanovic /// set and get option.
215863d99982SDamjan Jovanovic int nBufferLen = sizeof ( sal_Int32);
215963d99982SDamjan Jovanovic // LLA: SO_DONTROUTE expect an integer boolean, what ever it is, it's not sal_Bool!
216063d99982SDamjan Jovanovic
216163d99982SDamjan Jovanovic sal_Int32 * pbDontRouteSet = ( sal_Int32 * )malloc( sizeof ( sal_Int32 ) );
216263d99982SDamjan Jovanovic *pbDontRouteSet = 1; // sal_True;
216363d99982SDamjan Jovanovic
216463d99982SDamjan Jovanovic sal_Int32 * pGetBuffer = ( sal_Int32 * )malloc( sizeof ( sal_Int32 ) );
216563d99982SDamjan Jovanovic *pGetBuffer = 0;
216663d99982SDamjan Jovanovic
216763d99982SDamjan Jovanovic // maybe asAcceptorSocket is not right initialized
216863d99982SDamjan Jovanovic sal_Bool b1 = asAcceptorSocket.setOption( osl_Socket_OptionDontRoute, pbDontRouteSet, nBufferLen );
216963d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == b1 )) << "setOption function failed.";
217063d99982SDamjan Jovanovic sal_Int32 n2 = asAcceptorSocket.getOption( osl_Socket_OptionDontRoute, pGetBuffer, nBufferLen );
217163d99982SDamjan Jovanovic ASSERT_TRUE(( n2 == nBufferLen )) << "getOption function failed.";
217263d99982SDamjan Jovanovic
217363d99982SDamjan Jovanovic // on Linux, the value of option is 1, on Solaris, it's 16, but it's not important the exact value,
217463d99982SDamjan Jovanovic // just judge it is zero or not!
217563d99982SDamjan Jovanovic sal_Bool bOK = ( 0 != *pGetBuffer );
217663d99982SDamjan Jovanovic printf("#setOption_001: getOption is %d \n", *pGetBuffer);
217763d99982SDamjan Jovanovic
217863d99982SDamjan Jovanovic // toggle check, set to 0
217963d99982SDamjan Jovanovic *pbDontRouteSet = 0;
218063d99982SDamjan Jovanovic
218163d99982SDamjan Jovanovic sal_Bool b3 = asAcceptorSocket.setOption( osl_Socket_OptionDontRoute, pbDontRouteSet, sizeof ( sal_Int32 ) );
218263d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == b3 )) << "setOption function failed.";
218363d99982SDamjan Jovanovic sal_Int32 n4 = asAcceptorSocket.getOption( osl_Socket_OptionDontRoute, pGetBuffer, nBufferLen );
218463d99982SDamjan Jovanovic ASSERT_TRUE(( n4 == nBufferLen )) << "getOption (DONTROUTE) function failed.";
218563d99982SDamjan Jovanovic
218663d99982SDamjan Jovanovic sal_Bool bOK2 = ( 0 == *pGetBuffer );
218763d99982SDamjan Jovanovic
218863d99982SDamjan Jovanovic printf("#setOption_001: getOption is %d \n", *pGetBuffer);
218963d99982SDamjan Jovanovic
219063d99982SDamjan Jovanovic // LLA: sal_Bool * pbDontTouteSet = ( sal_Bool * )malloc( sizeof ( sal_Bool ) );
219163d99982SDamjan Jovanovic // LLA: *pbDontTouteSet = sal_True;
219263d99982SDamjan Jovanovic // LLA: sal_Bool * pbDontTouteGet = ( sal_Bool * )malloc( sizeof ( sal_Bool ) );
219363d99982SDamjan Jovanovic // LLA: *pbDontTouteGet = sal_False;
219463d99982SDamjan Jovanovic // LLA: asAcceptorSocket.setOption( osl_Socket_OptionDontRoute, pbDontTouteSet, sizeof ( sal_Bool ) );
219563d99982SDamjan Jovanovic // LLA: asAcceptorSocket.getOption( osl_Socket_OptionDontRoute, pbDontTouteGet, sizeof ( sal_Bool ) );
219663d99982SDamjan Jovanovic // LLA: ::rtl::OUString suError = outputError(::rtl::OUString::valueOf((sal_Int32)*pbDontTouteGet),
219763d99982SDamjan Jovanovic // LLA: ::rtl::OUString::valueOf((sal_Int32)*pbDontTouteSet),
219863d99982SDamjan Jovanovic // LLA: "test for setOption function: set osl_Socket_OptionDontRoute and then check");
219963d99982SDamjan Jovanovic // LLA:
220063d99982SDamjan Jovanovic // LLA: sal_Bool bOK = ( sal_True == *pbDontTouteGet );
220163d99982SDamjan Jovanovic // LLA: free( pbDontTouteSet );
220263d99982SDamjan Jovanovic // LLA: free( pbDontTouteGet );
2203cdf0e10cSrcweir
220463d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == bOK ) && (sal_True == bOK2)) << "test for setOption function: set option of a socket and then check.";
2205cdf0e10cSrcweir
220663d99982SDamjan Jovanovic free( pbDontRouteSet );
220763d99982SDamjan Jovanovic free( pGetBuffer );
220863d99982SDamjan Jovanovic // LLA: ASSERT_TRUE(sal_True == bOK) << suError;
220963d99982SDamjan Jovanovic }
2210cdf0e10cSrcweir
TEST_F(setOption,setOption_002)221163d99982SDamjan Jovanovic TEST_F(setOption, setOption_002)
221263d99982SDamjan Jovanovic {
221363d99982SDamjan Jovanovic /// set and get option.
2214cdf0e10cSrcweir
221563d99982SDamjan Jovanovic // sal_Int32 * pbLingerSet = ( sal_Int32 * )malloc( nBufferLen );
221663d99982SDamjan Jovanovic // *pbLingerSet = 7;
221763d99982SDamjan Jovanovic // sal_Int32 * pbLingerGet = ( sal_Int32 * )malloc( nBufferLen );
221863d99982SDamjan Jovanovic /* struct */linger aLingerSet;
221963d99982SDamjan Jovanovic sal_Int32 nBufferLen = sizeof( struct linger );
222063d99982SDamjan Jovanovic aLingerSet.l_onoff = 1;
222163d99982SDamjan Jovanovic aLingerSet.l_linger = 7;
2222cdf0e10cSrcweir
222363d99982SDamjan Jovanovic linger aLingerGet;
2224cdf0e10cSrcweir
222563d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionLinger, &aLingerSet, nBufferLen );
2226cdf0e10cSrcweir
222763d99982SDamjan Jovanovic sal_Int32 n1 = asAcceptorSocket.getOption( osl_Socket_OptionLinger, &aLingerGet, nBufferLen );
222863d99982SDamjan Jovanovic ASSERT_TRUE(( n1 == nBufferLen )) << "getOption (SO_LINGER) function failed.";
2229cdf0e10cSrcweir
223063d99982SDamjan Jovanovic //printf("#setOption_002: getOption is %d \n", aLingerGet.l_linger);
223163d99982SDamjan Jovanovic sal_Bool bOK = ( 7 == aLingerGet.l_linger );
223263d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK) << "test for setOption function: set option of a socket and then check. ";
2233cdf0e10cSrcweir
223463d99982SDamjan Jovanovic }
2235cdf0e10cSrcweir
TEST_F(setOption,setOption_003)223663d99982SDamjan Jovanovic TEST_F(setOption, setOption_003)
223763d99982SDamjan Jovanovic {
223863d99982SDamjan Jovanovic linger aLingerSet;
223963d99982SDamjan Jovanovic aLingerSet.l_onoff = 1;
224063d99982SDamjan Jovanovic aLingerSet.l_linger = 7;
2241cdf0e10cSrcweir
224263d99982SDamjan Jovanovic sal_Bool b1 = asAcceptorSocket.setOption( osl_Socket_OptionLinger, &aLingerSet, 0 );
224363d99982SDamjan Jovanovic printUString( asAcceptorSocket.getErrorAsString() );
224463d99982SDamjan Jovanovic ASSERT_TRUE(( b1 == sal_False )) << "setOption (SO_LINGER) function failed for optlen is 0.";
224563d99982SDamjan Jovanovic }
2246cdf0e10cSrcweir
TEST_F(setOption,setOption_simple_001)224763d99982SDamjan Jovanovic TEST_F(setOption, setOption_simple_001)
224863d99982SDamjan Jovanovic {
224963d99982SDamjan Jovanovic /// set and get option.
225063d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionDontRoute, 1 ); //sal_True );
225163d99982SDamjan Jovanovic sal_Bool bOK = ( 0 != asAcceptorSocket.getOption( osl_Socket_OptionDontRoute ) );
2252cdf0e10cSrcweir
225363d99982SDamjan Jovanovic printf("setOption_simple_001(): getoption is %d \n", asAcceptorSocket.getOption( osl_Socket_OptionDontRoute ) );
225463d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == bOK )) << "test for setOption function: set option of a socket and then check.";
225563d99982SDamjan Jovanovic }
2256cdf0e10cSrcweir
TEST_F(setOption,setOption_simple_002)225763d99982SDamjan Jovanovic TEST_F(setOption, setOption_simple_002)
225863d99982SDamjan Jovanovic {
225963d99982SDamjan Jovanovic /// set and get option.
226063d99982SDamjan Jovanovic // LLA: this does not work, due to the fact that SO_LINGER is a structure
226163d99982SDamjan Jovanovic // LLA: asAcceptorSocket.setOption( osl_Socket_OptionLinger, 7 );
226263d99982SDamjan Jovanovic // LLA: sal_Bool bOK = ( 7 == asAcceptorSocket.getOption( osl_Socket_OptionLinger ) );
2263cdf0e10cSrcweir
226463d99982SDamjan Jovanovic // LLA: ASSERT_TRUE(// LLA: ( sal_True == bOK )) << "test for setOption function: set option of a socket and then check.";
226563d99982SDamjan Jovanovic }
2266cdf0e10cSrcweir
2267cdf0e10cSrcweir
2268cdf0e10cSrcweir /** testing the method:
2269cdf0e10cSrcweir inline sal_Bool SAL_CALL enableNonBlockingMode( sal_Bool bNonBlockingMode);
2270cdf0e10cSrcweir */
227163d99982SDamjan Jovanovic class enableNonBlockingMode : public ::testing::Test
2272cdf0e10cSrcweir {
2273cdf0e10cSrcweir public:
2274cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
2275cdf0e10cSrcweir }; // class enableNonBlockingMode
2276cdf0e10cSrcweir
TEST_F(enableNonBlockingMode,enableNonBlockingMode_001)227763d99982SDamjan Jovanovic TEST_F(enableNonBlockingMode, enableNonBlockingMode_001)
227863d99982SDamjan Jovanovic {
227963d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT );
228063d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
228163d99982SDamjan Jovanovic
228263d99982SDamjan Jovanovic /// launch server socket
228363d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
228463d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
228563d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
228663d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
228763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
228863d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
228963d99982SDamjan Jovanovic asAcceptorSocket.acceptConnection(ssConnection); /// waiting for incoming connection...
229063d99982SDamjan Jovanovic
229163d99982SDamjan Jovanovic /// if reach this statement, it is non-blocking mode, since acceptConnection will blocked by default.
229263d99982SDamjan Jovanovic sal_Bool bOK = sal_True;
229363d99982SDamjan Jovanovic asAcceptorSocket.close( );
229463d99982SDamjan Jovanovic
229563d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == bOK )) << "test for enableNonBlockingMode function: launch a server socket and make it non blocking. if it can pass the acceptConnection statement, it is non-blocking";
229663d99982SDamjan Jovanovic }
2297cdf0e10cSrcweir
2298cdf0e10cSrcweir /** testing the method:
2299cdf0e10cSrcweir inline sal_Bool SAL_CALL isNonBlockingMode() const;
2300cdf0e10cSrcweir */
230163d99982SDamjan Jovanovic class isNonBlockingMode : public ::testing::Test
2302cdf0e10cSrcweir {
2303cdf0e10cSrcweir public:
2304cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
230563d99982SDamjan Jovanovic }; // class isNonBlockingMode
2306cdf0e10cSrcweir
TEST_F(isNonBlockingMode,isNonBlockingMode_001)230763d99982SDamjan Jovanovic TEST_F(isNonBlockingMode, isNonBlockingMode_001)
230863d99982SDamjan Jovanovic {
230963d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT );
231063d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
2311cdf0e10cSrcweir
231263d99982SDamjan Jovanovic /// launch server socket
231363d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); // sal_True);
231463d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
231563d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
231663d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
231763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
2318cdf0e10cSrcweir
231963d99982SDamjan Jovanovic sal_Bool bOK3 = asAcceptorSocket.isNonBlockingMode( );
232063d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
232163d99982SDamjan Jovanovic asAcceptorSocket.acceptConnection(ssConnection); /// waiting for incoming connection...
2322cdf0e10cSrcweir
232363d99982SDamjan Jovanovic /// if reach this statement, it is non-blocking mode, since acceptConnection will blocked by default.
232463d99982SDamjan Jovanovic sal_Bool bOK4 = asAcceptorSocket.isNonBlockingMode( );
232563d99982SDamjan Jovanovic asAcceptorSocket.close( );
2326cdf0e10cSrcweir
232763d99982SDamjan Jovanovic ASSERT_TRUE(( sal_False == bOK3 ) && ( sal_True == bOK4 )) << "test for isNonBlockingMode function: launch a server socket and make it non blocking. it is expected to change from blocking mode to non-blocking mode.";
232863d99982SDamjan Jovanovic }
2329cdf0e10cSrcweir
2330cdf0e10cSrcweir /** testing the method:
2331cdf0e10cSrcweir inline void SAL_CALL clearError() const;
2332cdf0e10cSrcweir */
233363d99982SDamjan Jovanovic class clearError : public ::testing::Test
2334cdf0e10cSrcweir {
2335cdf0e10cSrcweir public:
2336cdf0e10cSrcweir oslSocket sHandle;
2337cdf0e10cSrcweir // initialization
SetUp()233863d99982SDamjan Jovanovic void SetUp( )
2339cdf0e10cSrcweir {
2340cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
2341cdf0e10cSrcweir }
2342cdf0e10cSrcweir
TearDown()234363d99982SDamjan Jovanovic void TearDown( )
2344cdf0e10cSrcweir {
2345cdf0e10cSrcweir sHandle = NULL;
2346cdf0e10cSrcweir }
2347cdf0e10cSrcweir }; // class clearError
2348cdf0e10cSrcweir
TEST_F(clearError,clearError_001)234963d99982SDamjan Jovanovic TEST_F(clearError, clearError_001)
235063d99982SDamjan Jovanovic {
235163d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
235263d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIpInval, IP_PORT_HTTP2 );
235363d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr;
235463d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
235563d99982SDamjan Jovanovic sSocket.bind( saBindSocketAddr );//build an error "osl_Socket_E_AddrNotAvail"
235663d99982SDamjan Jovanovic oslSocketError seBind = sSocket.getError( );
235763d99982SDamjan Jovanovic sSocket.clearError( );
235863d99982SDamjan Jovanovic
235963d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_E_None == sSocket.getError( ) && seBind != osl_Socket_E_None) << "test for clearError function: trick an error called sSocket.getError( ), and then clear the error states, check the result.";
236063d99982SDamjan Jovanovic }
2361cdf0e10cSrcweir
2362cdf0e10cSrcweir /** testing the methods:
2363cdf0e10cSrcweir inline oslSocketError getError() const;
2364cdf0e10cSrcweir inline ::rtl::OUString getErrorAsString( ) const;
2365cdf0e10cSrcweir */
236663d99982SDamjan Jovanovic class getError : public ::testing::Test
2367cdf0e10cSrcweir {
2368cdf0e10cSrcweir public:
2369cdf0e10cSrcweir oslSocket sHandle;
2370cdf0e10cSrcweir // initialization
SetUp()237163d99982SDamjan Jovanovic void SetUp( )
2372cdf0e10cSrcweir {
2373cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
2374cdf0e10cSrcweir }
2375cdf0e10cSrcweir
TearDown()237663d99982SDamjan Jovanovic void TearDown( )
2377cdf0e10cSrcweir {
2378cdf0e10cSrcweir sHandle = NULL;
2379cdf0e10cSrcweir }
238063d99982SDamjan Jovanovic }; // class getError
2381cdf0e10cSrcweir
TEST_F(getError,getError_001)238263d99982SDamjan Jovanovic TEST_F(getError, getError_001)
238363d99982SDamjan Jovanovic {
238463d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
238563d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIp1, IP_PORT_FTP );
238663d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr;
2387cdf0e10cSrcweir
238863d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_E_None == sSocket.getError( )) << "test for getError function: should get no error.";
238963d99982SDamjan Jovanovic }
2390cdf0e10cSrcweir
TEST_F(getError,getError_002)239163d99982SDamjan Jovanovic TEST_F(getError, getError_002)
239263d99982SDamjan Jovanovic {
239363d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
239463d99982SDamjan Jovanovic ::osl::SocketAddr saBindSocketAddr( aHostIpInval, IP_PORT_FTP );
239563d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr;
239663d99982SDamjan Jovanovic sSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
239763d99982SDamjan Jovanovic sSocket.bind( saBindSocketAddr );//build an error "osl_Socket_E_AddrNotAvail"
239863d99982SDamjan Jovanovic //on Solaris, the error no is EACCES, but it has no mapped value, so getError() returned osl_Socket_E_InvalidError.
2399cdf0e10cSrcweir #if defined(SOLARIS)
240063d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_E_InvalidError == sSocket.getError( )) << "trick an error called sSocket.getError( ), check the getError result.Failed on Solaris, returned osl_Socket_E_InvalidError because no entry to map the errno EACCES. ";
2401cdf0e10cSrcweir #else
240263d99982SDamjan Jovanovic //while on Linux & Win32, the errno is EADDRNOTAVAIL, getError returned osl_Socket_E_AddrNotAvail.
2403cdf0e10cSrcweir
240463d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_E_AddrNotAvail == sSocket.getError( )) << "trick an error called sSocket.getError( ), check the getError result.Failed on Solaris, returned osl_Socket_E_InvalidError because no entry to map the errno EACCES. Passed on Linux & Win32";
2405cdf0e10cSrcweir #endif
240663d99982SDamjan Jovanovic }
2407cdf0e10cSrcweir
2408cdf0e10cSrcweir
2409cdf0e10cSrcweir /** testing the methods:
2410cdf0e10cSrcweir inline oslSocket getHandle() const;
2411cdf0e10cSrcweir */
2412cdf0e10cSrcweir
241363d99982SDamjan Jovanovic class getHandle : public ::testing::Test
2414cdf0e10cSrcweir {
2415cdf0e10cSrcweir public:
2416cdf0e10cSrcweir oslSocket sHandle;
2417cdf0e10cSrcweir // initialization
SetUp()241863d99982SDamjan Jovanovic void SetUp( )
2419cdf0e10cSrcweir {
2420cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
2421cdf0e10cSrcweir }
2422cdf0e10cSrcweir
TearDown()242363d99982SDamjan Jovanovic void TearDown( )
2424cdf0e10cSrcweir {
2425cdf0e10cSrcweir sHandle = NULL;
2426cdf0e10cSrcweir }
242763d99982SDamjan Jovanovic }; // class getHandle
2428cdf0e10cSrcweir
2429cdf0e10cSrcweir
TEST_F(getHandle,getHandle_001)243063d99982SDamjan Jovanovic TEST_F(getHandle, getHandle_001)
243163d99982SDamjan Jovanovic {
243263d99982SDamjan Jovanovic ::osl::Socket sSocket(sHandle);
243363d99982SDamjan Jovanovic ::osl::Socket assignSocket = sSocket.getHandle();
2434cdf0e10cSrcweir
243563d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == assignSocket.getType( )) << "test for operators_assignment_handle function: test the assignment operator.";
243663d99982SDamjan Jovanovic }
2437cdf0e10cSrcweir
TEST_F(getHandle,getHandle_002)243863d99982SDamjan Jovanovic TEST_F(getHandle, getHandle_002)
243963d99982SDamjan Jovanovic {
244063d99982SDamjan Jovanovic ::osl::Socket sSocket( sHandle );
244163d99982SDamjan Jovanovic ::osl::Socket assignSocket ( sSocket.getHandle( ) );
2442cdf0e10cSrcweir
244363d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == assignSocket.getType( )) << "test for operators_assignment function: assignment operator";
244463d99982SDamjan Jovanovic }
2445cdf0e10cSrcweir
2446cdf0e10cSrcweir
2447cdf0e10cSrcweir } // namespace osl_Socket
2448cdf0e10cSrcweir
2449cdf0e10cSrcweir
2450cdf0e10cSrcweir
2451cdf0e10cSrcweir namespace osl_StreamSocket
2452cdf0e10cSrcweir {
2453cdf0e10cSrcweir
2454cdf0e10cSrcweir /** testing the methods:
2455cdf0e10cSrcweir inline StreamSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
2456cdf0e10cSrcweir oslProtocol Protocol = osl_Socket_ProtocolIp,
2457cdf0e10cSrcweir oslSocketType Type = osl_Socket_TypeStream);
2458cdf0e10cSrcweir
2459cdf0e10cSrcweir inline StreamSocket( const StreamSocket & );
2460cdf0e10cSrcweir
2461cdf0e10cSrcweir inline StreamSocket( oslSocket Socket , __sal_NoAcquire noacquire );
2462cdf0e10cSrcweir
2463cdf0e10cSrcweir inline StreamSocket( oslSocket Socket );
2464cdf0e10cSrcweir */
2465cdf0e10cSrcweir
246663d99982SDamjan Jovanovic class OslStreamSocketCtors : public ::testing::Test
2467cdf0e10cSrcweir {
2468cdf0e10cSrcweir public:
2469cdf0e10cSrcweir oslSocket sHandle;
2470cdf0e10cSrcweir // initialization
SetUp()247163d99982SDamjan Jovanovic void SetUp( )
2472cdf0e10cSrcweir {
2473cdf0e10cSrcweir sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
2474cdf0e10cSrcweir }
2475cdf0e10cSrcweir
TearDown()247663d99982SDamjan Jovanovic void TearDown( )
2477cdf0e10cSrcweir {
2478cdf0e10cSrcweir sHandle = NULL;
2479cdf0e10cSrcweir }
248063d99982SDamjan Jovanovic }; // class ctors
2481cdf0e10cSrcweir
TEST_F(OslStreamSocketCtors,ctors_none)248263d99982SDamjan Jovanovic TEST_F(OslStreamSocketCtors, ctors_none)
248363d99982SDamjan Jovanovic {
248463d99982SDamjan Jovanovic /// Socket constructor.
248563d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
2486cdf0e10cSrcweir
248763d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == ssSocket.getType( )) << "test for ctors_none constructor function: check if the stream socket was created successfully.";
248863d99982SDamjan Jovanovic }
2489cdf0e10cSrcweir
TEST_F(OslStreamSocketCtors,ctors_acquire)249063d99982SDamjan Jovanovic TEST_F(OslStreamSocketCtors, ctors_acquire)
249163d99982SDamjan Jovanovic {
249263d99982SDamjan Jovanovic /// Socket constructor.
249363d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( sHandle );
2494cdf0e10cSrcweir
249563d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == ssSocket.getType( )) << "test for ctors_acquire constructor function: check if the socket was created successfully";
249663d99982SDamjan Jovanovic }
2497cdf0e10cSrcweir
TEST_F(OslStreamSocketCtors,ctors_no_acquire)249863d99982SDamjan Jovanovic TEST_F(OslStreamSocketCtors, ctors_no_acquire)
249963d99982SDamjan Jovanovic {
250063d99982SDamjan Jovanovic /// Socket constructor.
250163d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( sHandle, SAL_NO_ACQUIRE );
2502cdf0e10cSrcweir
250363d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == ssSocket.getType( )) << " test for ctors_no_acquire constructor function: check if the socket was created successfully";
250463d99982SDamjan Jovanovic }
2505cdf0e10cSrcweir
TEST_F(OslStreamSocketCtors,ctors_copy_ctor)250663d99982SDamjan Jovanovic TEST_F(OslStreamSocketCtors, ctors_copy_ctor)
250763d99982SDamjan Jovanovic {
250863d99982SDamjan Jovanovic /// Socket constructor.
250963d99982SDamjan Jovanovic ::osl::StreamSocket ssSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
251063d99982SDamjan Jovanovic /// Socket copy constructor.
251163d99982SDamjan Jovanovic ::osl::StreamSocket copySocket( ssSocket );
2512cdf0e10cSrcweir
251363d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == copySocket.getType( )) << " test for ctors_copy_ctor constructor function: create new Socket instance using copy constructor";
251463d99982SDamjan Jovanovic }
2515cdf0e10cSrcweir
251663d99982SDamjan Jovanovic class send_recv: public ::testing::Test
2517cdf0e10cSrcweir {
2518cdf0e10cSrcweir public:
2519cdf0e10cSrcweir // initialization
SetUp()252063d99982SDamjan Jovanovic void SetUp( )
2521cdf0e10cSrcweir {
2522cdf0e10cSrcweir }
2523cdf0e10cSrcweir
TearDown()252463d99982SDamjan Jovanovic void TearDown( )
2525cdf0e10cSrcweir {
2526cdf0e10cSrcweir
2527cdf0e10cSrcweir }
2528cdf0e10cSrcweir
write_read(sal_Int32 _nBufferSize,int _nValue)252963d99982SDamjan Jovanovic void write_read(sal_Int32 _nBufferSize, int _nValue)
253063d99982SDamjan Jovanovic {
253163d99982SDamjan Jovanovic //client sent two strings, and server received, check the order and value
253263d99982SDamjan Jovanovic WriteSocketThread myServerThread(_nBufferSize, _nValue);
253363d99982SDamjan Jovanovic ReadSocketThread myClientThread(_nBufferSize, _nValue);
253463d99982SDamjan Jovanovic myServerThread.create( );
253563d99982SDamjan Jovanovic // thread_sleep( 1 );
253663d99982SDamjan Jovanovic myClientThread.create( );
2537cdf0e10cSrcweir
253863d99982SDamjan Jovanovic //wait until the thread terminate
253963d99982SDamjan Jovanovic myClientThread.join( );
254063d99982SDamjan Jovanovic myServerThread.join( );
2541cdf0e10cSrcweir
254263d99982SDamjan Jovanovic //Maximum Packet Size is ( ARPANET, MILNET = 1007 Ethernet (10Mb) = 1500
254363d99982SDamjan Jovanovic // Proteon PRONET = 2046), so here test read 4000 bytes
254463d99982SDamjan Jovanovic sal_Int32 nLength = myClientThread.getCount();
254563d99982SDamjan Jovanovic bool bIsOk = myClientThread.isOk(); // check if the values are right.
2546cdf0e10cSrcweir
254763d99982SDamjan Jovanovic printf("Length:=%d\n", nLength);
254863d99982SDamjan Jovanovic printf(" bIsOk:=%d\n", bIsOk);
2549cdf0e10cSrcweir
255063d99982SDamjan Jovanovic ASSERT_TRUE(nLength == _nBufferSize && bIsOk == true) << " test for write/read values with two threads: send data from server, check readed data in client.";
255163d99982SDamjan Jovanovic }
2552cdf0e10cSrcweir }; // class send_recv
2553cdf0e10cSrcweir
TEST_F(send_recv,send_recv1)255463d99982SDamjan Jovanovic TEST_F(send_recv, send_recv1)
255563d99982SDamjan Jovanovic {
255663d99982SDamjan Jovanovic //client sent two strings, and server received, check the order and value
255763d99982SDamjan Jovanovic ServerSocketThread myServerThread;
255863d99982SDamjan Jovanovic ClientSocketThread myClientThread;
255963d99982SDamjan Jovanovic myServerThread.create( );
256063d99982SDamjan Jovanovic myClientThread.create( );
256163d99982SDamjan Jovanovic
256263d99982SDamjan Jovanovic //wait until the thread terminate
256363d99982SDamjan Jovanovic myClientThread.join( );
256463d99982SDamjan Jovanovic myServerThread.join( );
256563d99982SDamjan Jovanovic sal_Char myStr[30] = "";
256663d99982SDamjan Jovanovic strcat( myStr, pTestString1 );
256763d99982SDamjan Jovanovic strcat( myStr, pTestString2 );
256863d99982SDamjan Jovanovic sal_Int32 nRes = strcmp( myServerThread.pReadBuffer, myStr );
256963d99982SDamjan Jovanovic ASSERT_TRUE(nRes == 0) << " test for send/recv with two threads: launch Server/Client threads, send data from client, check received data in Server thread.";
257063d99982SDamjan Jovanovic }
257163d99982SDamjan Jovanovic
257263d99982SDamjan Jovanovic // error when recv
TEST_F(send_recv,send_recv2)257363d99982SDamjan Jovanovic TEST_F(send_recv, send_recv2)
257463d99982SDamjan Jovanovic {
257563d99982SDamjan Jovanovic ::osl::AcceptorSocket asAcceptorSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
257663d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT9 );
257763d99982SDamjan Jovanovic ::osl::StreamSocket ssStreamConnection;
257863d99982SDamjan Jovanovic sal_Char pReadBuffer[30] = "";
257963d99982SDamjan Jovanovic
258063d99982SDamjan Jovanovic ClientSocketThread myClientThread;
258163d99982SDamjan Jovanovic myClientThread.create( );
258263d99982SDamjan Jovanovic
258363d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
258463d99982SDamjan Jovanovic
258563d99982SDamjan Jovanovic asAcceptorSocket.bind( saLocalSocketAddr );
258663d99982SDamjan Jovanovic asAcceptorSocket.listen( 1 );
258763d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
258863d99982SDamjan Jovanovic asAcceptorSocket.acceptConnection( ssStreamConnection );
258963d99982SDamjan Jovanovic sal_Int32 nReadNumber = ssStreamConnection.recv( pReadBuffer, 11 );
259063d99982SDamjan Jovanovic
259163d99982SDamjan Jovanovic myClientThread.join( ) ;
259263d99982SDamjan Jovanovic ssStreamConnection.close();
259363d99982SDamjan Jovanovic asAcceptorSocket.close();
259463d99982SDamjan Jovanovic ASSERT_TRUE(nReadNumber == -1) << " test for send/recv, recv error!";
259563d99982SDamjan Jovanovic }
259663d99982SDamjan Jovanovic
TEST_F(send_recv,write_read_001)259763d99982SDamjan Jovanovic TEST_F(send_recv, write_read_001)
259863d99982SDamjan Jovanovic {
259963d99982SDamjan Jovanovic write_read(50, 10);
260063d99982SDamjan Jovanovic }
TEST_F(send_recv,write_read_002)260163d99982SDamjan Jovanovic TEST_F(send_recv, write_read_002)
260263d99982SDamjan Jovanovic {
260363d99982SDamjan Jovanovic write_read(1024, 20);
260463d99982SDamjan Jovanovic }
TEST_F(send_recv,write_read_003)260563d99982SDamjan Jovanovic TEST_F(send_recv, write_read_003)
260663d99982SDamjan Jovanovic {
260763d99982SDamjan Jovanovic write_read(4000, 1);
260863d99982SDamjan Jovanovic }
TEST_F(send_recv,write_read_004)260963d99982SDamjan Jovanovic TEST_F(send_recv, write_read_004)
261063d99982SDamjan Jovanovic {
261163d99982SDamjan Jovanovic write_read(8192, 3);
261263d99982SDamjan Jovanovic }
261363d99982SDamjan Jovanovic
261463d99982SDamjan Jovanovic
2615cdf0e10cSrcweir class SendClientThread : public ClientSocketThread
2616cdf0e10cSrcweir {
2617cdf0e10cSrcweir protected:
2618cdf0e10cSrcweir
run()2619cdf0e10cSrcweir void SAL_CALL run( )
2620cdf0e10cSrcweir {
2621cdf0e10cSrcweir TimeValue *pTimeout;
2622cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
2623cdf0e10cSrcweir pTimeout->Seconds = 5;
2624cdf0e10cSrcweir pTimeout->Nanosec = 0;
2625cdf0e10cSrcweir
2626cdf0e10cSrcweir if ( osl_Socket_Ok == csConnectorSocket.connect( saTargetSocketAddr, pTimeout ))
2627cdf0e10cSrcweir {
2628cdf0e10cSrcweir sal_Int32 nWrite1 = csConnectorSocket.write( pTestString1, 11 ); // "test socket"
2629cdf0e10cSrcweir
2630cdf0e10cSrcweir sal_Int32 nWrite2 = csConnectorSocket.write( pTestString2, strlen( pTestString2 ) + 1 );
2631cdf0e10cSrcweir thread_sleep( 2 );
2632cdf0e10cSrcweir csConnectorSocket.write( pTestString2, strlen( pTestString2 ) + 1 );
263363d99982SDamjan Jovanovic printf("nWrite1 is %d, nWrite2 is %d\n", nWrite1, nWrite2 );
2634cdf0e10cSrcweir //thread_sleep( 1 );
2635cdf0e10cSrcweir }
2636cdf0e10cSrcweir else
263763d99982SDamjan Jovanovic printf("# SendClientThread: connect failed! \n");
2638cdf0e10cSrcweir
2639cdf0e10cSrcweir csConnectorSocket.close();
2640cdf0e10cSrcweir free( pTimeout );
2641cdf0e10cSrcweir }
2642cdf0e10cSrcweir
2643cdf0e10cSrcweir };
2644cdf0e10cSrcweir
264563d99982SDamjan Jovanovic class shutdown: public ::testing::Test
2646cdf0e10cSrcweir {
2647cdf0e10cSrcweir public:
2648cdf0e10cSrcweir // initialization
SetUp()264963d99982SDamjan Jovanovic void SetUp( )
2650cdf0e10cSrcweir {
2651cdf0e10cSrcweir }
2652cdf0e10cSrcweir
TearDown()265363d99982SDamjan Jovanovic void TearDown( )
2654cdf0e10cSrcweir {
2655cdf0e10cSrcweir
2656cdf0e10cSrcweir }
265763d99982SDamjan Jovanovic }; // class shutdown
2658cdf0e10cSrcweir
265963d99982SDamjan Jovanovic // similar to close_002
TEST_F(shutdown,shutdown_001)266063d99982SDamjan Jovanovic TEST_F(shutdown, shutdown_001)
266163d99982SDamjan Jovanovic {
2662cdf0e10cSrcweir #if defined(LINUX)
266363d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
266463d99982SDamjan Jovanovic AcceptorThread myAcceptorThread( asSocket, aHostIp1 );
266563d99982SDamjan Jovanovic myAcceptorThread.create();
2666cdf0e10cSrcweir
266763d99982SDamjan Jovanovic thread_sleep( 1 );
2668cdf0e10cSrcweir
266963d99982SDamjan Jovanovic //when accepting, shutdown the socket, the thread will not block for accepting
267063d99982SDamjan Jovanovic asSocket.shutdown();
267163d99982SDamjan Jovanovic myAcceptorThread.join();
2672cdf0e10cSrcweir
267363d99982SDamjan Jovanovic ASSERT_TRUE(myAcceptorThread.isOK( ) == sal_True) << "test for close when is accepting: the socket will quit accepting status.";
2674cdf0e10cSrcweir #endif
267563d99982SDamjan Jovanovic }
2676cdf0e10cSrcweir
TEST_F(shutdown,shutdown_002)267763d99982SDamjan Jovanovic TEST_F(shutdown, shutdown_002)
267863d99982SDamjan Jovanovic {
267963d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
268063d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT9);
268163d99982SDamjan Jovanovic asSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
268263d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.bind( saLocalSocketAddr ) == sal_True) << "shutdown_002: bind fail";
268363d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.listen( 1 ) == sal_True) << "shutdown_002: listen fail";
268463d99982SDamjan Jovanovic sal_Char pReadBuffer[40];
268563d99982SDamjan Jovanovic SendClientThread mySendThread;
268663d99982SDamjan Jovanovic mySendThread.create();
268763d99982SDamjan Jovanovic
268863d99982SDamjan Jovanovic asSocket.enableNonBlockingMode( sal_False );
268963d99982SDamjan Jovanovic ::osl::StreamSocket ssConnectionSocket;
269063d99982SDamjan Jovanovic oslSocketResult eResult = asSocket.acceptConnection( ssConnectionSocket );
269163d99982SDamjan Jovanovic ASSERT_TRUE(eResult == osl_Socket_Ok) << "shutdown_002: acceptConnection fail";
269263d99982SDamjan Jovanovic
269363d99982SDamjan Jovanovic /* set socket option SO_LINGER 0, so close immediately */
269463d99982SDamjan Jovanovic linger aLingerSet;
269563d99982SDamjan Jovanovic sal_Int32 nBufferLen = sizeof( struct linger );
269663d99982SDamjan Jovanovic aLingerSet.l_onoff = 0;
269763d99982SDamjan Jovanovic aLingerSet.l_linger = 0;
269863d99982SDamjan Jovanovic
269963d99982SDamjan Jovanovic ssConnectionSocket.setOption( osl_Socket_OptionLinger, &aLingerSet, nBufferLen );
270063d99982SDamjan Jovanovic thread_sleep( 1 );
270163d99982SDamjan Jovanovic //sal_uInt32 nRecv1 = 0;
270263d99982SDamjan Jovanovic sal_Int32 nRead1 = ssConnectionSocket.read( pReadBuffer, 11 );
270363d99982SDamjan Jovanovic
270463d99982SDamjan Jovanovic //shutdown read after client the first send complete
270563d99982SDamjan Jovanovic ssConnectionSocket.shutdown( osl_Socket_DirRead );
270663d99982SDamjan Jovanovic
270763d99982SDamjan Jovanovic sal_Int32 nRead2 = ssConnectionSocket.read( pReadBuffer + nRead1, 12 );
270863d99982SDamjan Jovanovic sal_Int32 nRead3 = ssConnectionSocket.read( pReadBuffer + nRead1 + nRead2, 12 );
270963d99982SDamjan Jovanovic printf("after read 2, nRead1 is %d, nRead2 is %d, nRead3 is %d \n", nRead1, nRead2, nRead3 );
271063d99982SDamjan Jovanovic mySendThread.join();
271163d99982SDamjan Jovanovic
271263d99982SDamjan Jovanovic ssConnectionSocket.close();
271363d99982SDamjan Jovanovic asSocket.close();
271463d99982SDamjan Jovanovic
271563d99982SDamjan Jovanovic /* on Linux, if send is before shutdown(DirRead), can read, nRecv2 still > 0,
271663d99982SDamjan Jovanovic http://dbforums.com/arch/186/2002/12/586417
271763d99982SDamjan Jovanovic While on Solaris, after shutdown(DirRead), all read will return 0
271863d99982SDamjan Jovanovic */
2719cdf0e10cSrcweir #ifdef LINUX
272063d99982SDamjan Jovanovic ASSERT_TRUE(nRead1 > 0 && nRead3 == 0) << "test for shutdown read direction: the socket can not read(recv).";
2721cdf0e10cSrcweir #else
272263d99982SDamjan Jovanovic ASSERT_TRUE(nRead1 > 0 && nRead2 == 0 && nRead3 == 0) << "test for shutdown read direction: the socket can not read(recv).";
2723cdf0e10cSrcweir #endif
2724cdf0e10cSrcweir
272563d99982SDamjan Jovanovic }
2726cdf0e10cSrcweir
TEST_F(shutdown,shutdown_003)272763d99982SDamjan Jovanovic TEST_F(shutdown, shutdown_003)
272863d99982SDamjan Jovanovic {
272963d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
273063d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT9);
273163d99982SDamjan Jovanovic asSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
273263d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.bind( saLocalSocketAddr ) == sal_True) << "shutdown_002: bind fail";
273363d99982SDamjan Jovanovic ASSERT_TRUE(asSocket.listen( 1 ) == sal_True) << "shutdown_002: listen fail";
273463d99982SDamjan Jovanovic sal_Char pReadBuffer[40];
273563d99982SDamjan Jovanovic SendClientThread mySendThread;
273663d99982SDamjan Jovanovic mySendThread.create();
273763d99982SDamjan Jovanovic
273863d99982SDamjan Jovanovic asSocket.enableNonBlockingMode( sal_False );
273963d99982SDamjan Jovanovic ::osl::StreamSocket ssConnectionSocket;
274063d99982SDamjan Jovanovic oslSocketResult eResult = asSocket.acceptConnection( ssConnectionSocket );
274163d99982SDamjan Jovanovic ASSERT_TRUE(eResult == osl_Socket_Ok) << "shutdown_002: acceptConnection fail";
274263d99982SDamjan Jovanovic
274363d99982SDamjan Jovanovic thread_sleep( 1 );
274463d99982SDamjan Jovanovic //shutdown write after client the first send complete
274563d99982SDamjan Jovanovic ssConnectionSocket.shutdown( osl_Socket_DirWrite );
274663d99982SDamjan Jovanovic
274763d99982SDamjan Jovanovic // recv should not shutdown
274863d99982SDamjan Jovanovic sal_Int32 nRead1 = ssConnectionSocket.read( pReadBuffer, 11 );
274963d99982SDamjan Jovanovic
275063d99982SDamjan Jovanovic sal_Int32 nWrite = ssConnectionSocket.write( pReadBuffer, 11 );
275163d99982SDamjan Jovanovic // still can read
275263d99982SDamjan Jovanovic sal_Int32 nRead3 = ssConnectionSocket.read( pReadBuffer + nRead1 , 12 );
275363d99982SDamjan Jovanovic printf("after read 2, nRead1 is %d, nWrite is %d, nRead3 is %d\n", nRead1, nWrite, nRead3 );
275463d99982SDamjan Jovanovic mySendThread.join();
275563d99982SDamjan Jovanovic ssConnectionSocket.close();
275663d99982SDamjan Jovanovic asSocket.close();
275763d99982SDamjan Jovanovic
275863d99982SDamjan Jovanovic ASSERT_TRUE(nRead1 > 0 && nWrite == 0 && nRead3 > 0) << "test for shutdown read direction: the socket can not send(write).";
2759cdf0e10cSrcweir
276063d99982SDamjan Jovanovic }
2761cdf0e10cSrcweir
276263d99982SDamjan Jovanovic class isExceptionPending: public ::testing::Test
2763cdf0e10cSrcweir {
2764cdf0e10cSrcweir public:
2765cdf0e10cSrcweir }; // class isExceptionPending
2766cdf0e10cSrcweir
276763d99982SDamjan Jovanovic /**tester's comments: lack of a case that return sal_True, do not know when it will return sal_True*/
TEST_F(isExceptionPending,isExPending_001)276863d99982SDamjan Jovanovic TEST_F(isExceptionPending, isExPending_001)
276963d99982SDamjan Jovanovic {
277063d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
277163d99982SDamjan Jovanovic TimeValue *pTimeout;
277263d99982SDamjan Jovanovic pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
277363d99982SDamjan Jovanovic pTimeout->Seconds = 3;
277463d99982SDamjan Jovanovic pTimeout->Nanosec = 0;
277563d99982SDamjan Jovanovic sal_Bool bOk = asSocket.isExceptionPending( pTimeout );
277663d99982SDamjan Jovanovic free( pTimeout );
277763d99982SDamjan Jovanovic
277863d99982SDamjan Jovanovic ASSERT_TRUE(bOk == sal_False) << "test for isExceptionPending.";
277963d99982SDamjan Jovanovic }
2780cdf0e10cSrcweir
2781cdf0e10cSrcweir
2782cdf0e10cSrcweir } // namespace osl_StreamSocket
2783cdf0e10cSrcweir
2784cdf0e10cSrcweir
2785cdf0e10cSrcweir namespace osl_ConnectorSocket
2786cdf0e10cSrcweir {
2787cdf0e10cSrcweir
2788cdf0e10cSrcweir /** testing the method:
2789cdf0e10cSrcweir ConnectorSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
2790cdf0e10cSrcweir oslProtocol Protocol = osl_Socket_ProtocolIp,
2791cdf0e10cSrcweir oslSocketType Type = osl_Socket_TypeStream);
2792cdf0e10cSrcweir */
2793cdf0e10cSrcweir
279463d99982SDamjan Jovanovic class OslConnectorSocketCtors : public ::testing::Test
2795cdf0e10cSrcweir {
2796cdf0e10cSrcweir public:
279763d99982SDamjan Jovanovic }; // class ctors
2798cdf0e10cSrcweir
TEST_F(OslConnectorSocketCtors,ctors_001)279963d99982SDamjan Jovanovic TEST_F(OslConnectorSocketCtors, ctors_001)
280063d99982SDamjan Jovanovic {
280163d99982SDamjan Jovanovic /// Socket constructor.
280263d99982SDamjan Jovanovic ::osl::ConnectorSocket csSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
2803cdf0e10cSrcweir
280463d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == csSocket.getType( )) << "test for ctors_001 constructor function: check if the connector socket was created successfully.";
280563d99982SDamjan Jovanovic }
2806cdf0e10cSrcweir
2807cdf0e10cSrcweir /** testing the method:
2808cdf0e10cSrcweir oslSocketResult SAL_CALL connect(const SocketAddr& TargetHost, const TimeValue* pTimeout = 0);
2809cdf0e10cSrcweir */
2810cdf0e10cSrcweir
281163d99982SDamjan Jovanovic class connect : public ::testing::Test
2812cdf0e10cSrcweir {
2813cdf0e10cSrcweir public:
2814cdf0e10cSrcweir TimeValue *pTimeout;
2815cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
2816cdf0e10cSrcweir ::osl::ConnectorSocket csConnectorSocket;
2817cdf0e10cSrcweir
2818cdf0e10cSrcweir
2819cdf0e10cSrcweir // initialization
SetUp()282063d99982SDamjan Jovanovic void SetUp( )
2821cdf0e10cSrcweir {
2822cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
2823cdf0e10cSrcweir pTimeout->Seconds = 3;
2824cdf0e10cSrcweir pTimeout->Nanosec = 0;
2825cdf0e10cSrcweir // sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
2826cdf0e10cSrcweir }
2827cdf0e10cSrcweir
TearDown()282863d99982SDamjan Jovanovic void TearDown( )
2829cdf0e10cSrcweir {
2830cdf0e10cSrcweir free( pTimeout );
2831cdf0e10cSrcweir // sHandle = NULL;
2832cdf0e10cSrcweir asAcceptorSocket.close( );
2833cdf0e10cSrcweir csConnectorSocket.close( );
2834cdf0e10cSrcweir }
283563d99982SDamjan Jovanovic }; // class connect
2836cdf0e10cSrcweir
TEST_F(connect,connect_001)283763d99982SDamjan Jovanovic TEST_F(connect, connect_001)
283863d99982SDamjan Jovanovic {
283963d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT2 );
284063d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT2 );
284163d99982SDamjan Jovanovic ::osl::SocketAddr saPeerSocketAddr( aHostIp2, IP_PORT_FTP );
284263d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
284363d99982SDamjan Jovanovic
284463d99982SDamjan Jovanovic /// launch server socket
284563d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
284663d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
284763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
284863d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
284963d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
285063d99982SDamjan Jovanovic
285163d99982SDamjan Jovanovic //asAcceptorSocket.enableNonBlockingMode( sal_True );
285263d99982SDamjan Jovanovic //oslSocketResult eResultAccept = asAcceptorSocket.acceptConnection(ssConnection); /// waiting for incoming connection...
285363d99982SDamjan Jovanovic //ASSERT_TRUE(osl_Socket_Ok == eResultAccept) << "accept failed.";
285463d99982SDamjan Jovanovic /// launch client socket
285563d99982SDamjan Jovanovic oslSocketResult eResult = csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
285663d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_Ok == eResult) << "connect failed.";
285763d99982SDamjan Jovanovic
285863d99982SDamjan Jovanovic /// get peer information
285963d99982SDamjan Jovanovic csConnectorSocket.getPeerAddr( saPeerSocketAddr );/// connected.
286063d99982SDamjan Jovanovic
286163d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == compareSocketAddr( saPeerSocketAddr, saLocalSocketAddr ) ) &&
286263d99982SDamjan Jovanovic ( osl_Socket_Ok == eResult )) << "test for connect function: try to create a connection with remote host. and check the setup address.";
286363d99982SDamjan Jovanovic }
286463d99982SDamjan Jovanovic //non-blocking mode connect?
TEST_F(connect,connect_002)286563d99982SDamjan Jovanovic TEST_F(connect, connect_002)
286663d99982SDamjan Jovanovic {
286763d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT3 );
286863d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT3 );
286963d99982SDamjan Jovanovic ::osl::SocketAddr saPeerSocketAddr( aHostIp2, IP_PORT_FTP );
2870cdf0e10cSrcweir
287163d99982SDamjan Jovanovic asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1 ); //sal_True);
287263d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
287363d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
287463d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
287563d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
287663d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
2877cdf0e10cSrcweir
287863d99982SDamjan Jovanovic csConnectorSocket.enableNonBlockingMode( sal_True );
2879cdf0e10cSrcweir
288063d99982SDamjan Jovanovic oslSocketResult eResult = csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
288163d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_InProgress == eResult || osl_Socket_Ok == eResult) << "connect failed.";
2882cdf0e10cSrcweir
288363d99982SDamjan Jovanovic /// get peer information
288463d99982SDamjan Jovanovic csConnectorSocket.getPeerAddr( saPeerSocketAddr );
2885cdf0e10cSrcweir
288663d99982SDamjan Jovanovic ASSERT_TRUE( sal_True == compareSocketAddr( saPeerSocketAddr, saLocalSocketAddr ) )
288763d99982SDamjan Jovanovic << "test for connect function: try to create a connection with remote host. and check the setup address.";
288863d99982SDamjan Jovanovic }
288963d99982SDamjan Jovanovic // really an error or just delayed
289063d99982SDamjan Jovanovic // how to design scenarios that will return osl_Socket_Interrupted, osl_Socket_TimedOut
TEST_F(connect,connect_003)289163d99982SDamjan Jovanovic TEST_F(connect, connect_003)
289263d99982SDamjan Jovanovic {
289363d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr1( aHostIp1, IP_PORT_MYPORT3 );
289463d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr2( aHostIpInval1, IP_PORT_MYPORT3 );
2895cdf0e10cSrcweir
289663d99982SDamjan Jovanovic csConnectorSocket.enableNonBlockingMode( sal_False );
2897cdf0e10cSrcweir
289863d99982SDamjan Jovanovic oslSocketResult eResult1 = csConnectorSocket.connect( saTargetSocketAddr1, pTimeout );
289963d99982SDamjan Jovanovic oslSocketResult eResult2 = csConnectorSocket.connect( saTargetSocketAddr2, pTimeout );
290063d99982SDamjan Jovanovic CloseSocketThread myCloseThread( csConnectorSocket );
290163d99982SDamjan Jovanovic oslSocketResult eResult3 = csConnectorSocket.connect( saTargetSocketAddr2, pTimeout );
290263d99982SDamjan Jovanovic myCloseThread.join();
290363d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_Error == eResult1 &&
290463d99982SDamjan Jovanovic osl_Socket_Error == eResult2 && osl_Socket_Error == eResult3) << "connect should failed.";
2905cdf0e10cSrcweir
290663d99982SDamjan Jovanovic }
2907cdf0e10cSrcweir
290863d99982SDamjan Jovanovic // really an error in non-blocking mode
TEST_F(connect,connect_004)290963d99982SDamjan Jovanovic TEST_F(connect, connect_004)
291063d99982SDamjan Jovanovic {
291163d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIpInval1, IP_PORT_MYPORT3 );
2912cdf0e10cSrcweir
291363d99982SDamjan Jovanovic csConnectorSocket.enableNonBlockingMode( sal_True );
2914cdf0e10cSrcweir
291563d99982SDamjan Jovanovic oslSocketResult eResult = csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
291663d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_Error == eResult) << "connect should failed.";
291763d99982SDamjan Jovanovic }
291863d99982SDamjan Jovanovic /** here need a case: immediate connection, say in non-blocking mode connect return osl_Socket_Ok
291963d99982SDamjan Jovanovic */
2920cdf0e10cSrcweir
2921cdf0e10cSrcweir
2922cdf0e10cSrcweir } // namespace osl_ConnectorSocket
2923cdf0e10cSrcweir
2924cdf0e10cSrcweir
2925cdf0e10cSrcweir
2926cdf0e10cSrcweir namespace osl_AcceptorSocket
2927cdf0e10cSrcweir {
2928cdf0e10cSrcweir
2929cdf0e10cSrcweir /** testing the methods:
2930cdf0e10cSrcweir inline AcceptorSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
2931cdf0e10cSrcweir oslProtocol Protocol = osl_Socket_ProtocolIp,
2932cdf0e10cSrcweir oslSocketType Type = osl_Socket_TypeStream);
2933cdf0e10cSrcweir */
2934cdf0e10cSrcweir
293563d99982SDamjan Jovanovic class OslAcceptorSocketCtors : public ::testing::Test
2936cdf0e10cSrcweir {
2937cdf0e10cSrcweir public:
293863d99982SDamjan Jovanovic }; // class ctors
2939cdf0e10cSrcweir
TEST_F(OslAcceptorSocketCtors,ctors_001)294063d99982SDamjan Jovanovic TEST_F(OslAcceptorSocketCtors, ctors_001)
294163d99982SDamjan Jovanovic {
294263d99982SDamjan Jovanovic /// Socket constructor.
294363d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
2944cdf0e10cSrcweir
294563d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeStream == asSocket.getType( )) << "test for ctors_001 constructor function: check if the acceptor socket was created successfully.";
294663d99982SDamjan Jovanovic }
2947cdf0e10cSrcweir
2948cdf0e10cSrcweir #if 0
294963d99982SDamjan Jovanovic class operator_assign : public ::testing::Test
2950cdf0e10cSrcweir {
2951cdf0e10cSrcweir public:
295263d99982SDamjan Jovanovic }; // class operator_assign
2953cdf0e10cSrcweir
295463d99982SDamjan Jovanovic TEST_F(operator_assign, assign_001)
295563d99982SDamjan Jovanovic {
2956cdf0e10cSrcweir #if defined(LINUX)
295763d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocket( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
295863d99982SDamjan Jovanovic ::osl::AcceptorSocket asSocketAssign( osl_Socket_FamilyInet, osl_Socket_ProtocolIp, osl_Socket_TypeStream );
295963d99982SDamjan Jovanovic asSocket.setOption( osl_Socket_OptionReuseAddr, 1);
296063d99982SDamjan Jovanovic ::osl::SocketAddr saSocketAddr( aHostIp1, IP_PORT_MYPORT4 );
296163d99982SDamjan Jovanovic asSocket.bind( saSocketAddr );
2962cdf0e10cSrcweir
296363d99982SDamjan Jovanovic AcceptorThread myAcceptorThread( asSocketAssign, aHostIp1 );
296463d99982SDamjan Jovanovic myAcceptorThread.create();
2965cdf0e10cSrcweir
296663d99982SDamjan Jovanovic thread_sleep( 1 );
296763d99982SDamjan Jovanovic //when accepting, assign another socket to the socket, the thread will not be closed, so is blocking
296863d99982SDamjan Jovanovic asSocketAssign = asSocket;
2969cdf0e10cSrcweir
297063d99982SDamjan Jovanovic printf("#asSocketAssign port number is %d\n", asSocketAssign.getLocalPort() );
2971cdf0e10cSrcweir
297263d99982SDamjan Jovanovic asSocketAssign.shutdown();
297363d99982SDamjan Jovanovic myAcceptorThread.join();
2974cdf0e10cSrcweir
297563d99982SDamjan Jovanovic ASSERT_TRUE(myAcceptorThread.isOK() == sal_True) << "test for close when is accepting: the socket will quit accepting status.";
2976cdf0e10cSrcweir
2977cdf0e10cSrcweir
2978cdf0e10cSrcweir #endif /* LINUX */
297963d99982SDamjan Jovanovic }
2980cdf0e10cSrcweir #endif
2981cdf0e10cSrcweir
2982cdf0e10cSrcweir /** testing the method:
2983cdf0e10cSrcweir inline sal_Bool SAL_CALL listen(sal_Int32 MaxPendingConnections= -1);
2984cdf0e10cSrcweir inline oslSocketResult SAL_CALL acceptConnection( StreamSocket& Connection);
2985cdf0e10cSrcweir inline oslSocketResult SAL_CALL acceptConnection( StreamSocket& Connection, SocketAddr & PeerAddr);
2986cdf0e10cSrcweir */
2987cdf0e10cSrcweir
298863d99982SDamjan Jovanovic class listen_accept : public ::testing::Test
2989cdf0e10cSrcweir {
2990cdf0e10cSrcweir public:
2991cdf0e10cSrcweir TimeValue *pTimeout;
2992cdf0e10cSrcweir ::osl::AcceptorSocket asAcceptorSocket;
2993cdf0e10cSrcweir ::osl::ConnectorSocket csConnectorSocket;
2994cdf0e10cSrcweir
2995cdf0e10cSrcweir
2996cdf0e10cSrcweir // initialization
SetUp()299763d99982SDamjan Jovanovic void SetUp( )
2998cdf0e10cSrcweir {
2999cdf0e10cSrcweir pTimeout = ( TimeValue* )malloc( sizeof( TimeValue ) );
3000cdf0e10cSrcweir pTimeout->Seconds = 3;
3001cdf0e10cSrcweir pTimeout->Nanosec = 0;
3002cdf0e10cSrcweir asAcceptorSocket.setOption( osl_Socket_OptionReuseAddr, 1);
3003cdf0e10cSrcweir // sHandle = osl_createSocket( osl_Socket_FamilyInet, osl_Socket_TypeStream, osl_Socket_ProtocolIp );
3004cdf0e10cSrcweir }
3005cdf0e10cSrcweir
TearDown()300663d99982SDamjan Jovanovic void TearDown( )
3007cdf0e10cSrcweir {
3008cdf0e10cSrcweir free( pTimeout );
3009cdf0e10cSrcweir // sHandle = NULL;
3010cdf0e10cSrcweir asAcceptorSocket.close( );
3011cdf0e10cSrcweir csConnectorSocket.close( );
3012cdf0e10cSrcweir }
301363d99982SDamjan Jovanovic }; // class listen_accept
3014cdf0e10cSrcweir
TEST_F(listen_accept,listen_accept_001)301563d99982SDamjan Jovanovic TEST_F(listen_accept, listen_accept_001)
301663d99982SDamjan Jovanovic {
301763d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT3 );
301863d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT3 );
301963d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
3020cdf0e10cSrcweir
302163d99982SDamjan Jovanovic /// launch server socket
302263d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
302363d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
302463d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
302563d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
302663d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
3027cdf0e10cSrcweir
302863d99982SDamjan Jovanovic /// launch client socket
302963d99982SDamjan Jovanovic csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
3030cdf0e10cSrcweir
303163d99982SDamjan Jovanovic oslSocketResult eResult = asAcceptorSocket.acceptConnection(ssConnection); /// waiting for incoming connection...
3032cdf0e10cSrcweir
303363d99982SDamjan Jovanovic ASSERT_TRUE(( osl_Socket_Ok == eResult )) << "test for listen_accept function: try to create a connection with remote host, using listen and accept.";
303463d99982SDamjan Jovanovic }
3035cdf0e10cSrcweir
TEST_F(listen_accept,listen_accept_002)303663d99982SDamjan Jovanovic TEST_F(listen_accept, listen_accept_002)
303763d99982SDamjan Jovanovic {
303863d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT4 );
303963d99982SDamjan Jovanovic ::osl::SocketAddr saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT4 );
304063d99982SDamjan Jovanovic ::osl::SocketAddr saPeerSocketAddr( aHostIp2, IP_PORT_FTP );
304163d99982SDamjan Jovanovic ::osl::StreamSocket ssConnection;
304263d99982SDamjan Jovanovic
304363d99982SDamjan Jovanovic /// launch server socket
304463d99982SDamjan Jovanovic sal_Bool bOK1 = asAcceptorSocket.bind( saLocalSocketAddr );
304563d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK1) << "AcceptorSocket bind address failed.";
304663d99982SDamjan Jovanovic sal_Bool bOK2 = asAcceptorSocket.listen( 1 );
304763d99982SDamjan Jovanovic ASSERT_TRUE(sal_True == bOK2) << "AcceptorSocket listen failed.";
304863d99982SDamjan Jovanovic asAcceptorSocket.enableNonBlockingMode( sal_True );
304963d99982SDamjan Jovanovic
305063d99982SDamjan Jovanovic /// launch client socket
305163d99982SDamjan Jovanovic csConnectorSocket.connect( saTargetSocketAddr, pTimeout ); /// connecting to server...
305263d99982SDamjan Jovanovic
305363d99982SDamjan Jovanovic oslSocketResult eResult = asAcceptorSocket.acceptConnection(ssConnection, saPeerSocketAddr); /// waiting for incoming connection...
305463d99982SDamjan Jovanovic
305563d99982SDamjan Jovanovic ASSERT_TRUE(( sal_True == bOK2 ) &&
305663d99982SDamjan Jovanovic ( osl_Socket_Ok == eResult ) &&
305763d99982SDamjan Jovanovic ( sal_True == compareSocketAddr( saPeerSocketAddr, saLocalSocketAddr ) )) << "test for listen_accept function: try to create a connection with remote host, using listen and accept, accept with peer address.";
305863d99982SDamjan Jovanovic }
3059cdf0e10cSrcweir
TEST_F(listen_accept,listen_accept_003)306063d99982SDamjan Jovanovic TEST_F(listen_accept, listen_accept_003)
306163d99982SDamjan Jovanovic {
3062cdf0e10cSrcweir
306363d99982SDamjan Jovanovic }
3064cdf0e10cSrcweir
3065cdf0e10cSrcweir
3066cdf0e10cSrcweir } // namespace osl_AcceptorSocket
3067cdf0e10cSrcweir
3068cdf0e10cSrcweir
3069cdf0e10cSrcweir namespace osl_DatagramSocket
3070cdf0e10cSrcweir {
3071cdf0e10cSrcweir
3072cdf0e10cSrcweir /** testing the methods:
3073cdf0e10cSrcweir inline DatagramSocket(oslAddrFamily Family= osl_Socket_FamilyInet,
3074cdf0e10cSrcweir oslProtocol Protocol= osl_Socket_ProtocolIp,
3075cdf0e10cSrcweir oslSocketType Type= osl_Socket_TypeDgram);
3076cdf0e10cSrcweir */
3077cdf0e10cSrcweir
307863d99982SDamjan Jovanovic class DatagramSocketCtors : public ::testing::Test
3079cdf0e10cSrcweir {
3080cdf0e10cSrcweir public:
308163d99982SDamjan Jovanovic }; // class ctors
3082cdf0e10cSrcweir
TEST_F(DatagramSocketCtors,ctors_001)308363d99982SDamjan Jovanovic TEST_F(DatagramSocketCtors, ctors_001)
308463d99982SDamjan Jovanovic {
308563d99982SDamjan Jovanovic /// Socket constructor.
308663d99982SDamjan Jovanovic ::osl::DatagramSocket dsSocket;
3087cdf0e10cSrcweir
308863d99982SDamjan Jovanovic ASSERT_TRUE(osl_Socket_TypeDgram == dsSocket.getType( )) << "test for ctors_001 constructor function: check if the datagram socket was created successfully.";
308963d99982SDamjan Jovanovic }
3090cdf0e10cSrcweir
3091cdf0e10cSrcweir /**thread do sendTo, refer to http://www.coding-zone.co.uk/cpp/articles/140101networkprogrammingv.shtml
3092cdf0e10cSrcweir */
3093cdf0e10cSrcweir class TalkerThread : public Thread
3094cdf0e10cSrcweir {
3095cdf0e10cSrcweir protected:
3096cdf0e10cSrcweir ::osl::SocketAddr saTargetSocketAddr;
3097cdf0e10cSrcweir ::osl::DatagramSocket dsSocket;
3098cdf0e10cSrcweir
run()3099cdf0e10cSrcweir void SAL_CALL run( )
3100cdf0e10cSrcweir {
3101cdf0e10cSrcweir dsSocket.sendTo( saTargetSocketAddr, pTestString1, strlen( pTestString1 ) + 1 ); // "test socket"
3102cdf0e10cSrcweir dsSocket.shutdown();
3103cdf0e10cSrcweir }
3104cdf0e10cSrcweir
onTerminated()3105cdf0e10cSrcweir void SAL_CALL onTerminated( )
3106cdf0e10cSrcweir {
3107cdf0e10cSrcweir }
3108cdf0e10cSrcweir
3109cdf0e10cSrcweir public:
TalkerThread()3110cdf0e10cSrcweir TalkerThread( ):
3111cdf0e10cSrcweir saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT9 )
3112cdf0e10cSrcweir {
3113cdf0e10cSrcweir }
3114cdf0e10cSrcweir
~TalkerThread()3115cdf0e10cSrcweir ~TalkerThread( )
3116cdf0e10cSrcweir {
3117cdf0e10cSrcweir if ( isRunning( ) )
311863d99982SDamjan Jovanovic printf("# error: TalkerThread not terminated normally.\n" );
3119cdf0e10cSrcweir }
3120cdf0e10cSrcweir };
3121cdf0e10cSrcweir
3122cdf0e10cSrcweir /**thread do listen, refer to http://www.coding-zone.co.uk/cpp/articles/140101networkprogrammingv.shtml
3123cdf0e10cSrcweir */
3124cdf0e10cSrcweir class ListenerThread : public Thread
3125cdf0e10cSrcweir {
3126cdf0e10cSrcweir protected:
3127cdf0e10cSrcweir ::osl::SocketAddr saTargetSocketAddr;
3128cdf0e10cSrcweir ::osl::DatagramSocket dsSocket;
3129cdf0e10cSrcweir
run()3130cdf0e10cSrcweir void SAL_CALL run( )
3131cdf0e10cSrcweir {
3132cdf0e10cSrcweir ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT10 );
3133cdf0e10cSrcweir dsSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
3134cdf0e10cSrcweir if ( dsSocket.bind( saLocalSocketAddr ) == sal_False )
3135cdf0e10cSrcweir {
313663d99982SDamjan Jovanovic printf("DatagramSocket bind failed \n");
3137cdf0e10cSrcweir return;
3138cdf0e10cSrcweir }
3139cdf0e10cSrcweir //blocking mode: default
3140cdf0e10cSrcweir sal_Int32 nRecv = dsSocket.recvFrom( pRecvBuffer, 30, &saTargetSocketAddr); //strlen( pTestString2 ) + 1
314163d99982SDamjan Jovanovic printf("After recvFrom, nRecv is %d\n", nRecv);
3142cdf0e10cSrcweir }
3143cdf0e10cSrcweir
onTerminated()3144cdf0e10cSrcweir void SAL_CALL onTerminated( )
3145cdf0e10cSrcweir {
3146cdf0e10cSrcweir }
3147cdf0e10cSrcweir
3148cdf0e10cSrcweir public:
3149cdf0e10cSrcweir sal_Char pRecvBuffer[30];
ListenerThread()3150cdf0e10cSrcweir ListenerThread( ):
3151cdf0e10cSrcweir saTargetSocketAddr( aHostIp1, IP_PORT_MYPORT10 )
3152cdf0e10cSrcweir {
3153cdf0e10cSrcweir pRecvBuffer[0] = '\0';
3154cdf0e10cSrcweir }
3155cdf0e10cSrcweir
~ListenerThread()3156cdf0e10cSrcweir ~ListenerThread( )
3157cdf0e10cSrcweir {
3158cdf0e10cSrcweir if ( isRunning( ) )
315963d99982SDamjan Jovanovic printf("# error: ListenerThread not terminated normally.\n" );
3160cdf0e10cSrcweir }
3161cdf0e10cSrcweir
3162cdf0e10cSrcweir };
3163cdf0e10cSrcweir
3164cdf0e10cSrcweir /** testing the methods:
3165cdf0e10cSrcweir inline sal_Int32 DatagramSocket::recvFrom(void* pBuffer, sal_uInt32 BufferSize,
3166cdf0e10cSrcweir SocketAddr* pSenderAddr, oslSocketMsgFlag Flag )
3167cdf0e10cSrcweir inline sal_Int32 DatagramSocket::sendTo( const SocketAddr& ReceiverAddr,
3168cdf0e10cSrcweir const void* pBuffer, sal_uInt32 BufferSize, oslSocketMsgFlag Flag )
3169cdf0e10cSrcweir */
3170cdf0e10cSrcweir
317163d99982SDamjan Jovanovic class sendTo_recvFrom : public ::testing::Test
3172cdf0e10cSrcweir {
3173cdf0e10cSrcweir public:
317463d99982SDamjan Jovanovic }; // class sendTo_recvFrom
3175cdf0e10cSrcweir
TEST_F(sendTo_recvFrom,sr_001)317663d99982SDamjan Jovanovic TEST_F(sendTo_recvFrom, sr_001)
317763d99982SDamjan Jovanovic {
317863d99982SDamjan Jovanovic ::osl::SocketAddr saLocalSocketAddr( aHostIp1, IP_PORT_MYPORT9 );
317963d99982SDamjan Jovanovic ::osl::DatagramSocket dsSocket;
318063d99982SDamjan Jovanovic dsSocket.setOption( osl_Socket_OptionReuseAddr, 1 );
318163d99982SDamjan Jovanovic dsSocket.bind( saLocalSocketAddr );
3182cdf0e10cSrcweir
318363d99982SDamjan Jovanovic sal_Char pReadBuffer[30];
318463d99982SDamjan Jovanovic TalkerThread myTalkThread;
318563d99982SDamjan Jovanovic myTalkThread.create();
318663d99982SDamjan Jovanovic sal_Int32 nRecv = dsSocket.recvFrom( pReadBuffer, 30, &saLocalSocketAddr);
318763d99982SDamjan Jovanovic myTalkThread.join();
318863d99982SDamjan Jovanovic //printf("#received buffer is %s# \n", pReadBuffer);
3189cdf0e10cSrcweir
319063d99982SDamjan Jovanovic sal_Bool bOk = ( strcmp(pReadBuffer, pTestString1) == 0 );
3191cdf0e10cSrcweir
319263d99982SDamjan Jovanovic ASSERT_TRUE(nRecv > 0 && bOk == sal_True) << "test for sendTo/recvFrom function: create a talker thread and recvFrom in the main thread, check if the datagram socket can communicate successfully.";
319363d99982SDamjan Jovanovic }
3194cdf0e10cSrcweir
TEST_F(sendTo_recvFrom,sr_002)319563d99982SDamjan Jovanovic TEST_F(sendTo_recvFrom, sr_002)
319663d99982SDamjan Jovanovic {
319763d99982SDamjan Jovanovic ::osl::SocketAddr saListenSocketAddr( aHostIp1, IP_PORT_MYPORT10 );
319863d99982SDamjan Jovanovic ::osl::DatagramSocket dsSocket;
3199cdf0e10cSrcweir
320063d99982SDamjan Jovanovic //listener thread construct a DatagramSocket, recvFrom waiting for data, then main thread sendto data
320163d99982SDamjan Jovanovic ListenerThread myListenThread;
320263d99982SDamjan Jovanovic myListenThread.create();
320363d99982SDamjan Jovanovic //to grantee the recvFrom is before sendTo
320463d99982SDamjan Jovanovic thread_sleep( 1 );
3205cdf0e10cSrcweir
320663d99982SDamjan Jovanovic sal_Int32 nSend = dsSocket.sendTo( saListenSocketAddr, pTestString2, strlen( pTestString2 ) + 1 );
3207cdf0e10cSrcweir
320863d99982SDamjan Jovanovic ASSERT_TRUE(nSend > 0) << "DatagramSocket sendTo failed: nSend <= 0.";
3209cdf0e10cSrcweir
321063d99982SDamjan Jovanovic myListenThread.join();
321163d99982SDamjan Jovanovic //printf("#received buffer is %s# \n", myListenThread.pRecvBuffer);
3212cdf0e10cSrcweir
321363d99982SDamjan Jovanovic sal_Bool bOk = ( strcmp( myListenThread.pRecvBuffer, pTestString2) == 0 );
3214cdf0e10cSrcweir
321563d99982SDamjan Jovanovic ASSERT_TRUE(bOk == sal_True) << "test for sendTo/recvFrom function: create a listener thread and sendTo in the main thread, check if the datagram socket can communicate successfully.";
321663d99982SDamjan Jovanovic }
3217cdf0e10cSrcweir
321863d99982SDamjan Jovanovic //sendTo error, return -1; recvFrom error, return -1
TEST_F(sendTo_recvFrom,sr_003)321963d99982SDamjan Jovanovic TEST_F(sendTo_recvFrom, sr_003)
322063d99982SDamjan Jovanovic {
322163d99982SDamjan Jovanovic ::osl::SocketAddr saListenSocketAddr( aHostIpInval1, IP_PORT_MYPORT10 );
322263d99982SDamjan Jovanovic ::osl::DatagramSocket dsSocket;
322363d99982SDamjan Jovanovic // Transport endpoint is not connected
322463d99982SDamjan Jovanovic sal_Int32 nSend = dsSocket.sendTo( saListenSocketAddr, pTestString2, strlen( pTestString2 ) + 1 );
322563d99982SDamjan Jovanovic ASSERT_TRUE(nSend == -1) << "DatagramSocket sendTo should fail: nSend <= 0.";
322663d99982SDamjan Jovanovic }
3227cdf0e10cSrcweir
TEST_F(sendTo_recvFrom,sr_004)322863d99982SDamjan Jovanovic TEST_F(sendTo_recvFrom, sr_004)
322963d99982SDamjan Jovanovic {
323063d99982SDamjan Jovanovic ::osl::SocketAddr saListenSocketAddr1( aHostIpInval1, IP_PORT_MYPORT10 );
323163d99982SDamjan Jovanovic ::osl::SocketAddr saListenSocketAddr2( aHostIp2, IP_PORT_MYPORT10 );
323263d99982SDamjan Jovanovic ::osl::DatagramSocket dsSocket;
323363d99982SDamjan Jovanovic
323463d99982SDamjan Jovanovic dsSocket.enableNonBlockingMode( sal_True );
323563d99982SDamjan Jovanovic
323663d99982SDamjan Jovanovic sal_Char pReadBuffer[30];
323763d99982SDamjan Jovanovic //sal_Int32 nRecv1 = dsSocket.recvFrom( pReadBuffer, 30, &saListenSocketAddr1 );
323863d99982SDamjan Jovanovic
323963d99982SDamjan Jovanovic // will block ?
324063d99982SDamjan Jovanovic CloseSocketThread myThread( dsSocket );
324163d99982SDamjan Jovanovic myThread.create();
324263d99982SDamjan Jovanovic sal_Int32 nRecv2 = dsSocket.recvFrom( pReadBuffer, 30, &saListenSocketAddr1 );
324363d99982SDamjan Jovanovic myThread.join();
324463d99982SDamjan Jovanovic //printf("#nRecv1 is %d nRecv2 is %d\n", nRecv1, nRecv2 );
324563d99982SDamjan Jovanovic ASSERT_TRUE(nRecv2 == -1) << "DatagramSocket sendTo should fail: nSend <= 0.";
324663d99982SDamjan Jovanovic }
3247cdf0e10cSrcweir
3248cdf0e10cSrcweir
3249cdf0e10cSrcweir } // namespace osl_DatagramSocket
3250cdf0e10cSrcweir
signalHandler(void * pData,oslSignalInfo * pInfo)325163d99982SDamjan Jovanovic static oslSignalAction SAL_CALL signalHandler(void* pData, oslSignalInfo* pInfo)
325263d99982SDamjan Jovanovic {
325363d99982SDamjan Jovanovic return osl_Signal_ActCallNextHdl;
325463d99982SDamjan Jovanovic }
3255cdf0e10cSrcweir
main(int argc,char ** argv)325663d99982SDamjan Jovanovic int main(int argc, char **argv)
325763d99982SDamjan Jovanovic {
325863d99982SDamjan Jovanovic osl_addSignalHandler(signalHandler, NULL);
325963d99982SDamjan Jovanovic ::testing::InitGoogleTest(&argc, argv);
326063d99982SDamjan Jovanovic return RUN_ALL_TESTS();
326163d99982SDamjan Jovanovic }
3262