// Copyright (c) 2004-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:
// This contains ESock Test cases from section 14
// 
//

// EPOC includes
#include <e32base.h>
#include <test/es_dummy.h>

// Test system includes
#include "SocketTestSection14.h"


// Test step 14.1
const TDesC& CSocketTest14_1::GetTestName()
	{
	_LIT(ret,"Test14.1");
	return ret;
	}

enum TVerdict CSocketTest14_1::InternalDoTestStepL( void )
	{
	TVerdict verdict = EPass;
	
	Logger().WriteFormat(_L("Testing erroring a listening socket"));
	RSocketServ ss;
	TInt ret=OptimalConnect(ss);
	CleanupClosePushL(ss);
    TESTL(KErrNone == ret);	
    
	Logger().WriteFormat(_L("Open by name"));             
	RSocket sock, sock2;                                                    
	ret=sock.Open(ss,_L("Dummy Protocol 3")); // dummy 3 is reconnectable                         
	TESTL(KErrNone == ret);	
	
	ret=sock2.Open(ss); // null socket to accept onto                         
	TESTL(KErrNone == ret);	
	
	Logger().WriteFormat(_L("Set test option"));             
	const TInt KExpectedError = -4567; // Something random.
	ret=sock.SetOpt(KDummyOptionSetErrorNextListen,0,KExpectedError);
	TESTL(KErrNone == ret);	
	
	TSockAddr addr;
	ret=sock.Bind(addr);
	TESTL(KErrNone == ret);	
	
	Logger().WriteFormat(_L("Listen"));             
	ret=sock.Listen(0); // No need for a que
	TESTL(KErrNone == ret);	
	
	Logger().WriteFormat(_L("Accept - error"));             
	TRequestStatus rstat;
	sock.Accept(sock2, rstat);
	User::WaitForRequest(rstat);
	TESTL(rstat.Int() == KExpectedError);	
	
	Logger().WriteFormat(_L("Listen - reconnect"));             
	ret=sock.Listen(1);
	TESTL(KErrNone == ret);	
	
    Logger().WriteFormat(_L("Accept"));             
	sock.Accept(sock2, rstat);
    //emulate en connect complete event
	ret=sock.SetOpt(KDummyOptionSetConnectComplete,0,0);
	TESTL(KErrNone == ret);	
	User::WaitForRequest(rstat);
	TESTL(rstat.Int() == KErrNone);	
	
	CleanupStack::Pop(&ss);
    ss.Close();
	
	SetTestStepResult(verdict);
	return verdict;
	}
	
	// Test step 14.2
const TDesC& CSocketTest14_2::GetTestName()
	{
	_LIT(ret,"Test14.2");
	return ret;
	}

enum TVerdict CSocketTest14_2::InternalDoTestStepL( void )
	{
	TVerdict verdict = EPass;
	TInt ret;
	
	Logger().WriteFormat(_L("Test14.2 Error writing to socket"));
	RSocketServ ss;
	ret = OptimalConnect(ss);
	TESTL(KErrNone == ret);	
	CleanupClosePushL(ss);
    
	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             
	RSocket sock;                                                  
	ret = sock.Open(ss,_L("Dummy Protocol 3")); // dummy 3 is reconnectable
	TESTL(KErrNone == ret);
	
	TSockAddr addr;
	TRequestStatus stat;
	sock.Connect(addr, stat);
	User::WaitForRequest(stat);
	TESTL(KErrNone == stat.Int());	
	
	const TInt KExpectedError = -4567; // Something random.
	Logger().WriteFormat(_L("Set write error code to %d"), KExpectedError);             
	ret=sock.SetOpt(KDummyOptionSetErrorNextWrite, 0, KExpectedError);
	TESTL(KErrNone == ret);	
		
	_LIT8(KWriteData,"1234\t\n\rcwe8\'\"");
	Logger().WriteFormat(_L("Sending Data - Should fail with %d"), KExpectedError);             
	sock.Send(KWriteData(), 0, stat);
	User::WaitForRequest(stat);
	TESTL(KExpectedError == stat.Int());	
	
	Logger().WriteFormat(_L("Sending Data - Should Succeed"));             
	sock.Send(KWriteData(),0,stat);
	User::WaitForRequest(stat);
	TESTL(KErrNone == stat.Int());	
	
	Logger().WriteFormat(_L("Receiving Data"));
	TBuf8<20> buf;          
	sock.Recv(buf, 0, stat);
	User::WaitForRequest(stat);
	TESTL(KErrNone == stat.Int());	
	
    TESTL(buf == KWriteData);	
	
	CleanupStack::Pop(&ss);
    ss.Close();
	
	SetTestStepResult(verdict);
	return verdict;
	}
	
	// Test step 14.3
