diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/apputils/tsrc/t_strings/StringPoolTransitions.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lowlevellibsandfws/apputils/tsrc/t_strings/StringPoolTransitions.inl Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,1760 @@ +// Copyright (c) 1997-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: +// The implementation of the transition classes upon the RStringPool class methods. +// +// + +#include "short.h" +#include "long.h" +#include "irrelevant.h" +#include "shortcs.h" +#include "longcs.h" +#include "irrelevantcs.h" +#include "short2.h" +#include "short3.h" +#include "short4.h" +#include "shortcs2.h" +#include "shortcs3.h" +#include "shortcs4.h" +#include "securitypolicypluginstrings.h" + +// ______________________________________________________________________________ +// +_LIT(KStringPoolNewLTransition,"CStringPool_NewL_Transition"); + +inline CStringPool_NewL_Transition::CStringPool_NewL_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolNewLTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_NewL_Transition::TransitMethodL() + { + _LIT(KStringPoolNewLTransitMethod, "CStringPool::NewL transition"); + Context().DataLogger().LogInformation(KStringPoolNewLTransitMethod); + Context().iStringPool.OpenL(); + RStringPool p = Context().iStringPool; + + _LIT8(KStringA, "String"); + _LIT8(KStringB, "Another String"); + _LIT8(KStringD, "String"); + + _LIT8(KStringFA, "String"); + _LIT8(KStringFB, "Another String"); + _LIT8(KStringFD, "sTRING"); + + Context().iA = p.OpenStringL(KStringA()); + Context().iB = p.OpenStringL(KStringB()); + Context().iD = p.OpenStringL(KStringD()); + + Context().iFA = p.OpenFStringL(KStringFA()); + Context().iFB = p.OpenFStringL(KStringFB()); + Context().iFD = p.OpenFStringL(KStringFD()); + + Context().iADes.Set(KStringA); + Context().iBDes.Set(KStringB); + Context().iDDes.Set(KStringD); + + Context().iFADes.Set(KStringFA); + Context().iFBDes.Set(KStringFB); + Context().iFDDes.Set(KStringFD); + + Context().iInt = -1; + Context().iFint = -1; + } + +inline CStringPool_UnitTestContext& CStringPool_NewL_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolDtorTransition,"CStringPool_Dtor_Transition"); + +inline CStringPool_Dtor_Transition::CStringPool_Dtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolDtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_Dtor_Transition::TransitMethodL() + { + _LIT(KStringPoolDtorTransitMethod, "CStringPool::Dtor transition"); + Context().DataLogger().LogInformation(KStringPoolDtorTransitMethod); + + Context().iA.Close(); + Context().iB.Close(); + Context().iD.Close(); + + Context().iFA.Close(); + Context().iFB.Close(); + Context().iFD.Close(); + + Context().iStringPool.Close(); + + + + } + +inline CStringPool_UnitTestContext& CStringPool_Dtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// Add additional Transition class Implementations here... + +// ______________________________________________________________________________ +// +_LIT(KRStringPoolAeqATransition,"CRStringPool_AeqA_Transition"); + +inline CStringPool_AeqA_Transition::CStringPool_AeqA_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KRStringPoolAeqATransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_AeqA_Transition::TransitMethodL() + { + _LIT(KRStringPoolAeqATransitMethod, "CRStringPool::AeqA transition"); + Context().DataLogger().LogInformation(KRStringPoolAeqATransitMethod); + RString temp = Context().iA; + Context().iResult = Context().iA == temp;; + } + +inline CStringPool_UnitTestContext& CStringPool_AeqA_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolAneATransition,"CStringPool_AneA_Transition"); + +inline CStringPool_AneA_Transition::CStringPool_AneA_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolAneATransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_AneA_Transition::TransitMethodL() + { + _LIT(KStringPoolAneATransitMethod, "CStringPool::AneA transition"); + Context().DataLogger().LogInformation(KStringPoolAneATransitMethod); + RString temp = Context().iA; + Context().iResult = Context().iA != temp;; + } + +inline CStringPool_UnitTestContext& CStringPool_AneA_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolAeqBTransition,"CStringPool_AeqB_Transition"); + +inline CStringPool_AeqB_Transition::CStringPool_AeqB_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolAeqBTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_AeqB_Transition::TransitMethodL() + { + _LIT(KStringPoolAeqBTransitMethod, "CStringPool::AeqB transition"); + Context().DataLogger().LogInformation(KStringPoolAeqBTransitMethod); + Context().iResult = Context().iA == Context().iB; + } + +inline CStringPool_UnitTestContext& CStringPool_AeqB_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolAneBTransition,"CStringPool_AneB_Transition"); + +inline CStringPool_AneB_Transition::CStringPool_AneB_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolAneBTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_AneB_Transition::TransitMethodL() + { + _LIT(KStringPoolAneBTransitMethod, "CStringPool::AneB transition"); + Context().DataLogger().LogInformation(KStringPoolAneBTransitMethod); + Context().iResult = Context().iA != Context().iB; + } + +inline CStringPool_UnitTestContext& CStringPool_AneB_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolAeqDTransition,"CStringPool_AeqD_Transition"); + +inline CStringPool_AeqD_Transition::CStringPool_AeqD_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolAeqDTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_AeqD_Transition::TransitMethodL() + { + _LIT(KStringPoolAeqDTransitMethod, "CStringPool::AeqD transition"); + Context().DataLogger().LogInformation(KStringPoolAeqDTransitMethod); + Context().iResult = Context().iA == Context().iD; + } + +inline CStringPool_UnitTestContext& CStringPool_AeqD_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolAneDTransition,"CStringPool_AneD_Transition"); + +inline CStringPool_AneD_Transition::CStringPool_AneD_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolAneDTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_AneD_Transition::TransitMethodL() + { + _LIT(KStringPoolAneDTransitMethod, "CStringPool::AneD transition"); + Context().DataLogger().LogInformation(KStringPoolAneDTransitMethod); + Context().iResult = Context().iA != Context().iD; + } + +inline CStringPool_UnitTestContext& CStringPool_AneD_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolDescTransition,"CStringPool_Desc_Transition"); + +inline CStringPool_Desc_Transition::CStringPool_Desc_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolDescTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_Desc_Transition::TransitMethodL() + { + _LIT(KStringPoolDescTransitMethod, "CStringPool::Desc transition"); + Context().DataLogger().LogInformation(KStringPoolDescTransitMethod); + Context().iResult = Context().iADes.Compare(Context().iA.DesC()); + } + +inline CStringPool_UnitTestContext& CStringPool_Desc_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolCopyTransition,"CStringPool_Copy_Transition"); + +inline CStringPool_Copy_Transition::CStringPool_Copy_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolCopyTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_Copy_Transition::TransitMethodL() + { + _LIT(KStringPoolCopyTransitMethod, "CStringPool::Copy transition"); + Context().DataLogger().LogInformation(KStringPoolCopyTransitMethod); + Context().iC = Context().iA.Copy(); + Context().iResult = Context().iA == Context().iC; + } + +inline CStringPool_UnitTestContext& CStringPool_Copy_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolCDesCTransition,"CStringPool_CDesC_Transition"); + +inline CStringPool_CDesC_Transition::CStringPool_CDesC_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolCDesCTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_CDesC_Transition::TransitMethodL() + { + _LIT(KStringPoolCDesCTransitMethod, "CStringPool::CDesC transition"); + Context().DataLogger().LogInformation(KStringPoolCDesCTransitMethod); + Context().iResult = Context().iADes.Compare(Context().iC.DesC()); + } + +inline CStringPool_UnitTestContext& CStringPool_CDesC_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolCloseTransition,"CStringPool_Close_Transition"); + +inline CStringPool_Close_Transition::CStringPool_Close_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolCloseTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_Close_Transition::TransitMethodL() + { + _LIT(KStringPoolCloseTransitMethod, "CStringPool::Close transition"); + Context().DataLogger().LogInformation(KStringPoolCloseTransitMethod); + Context().iC.Close(); + } + +inline CStringPool_UnitTestContext& CStringPool_Close_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolIntTransition,"CStringPool_Int_Transition"); + +inline CStringPool_Int_Transition::CStringPool_Int_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolIntTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_Int_Transition::TransitMethodL() + { + _LIT(KStringPoolIntTransitMethod, "aaCStringPool::Int transition"); + Context().DataLogger().LogInformation(KStringPoolIntTransitMethod); + Context().iResult = Context().iTE.Index(Context().iTestTable) == Context().iInt; + } + +inline CStringPool_UnitTestContext& CStringPool_Int_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } +// ______________________________________________________________________________ +// +_LIT(KStringPoolStringTokenTransition,"CStringPool_StringToken_Transition"); + +inline CStringPool_StringToken_Transition::CStringPool_StringToken_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolStringTokenTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_StringToken_Transition::TransitMethodL() + { + _LIT(KStringPoolStringTokenTransitMethod, "CStringPool::StringToken transition"); + Context().DataLogger().LogInformation(KStringPoolStringTokenTransitMethod); + RStringToken t = Context().iA; + Context().iC = Context().iStringPool.String(t); + Context().iResult = Context().iC == Context().iA; + } + +inline CStringPool_UnitTestContext& CStringPool_StringToken_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +// ______________________________________________________________________________ +// +_LIT(KRstringPoolFAeqATransition,"CRStringPool_AeqA_Transition"); + +inline CStringPool_FAeqA_Transition::CStringPool_FAeqA_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KRstringPoolFAeqATransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FAeqA_Transition::TransitMethodL() + { + _LIT(KRstringPoolFAeqATransitMethod, "CRStringPool::AeqA transition"); + Context().DataLogger().LogInformation(KRstringPoolFAeqATransitMethod); + RStringF temp = Context().iFA; + Context().iResult = Context().iFA == temp;; + } + +inline CStringPool_UnitTestContext& CStringPool_FAeqA_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFAneATransition,"CStringPool_FAneA_Transition"); + +inline CStringPool_FAneA_Transition::CStringPool_FAneA_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFAneATransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FAneA_Transition::TransitMethodL() + { + _LIT(KStringPoolFAneATransitMethod, "CStringPoolF::AneA transition"); + Context().DataLogger().LogInformation(KStringPoolFAneATransitMethod); + RStringF temp = Context().iFA; + Context().iResult = Context().iFA != temp;; + } + +inline CStringPool_UnitTestContext& CStringPool_FAneA_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFAeqBTransition,"CStringPool_FAeqB_Transition"); + +inline CStringPool_FAeqB_Transition::CStringPool_FAeqB_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFAeqBTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FAeqB_Transition::TransitMethodL() + { + _LIT(KStringPoolFAeqBTransitMethod, "CStringPoolF::AeqB transition"); + Context().DataLogger().LogInformation(KStringPoolFAeqBTransitMethod); + Context().iResult = Context().iFA == Context().iFB; + } + +inline CStringPool_UnitTestContext& CStringPool_FAeqB_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFAneBTransition,"CStringPool_FAneB_Transition"); + +inline CStringPool_FAneB_Transition::CStringPool_FAneB_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFAneBTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FAneB_Transition::TransitMethodL() + { + _LIT(KStringPoolFAneBTransitMethod, "CStringPoolF::AneB transition"); + Context().DataLogger().LogInformation(KStringPoolFAneBTransitMethod); + Context().iResult = Context().iFA != Context().iFB; + } + +inline CStringPool_UnitTestContext& CStringPool_FAneB_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFAeqDTransition,"CStringPool_FAeqD_Transition"); + +inline CStringPool_FAeqD_Transition::CStringPool_FAeqD_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFAeqDTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FAeqD_Transition::TransitMethodL() + { + _LIT(KStringPoolFAeqDTransitMethod, "CStringPoolF::AeqD transition"); + Context().DataLogger().LogInformation(KStringPoolFAeqDTransitMethod); + Context().iResult = Context().iFA == Context().iFD; + } + +inline CStringPool_UnitTestContext& CStringPool_FAeqD_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFAneDTransition,"CStringPool_FAneD_Transition"); + +inline CStringPool_FAneD_Transition::CStringPool_FAneD_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFAneDTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FAneD_Transition::TransitMethodL() + { + _LIT(KStringPoolFAneDTransitMethod, "CStringPoolF::AneD transition"); + Context().DataLogger().LogInformation(KStringPoolFAneDTransitMethod); + Context().iResult = Context().iFA != Context().iFD; + } + +inline CStringPool_UnitTestContext& CStringPool_FAneD_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFDescTransition,"CStringPool_FDesc_Transition"); + +inline CStringPool_FDesc_Transition::CStringPool_FDesc_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFDescTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FDesc_Transition::TransitMethodL() + { + _LIT(KStringPoolFDescTransitMethod, "CStringPoolF::Desc transition"); + Context().DataLogger().LogInformation(KStringPoolFDescTransitMethod); + Context().iResult = Context().iADes.Compare(Context().iFA.DesC()); + } + +inline CStringPool_UnitTestContext& CStringPool_FDesc_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFCopyTransition,"CStringPool_FCopy_Transition"); + +inline CStringPool_FCopy_Transition::CStringPool_FCopy_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFCopyTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FCopy_Transition::TransitMethodL() + { + _LIT(KStringPoolFCopyTransitMethod, "CStringPoolF::Copy transition"); + Context().DataLogger().LogInformation(KStringPoolFCopyTransitMethod); + Context().iFC = Context().iFA.Copy(); + Context().iResult = Context().iFA == Context().iFC; + } + +inline CStringPool_UnitTestContext& CStringPool_FCopy_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFCDesCTransition,"CStringPool_FCDesC_Transition"); + +inline CStringPool_FCDesC_Transition::CStringPool_FCDesC_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFCDesCTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FCDesC_Transition::TransitMethodL() + { + _LIT(KStringPoolFCDesCTransitMethod, "CStringPoolF::CDesC transition"); + Context().DataLogger().LogInformation(KStringPoolFCDesCTransitMethod); + Context().iResult = Context().iADes.Compare(Context().iFC.DesC()); + } + +inline CStringPool_UnitTestContext& CStringPool_FCDesC_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFCloseTransition,"CStringPool_FClose_Transition"); + +inline CStringPool_FClose_Transition::CStringPool_FClose_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFCloseTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FClose_Transition::TransitMethodL() + { + _LIT(KStringPoolFCloseTransitMethod, "CStringPoolF::Close transition"); + Context().DataLogger().LogInformation(KStringPoolFCloseTransitMethod); + Context().iFC.Close(); + } + +inline CStringPool_UnitTestContext& CStringPool_FClose_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolFIntTransition,"CStringPool_FInt_Transition"); + +inline CStringPool_FInt_Transition::CStringPool_FInt_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFIntTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FInt_Transition::TransitMethodL() + { + _LIT(KStringPoolFIntTransitMethod, "CStringPoolF::Int transition"); + Context().DataLogger().LogInformation(KStringPoolFIntTransitMethod); + Context().iResult = Context().iTFE.Index(Context().iTestTable) == Context().iFint; + } + +inline CStringPool_UnitTestContext& CStringPool_FInt_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } +// ______________________________________________________________________________ +// +_LIT(KStringPoolFStringTokenTransition,"CStringPool_FStringToken_Transition"); + +inline CStringPool_FStringToken_Transition::CStringPool_FStringToken_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolFStringTokenTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_FStringToken_Transition::TransitMethodL() + { + _LIT(KStringPoolFStringTokenTransitMethod, "CStringPoolF::StringToken transition"); + Context().DataLogger().LogInformation(KStringPoolFStringTokenTransitMethod); + RStringTokenF t = Context().iFA; + Context().iFC = Context().iStringPool.StringF(t); + Context().iResult = Context().iFC == Context().iFA; + } + +inline CStringPool_UnitTestContext& CStringPool_FStringToken_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } +// ______________________________________________________________________________ +// +_LIT(KStringPoolSmallCtorTransition,"CStringPool_ShortCtor_Transition"); + +inline CStringPool_ShortCtor_Transition::CStringPool_ShortCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolSmallCtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_ShortCtor_Transition::TransitMethodL() + { + _LIT(KStringPoolSmallCtorTransitMethod, "CStringPool::SmallCtor transition"); + Context().DataLogger().LogInformation(KStringPoolSmallCtorTransitMethod); + + //Set the table used in this test + Context().iTestTable=Short::Table; + Context().iStringPool.OpenL(Context().iTestTable); + RStringPool p = Context().iStringPool; + + _LIT8(KStringA, "String"); + _LIT8(KStringB, "Another String"); + _LIT8(KStringD, "String"); + + _LIT8(KStringFA, "String"); + _LIT8(KStringFB, "Another String"); + _LIT8(KStringFD, "sTRING"); + + + Context().iA = p.OpenStringL(KStringA()); + CleanupClosePushL(Context().iA); + Context().iB = p.OpenStringL(KStringB()); + CleanupClosePushL(Context().iB); + Context().iD = p.OpenStringL(KStringD()); + CleanupClosePushL(Context().iD); + + Context().iFA = p.OpenFStringL(KStringFA()); + CleanupClosePushL(Context().iFA); + Context().iFB = p.OpenFStringL(KStringFB()); + CleanupClosePushL(Context().iFB); + Context().iFD = p.OpenFStringL(KStringFD()); + CleanupClosePushL(Context().iFD); + + +// Context().iTE = p.String(0,Context().iTestTable); + Context().iTFE = p.StringF(0,Context().iTestTable); + + // Create an empty string + Context().iEmptyOne = RStringF() ; + + + Context().iADes.Set(KStringA); + Context().iBDes.Set(KStringB); + Context().iDDes.Set(KStringD); + + Context().iFADes.Set(KStringFA); + Context().iFBDes.Set(KStringFB); + Context().iFDDes.Set(KStringFD); + + Context().iInt = 0; + Context().iFint = 0; + Context().iNotFound = -1; + CleanupStack::Pop(6); + } + +inline CStringPool_UnitTestContext& CStringPool_ShortCtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolIrrelevantCtorTransition,"CStringPool_IrrelevantCtor_Transition"); + +inline CStringPool_IrrelevantCtor_Transition::CStringPool_IrrelevantCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransition(KStringPoolIrrelevantCtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_IrrelevantCtor_Transition::TransitMethodL() + { + _LIT(KStringPoolIrrelevantCtorTransitMethod, "CStringPool::IrrelevantCtor transition"); + Context().DataLogger().LogInformation(KStringPoolIrrelevantCtorTransitMethod); + + //Set the table used in this test + Context().iTestTable=Irrelevant::Table; + Context().iStringPool.OpenL(Context().iTestTable); + RStringPool p = Context().iStringPool; + + _LIT8(KStringA, "String"); + _LIT8(KStringB, "Another String"); + _LIT8(KStringD, "String"); + + _LIT8(KStringFA, "String"); + _LIT8(KStringFB, "Another String"); + _LIT8(KStringFD, "sTRING"); + + Context().iA = p.OpenStringL(KStringA()); + Context().iB = p.OpenStringL(KStringB()); + Context().iD = p.OpenStringL(KStringD()); + + Context().iFA = p.OpenFStringL(KStringFA()); + Context().iFB = p.OpenFStringL(KStringFB()); + Context().iFD = p.OpenFStringL(KStringFD()); + +// Context().iTE = p.String(0,Context().iTestTable); + Context().iTFE = p.StringF(0,Context().iTestTable); + + Context().iADes.Set(KStringA); + Context().iBDes.Set(KStringB); + Context().iDDes.Set(KStringD); + + Context().iFADes.Set(KStringFA); + Context().iFBDes.Set(KStringFB); + Context().iFDDes.Set(KStringFD); + + + Context().iFint = 0; + } + +inline CStringPool_UnitTestContext& CStringPool_IrrelevantCtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolLongCtorTransition,"CStringPool_LongCtor_Transition"); + +inline CStringPool_LongCtor_Transition::CStringPool_LongCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransition(KStringPoolLongCtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_LongCtor_Transition::TransitMethodL() + { + _LIT(KStringPoolLongCtorTransitMethod, "CStringPool::LongCtor transition"); + Context().DataLogger().LogInformation(KStringPoolLongCtorTransitMethod); + + //Set the table used in this test + Context().iTestTable=Long::Table; + Context().iStringPool.OpenL(Context().iTestTable); + RStringPool p = Context().iStringPool; + + _LIT8(KStringA, "String"); + _LIT8(KStringB, "Another String"); + _LIT8(KStringD, "String"); + + _LIT8(KStringFA, "String"); + _LIT8(KStringFB, "Another String"); + _LIT8(KStringFD, "sTRING"); + + Context().iA = p.OpenStringL(KStringA()); + Context().iB = p.OpenStringL(KStringB()); + Context().iD = p.OpenStringL(KStringD()); + + Context().iFA = p.OpenFStringL(KStringFA()); + Context().iFB = p.OpenFStringL(KStringFB()); + Context().iFD = p.OpenFStringL(KStringFD()); + +// Context().iTE = p.String(0,Context().iTestTable); + Context().iTFE = p.StringF(0,Context().iTestTable); + + Context().iADes.Set(KStringA); + Context().iBDes.Set(KStringB); + Context().iDDes.Set(KStringD); + + Context().iFADes.Set(KStringFA); + Context().iFBDes.Set(KStringFB); + Context().iFDDes.Set(KStringFD); + + Context().iInt = 0; + Context().iFint = 0; + } + +inline CStringPool_UnitTestContext& CStringPool_LongCtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +//____________________________________________________________________ +// +_LIT(KStringPoolStringF_Index_TableTransition,"CStringPool_StringF_Index_Table_Transition"); + +inline CStringPool_StringF_Index_Table_Transition::CStringPool_StringF_Index_Table_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolStringF_Index_TableTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_StringF_Index_Table_Transition::TransitMethodL() + { + _LIT(KStringPoolStringF_Index_TableTransitMethod, "CStringPool::StringF_Index_Table transition"); + Context().DataLogger().LogInformation(KStringPoolStringF_Index_TableTransitMethod); + + Context().iResult = Context().iTFE == Context().iFA; + } + +inline CStringPool_UnitTestContext& CStringPool_StringF_Index_Table_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolshortCSCtorTransition,"CStringPool_ShortCSCtor_Transition"); + +inline CStringPool_ShortCSCtor_Transition::CStringPool_ShortCSCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolshortCSCtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_ShortCSCtor_Transition::TransitMethodL() + { + _LIT(KStringPoolshortCSCtorTransitMethod, "CStringPool::ShortCSCtor transition"); + Context().DataLogger().LogInformation(KStringPoolshortCSCtorTransitMethod); + + + //Set the table used in this test + Context().iTestTable=ShortCS::Table; + Context().iStringPool.OpenL(Context().iTestTable); + RStringPool p = Context().iStringPool; + + _LIT8(KStringA, "String"); + _LIT8(KStringB, "Another String"); + _LIT8(KStringD, "String"); + + _LIT8(KStringFA, "String"); + _LIT8(KStringFB, "Another String"); + _LIT8(KStringFD, "sTRING"); + + + Context().iA = p.OpenStringL(KStringA()); + CleanupClosePushL(Context().iA); + Context().iB = p.OpenStringL(KStringB()); + CleanupClosePushL(Context().iB); + Context().iD = p.OpenStringL(KStringD()); + CleanupClosePushL(Context().iD); + + Context().iFA = p.OpenFStringL(KStringFA()); + CleanupClosePushL(Context().iFA); + Context().iFB = p.OpenFStringL(KStringFB()); + CleanupClosePushL(Context().iFB); + Context().iFD = p.OpenFStringL(KStringFD()); + CleanupClosePushL(Context().iFD); + + Context().iTE = p.String(0,Context().iTestTable); +// Context().iTFE = p.StringF(0,Context().iTestTable); + + + Context().iADes.Set(KStringA); + Context().iBDes.Set(KStringB); + Context().iDDes.Set(KStringD); + + Context().iFADes.Set(KStringFA); + Context().iFBDes.Set(KStringFB); + Context().iFDDes.Set(KStringFD); + + + Context().iInt = 0; + CleanupStack::Pop(6); + } + +inline CStringPool_UnitTestContext& CStringPool_ShortCSCtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } +// ______________________________________________________________________________ +// +_LIT(KStringPoolString_Index_TableTransition,"CStringPool_String_Index_Table_Transition"); + +inline CStringPool_String_Index_Table_Transition::CStringPool_String_Index_Table_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolString_Index_TableTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_String_Index_Table_Transition::TransitMethodL() + { + _LIT(KStringPoolString_Index_TableTransitMethod, "CStringPool::String_Index_Table transition"); + Context().DataLogger().LogInformation(KStringPoolString_Index_TableTransitMethod); + + Context().iResult = Context().iTE == Context().iA; + } + +inline CStringPool_UnitTestContext& CStringPool_String_Index_Table_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolIrrelevantCSCtorTransition,"CStringPool_IrrelevantCSCtor_Transition"); + +inline CStringPool_IrrelevantCSCtor_Transition::CStringPool_IrrelevantCSCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolIrrelevantCSCtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_IrrelevantCSCtor_Transition::TransitMethodL() + { + _LIT(KStringPoolIrrelevantCSCtorTransitMethod, "CStringPool::IrrelevantCSCtor transition"); + Context().DataLogger().LogInformation(KStringPoolIrrelevantCSCtorTransitMethod); + + //Set the table used in this test + Context().iTestTable=IrrelevantCS::Table; + Context().iStringPool.OpenL(Context().iTestTable); + RStringPool p = Context().iStringPool; + + _LIT8(KStringA, "String"); + _LIT8(KStringB, "Another String"); + _LIT8(KStringD, "String"); + + _LIT8(KStringFA, "String"); + _LIT8(KStringFB, "Another String"); + _LIT8(KStringFD, "sTRING"); + + Context().iA = p.OpenStringL(KStringA()); + Context().iB = p.OpenStringL(KStringB()); + Context().iD = p.OpenStringL(KStringD()); + + Context().iFA = p.OpenFStringL(KStringFA()); + Context().iFB = p.OpenFStringL(KStringFB()); + Context().iFD = p.OpenFStringL(KStringFD()); + + Context().iTE = p.String(0,Context().iTestTable); +// Context().iTFE = p.StringF(0,Context().iTestTable); + + Context().iADes.Set(KStringA); + Context().iBDes.Set(KStringB); + Context().iDDes.Set(KStringD); + + Context().iFADes.Set(KStringFA); + Context().iFBDes.Set(KStringFB); + Context().iFDDes.Set(KStringFD); + + + Context().iFint = 0; + Context().iInt = 0; + } + +inline CStringPool_UnitTestContext& CStringPool_IrrelevantCSCtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolLargeCSCtorTransition,"CStringPool_LargeCSCtor_Transition"); + +inline CStringPool_LargeCSCtor_Transition::CStringPool_LargeCSCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolLargeCSCtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_LargeCSCtor_Transition::TransitMethodL() + { + _LIT(KStringPoolLargeCSCtorTransitMethod, "CStringPool::LargeCSCtor transition"); + Context().DataLogger().LogInformation(KStringPoolLargeCSCtorTransitMethod); + + //Set the table used in this test + Context().iTestTable=LongCS::Table; + Context().iStringPool.OpenL(Context().iTestTable); + RStringPool p = Context().iStringPool; + + _LIT8(KStringA, "String"); + _LIT8(KStringB, "Another String"); + _LIT8(KStringD, "String"); + + _LIT8(KStringFA, "String"); + _LIT8(KStringFB, "Another String"); + _LIT8(KStringFD, "sTRING"); + + Context().iA = p.OpenStringL(KStringA()); + Context().iB = p.OpenStringL(KStringB()); + Context().iD = p.OpenStringL(KStringD()); + + Context().iFA = p.OpenFStringL(KStringFA()); + Context().iFB = p.OpenFStringL(KStringFB()); + Context().iFD = p.OpenFStringL(KStringFD()); + + Context().iTE = p.String(0,Context().iTestTable); +// Context().iTFE = p.StringF(0,Context().iTestTable); + + Context().iADes.Set(KStringA); + Context().iBDes.Set(KStringB); + Context().iDDes.Set(KStringD); + + Context().iFADes.Set(KStringFA); + Context().iFBDes.Set(KStringFB); + Context().iFDDes.Set(KStringFD); + + Context().iInt = 0; + Context().iFint = 0; + } + +inline CStringPool_UnitTestContext& CStringPool_LargeCSCtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } +// ______________________________________________________________________________ +// +_LIT(KStringPoolShortCtor_CBTransition,"CStringPool_Short_CB_Transition"); + +inline CStringPool_Short_CB_Transition::CStringPool_Short_CB_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolShortCtor_CBTransition, aUTContext, aValidator) + { + // Do nothing here. + } + + + + + +inline void CStringPool_Short_CB_Transition::TransitMethodL() + { + _LIT(KStringPoolShortCtor_CBTransitMethod, "CStringPool::ShortCtor_CB transition"); + Context().DataLogger().LogInformation(KStringPoolShortCtor_CBTransitMethod); + + //Set the table used in this test + Context().iTestTable=Short::Table; + + Context().iMyExtObj.a=0; + Context().iMyExtObj2.a=0; + Context().iMyExtObj3.a=0; + Context().iStringPool.OpenL(Context().iTestTable,Context().iMyExtObj); + CleanupClosePushL(Context().iStringPool); + Context().iStringPool.OpenL(Context().iTestTable,Context().iMyExtObj2); + Context().iStringPool.OpenL(Context().iTestTable,Context().iMyExtObj3); + Context().iStringPool.Close(); + Context().iResult= (Context().iMyExtObj.a) && (Context().iMyExtObj2.a)&&(Context().iMyExtObj3.a); + CleanupStack::Pop();//Context().iStringPool + } + +inline CStringPool_UnitTestContext& CStringPool_Short_CB_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleTableCICtorTransition,"CStringPool_MultipleTableCICtor_Transition"); + +inline CStringPool_MultipleTableCICtor_Transition::CStringPool_MultipleTableCICtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleTableCICtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleTableCICtor_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleTableCICtorTransitMethod, "CStringPool::MultipleTableCICtor transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleTableCICtorTransitMethod); + + Context().iStringPool.OpenL(); + + _LIT8(KStringA, "AnotherString"); + CleanupClosePushL(Context().iFF); + Context().iFF=Context().iStringPool.OpenFStringL(KStringA); // Dynamic string + CleanupStack::Pop(); // iFF + + + Context().iTestTable=Short::Table; + Context().iStringPool.OpenL(Context().iTestTable); + + Context().iTestTable2=Short3::Table; // Non-duplicate table + Context().iStringPool.OpenL(Context().iTestTable2); + + Context().iTestTable3=Short2::Table; + Context().iStringPool.OpenL(Context().iTestTable3); + + Context().iTestTable4=Short4::Table; // Duplicate of a duplicate table + Context().iStringPool.OpenL(Context().iTestTable4); + Context().iStringPool.OpenL(Context().iTestTable4); // Add same table twice + + Context().iFA=Context().iStringPool.StringF(Short::EString, Context().iTestTable); // String + Context().iFB=Context().iStringPool.StringF(Short2::EString, Context().iTestTable3); // String + Context().iFC=Context().iStringPool.StringF(Short3::EString3, Context().iTestTable2); // String3, non-duplicate + Context().iFD=Context().iStringPool.StringF(Short4::EAnotherString , Context().iTestTable4); // AnotherString3 duplicate of a duplicate + + Context().iFE=Context().iStringPool.StringF(Short2::EAnotherString , Context().iTestTable3); // Duplicate of dynamic string + + Context().iIndex1=Context().iFA.Index(Context().iTestTable); // 0 + Context().iIndex2=Context().iFB.Index(Context().iTestTable3); // 1 + Context().iIndex3=Context().iFC.Index(Context().iTestTable2); // 1 + Context().iIndex4=Context().iFD.Index(Context().iTestTable4); // 0 + + + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleTableCICtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMutlipleCICeqCTransition,"CStringPool_MutlipleCICeqC_Transition"); + +inline CStringPool_MutlipleCICeqC_Transition::CStringPool_MutlipleCICeqC_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMutlipleCICeqCTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MutlipleCICeqC_Transition::TransitMethodL() + { + _LIT(KStringPoolMutlipleCICeqCTransitMethod, "CStringPool::MutlipleCICeqC transition"); + Context().DataLogger().LogInformation(KStringPoolMutlipleCICeqCTransitMethod); + _LIT8(KStringC, "String3"); + Context().iResult = (Context().iFC.DesC().CompareF(KStringC))==0; + } + +inline CStringPool_UnitTestContext& CStringPool_MutlipleCICeqC_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleCIStringToIndexTransition,"CStringPool_MultipleCIStringToIndex_Transition"); + +inline CStringPool_MultipleCIStringToIndex_Transition::CStringPool_MultipleCIStringToIndex_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleCIStringToIndexTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleCIStringToIndex_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleCIStringToIndexTransitMethod, "CStringPool::MultipleCIStringToIndex transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleCIStringToIndexTransitMethod); + if (Context().iIndex1==0 && Context().iIndex2==1 && Context().iIndex3==1 && Context().iIndex4==0) + Context().iResult = ETrue; + else + Context().iResult = EFalse; + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleCIStringToIndex_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleCIDynamicStringTransition,"CStringPool_MultipleCIDynamicString_Transition"); + +inline CStringPool_MultipleCIDynamicString_Transition::CStringPool_MultipleCIDynamicString_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleCIDynamicStringTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleCIDynamicString_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleCIDynamicStringTransitMethod, "CStringPool::MultipleCIDynamicString transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleCIDynamicStringTransitMethod); + Context().iResult = Context().iFE==Context().iFF; + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleCIDynamicString_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleCIIndexToStringDynamicTransition,"CStringPool_MultipleCIIndexToStringDynamic_Transition"); + +inline CStringPool_MultipleCIIndexToStringDynamic_Transition::CStringPool_MultipleCIIndexToStringDynamic_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleCIIndexToStringDynamicTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleCIIndexToStringDynamic_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleCIIndexToStringDynamicTransitMethod, "CStringPool::MultipleCIIndexToStringDynamic transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleCIIndexToStringDynamicTransitMethod); + _LIT8(KStringE, "AnotherString"); + Context().iResult = (Context().iFE.DesC().CompareF(KStringE))==0; + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleCIIndexToStringDynamic_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// For case sensitive + + +// ______________________________________________________________________________ +// +/** + @internalComponent + Comments : Transition test of the StringPool::MultipleTableCSCtor method. + */ +class CStringPool_MultipleTableCSCtor_Transition : public CTransitionType + { +public: + /** + @fn CStringPool_MultipleTableCSCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) + Intended Usage : Standard c'tor method. + Error Condition : None. + @since 7.0 + @param aUTContext The context this transition is operating in. + @param aValidator Used for checking the pre & post conditions of the test object. + @pre None. + @post CStringPool_MultipleTableCSCtor_Transition is fully constructed. + */ + CStringPool_MultipleTableCSCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator); + /** + @fn TransitMethodL() + Intended Usage : To execute the StringPool::MultipleTableCSCtor method for the test harness. + Error Condition : Leaves with an error code. + @leave KErrNoMemory, (@see StringPool::MultipleTableCSCtor) + @since 7.0 + @return None + @pre CStringPool_MultipleTableCSCtor_Transition is fully constructed. + @post No change in the CStringPool_MultipleTableCSCtor_Transition apart + from iStringPool, which may have changed state. + (@see StringPool::MultipleTableCSCtor post-condition) for iStringPool's new state. + */ + inline void TransitMethodL(); + + /** + @fn Context() const + Intended Usage : To provide access to the unit test context cast to the correct type. + Error Condition : None. + @since 7.0 + @return The unit test context cast to a CStringPool_UnitTestContext + @pre iUTContext is a valid CStringPool_UnitTestContext. + @post No change in the CStringPool_MultipleTableCSCtor_Transition + */ + inline CStringPool_UnitTestContext& Context() const; + }; // CStringPool_MultipleTableCSCtor_Transition + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleTableCSCtorTransition,"CStringPool_MultipleTableCSCtor_Transition"); + +inline CStringPool_MultipleTableCSCtor_Transition::CStringPool_MultipleTableCSCtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleTableCSCtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleTableCSCtor_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleTableCSCtorTransitMethod, "CStringPool::MultipleTableCSCtor transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleTableCSCtorTransitMethod); + + Context().iStringPool.OpenL(); + + _LIT8(KStringA, "AnotherString"); + CleanupClosePushL(Context().iF); + Context().iF=Context().iStringPool.OpenStringL(KStringA); // Dynamic string + CleanupStack::Pop(); // iF + + + Context().iTestTable=ShortCS::Table; + Context().iStringPool.OpenL(Context().iTestTable); + + Context().iTestTable2=ShortCS3::Table; // Non-duplicate table + Context().iStringPool.OpenL(Context().iTestTable2); + + Context().iTestTable3=ShortCS2::Table; + Context().iStringPool.OpenL(Context().iTestTable3); + + Context().iTestTable4=ShortCS4::Table; // Duplicate of a duplicate table + Context().iStringPool.OpenL(Context().iTestTable4); + Context().iStringPool.OpenL(Context().iTestTable4); // Add same table twice + + Context().iA=Context().iStringPool.String(ShortCS::EString, Context().iTestTable); // String + Context().iB=Context().iStringPool.String(ShortCS2::EString, Context().iTestTable3); // String + Context().iC=Context().iStringPool.String(ShortCS3::EString3, Context().iTestTable2); // String3, non-duplicate + Context().iD=Context().iStringPool.String(ShortCS4::EAnotherString , Context().iTestTable4); // AnotherString3 duplicate of a duplicate + + Context().iE=Context().iStringPool.String(ShortCS2::EAnotherString , Context().iTestTable3); // Duplicate of dynamic string + + Context().iIndex1=Context().iA.Index(Context().iTestTable); // 0 + Context().iIndex2=Context().iB.Index(Context().iTestTable3); // 1 + Context().iIndex3=Context().iC.Index(Context().iTestTable2); // 1 + Context().iIndex4=Context().iD.Index(Context().iTestTable4); // 2 + + + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleTableCSCtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMutlipleCSCeqCTransition,"CStringPool_MutlipleCSCeqC_Transition"); + +inline CStringPool_MutlipleCSCeqC_Transition::CStringPool_MutlipleCSCeqC_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMutlipleCSCeqCTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MutlipleCSCeqC_Transition::TransitMethodL() + { + _LIT(KStringPoolMutlipleCSCeqCTransitMethod, "CStringPool::MutlipleCSCeqC transition"); + Context().DataLogger().LogInformation(KStringPoolMutlipleCSCeqCTransitMethod); + _LIT8(KStringC, "String3"); + Context().iResult = (Context().iC.DesC().CompareF(KStringC))==0; + } + +inline CStringPool_UnitTestContext& CStringPool_MutlipleCSCeqC_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleCSStringToIndexTransition,"CStringPool_MultipleCSStringToIndex_Transition"); + +inline CStringPool_MultipleCSStringToIndex_Transition::CStringPool_MultipleCSStringToIndex_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleCSStringToIndexTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleCSStringToIndex_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleCSStringToIndexTransitMethod, "CStringPool::MultipleCSStringToIndex transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleCSStringToIndexTransitMethod); + if (Context().iIndex1==0 && Context().iIndex2==1 && Context().iIndex3==1 && Context().iIndex4==2) + Context().iResult = ETrue; + else + Context().iResult = EFalse; + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleCSStringToIndex_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleCSDynamicStringTransition,"CStringPool_MultipleCSDynamicString_Transition"); + +inline CStringPool_MultipleCSDynamicString_Transition::CStringPool_MultipleCSDynamicString_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleCSDynamicStringTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleCSDynamicString_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleCSDynamicStringTransitMethod, "CStringPool::MultipleCSDynamicString transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleCSDynamicStringTransitMethod); + Context().iResult = Context().iE==Context().iF; + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleCSDynamicString_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleCSIndexToStringDynamicTransition,"CStringPool_MultipleCSIndexToStringDynamic_Transition"); + +inline CStringPool_MultipleCSIndexToStringDynamic_Transition::CStringPool_MultipleCSIndexToStringDynamic_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleCSIndexToStringDynamicTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleCSIndexToStringDynamic_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleCSIndexToStringDynamicTransitMethod, "CStringPool::MultipleCSIndexToStringDynamic transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleCSIndexToStringDynamicTransitMethod); + _LIT8(KStringE, "AnotherString"); + Context().iResult = (Context().iE.DesC().CompareF(KStringE))==0; + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleCSIndexToStringDynamic_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolMultipleTableDtorTransition,"CStringPool_MultipleTableDtor_Transition"); + +inline CStringPool_MultipleTableDtor_Transition::CStringPool_MultipleTableDtor_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolMultipleTableDtorTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_MultipleTableDtor_Transition::TransitMethodL() + { + _LIT(KStringPoolMultipleTableDtorTransitMethod, "CStringPool::MultipleTableDtor transition"); + Context().DataLogger().LogInformation(KStringPoolMultipleTableDtorTransitMethod); + Context().iA.Close(); + Context().iB.Close(); + Context().iC.Close(); + Context().iD.Close(); + Context().iE.Close(); + Context().iF.Close(); + + Context().iFA.Close(); + Context().iFB.Close(); + Context().iFC.Close(); + Context().iFD.Close(); + Context().iFE.Close(); + Context().iFF.Close(); + + Context().iStringPool.Close(); + } + +inline CStringPool_UnitTestContext& CStringPool_MultipleTableDtor_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolBEU55DJG3Transition,"CStringPool_BEU55DJG3_Transition"); + +inline CStringPool_BEU55DJG3_Transition::CStringPool_BEU55DJG3_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolBEU55DJG3Transition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_BEU55DJG3_Transition::TransitMethodL() + { + _LIT(KStringPoolBEU55DJG3TransitMethod, "CStringPool::BEU55DJG3 transition"); + _LIT(KMinus1, "The Index() function returns = KErrNotFound"); + _LIT(KOther, "The Index() function returns something != -1"); + Context().DataLogger().LogInformation(KStringPoolBEU55DJG3TransitMethod); + TInt result; + result = Context().iEmptyOne.Index(Context().iTestTable); + if (result == KErrNotFound) + { + Context().iResult = 1; //ETrue + Context().DataLogger().LogInformation(KMinus1); + } + else + { + Context().iResult = 0 ;//EFalse + Context().DataLogger().LogInformation(KOther); + } + + } + +inline CStringPool_UnitTestContext& CStringPool_BEU55DJG3_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolKRN56NDEZTransition,"CStringPool_KRN56NDEZ_Transition"); + +inline CStringPool_KRN56NDEZ_Transition::CStringPool_KRN56NDEZ_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolKRN56NDEZTransition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_KRN56NDEZ_Transition::TransitMethodL() + { + _LIT(KStringPoolKRN56NDEZTransitMethod, "CStringPool::KRN56NDEZ transition"); + _LIT(KTestOK,"\n Test Passed"); + _LIT(KTestFailed,"\nTest Failed"); + + + Context().DataLogger().LogInformation(KStringPoolKRN56NDEZTransitMethod); + + //Open 2 tables with some string duplicates and open them + Context().iStringPool.OpenL(Short::Table); + Context().iStringPool.OpenL(Short2::Table); + + Context().iFAString = Context().iStringPool.StringF(Short2::EString,Short2::Table); + const TStringTable* originalTable= Context().iFAString.OriginalTableRef(); + + Context().iFADuplicateString = Context().iStringPool.StringF(Short::EString,Short::Table); + const TStringTable* ShortTable= Context().iFA.OriginalTableRef(); + + + if (ShortTable==originalTable) + { + Context().iResult=ETrue; + Context().DataLogger().LogInformation(KTestOK); + } + else + { + Context().iResult=EFalse; + Context().DataLogger().LogInformation(KTestFailed); + } + + } + +inline CStringPool_UnitTestContext& CStringPool_KRN56NDEZ_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + +// ______________________________________________________________________________ +// +_LIT(KStringPoolAPY57TEH3Transition,"CStringPool_APY57TEH3_Transition"); + +inline CStringPool_APY57TEH3_Transition::CStringPool_APY57TEH3_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolAPY57TEH3Transition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_APY57TEH3_Transition::TransitMethodL() + { + _LIT(KStringPoolAPY57TEH3TransitMethod, "CStringPool::APY57TEH3 transition"); + Context().DataLogger().LogInformation(KStringPoolAPY57TEH3TransitMethod); + + + Context().iResult=(Context().iEmptyOne!=Context().iTFE); + + + } + +inline CStringPool_UnitTestContext& CStringPool_APY57TEH3_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } + + +// ______________________________________________________________________________ +// +_LIT(KStringPoolHAD57SK27Transition,"CStringPool_HAD57SK27_Transition"); + +inline CStringPool_HAD57SK27_Transition::CStringPool_HAD57SK27_Transition(CUnitTestContext& aUTContext, + TTransitionValidator& aValidator) +: CTransitionType(KStringPoolHAD57SK27Transition, aUTContext, aValidator) + { + // Do nothing here. + } + +inline void CStringPool_HAD57SK27_Transition::TransitMethodL() + { + _LIT(KStringPoolHAD57SK27TransitMethod, "CStringPool::HAD57SK27 transition"); + Context().DataLogger().LogInformation(KStringPoolHAD57SK27TransitMethod); + + + // Create string pool and load HTTP static table + RStringPool pool; + + pool.OpenL(); + + _LIT8(KUndeletable_EX, "_ex"); + Context().iUndeletable_EX = pool.OpenStringL(KUndeletable_EX); + + _LIT8(KUndeletable_A," _a"); + Context().iUndeletable_A = pool.OpenStringL(KUndeletable_A()); + + // Load SecurityPolicyProperties static table + pool.OpenL(SecurityPolicyPluginStrings::Table); + + // Close strings opened + Context().iUndeletable_EX.Close(); + Context().iUndeletable_A.Close(); + + // Close the string pool + pool.Close(); + //if at this point the m pool string pool closes fine .the test has passed + _LIT(KTestHAD57SK27OK,"\n Defect HAD57SK27OK test : OK\n"); + Context().DataLogger().LogInformation(KTestHAD57SK27OK); + Context().iResult=ETrue; + + } + +inline CStringPool_UnitTestContext& CStringPool_HAD57SK27_Transition::Context() const + { + return REINTERPRET_CAST(CStringPool_UnitTestContext&,iUTContext); + } +