diff -r 000000000000 -r dfb7c4ff071f commsconfig/commsdatabaseshim/ts_commdb/Step_022_xx.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsconfig/commsdatabaseshim/ts_commdb/Step_022_xx.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,1573 @@ +// Copyright (c) 2001-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 CommDb Unit Test Cases 022.XX +// +// + +// EPOC includes +#include +#include +#include + +// Test system includes +#include +#include +#include "Teststepcommdb.h" +#include "TestSuiteCommdb.h" +#include "Step_022_xx.h" + + +// +// Test step 022.01 +// + +// constructor +CCommDbTest022_01::CCommDbTest022_01() + { + // store the name of this test case + iTestStepName = _L("step_022_01"); + } + +// destructor +CCommDbTest022_01::~CCommDbTest022_01() + { + } + + +TVerdict CCommDbTest022_01::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_01::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD, ECommDbConnectionDirectionOutgoing); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #1")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #2")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + + return ret; + } + + +TVerdict CCommDbTest022_01::doTestStepL( ) + { + Log(_L("Step 022.01 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + + +// +// Test step 022.02 +// + +// constructor +CCommDbTest022_02::CCommDbTest022_02() + { + // store the name of this test case + iTestStepName = _L("step_022_02"); + } + +// destructor +CCommDbTest022_02::~CCommDbTest022_02() + { + } + + +TVerdict CCommDbTest022_02::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_02::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD, ECommDbConnectionDirectionIncoming); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #3")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #4")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #6")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + } + + return ret; + } + + +TVerdict CCommDbTest022_02::doTestStepL( ) + { + Log(_L("Step 022.02 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + +// +// Test step 022.03 +// + +// constructor +CCommDbTest022_03::CCommDbTest022_03() + { + // store the name of this test case + iTestStepName = _L("step_022_03"); + } + +// destructor +CCommDbTest022_03::~CCommDbTest022_03() + { + } + + +TVerdict CCommDbTest022_03::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_03::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerWcdma, ECommDbConnectionDirectionOutgoing); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #5")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #7")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + + return ret; + } + + +TVerdict CCommDbTest022_03::doTestStepL( ) + { + Log(_L("Step 022.03 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + +// +// Test step 022.04 +// + +// constructor +CCommDbTest022_04::CCommDbTest022_04() + { + // store the name of this test case + iTestStepName = _L("step_022_04"); + } + +// destructor +CCommDbTest022_04::~CCommDbTest022_04() + { + } + + +TVerdict CCommDbTest022_04::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_04::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD, ECommDbConnectionDirectionOutgoing); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #1")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #2")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + + return ret; + } + + +TVerdict CCommDbTest022_04::doTestStepL( ) + { + Log(_L("Step 022.04 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + + +// +// Test step 022.05 +// + +// constructor +CCommDbTest022_05::CCommDbTest022_05() + { + // store the name of this test case + iTestStepName = _L("step_022_05"); + } + +// destructor +CCommDbTest022_05::~CCommDbTest022_05() + { + } + + +TVerdict CCommDbTest022_05::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_05::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerWcdma, ECommDbConnectionDirectionIncoming); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #9")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #10")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + + return ret; + } + + +TVerdict CCommDbTest022_05::doTestStepL( ) + { + Log(_L("Step 022.05 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + +// +// Test step 022.06 +// + +// constructor +CCommDbTest022_06::CCommDbTest022_06() + { + // store the name of this test case + iTestStepName = _L("step_022_06"); + } + +// destructor +CCommDbTest022_06::~CCommDbTest022_06() + { + } + + +TVerdict CCommDbTest022_06::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_06::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerWcdma, ECommDbConnectionDirectionIncoming); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #9")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #10")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + + return ret; + } + + +TVerdict CCommDbTest022_06::doTestStepL( ) + { + Log(_L("Step 022.06 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + +// +// Test step 022.07 +// + +// constructor +CCommDbTest022_07::CCommDbTest022_07() + { + // store the name of this test case + iTestStepName = _L("step_022_07"); + } + +// destructor +CCommDbTest022_07::~CCommDbTest022_07() + { + } + + +TVerdict CCommDbTest022_07::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_07::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD, ECommDbConnectionDirectionIncoming); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #3")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #4")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #6")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + } + + return ret; + } + + +TVerdict CCommDbTest022_07::doTestStepL( ) + { + Log(_L("Step 022.07 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + +// +// Test step 022.08 +// + +// constructor +CCommDbTest022_08::CCommDbTest022_08() + { + // store the name of this test case + iTestStepName = _L("step_022_08"); + } + +// destructor +CCommDbTest022_08::~CCommDbTest022_08() + { + } + + +TVerdict CCommDbTest022_08::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_08::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerLAN, ECommDbConnectionDirectionIncoming); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #11")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #12")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + + return ret; + } + + +TVerdict CCommDbTest022_08::doTestStepL( ) + { + Log(_L("Step 022.08 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + +// +// Test step 022.09 +// + +// constructor +CCommDbTest022_09::CCommDbTest022_09() + { + // store the name of this test case + iTestStepName = _L("step_022_09"); + } + +// destructor +CCommDbTest022_09::~CCommDbTest022_09() + { + } + + +TVerdict CCommDbTest022_09::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_09::executeStepL() + { + TInt ret=KErrGeneral; + + //Open a view on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerLAN, ECommDbConnectionDirectionOutgoing); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( !value.Compare(_L("Record #11")) ) + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + if ( !value.Compare(_L("Record #12")) ) + { + //There should be no more records + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + ret = KErrNone; + } + } + + return ret; + } + + +TVerdict CCommDbTest022_09::doTestStepL( ) + { + Log(_L("Step 022.09 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + +// +// Test step 022.10 +// + +// constructor +CCommDbTest022_10::CCommDbTest022_10() + { + // store the name of this test case + iTestStepName = _L("step_022_10"); + } + +// destructor +CCommDbTest022_10::~CCommDbTest022_10() + { + } + + +TVerdict CCommDbTest022_10::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + +TInt CCommDbTest022_10::executeStepL() + { + TInt ret=KErrNone; + + //Open a view with multiple bearers on the IAP table, then check the records returned + iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD | KCommDbBearerLAN, ECommDbConnectionDirectionOutgoing); + CleanupStack::Pop(); + + CDBLEAVE( iTheView->GotoFirstRecord(), KErrNone ); + TBuf value; + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value ); + if( value.Compare(_L("Record #1")) && ret == KErrNone) + { + ret = KErrGeneral; + } + else + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + } + + if ( value.Compare(_L("Record #2")) && ret == KErrNone ) + { + ret = KErrGeneral; + } + else + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + } + + if ( value.Compare(_L("Record #11")) && ret == KErrNone ) + { + ret = KErrGeneral; + } + else + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNone ); + iTheView->ReadTextL( TPtrC(COMMDB_NAME), value); + } + + if ( value.Compare(_L("Record #12")) && ret == KErrNone ) + { + ret = KErrGeneral; + } + else + { + CDBLEAVE( iTheView->GotoNextRecord(), KErrNotFound ); + } + + + return ret; + } + + +TVerdict CCommDbTest022_10::doTestStepL( ) + { + Log(_L("Step 022.10 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + +// +// Test step 022.11 +// + +// constructor +CCommDbTest022_11::CCommDbTest022_11() + { + // store the name of this test case + iTestStepName = _L("step_022_11"); + } + +// destructor +CCommDbTest022_11::~CCommDbTest022_11() + { + } + + +TVerdict CCommDbTest022_11::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + + +#define INVALID_BEARER 0x200 + +TInt CCommDbTest022_11::executeStepL() + { + TInt ret=KErrGeneral; + + + TRAPD( r, iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( INVALID_BEARER , ECommDbConnectionDirectionOutgoing) ); + if ( r!=KErrNone ) + { + ret = r; + } + else + { + //Shouldnt get here, but just in case .... + CleanupStack::Pop(); + } + + return ret; + } + + +TVerdict CCommDbTest022_11::doTestStepL( ) + { + Log(_L("Step 022.11 called ")); + + + if ( executeStepL() == KErrArgument ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + + +// +// Test step 022.12 +// + +// constructor +CCommDbTest022_12::CCommDbTest022_12() + { + // store the name of this test case + iTestStepName = _L("step_022_12"); + } + +// destructor +CCommDbTest022_12::~CCommDbTest022_12() + { + } + + +TVerdict CCommDbTest022_12::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + + +#define INVALID_DIRECTION 0xF + +TInt CCommDbTest022_12::executeStepL() + { + TInt ret=KErrGeneral; + + //Due to the strong type checking in C++, this test step is not particularly valid + TRAPD( r, iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD , (TCommDbConnectionDirection)INVALID_DIRECTION ) ); + if ( r!=KErrNone ) + { + ret = r; + } + else + { + //Shouldnt get here, but just in case .... + CleanupStack::Pop(); + } + + return ret; + } + + +TVerdict CCommDbTest022_12::doTestStepL( ) + { + Log(_L("Step 022.12 called ")); + + + if ( executeStepL() == KErrArgument ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + + +// +// Test step 022.13 +// + +// constructor +CCommDbTest022_13::CCommDbTest022_13() + { + // store the name of this test case + iTestStepName = _L("step_022_13"); + } + +// destructor +CCommDbTest022_13::~CCommDbTest022_13() + { + } + + +TVerdict CCommDbTest022_13::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + + +TInt CCommDbTest022_13::executeStepL() + { + TInt ret=KErrGeneral; + + //Due to the strong type checking in C++, this test step is not particularly valid + TRAPD( r, iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD , (TCommDbConnectionDirection)5 ) ); + if ( r!=KErrNone ) + { + ret = r; + } + else + { + //Shouldnt get here, but just in case .... + CleanupStack::Pop(); + } + + return ret; + } + + +TVerdict CCommDbTest022_13::doTestStepL( ) + { + Log(_L("Step 022.13 called ")); + + + if ( executeStepL() == KErrArgument ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + +// +// Test step 022.14 +// + +// constructor +CCommDbTest022_14::CCommDbTest022_14() + { + // store the name of this test case + iTestStepName = _L("step_022_14"); + } + +// destructor +CCommDbTest022_14::~CCommDbTest022_14() + { + } + + +TVerdict CCommDbTest022_14::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + + +#define INVALID_DIRECTION2 0xffffffff + +TInt CCommDbTest022_14::executeStepL() + { + TInt ret=KErrGeneral; + + //Due to the strong type checking in C++, this test step is not particularly valid + TRAPD( r, iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( KCommDbBearerCSD , (TCommDbConnectionDirection)INVALID_DIRECTION2 ) ); + if ( r!=KErrNone ) + { + ret = r; + } + else + { + //Shouldnt get here, but just in case .... + CleanupStack::Pop(); + } + + return ret; + } + + +TVerdict CCommDbTest022_14::doTestStepL( ) + { + Log(_L("Step 022.14 called ")); + + + if ( executeStepL() == KErrArgument ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + +// +// Test step 022.15 +// + +// constructor +CCommDbTest022_15::CCommDbTest022_15() + { + // store the name of this test case + iTestStepName = _L("step_022_15"); + } + +// destructor +CCommDbTest022_15::~CCommDbTest022_15() + { + } + + +TVerdict CCommDbTest022_15::doTestStepPreambleL() + { + openDbL(); + return EPass; + } + + +#define UNSUPPORTED_BEARER 0x30 + +TInt CCommDbTest022_15::executeStepL() + { + TInt ret=KErrGeneral; + // Similar to test 022_11, but with direction incoming... + + TRAPD( r, iTheView = iTheDb->OpenIAPTableViewMatchingBearerSetLC( UNSUPPORTED_BEARER , ECommDbConnectionDirectionIncoming) ); + if ( r!=KErrNone ) + { + ret = r; + } + else + { + //Shouldnt get here, but just in case .... + CleanupStack::Pop(); + } + + return ret; + } + + +TVerdict CCommDbTest022_15::doTestStepL( ) + { + Log(_L("Step 022.15 called ")); + + + if ( executeStepL() == KErrArgument ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + + +// +// Test step 022.16 +// + +// constructor +CCommDbTest022_16::CCommDbTest022_16() + { + // store the name of this test case + iTestStepName = _L("step_022_16"); + } + +// destructor +CCommDbTest022_16::~CCommDbTest022_16() + { + } + +TVerdict CCommDbTest022_16::doTestStepL( ) + { + Log(_L("Step 022.16 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.01 + + CCommDbTest022_01* step022_01 = new(ELeave) CCommDbTest022_01; + CleanupStack::PushL(step022_01); + step022_01->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_01, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_01); + + + + return iTestStepResult; + +} + + +// +// Test step 022.17 +// + +// constructor +CCommDbTest022_17::CCommDbTest022_17() + { + // store the name of this test case + iTestStepName = _L("step_022_17"); + } + +// destructor +CCommDbTest022_17::~CCommDbTest022_17() + { + } + +TVerdict CCommDbTest022_17::doTestStepL( ) + { + Log(_L("Step 022.17 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.02 + + CCommDbTest022_02* step022_02 = new CCommDbTest022_02; + CleanupStack::PushL(step022_02); + step022_02->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_02, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_02); + + return iTestStepResult; + + } + +// +// Test step 022.18 +// + +// constructor +CCommDbTest022_18::CCommDbTest022_18() + { + // store the name of this test case + iTestStepName = _L("step_022_18"); + } + +// destructor +CCommDbTest022_18::~CCommDbTest022_18() + { + } + +TVerdict CCommDbTest022_18::doTestStepL( ) + { + Log(_L("Step 022.18 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.03 + + CCommDbTest022_03* step022_03 = new CCommDbTest022_03; + CleanupStack::PushL(step022_03); + step022_03->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_03, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_03); + + return iTestStepResult; + + } + +// +// Test step 022.19 +// + +// constructor +CCommDbTest022_19::CCommDbTest022_19() + { + // store the name of this test case + iTestStepName = _L("step_022_19"); + } + +// destructor +CCommDbTest022_19::~CCommDbTest022_19() + { + } + +TVerdict CCommDbTest022_19::doTestStepL( ) + { + Log(_L("Step 022.19 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.04 + + CCommDbTest022_04* step022_04 = new CCommDbTest022_04; + CleanupStack::PushL(step022_04); + step022_04->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_04, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_04); + + return iTestStepResult; + + } + +// +// Test step 022.20 +// + +// constructor +CCommDbTest022_20::CCommDbTest022_20() + { + // store the name of this test case + iTestStepName = _L("step_022_20"); + } + +// destructor +CCommDbTest022_20::~CCommDbTest022_20() + { + } + +TVerdict CCommDbTest022_20::doTestStepL( ) + { + Log(_L("Step 022.20 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.05 + + CCommDbTest022_05* step022_05 = new CCommDbTest022_05; + CleanupStack::PushL(step022_05); + step022_05->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_05, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_05); + + return iTestStepResult; + + } + +// +// Test step 022.21 +// + +// constructor +CCommDbTest022_21::CCommDbTest022_21() + { + // store the name of this test case + iTestStepName = _L("step_022_21"); + } + +// destructor +CCommDbTest022_21::~CCommDbTest022_21() + { + } + +TVerdict CCommDbTest022_21::doTestStepL( ) + { + Log(_L("Step 022.21 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.06 + + CCommDbTest022_06* step022_06 = new CCommDbTest022_06; + CleanupStack::PushL(step022_06); + step022_06->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_06, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_06); + + return iTestStepResult; + + } + +// +// Test step 022.22 +// + +// constructor +CCommDbTest022_22::CCommDbTest022_22() + { + // store the name of this test case + iTestStepName = _L("step_022_22"); + } + +// destructor +CCommDbTest022_22::~CCommDbTest022_22() + { + } + +TVerdict CCommDbTest022_22::doTestStepL( ) + { + Log(_L("Step 022.22 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.07 + + CCommDbTest022_07* step022_07 = new CCommDbTest022_07; + CleanupStack::PushL(step022_07); + step022_07->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_07, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_07); + + return iTestStepResult; + + } + +// +// Test step 022.23 +// + +// constructor +CCommDbTest022_23::CCommDbTest022_23() + { + // store the name of this test case + iTestStepName = _L("step_022_23"); + } + +// destructor +CCommDbTest022_23::~CCommDbTest022_23() + { + } + +TVerdict CCommDbTest022_23::doTestStepL( ) + { + Log(_L("Step 022.23 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.08 + + CCommDbTest022_08* step022_08 = new CCommDbTest022_08; + CleanupStack::PushL(step022_08); + step022_08->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_08, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_08); + + return iTestStepResult; + + } + +// +// Test step 022.24 +// + +// constructor +CCommDbTest022_24::CCommDbTest022_24() + { + // store the name of this test case + iTestStepName = _L("step_022_24"); + } + +// destructor +CCommDbTest022_24::~CCommDbTest022_24() + { + } + +TVerdict CCommDbTest022_24::doTestStepL( ) + { + Log(_L("Step 022.24 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.09 + + CCommDbTest022_09* step022_09 = new CCommDbTest022_09; + CleanupStack::PushL(step022_09); + step022_09->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_09, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_09); + + return iTestStepResult; + + } + +// +// Test step 022.25 +// + +// constructor +CCommDbTest022_25::CCommDbTest022_25() + { + // store the name of this test case + iTestStepName = _L("step_022_25"); + } + +// destructor +CCommDbTest022_25::~CCommDbTest022_25() + { + } + +TVerdict CCommDbTest022_25::doTestStepL( ) + { + Log(_L("Step 022.25 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.10 + + CCommDbTest022_10* step022_10 = new CCommDbTest022_10; + CleanupStack::PushL(step022_10); + step022_10->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_10, KErrNone) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_10); + + return iTestStepResult; + + } + +// +// Test step 022.26 +// + +// constructor +CCommDbTest022_26::CCommDbTest022_26() + { + // store the name of this test case + iTestStepName = _L("step_022_26"); + } + +// destructor +CCommDbTest022_26::~CCommDbTest022_26() + { + } + +TVerdict CCommDbTest022_26::doTestStepL( ) + { + Log(_L("Step 022.26 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.11 + + CCommDbTest022_11* step022_11 = new CCommDbTest022_11; + CleanupStack::PushL(step022_11); + step022_11->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_11, KErrArgument) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_11); + + return iTestStepResult; + + } + +// +// Test step 022.27 +// + +// constructor +CCommDbTest022_27::CCommDbTest022_27() + { + // store the name of this test case + iTestStepName = _L("step_022_27"); + } + +// destructor +CCommDbTest022_27::~CCommDbTest022_27() + { + } + +TVerdict CCommDbTest022_27::doTestStepL( ) + { + Log(_L("Step 022.27 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.12 + + CCommDbTest022_12* step022_12 = new CCommDbTest022_12; + CleanupStack::PushL(step022_12); + step022_12->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_12, KErrArgument) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_12); + + return iTestStepResult; + + } + +// +// Test step 022.28 +// + +// constructor +CCommDbTest022_28::CCommDbTest022_28() + { + // store the name of this test case + iTestStepName = _L("step_022_28"); + } + +// destructor +CCommDbTest022_28::~CCommDbTest022_28() + { + } + +TVerdict CCommDbTest022_28::doTestStepL( ) + { + Log(_L("Step 022.28 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.13 + + CCommDbTest022_13* step022_13 = new CCommDbTest022_13; + CleanupStack::PushL(step022_13); + step022_13->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_13, KErrArgument) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_13); + + return iTestStepResult; + + } + +// +// Test step 022.29 +// + +// constructor +CCommDbTest022_29::CCommDbTest022_29() + { + // store the name of this test case + iTestStepName = _L("step_022_29"); + } + +// destructor +CCommDbTest022_29::~CCommDbTest022_29() + { + } + +TVerdict CCommDbTest022_29::doTestStepL( ) + { + Log(_L("Step 022.29 called ")); + + iTestStepResult = EPass; + + // Heap test for 022.14 + + CCommDbTest022_14* step022_14 = new CCommDbTest022_14; + CleanupStack::PushL(step022_14); + step022_14->iSuite = iSuite; + if ( doTestStepWithHeapFailureL( *step022_14, KErrArgument) == EFail ) + iTestStepResult = EFail; + CleanupStack::PopAndDestroy(step022_14); + + return iTestStepResult; + + } + + +// +// Test step 022.30 +// + +// constructor +CCommDbTest022_30::CCommDbTest022_30() + { + // store the name of this test case + iTestStepName = _L("step_022_30"); + } + +// destructor +CCommDbTest022_30::~CCommDbTest022_30() + { + } + +TInt CCommDbTest022_30::executeStepL() + { + TInt ret = KErrGeneral; + + CCommsDatabase* db = CCommsDatabase::NewL(); + CleanupStack::PushL(db); + + CCommsDbTableView* view1 = db->OpenTableLC( TPtrC(IAP) ); + TUint32 a = 0; + User::LeaveIfError(view1->InsertRecord(a)); + // expected commdb currently only has 1 IAP, hence 2 here + if (a != 2) + { + User::Leave(KErrGeneral); + } + CleanupStack::Pop(view1); + + CCommsDbTableView* view2 = db->OpenIAPTableViewMatchingBearerSetLC(KCommDbBearerWcdma, ECommDbConnectionDirectionOutgoing); + a = 0; + User::LeaveIfError(view2->InsertRecord(a)); + if (a != 3) + { + User::Leave(KErrGeneral); + } + CleanupStack::Pop(view2); + + CleanupStack::Pop(db); + + ret = KErrNone; + return ret; + } + + +TVerdict CCommDbTest022_30::doTestStepL( ) + { + Log(_L("Step 022.30 called ")); + + + if ( executeStepL() == KErrNone ) + iTestStepResult = EPass; + else + iTestStepResult = EFail; + + return iTestStepResult; + } + +//EOF