const TDesC& CSocketTest14_3::GetTestName()
	{
	_LIT(ret,"Test14.3");
	return ret;
	}

enum TVerdict CSocketTest14_3::InternalDoTestStepL( void )
	{
	TVerdict verdict = EPass;
	TInt ret;
	
	Logger().WriteFormat(_L("Test14.3 Error shutting a socket down"));
	RSocketServ ss;
	ret = OptimalConnect(ss);
	TESTL(KErrNone == ret);	
	CleanupClosePushL(ss);
    
	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             
	RSocket sock;                                                  
	ret = sock.Open(ss,_L("Dummy Protocol 3")); // dummy 3 is reconnectable
	TESTL(KErrNone == ret);
	
	TSockAddr addr;
	TRequestStatus stat;
	sock.Connect(addr, stat);
	User::WaitForRequest(stat);
	TESTL(KErrNone == stat.Int());	
	
	const TInt KExpectedError = -4567; // Something random.
	Logger().WriteFormat(_L("Set write error code to %d"), KExpectedError);             
	ret=sock.SetOpt(KDummyOptionSetErrorNextShutdown, 0, KExpectedError);
	TESTL(KErrNone == ret);	
	
	Logger().WriteFormat(_L("Shutting the socket down"));             
	sock.Shutdown(RSocket::EImmediate,stat);
	User::WaitForRequest(stat);
	TESTL(KExpectedError == stat.Int());	
	
	CleanupStack::Pop(&ss);
    ss.Close();
	
	SetTestStepResult(verdict);
	return verdict;
	}
	
		// Test step 14.4
const TDesC& CSocketTest14_4::GetTestName()
	{
	_LIT(ret,"Test14.4");
	return ret;
	}

