--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/test/TE_RConnectionSuite/src/TE_AllInterfaceNotification.cpp Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,1693 @@
+// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// TS_AllInterfaceNotification.cpp
+// Contains the implementation of test cases testing the all interface notification
+// functionality of RConnection.
+//
+//
+
+/**
+ @file
+*/
+
+#include "TE_AllInterfaceNotification.h"
+#include <ss_std.h>
+
+#define ListOfSuitableIAPs iHungryNifIap, iDummyNifIap, iDefaultIap, iSecondHungryNifIap, iThirdHungryNifIap, iSecondDummyNifIap, iThirdDummyNifIap, iFourthDummyNifIap, iFifthDummyNifIap
+
+/******************************************************************************
+ *
+ * Test 300
+ *
+ *****************************************************************************/
+
+// Constructor
+
+// creates a connection and destroys it again
+enum TVerdict TE_RConnectionTest300::doTestStepL(void)
+{
+ TInt err;
+
+ RConnection activeConn;
+ RConnection conn;
+ RSocketServ ss;
+
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ err = OpenConnection(conn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(conn);
+
+ err = OpenConnection(activeConn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(activeConn);
+
+ err = StartConnection(conn);
+ TESTEL(KErrNone == err, err);
+
+ // issue request
+ AllInterfaceNotification(conn, status, info);
+
+ // start another different connection to complete request if it hasn't already done so
+ err = StartConnectionWithOverrides(activeConn, 1);
+ TESTEL(KErrNone == err, err);
+
+ // wait for completion
+ User::WaitForRequest(status);
+
+ // check for correct value
+ TESTEL(status.Int() == KErrInUse, status.Int());
+
+ CloseConnection(activeConn);
+ CleanupStack::Pop();
+
+ CloseConnection(conn);
+ CleanupStack::Pop();
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest300
+
+/******************************************************************************
+ *
+ * Test 301
+ *
+ *****************************************************************************/
+
+
+// creates a connection and destroys it again
+enum TVerdict TE_RConnectionTest301::doTestStepL(void)
+{
+ TInt err;
+
+ RConnection activeConn;
+ RConnection conn;
+ RSocketServ ss;
+
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ err = OpenConnection(conn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(conn);
+
+ err = OpenConnection(activeConn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(activeConn);
+
+ err = StartConnectionWithOverrides(conn, 1);
+ TESTEL(KErrNone == err, err);
+
+ // issue request
+ AllInterfaceNotification(conn, status, info);
+
+ // start another different connection to complete request if it hasn't already done so
+ err = StartConnectionWithOverrides(activeConn, 6);
+ TESTEL(KErrNone == err, err);
+
+ // wait for completion
+ User::WaitForRequest(status);
+
+ // check for correct value
+ TESTEL(status.Int() == KErrInUse, status.Int());
+
+ CloseConnection(activeConn);
+ CleanupStack::Pop();
+
+ CloseConnection(conn);
+ CleanupStack::Pop();
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest301
+
+/******************************************************************************
+ *
+ * Test 302
+ *
+ *****************************************************************************/
+
+
+// creates a connection and destroys it again
+enum TVerdict TE_RConnectionTest302::doTestStepL(void)
+{
+ TInt err;
+
+ RConnection activeConn;
+ RConnection conn;
+ RConnection conn2;
+ RSocketServ ss;
+ TUint numOfConnections;
+ TPckgBuf<TConnectionInfo> connInfo;
+
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ err = OpenConnection(conn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(conn);
+
+ err = OpenConnection(conn2, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(conn2);
+
+ err = OpenConnection(activeConn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(activeConn);
+
+ err = StartConnectionWithOverrides(conn, 1);
+ TESTEL(KErrNone == err, err);
+
+ // need to call Enumerate() before GetConnectionInfo() to set up array used there
+ err = EnumerateConnections(conn, numOfConnections);
+ TESTEL(KErrNone == err, err);
+ TESTEL(1 == numOfConnections, numOfConnections);
+
+ err = conn.GetConnectionInfo(1, connInfo);
+ TESTEL(KErrNone == err, err);
+
+ err = AttachNormal(conn2, connInfo);
+ TESTEL(KErrNone == err, err);
+
+ // issue request
+ AllInterfaceNotification(conn2, status, info);
+
+ // start another different connection to complete request if it hasn't already done so
+ err = StartConnectionWithOverrides(activeConn, 6);
+ TESTEL(KErrNone == err, err);
+
+ // wait for completion
+ User::WaitForRequest(status);
+
+ // check for correct value
+ TESTEL(status.Int() == KErrInUse, status.Int());
+
+ CloseConnection(activeConn);
+ CleanupStack::Pop();
+
+ CloseConnection(conn2);
+ CleanupStack::Pop();
+
+ CloseConnection(conn);
+ CleanupStack::Pop();
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest302
+
+/******************************************************************************
+ *
+ * Test 303
+ *
+ *****************************************************************************/
+
+
+// creates a connection and destroys it again
+enum TVerdict TE_RConnectionTest303::doTestStepL(void)
+{
+ TInt err;
+
+ RConnection conn;
+ RConnection monConn;
+ RSocketServ ss;
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ err = OpenConnection(conn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(conn);
+
+ err = OpenConnection(monConn, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monConn);
+
+ // issue request
+ AllInterfaceNotification(monConn, status, info);
+
+ // start another different connection to complete request if it hasn't already done so
+ err = StartConnectionWithOverrides(conn, 1);
+ TESTEL(KErrNone == err, err);
+
+ // wait for completion - to ensure that monitoring actually occurs
+ User::WaitForRequest(status);
+
+ // check for correct value
+ TESTEL(status.Int() == KErrNone, status.Int());
+
+ // issue another request (to be cancelled)
+ AllInterfaceNotification(monConn, status, info);
+
+ User::After(iShortTimeout); // wait for a period of time
+
+ // cancel request
+ CancelAllInterfaceNotificationL(monConn);
+
+ // wait for request completion
+ User::WaitForRequest(status);
+
+ // check for correct value
+ TESTEL(status.Int() == KErrCancel, status.Int());
+
+ CloseConnection(monConn);
+ CleanupStack::Pop();
+
+ CloseConnection(conn);
+ CleanupStack::Pop();
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest303
+
+/******************************************************************************
+ *
+ * Test 304
+ *
+ *****************************************************************************/
+
+
+// creates a connection and destroys it again
+enum TVerdict TE_RConnectionTest304::doTestStepL(void)
+{
+ TInt err;
+
+ RSocketServ socketServer;
+ RConnection connection;
+ RConnection monitor;
+
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(socketServer);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(socketServer);
+
+ err = OpenConnection(connection, socketServer);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection);
+
+ err = OpenConnection(monitor, socketServer);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor);
+
+ // issue request
+ AllInterfaceNotification(monitor, status, info);
+
+ // start connection to complete request
+ err = StartConnection(connection);
+ TESTEL(KErrNone == err, err);
+
+ CheckInterfaceNotificationL(status, info, EInterfaceUp, &connection);
+
+ // issue request
+ AllInterfaceNotification(monitor, status, info);
+
+ CloseConnection(connection);
+ CleanupStack::Pop();
+
+ CheckInterfaceNotificationL(status, info, EInterfaceDown);
+
+ CloseConnection(monitor);
+ CleanupStack::Pop();
+
+ CloseSocketServer(socketServer);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest304
+
+/******************************************************************************
+ *
+ * Test 305
+ *
+ *****************************************************************************/
+
+
+// creates a connection and destroys it again
+// Implicitly detect a single connection using SendTo()
+enum TVerdict TE_RConnectionTest305::doTestStepL(void)
+{
+ TInt err;
+
+ RConnection monitor;
+ RSocketServ ss;
+ RSocket sock;
+
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ err = OpenConnection(monitor, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor);
+
+ err = OpenUdpSocketL(sock, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(sock);
+
+ // issue request
+ AllInterfaceNotification(monitor, status, info);
+
+ err = TestUdpDataPathL(sock, iDummyNifSendAddr); // this will use SendTo()
+ TESTEL(KErrNone == err, err);
+
+ // check for interface up...
+ CheckInterfaceNotificationL(status, info, EInterfaceUp);
+
+ AllInterfaceNotification(monitor, status, info);
+
+ DestroyUdpSocket(sock);
+ CleanupStack::Pop();
+
+ // check for interface down...
+ CheckInterfaceNotificationL(status, info, EInterfaceDown);
+
+ CloseConnection(monitor);
+ CleanupStack::Pop();
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest305
+
+/******************************************************************************
+ *
+ * Test 306
+ *
+ *****************************************************************************/
+
+
+// creates a connection and destroys it again
+// Implicitly detect a single connection using SendTo()
+enum TVerdict TE_RConnectionTest306::doTestStepL(void)
+{
+ TInt err;
+
+ RSocketServ ss;
+ RSocket sock;
+
+ RConnection monitor;
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ err = OpenConnection(monitor, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor);
+
+ err = OpenTcpSocket(sock, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(sock);
+
+ // issue request
+ AllInterfaceNotification(monitor, status, info);
+
+ err = ConnectTcpSocket(sock, iEchoServerAddr); // this will use Connect()
+ TESTEL(KErrNone == err, err);
+
+ err = TestTcpDataPathL(sock);
+ TESTEL(KErrNone == err, err);
+
+ // check for interface up...
+ CheckInterfaceNotificationL(status, info, EInterfaceUp);
+
+ // issue request
+ AllInterfaceNotification(monitor, status, info);
+
+ err = DestroyTcpSocket(sock);
+ TESTEL(KErrNone == err, err);
+ CleanupStack::Pop();
+
+ // check for interface down...
+ CheckInterfaceNotificationL(status, info, EInterfaceDown);
+
+ CloseConnection(monitor);
+ CleanupStack::Pop();
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest306
+
+/******************************************************************************
+ *
+ * Test 307
+ *
+ *****************************************************************************/
+
+// Implicitly create a single connection using GetByName()
+enum TVerdict TE_RConnectionTest307::doTestStepL(void)
+{
+ TInt err;
+
+ RSocketServ ss;
+ RHostResolver hr;
+
+ RConnection monitor;
+ TRequestStatus status;
+ TInterfaceNotificationBuf info;
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ err = OpenConnection(monitor, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor);
+
+ err = OpenHostResolver(hr, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(hr);
+
+ // issue request
+ AllInterfaceNotification(monitor, status, info);
+
+ err = MakeNameRequest(hr, iTestName); // this will use GetByName()
+ TESTEL(KErrNone == err, err);
+
+ // check for interface up...
+ CheckInterfaceNotificationL(status, info, EInterfaceUp);
+
+ // issue request
+ AllInterfaceNotification(monitor, status, info);
+
+ DestroyHostResolver(hr);
+ CleanupStack::Pop();
+
+ // check for interface down...
+ CheckInterfaceNotificationL(status, info, EInterfaceDown);
+
+ CloseConnection(monitor);
+ CleanupStack::Pop();
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest307
+
+/******************************************************************************
+ *
+ * Test 308
+ *
+ *****************************************************************************/
+
+const TInt KTS308_NoofMonitors = 2;
+
+// creates a connection and destroys it again
+enum TVerdict TE_RConnectionTest308::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+
+ RSocketServ socketServer;
+ RConnection connection;
+
+ RConnection monitor[ KTS308_NoofMonitors ];
+ TRequestStatus status[ KTS308_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS308_NoofMonitors ];
+
+ err = OpenSocketServer(socketServer);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(socketServer);
+
+ err = OpenConnection(connection, socketServer);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection);
+
+ for( i = 0; i < KTS308_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], socketServer);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS308_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ // start connection to complete request
+ err = StartConnection(connection);
+ TESTEL(KErrNone == err, err);
+
+ // check for interface up...
+ for( i = 0; i < KTS308_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp, &connection);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS308_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ CloseConnection(connection);
+ CleanupStack::Pop();
+
+ // check for interface down...
+ for( i = 0; i < KTS308_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown, NULL);
+ }
+
+ // close monitors
+ for( i = 0; i < KTS308_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(socketServer);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest308
+
+/******************************************************************************
+ *
+ * Test 309
+ *
+ *****************************************************************************/
+
+
+const TInt KTS309_NoofMonitors = 2;
+
+// creates a connection and destroys it again
+// Implicitly detect a single connection using Connect()
+enum TVerdict TE_RConnectionTest309::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+
+ RSocketServ ss;
+ RSocket sock;
+
+ RConnection monitor[ KTS309_NoofMonitors ];
+ TRequestStatus status[ KTS309_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS309_NoofMonitors ];
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS309_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ err = OpenTcpSocket(sock, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(sock);
+
+ // issue requests
+ for( i = 0; i < KTS309_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ err = ConnectTcpSocket(sock, iEchoServerAddr); // this will use Connect()
+ TESTEL(KErrNone == err, err);
+
+ err = TestTcpDataPathL(sock);
+ TESTEL(KErrNone == err, err);
+
+ // check for interface up...
+ for( i = 0; i < KTS309_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS309_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ err = DestroyTcpSocket(sock);
+ TESTEL(KErrNone == err, err);
+ CleanupStack::Pop();
+
+ // check for interface down...
+ for( i = 0; i < KTS309_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown);
+ }
+
+ // close monitors
+ for( i = 0; i < KTS309_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest309
+
+/******************************************************************************
+ *
+ * Test 310
+ *
+ *****************************************************************************/
+
+
+const TInt KTS310_NoofMonitors = 2;
+
+// creates a connection and destroys it again
+// Implicitly detect a single connection using SendTo()
+enum TVerdict TE_RConnectionTest310::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+
+ RSocketServ ss;
+ RSocket sock;
+
+ RConnection monitor[ KTS310_NoofMonitors ];
+ TRequestStatus status[ KTS310_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS310_NoofMonitors ];
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS310_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ err = OpenUdpSocketL(sock, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(sock);
+
+ // issue requests
+ for( i = 0; i < KTS310_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ err = TestUdpDataPathL(sock, iDummyNifSendAddr); // this will use SendTo()
+ TESTEL(KErrNone == err, err);
+
+ // check for interface up...
+ for( i = 0; i < KTS310_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS310_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ DestroyUdpSocket(sock);
+ CleanupStack::Pop();
+
+ // check for interface down...
+ for( i = 0; i < KTS310_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown);
+ }
+
+ // close monitors
+ for( i = 0; i < KTS310_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest310
+
+/******************************************************************************
+ *
+ * Test 311
+ *
+ *****************************************************************************/
+
+const TInt KTS311_NoofMonitors = 2;
+
+// Implicitly create a single connection using GetByName()
+enum TVerdict TE_RConnectionTest311::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+
+ RSocketServ ss;
+ RHostResolver hr;
+
+ RConnection monitor[ KTS311_NoofMonitors ];
+ TRequestStatus status[ KTS311_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS311_NoofMonitors ];
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS311_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ err = OpenHostResolver(hr, ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(hr);
+
+ // issue requests
+ for( i = 0; i < KTS311_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ err = MakeNameRequest(hr, iTestName); // this will use GetByName()
+ TESTEL(KErrNone == err, err);
+
+ // check for interface up...
+ for( i = 0; i < KTS311_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS311_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ DestroyHostResolver(hr);
+ CleanupStack::Pop();
+
+ // check for interface down...
+ for( i = 0; i < KTS311_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown);
+ }
+
+ // close monitors
+ for( i = 0; i < KTS311_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest311
+
+/******************************************************************************
+ *
+ * Test 312
+ *
+ *****************************************************************************/
+
+const TInt KTS312_NoofMonitors = 1; // to make code same for multiple monitors
+const TInt KTS312_NoofConnections = 2;
+
+// Implicitly create a single connection using GetByName()
+enum TVerdict TE_RConnectionTest312::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+ TInt j; // used for nested loops
+
+ RSocketServ ss;
+ RConnection connection[ KTS312_NoofConnections ];
+ TInt iapId[] = {ListOfSuitableIAPs};
+
+ RConnection monitor[ KTS312_NoofMonitors ];
+ TRequestStatus status[ KTS312_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS312_NoofMonitors ];
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS312_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ for( i = 0; i < KTS312_NoofConnections; i++ )
+ {
+ err = OpenConnection(connection[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection[i]);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS312_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ // start several different connections
+ for( i = 0; i < KTS312_NoofConnections; i++ )
+ {
+ // the first of these should complete the initial request,
+ // the remainder should fill the cache
+ err = StartConnectionWithOverrides(connection[i], iapId[i]);
+ TESTEL(KErrNone == err, err);
+ }
+
+ for( j = 0; j < KTS312_NoofConnections; j++ )
+ {
+ for( i = 0; i < KTS312_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp, &connection[j]);
+ }
+
+ // re-issue requests, which should complete immediately with cached status
+ for( i = 0; i < KTS312_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ } // for j
+
+ // NOTE: request outstanding at this point...
+
+ // close connections
+ for( i = 0; i < KTS312_NoofConnections; i++ )
+ {
+ CloseConnection(connection[i]);
+ CleanupStack::Pop();
+ }
+
+ for( j = 0; j < KTS312_NoofConnections; j++ )
+ {
+ // check for interface down...
+ for( i = 0; i < KTS312_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown, NULL);
+ }
+
+ // reissue requests, except after last check
+ if( j != (KTS312_NoofConnections - 1) )
+ {
+ // re-issue requests, which should complete immediately with cached status
+ for( i = 0; i < KTS312_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+ }
+
+ } // for j
+
+ // close monitors
+ for( i = 0; i < KTS312_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest312
+
+/******************************************************************************
+ *
+ * Test 313
+ *
+ *****************************************************************************/
+
+const TInt KTS313_NoofMonitors = 2;
+const TInt KTS313_NoofConnections = 2;
+
+// Test multiple monitors receive notifications from multiple interfaces
+enum TVerdict TE_RConnectionTest313::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+ TInt j; // used for nested loops
+
+ RSocketServ ss;
+ RConnection connection[ KTS313_NoofConnections ];
+ TInt iapId[] = {ListOfSuitableIAPs};
+
+ RConnection monitor[ KTS313_NoofMonitors ];
+ TRequestStatus status[ KTS313_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS313_NoofMonitors ];
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS313_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ for( i = 0; i < KTS313_NoofConnections; i++ )
+ {
+ err = OpenConnection(connection[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection[i]);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS313_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ // start several different connections
+ for( i = 0; i < KTS313_NoofConnections; i++ )
+ {
+ // the first of these should complete the initial request,
+ // the remainder should fill the cache
+ err = StartConnectionWithOverrides(connection[i], iapId[i]);
+ TESTEL(KErrNone == err, err);
+ }
+
+ for( j = 0; j < KTS313_NoofConnections; j++ )
+ {
+ for( i = 0; i < KTS313_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp, &connection[j]);
+
+ // re-issue requests, which should complete immediately with cached status
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ } // for j
+
+ // NOTE: request outstanding at this point...
+
+ // close connections
+ for( i = 0; i < KTS313_NoofConnections; i++ )
+ {
+ CloseConnection(connection[i]);
+ CleanupStack::Pop();
+ }
+
+ for( j = 0; j < KTS313_NoofConnections; j++ )
+ {
+ // check for interface down...
+ for( i = 0; i < KTS313_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown, NULL);
+
+ // except after last check...
+ if( j != (KTS313_NoofConnections - 1) )
+ {
+ // ...re-issue request, which should complete immediately with cached status
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+ }
+
+
+ } // for j
+
+ // close monitors
+ for( i = 0; i < KTS313_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest313
+
+#undef TS313_NoofMonitors
+#undef TS313_NoofConnections
+
+/******************************************************************************
+ *
+ * Test 314
+ *
+ * This code will be the same as for test 316, but with just one monitor.
+ *
+ *****************************************************************************/
+
+const TInt KTS314_NoofMonitors = 1; // to make code same for multiple monitors
+const TInt KTS314_NoofConnections = ((TInt)KMaxInterfaceNotificationQueueLength+1);
+
+// Test multiple monitors receive notifications from multiple interfaces
+enum TVerdict TE_RConnectionTest314::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+ TInt j; // used for nested loops
+
+ RSocketServ ss;
+ RConnection connection[ KTS314_NoofConnections ];
+
+ RConnection monitor[ KTS314_NoofMonitors ];
+ TRequestStatus status[ KTS314_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS314_NoofMonitors ];
+ TInt iapId[] = {ListOfSuitableIAPs};
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS314_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ for( i = 0; i < KTS314_NoofConnections; i++ )
+ {
+ err = OpenConnection(connection[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection[i]);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS314_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ // start several different connections
+ for( i = 0; i < KTS314_NoofConnections; i++ )
+ {
+ // the first of these should complete the initial request,
+ // the remainder should fill the cache
+ err = StartConnectionWithOverrides(connection[i], iapId[i]);
+ if(KErrNone != err)
+ {
+ // Swallow outstanding signals
+ for(i=0;i<KTS314_NoofMonitors;i++)
+ {
+ User::WaitForAnyRequest();
+ }
+ User::Leave(err);
+ }
+ }
+
+ for( j = 0; j < KTS314_NoofConnections; j++ )
+ {
+ for( i = 0; i < KTS314_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp, &connection[j]);
+ // re-issue requests, which should complete immediately with cached status
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ } // for j
+
+ // NOTE: request outstanding at this point...
+
+ // close connections
+ for( i = 0; i < KTS314_NoofConnections; i++ )
+ {
+ CloseConnection(connection[i]);
+ CleanupStack::Pop();
+ }
+
+ for( j = 0; j < KTS314_NoofConnections; j++ )
+ {
+ // check for interface down...
+ for( i = 0; i < KTS314_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown, NULL);
+ }
+
+ // reissue requests, except after last check
+ if( j != (KTS314_NoofConnections - 1) )
+ {
+ // re-issue requests, which should complete immediately with cached status
+ for( i = 0; i < KTS314_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+ }
+
+ } // for j
+
+ // close monitors
+ for( i = 0; i < KTS314_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest314
+
+/******************************************************************************
+ *
+ * Test 315
+ *
+ * This code will be the same as for test 317, but with just one monitor.
+ *
+ *****************************************************************************/
+
+
+const TInt KTS315_NoofMonitors = 1; // to make code same for multiple monitors
+const TInt KTS315_NoofConnections = ((TInt)KMaxInterfaceNotificationQueueLength);
+
+// Test multiple monitors receive notifications from multiple interfaces
+enum TVerdict TE_RConnectionTest315::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+ TInt j; // used for nested loops
+
+ RSocketServ ss;
+ RConnection connection[ KTS315_NoofConnections ];
+
+ RConnection monitor[ KTS315_NoofMonitors ];
+ TRequestStatus status[ KTS315_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS315_NoofMonitors ];
+ TInt iapId[] = {ListOfSuitableIAPs};
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS315_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ for( i = 0; i < KTS315_NoofConnections; i++ )
+ {
+ err = OpenConnection(connection[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection[i]);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS315_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ // start several different connections
+ for( i = 0; i < KTS315_NoofConnections; i++ )
+ {
+ // the first of these should complete the initial request,
+ // the remainder should fill the cache
+ err = StartConnectionWithOverrides(connection[i], iapId[i]);
+ if(KErrNone != err)
+ {
+ // Swallow outstanding signals
+ for(i=0;i<KTS315_NoofMonitors;i++)
+ {
+ User::WaitForAnyRequest();
+ }
+ User::Leave(err);
+ }
+ }
+
+ // all but one connection status change should be cached
+ // the odd one having completed the outstanding request
+
+ // check completed request (uncached status change)
+ for( i = 0; i < KTS315_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp, &connection[0]);
+ }
+
+ // not checking for remainder of "up" values, these will be lost by subsequent "down" values
+
+ // close connections
+ for( i = 0; i < KTS315_NoofConnections; i++ )
+ {
+ CloseConnection(connection[i]);
+ CleanupStack::Pop();
+ }
+
+ // need to wait for interfaces to be taken down
+ err = WaitForAllInterfacesToCloseL(ss);
+ TESTEL(KErrNone == err, err);
+
+ // closing connection notifications should overwrite all "up" values in cache
+ for( j = 0; j < KTS315_NoofConnections; j++ )
+ {
+ for( i = 0; i < KTS315_NoofMonitors; i++ )
+ {
+ // re-issue requests, which should complete immediately with cached status
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ // check for interface down...
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown, NULL);
+ }
+ } // for j
+
+ // close monitors
+ for( i = 0; i < KTS315_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest315
+
+/******************************************************************************
+ *
+ * Test 316
+ *
+ * This code will be the same as for test 314, but with multiple monitors.
+ *
+ *****************************************************************************/
+
+const TInt KTS316_NoofMonitors = 2; // to make code same for multiple monitors
+const TInt KTS316_NoofConnections = ((TInt)KMaxInterfaceNotificationQueueLength+1);
+
+// Test multiple monitors receive notifications from multiple interfaces
+enum TVerdict TE_RConnectionTest316::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+ TInt j; // used for nested loops
+
+ RSocketServ ss;
+ RConnection connection[ KTS316_NoofConnections ];
+
+ RConnection monitor[ KTS316_NoofMonitors ];
+ TRequestStatus status[ KTS316_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS316_NoofMonitors ];
+ TInt iapId[] = {ListOfSuitableIAPs};
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS316_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ for( i = 0; i < KTS316_NoofConnections; i++ )
+ {
+ err = OpenConnection(connection[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection[i]);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS316_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ // start several different connections
+ for( i = 0; i < KTS316_NoofConnections; i++ )
+ {
+ // the first of these should complete the initial request,
+ // the remainder should fill the cache
+ err = StartConnectionWithOverrides(connection[i], iapId[i]);
+ if(KErrNone != err)
+ {
+ // Swallow outstanding signals
+ for(i=0;i<KTS316_NoofMonitors;i++)
+ {
+ User::WaitForAnyRequest();
+ }
+ User::Leave(err);
+ }
+ }
+
+ for( j = 0; j < KTS316_NoofConnections; j++ )
+ {
+ for( i = 0; i < KTS316_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp, &connection[j]);
+ }
+
+ // re-issue requests, which should complete immediately with cached status
+ for( i = 0; i < KTS316_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ } // for j
+
+ // NOTE: request outstanding at this point...
+
+ // close connections
+ for( i = 0; i < KTS316_NoofConnections; i++ )
+ {
+ CloseConnection(connection[i]);
+ CleanupStack::Pop();
+ }
+
+ for( j = 0; j < KTS316_NoofConnections; j++ )
+ {
+ // check for interface down...
+ for( i = 0; i < KTS316_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown, NULL);
+ }
+
+ // reissue requests, except after last check
+ if( j != (KTS316_NoofConnections - 1) )
+ {
+ // re-issue requests, which should complete immediately with cached status
+ for( i = 0; i < KTS316_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+ }
+
+ } // for j
+
+ // close monitors
+ for( i = 0; i < KTS316_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest316
+
+/******************************************************************************
+ *
+ * Test 317
+ *
+ * This code will be the same as for test 315, but with multiple monitors.
+ *
+ *****************************************************************************/
+
+const TInt KTS317_NoofMonitors = 2; // to make code same for multiple monitors
+const TInt KTS317_NoofConnections = ((TInt)KMaxInterfaceNotificationQueueLength);
+
+// Test multiple monitors receive notifications from multiple interfaces
+enum TVerdict TE_RConnectionTest317::doTestStepL(void)
+{
+ TInt err;
+ TInt i;
+ TInt j; // used for nested loops
+
+ RSocketServ ss;
+ RConnection connection[ KTS317_NoofConnections ];
+
+ RConnection monitor[ KTS317_NoofMonitors ];
+ TRequestStatus status[ KTS317_NoofMonitors ];
+ TInterfaceNotificationBuf info[ KTS317_NoofMonitors ];
+ TInt iapId[] = {ListOfSuitableIAPs};
+
+ err = OpenSocketServer(ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(ss);
+
+ for( i = 0; i < KTS317_NoofMonitors; i++ )
+ {
+ err = OpenConnection(monitor[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(monitor[i]);
+ }
+
+ for( i = 0; i < KTS317_NoofConnections; i++ )
+ {
+ err = OpenConnection(connection[i], ss);
+ TESTEL(KErrNone == err, err);
+ CleanupClosePushL(connection[i]);
+ }
+
+ // issue requests
+ for( i = 0; i < KTS317_NoofMonitors; i++ )
+ {
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ }
+
+ // start several different connections
+ for( i = 0; i < KTS317_NoofConnections; i++ )
+ {
+ // the first of these should complete the initial request,
+ // the remainder should fill the cache
+ err = StartConnectionWithOverrides(connection[i], iapId[i]);
+ if(KErrNone != err)
+ {
+ // Swallow outstanding signals
+ for(i=0;i<KTS317_NoofMonitors;i++)
+ {
+ User::WaitForAnyRequest();
+ }
+ User::Leave(err);
+ }
+ }
+
+ // all but one connection status change should be cached
+ // the odd one having completed the outstanding request
+
+ // check completed request (uncached status change)
+ for( i = 0; i < KTS317_NoofMonitors; i++ )
+ {
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceUp, &connection[0]);
+ }
+
+ // not checking for remainder of "up" values, these will be lost by subsequent "down" values
+
+ // close connections
+ for( i = 0; i < KTS317_NoofConnections; i++ )
+ {
+ CloseConnection(connection[i]);
+ CleanupStack::Pop();
+ }
+
+ // need to wait for interfaces to be taken down
+ err = WaitForAllInterfacesToCloseL(ss);
+ TESTEL(KErrNone == err, err);
+
+ // closing connection notifications should overwrite all "up" values in cache
+ for( j = 0; j < KTS317_NoofConnections; j++ )
+ {
+ // check for interface down...
+ for( i = 0; i < KTS317_NoofMonitors; i++ )
+ {
+ // re-issue requests, which should complete immediately with cached status
+ AllInterfaceNotification(monitor[i], status[i], info[i]);
+ // check for interface down...
+ CheckInterfaceNotificationL(status[i], info[i], EInterfaceDown);
+ }
+ } // for j
+
+ // close monitors
+ for( i = 0; i < KTS317_NoofMonitors; i++ )
+ {
+ CloseConnection(monitor[i]);
+ CleanupStack::Pop();
+ }
+
+ CloseSocketServer(ss);
+ CleanupStack::Pop();
+
+ return TestStepResult();
+
+} // TE_RConnectionTest317
+
+/******************************************************************************
+ *
+ * Test 318
+ *
+ * To test multiple start.
+ *
+ *****************************************************************************/
+// To test multiple start
+enum TVerdict TE_RConnectionTest318::doTestStepL(void)
+{
+ RSocketServ ss;
+ RConnection conn1;
+
+ TRequestStatus tStartConn;
+
+ TInt nErr = OpenSocketServer( ss );
+ TESTEL(KErrNone == nErr, nErr);
+ CleanupClosePushL(ss);
+
+ nErr = conn1.Open( ss );
+ TESTEL( nErr == KErrNone, nErr );
+ CleanupClosePushL(conn1);
+
+ conn1.Start( tStartConn );
+ nErr = conn1.Start();
+ //shouldn't be so quick KErrInUse expected
+ TESTEL( nErr == KErrInUse, nErr );
+ // wait for completion
+ User::WaitForRequest( tStartConn );
+ TESTEL( tStartConn.Int() == KErrNone, tStartConn.Int() );
+
+ //close conn1
+ conn1.Stop();
+ CleanupStack::PopAndDestroy();
+
+ //the other way around
+ nErr = conn1.Open( ss );
+ TESTEL( nErr == KErrNone, nErr );
+ CleanupClosePushL(conn1);
+
+ nErr = conn1.Start();
+ TESTEL( nErr == KErrNone, nErr );
+ conn1.Start( tStartConn );
+ User::WaitForRequest( tStartConn );
+ //should get KErrAlreadyExists
+ TESTEL( tStartConn.Int() == KErrAlreadyExists, tStartConn.Int() );
+
+ //close conn1
+ conn1.Stop();
+ CleanupStack::PopAndDestroy();
+
+ //close ss
+ CleanupStack::PopAndDestroy();
+ return TestStepResult();
+} // TE_RConnectionTest318
+
+/******************************************************************************
+ *
+ * Test 319
+ *
+ * To test progress
+ *
+ *****************************************************************************/
+
+// To test progress
+enum TVerdict TE_RConnectionTest319::doTestStepL(void)
+{
+ RSocketServ ss;
+ RConnection conn1;
+
+ TRequestStatus tStartConn;
+
+ TInt nErr = OpenSocketServer( ss );
+ TESTEL(KErrNone == nErr, nErr);
+ CleanupClosePushL(ss);
+
+ nErr = conn1.Open( ss );
+ TESTEL( nErr == KErrNone, nErr );
+ CleanupClosePushL(conn1);
+
+ TNifProgress tProg;
+ conn1.Progress( tProg );
+ TESTEL( tProg.iError == KErrNone && tProg.iStage == 0, tProg.iError );
+
+ TNifProgressBuf tNifProgressBuf;
+ conn1.ProgressNotification( tNifProgressBuf, tStartConn, KConnProgressDefault );
+ nErr = conn1.Start();
+ TESTEL( nErr == KErrNone, nErr );
+ User::WaitForRequest( tStartConn );
+ TESTEL( tStartConn.Int() == KErrNone, tStartConn.Int() );
+ TESTEL( tNifProgressBuf().iStage == KStartingSelection, tNifProgressBuf().iStage );
+
+ //close conn1
+ conn1.Stop();
+ CleanupStack::PopAndDestroy();
+
+ nErr = conn1.Open( ss );
+ TESTEL( nErr == KErrNone, nErr );
+ CleanupClosePushL(conn1);
+
+ conn1.Progress( tProg );
+ TESTEL( tProg.iError == KErrNone && tProg.iStage == 0, tProg.iError );
+ //wait for particular guy
+ conn1.ProgressNotification( tNifProgressBuf, tStartConn, KFinishedSelection );
+ nErr = conn1.Start();
+ TESTEL( nErr == KErrNone, nErr );
+ User::WaitForRequest( tStartConn );
+ TESTEL( tStartConn.Int() == KErrNone, tStartConn.Int() );
+ TESTEL( tNifProgressBuf().iStage == KFinishedSelection, tNifProgressBuf().iStage );
+
+ //close conn1
+ conn1.Stop();
+ CleanupStack::PopAndDestroy();
+
+ //close ss
+ CleanupStack::PopAndDestroy();
+ return TestStepResult();
+} // TE_RConnectionTest319
+