examples/Base/IPC/AdvancedClientServerExample/test/te_ThreadClientServerTest/src/MainTestStep.cpp

Go to the documentation of this file.

/*
Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: Example CTestStep derived implementation 
*/



#include "MainTestStep.h"
#include "Te_ThreadClientServerTestSuiteDefs.h"

//common descriptors
_LIT(KTestCaseId, "tc_id");
_LIT8(KTestData, "abcdefghijklmnopqrstuvwxyz");

CMainTestStep::~CMainTestStep()
        {
        }
CMainTestStep::CMainTestStep(CTe_ThreadClientServerTestSuite& aParent)
:CTe_ThreadClientServerTestSuiteStepBase(aParent)
        {
        // **MUST** call SetTestStepName in the constructor as the controlling
        // framework uses the test step name immediately following construction to set
        // up the step's unique logging ID.
        SetTestStepName(KMainTestStep);
        }
TVerdict CMainTestStep::doTestStepL()
        {
          if (TestStepResult()==EPass)
                {
                // get the test case id from ini file
                TInt id;
                if (!GetIntFromConfig(ConfigSection(),KTestCaseId,id))
                        {
                        User::Panic(_L("Cannot fetch test case id value from ini file"), 1);
                        }
                        
                RThreadClient& client = iParent.Handler();
                if (id != 6)
                        {
                        //common setting for all test cases except test case SampleThreadServer-0006
                        CleanupClosePushL(client);
                        User::LeaveIfError(client.Connect());
                        INFO_PRINTF1(_L("Connected to Thread Server"));
                        }
        
                // common variables used in test cases
                TInt r;
                TRequestStatus status;
                
                switch (id)
                        {
                        case 1: 
                                {
                                // Test case "SampleThreadServer-0001"
                                // Check the device driver (both LDD and PDD) have been loaded when 
                                // client has connected to server
                                _LIT(KSampleDriverLddFileName,"DRIVER1_LDD");
                                _LIT(KSampleDriverPddFileName,"DRIVER1_PDD");
                                INFO_PRINTF1(_L("Trying to load the same device driver Pdd"));
                                r = User::LoadPhysicalDevice(KSampleDriverPddFileName);
                                INFO_PRINTF3(_L("Expect Error %d : Receive Error %d"), KErrAlreadyExists,r);
                                if (r!= KErrAlreadyExists)
                                        {
                                        SetTestStepResult(EFail);
                                        break;
                                        }
                                
                                INFO_PRINTF1(_L("Trying to load the same device driver Ldd"));
                                r = User::LoadLogicalDevice(KSampleDriverLddFileName);
                                INFO_PRINTF3(_L("Expect Error %d : Receive Error %d"), KErrAlreadyExists,r);
                                if (r!= KErrAlreadyExists)
                                        {
                                        SetTestStepResult(EFail);
                                        }
                                }
                                break;
                                
                        case 2:
                                {
                                // Test case "SampleThreadServer-0002"
                                // Issue asynchronous request to server
                                User::LeaveIfError(client.OpenDriver());
                                INFO_PRINTF1(_L("Device Driver Opened"));
                                
                                INFO_PRINTF1(_L("Sending Data 1"));
                                client.Send(KTestData,status);
                                User::WaitForRequest(status);
                                INFO_PRINTF3(_L("Expect Error %d : Receive Error %d"), KErrNone,status.Int());
                                if (status.Int()!=KErrNone)
                                        {
                                        SetTestStepResult(EFail);
                                        }
                                }
                                break;
                                
                        case 3:
                                {
                                // Test case "SampleThreadServer-0003"
                                // Cancel outstanding asynchronous request
                                User::LeaveIfError(client.OpenDriver());
                                INFO_PRINTF1(_L("Device Driver Opened"));
                                
                                INFO_PRINTF1(_L("Sending Data 2"));
                                client.Send(KTestData,status);
                                INFO_PRINTF1(_L("Cancel Sending Data 2"));
                                client.SendCancel();
                                User::WaitForRequest(status);
                                INFO_PRINTF3(_L("Expect Error %d : Receive Error %d"), KErrCancel,status.Int());
                                if (status!=KErrCancel)
                                        {
                                        SetTestStepResult(EFail);
                                        }
                                }
                                break;
                                
                        case 4:
                                {
                                // Test case "SampleThreadServer-0004"
                                // Issue two synchronous requests to server
                                User::LeaveIfError(client.OpenDriver());
                                INFO_PRINTF1(_L("Device Driver Opened"));
                                
                                INFO_PRINTF1(_L("Sending Data 3"));
                                client.Send(KTestData,status);
                                
                                TRequestStatus status2;
                                INFO_PRINTF1(_L("Sending Data 4"));
                                client.Send(KTestData,status2);
                                
                                User::WaitForRequest(status);
                                INFO_PRINTF1(_L("Finished Sending Data 3"));
                                INFO_PRINTF3(_L("Expect Error %d : Receive Error %d"), KErrNone,status.Int());
                                if (status!=KErrNone)
                                        {
                                        SetTestStepResult(EFail);
                                        }
                                User::WaitForRequest(status2);
                                INFO_PRINTF1(_L("Finished Sending Data 4"));
                                INFO_PRINTF3(_L("Expect Error %d : Receive Error %d"), KErrNone,status2.Int());
                                if (status2!=KErrNone)
                                        {
                                        SetTestStepResult(EFail);
                                        }
                                }
                                break;
                        
                        case 5:
                                {
                                // Test case "SampleThreadServer-0005"
                                // Repeatly loading and unloading device driver using client APIs
                                r = client.LoadDeviceDriver();
                                if (r!=KErrNone)
                                        {
                                        INFO_PRINTF2(_L("Loading Device Driver Finished with error %d"), r);
                                        SetTestStepResult(EFail);
                                        break;
                                        }
                                INFO_PRINTF1(_L("Device Driver Loaded"));
                                
                                r = client.UnloadDeviceDriver();
                                if (r!=KErrNone)
                                        {
                                        INFO_PRINTF2(_L("Unloading Device Driver Finished with error %d"), r);
                                        SetTestStepResult(EFail);
                                        break;
                                        }
                                INFO_PRINTF1(_L("Device Driver Unloaded"));
                                }
                                break;
                                
                        case 6:
                                {
                                // test case SampleThreadServer-0006
                                // two test steps are running concurrently to
                                // simulate two clients trying to connect to server
                                // at the same time
                                RThreadClient anotherClient;
                                CleanupClosePushL(anotherClient);
                                INFO_PRINTF1(_L("trying to connect to server"));
                                r = anotherClient.Connect();
                                INFO_PRINTF2(_L("Connected to Process Server with error %d"), r);
                                if (KErrNone!=r)
                                        {
                                        SetTestStepResult(EFail);
                                        }
                                CleanupStack::PopAndDestroy(&anotherClient);
                                INFO_PRINTF1(_L("Close Handle to ThreadServer"));
                                }
                                break;
                                
                        default:
                                User::Panic(_L("Unregonised Test Case IDs"), 1);
                        }
                
                if (id != 6)
                        {
                        CleanupStack::PopAndDestroy(&client); 
                        INFO_PRINTF1(_L("Close Handle to ThreadServer"));
                        }
                
                

                }
          return TestStepResult();
        }



//eof

---