enum TVerdict CSocketTest14_4::InternalDoTestStepL( void )
	{
	TVerdict verdict = EPass;
	TInt ret;
	
	Logger().WriteFormat(_L("Test14.4 Error connecting to socket down"));
	RSocketServ ss;
	ret = OptimalConnect(ss);
	TESTL(KErrNone == ret);	
	CleanupClosePushL(ss);
    
	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             
	RSocket sock;                                                  
	ret = sock.Open(ss,_L("Dummy Protocol 3")); // dummy 3 is reconnectable
	TESTL(KErrNone == ret);
	
	const TInt KExpectedError = -4567; // Something random.
	Logger().WriteFormat(_L("Set connect error code to %d"), KExpectedError);             
	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);
	TESTL(KErrNone == ret);
	
	TSockAddr addr;
	TRequestStatus stat;
	sock.Connect(addr, stat);
	User::WaitForRequest(stat);
	TESTL(KExpectedError == stat.Int());
	
	Logger().WriteFormat(_L("Set write error code to %d"), KExpectedError);             
	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);
	TESTL(KErrNone == ret);
	
	Logger().WriteFormat(_L("Performing Connect"));
	sock.Connect(addr, stat);
	User::WaitForRequest(stat);
	TESTL(KExpectedError == stat.Int());	
	
	Logger().WriteFormat(_L("Setting blocked connect"));             
	ret=sock.SetOpt(KDummyOptionSetBlockConnect, 0, TRUE);
	TESTL(KErrNone == ret);
	
	Logger().WriteFormat(_L("Set connect error code to %d"), KExpectedError);             
	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);
	TESTL(KErrNone == ret);	
	
	Logger().WriteFormat(_L("Performing Connect"));
	sock.Connect(addr, stat);
	User::WaitForRequest(stat);
	TESTL(KExpectedError == stat.Int());		
	
	Logger().WriteFormat(_L("Setting blocked connect"));             
	ret=sock.SetOpt(KDummyOptionSetBlockConnect, 0, TRUE);
	TESTL(KErrNone == ret);
	
	Logger().WriteFormat(_L("Performing Connect"));
	sock.Connect(addr, stat);
	
	Logger().WriteFormat(_L("Set connect error code to %d"), KExpectedError);             
	ret=sock.SetOpt(KDummyOptionSetErrorNextConnect, 0, KExpectedError);
	TESTL(KErrNone == ret);	
	
	Logger().WriteFormat(_L("Setting blocked connect off"));             
	ret=sock.SetOpt(KDummyOptionSetBlockConnect, 0, FALSE);
	TESTL(KErrNone == ret);
		
	User::WaitForRequest(stat);
	TESTL(KExpectedError == stat.Int());	
	
	
	CleanupStack::Pop(&ss);
    ss.Close();
	
	SetTestStepResult(verdict);
	return verdict;
	}
	
		// Test step 14.5
const TDesC& CSocketTest14_5::GetTestName()
	{
	_LIT(ret,"Test14.5");
	return ret;
	}

enum TVerdict CSocketTest14_5::InternalDoTestStepL( void )
	{
	TVerdict verdict = EPass;
	TInt ret;
	
	Logger().WriteFormat(_L("Test14.5 Two accepts accepting on the same null socket"));
	RSocketServ ss;
	ret = OptimalConnect(ss);
	TESTL(KErrNone == ret);	
	CleanupClosePushL(ss);
    
	Logger().WriteFormat(_L("Openning Dummy Protocol 2"));             
	RSocket sock;                                                  
	ret = sock.Open(ss,_L("Dummy Protocol 2")); 
	TESTL(KErrNone == ret);
	
	TSockAddr addr;
	TRequestStatus stat;
	
	Logger().WriteFormat(_L("Binding sock1"));             
	ret = sock.Bind(addr); 
	TESTL(KErrNone == ret);
	
	Logger().WriteFormat(_L("Listening on sock1"));             
	ret = sock.Listen(5); 
	TESTL(KErrNone == ret);
	
	Logger().WriteFormat(_L("Openning Dummy Protocol 3"));             
	RSocket sock2;                                                  
	ret = sock2.Open(ss,_L("Dummy Protocol 3")); 
	TESTL(KErrNone == ret);
	
	TSockAddr addr2;
		
	Logger().WriteFormat(_L("Binding sock2"));             
	ret = sock2.Bind(addr); 
	TESTL(KErrNone == ret);
	
	Logger().WriteFormat(_L("Listening on sock2"));             
	ret = sock2.Listen(5); 
	TESTL(KErrNone == ret);
	
	Logger().WriteFormat(_L("Null socket"));             
	RSocket nullsock;                                                  
	ret = nullsock.Open(ss); 
	TESTL(KErrNone == ret);
	
	TRequestStatus stat2;
	
	Logger().WriteFormat(_L("Accepting on sock1"));             
	sock.Accept(nullsock,stat); 
	
	Logger().WriteFormat(_L("Accepting on sock2"));             
	sock2.Accept(nullsock,stat2); 
	
	// Wait to be paniced
	User::After( 5000000 );
	
	//Should have panicked by now so lets just fail the test.
	verdict = EFail;
	CleanupStack::Pop(&ss);
    ss.Close();
	
	SetTestStepResult(verdict);
	return verdict;
	}