diff -r 000000000000 -r 40261b775718 mmlibs/mmfw/tsrc/mmfunittest/GEF/src/GlobalEffectTest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfunittest/GEF/src/GlobalEffectTest.cpp Tue Feb 02 01:56:55 2010 +0200 @@ -0,0 +1,503 @@ + +// GlobalEffectTest.cpp + +// Copyright (c) 2005-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: +// + +#include "GlobalEffectTest.h" +#include "TestGlobalEffect.hrh" +#include "TestEffect.h" + +#include + + +// +// RGlobalEffectPrimitiveTest +// + +RGlobalEffectPrimitiveTest* RGlobalEffectPrimitiveTest::NewL(TBool aAllocTest) + { + RGlobalEffectPrimitiveTest* self = new (ELeave) RGlobalEffectPrimitiveTest(aAllocTest); + return self; + } + +RGlobalEffectPrimitiveTest::RGlobalEffectPrimitiveTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-MMF-GEF-U-001"); + } + +TVerdict RGlobalEffectPrimitiveTest::DoTestStepL() + { + INFO_PRINTF1(_L("Check can actually open test GlobalEffect plugin")); + TVerdict result = EPass; + + __MM_HEAP_MARK; + + CTestGlobalEffect* plugin = NULL; + + TRAPD(error, plugin = CTestGlobalEffect::NewL(NULL)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("plugin opened as expected")); + delete plugin; + } + else + { + INFO_PRINTF2(_L("CreateImplementationL() failed - %d"), error); + result = EFail; + } + + __MM_HEAP_MARKEND; + + return result; + } + +// +// RGlobalEffectStdTest +// + +RGlobalEffectStdTest* RGlobalEffectStdTest::NewL(TBool aAllocTest) + { + RGlobalEffectStdTest* self = new (ELeave) RGlobalEffectStdTest(aAllocTest); + return self; + } + +RGlobalEffectStdTest::RGlobalEffectStdTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-MMF-GEF-U-002"); + } + +TVerdict RGlobalEffectStdTest::DoTestStepL() + { + INFO_PRINTF1(_L("Check standard plugins cleanup return errors")); + TVerdict result = EPass; + + { + __MM_HEAP_MARK; + + CMmfGlobalEqEffect* plugin = NULL; + + TRAPD(error, plugin = CMmfGlobalEqEffect::NewL(NULL)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("GlobalEq plugin opened managed to open!")); + delete plugin; + result = EFail; + } + else if (error==KErrNotSupported) + { + INFO_PRINTF1(_L("GlobalEq plugin not supported - as expected")); + } + else + { + INFO_PRINTF2(_L("GlobalEq CreateImplementationL() failed - %d"), error); + result = EFail; + } + + __MM_HEAP_MARKEND; + } + + { + __MM_HEAP_MARK; + + CMmfGlobalMegaEffect* plugin = NULL; + + TRAPD(error, plugin = CMmfGlobalMegaEffect::NewL(NULL)); + + if (error==KErrNone) + { + INFO_PRINTF1(_L("GlobalMega plugin opened managed to open!")); + delete plugin; + result = EFail; + } + else if (error==KErrNotSupported) + { + INFO_PRINTF1(_L("GlobalMega plugin not supported - as expected")); + } + else + { + INFO_PRINTF2(_L("GlobalMega CreateImplementationL() failed - %d"), error); + result = EFail; + } + + __MM_HEAP_MARKEND; + } + + return result; + } + +// +// RGlobalEffectMainTest +// + +RGlobalEffectMainTest* RGlobalEffectMainTest::NewL(TBool aAllocTest) + { + RGlobalEffectMainTest* self = new (ELeave) RGlobalEffectMainTest(aAllocTest); + return self; + } + +RGlobalEffectMainTest::RGlobalEffectMainTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-MMF-GEF-U-003"); + } + +TVerdict RGlobalEffectMainTest::DoTestStepL() + { + INFO_PRINTF1(_L("Check basic API calls on TestPlugin")); + TVerdict result = EPass; + + __MM_HEAP_MARK; + + CTestGlobalEffect* plugin = NULL; + + TRAPD(error, plugin = CTestGlobalEffect::NewL(NULL)); + + if (error!=KErrNone) + { + INFO_PRINTF2(_L("CreateImplementationL() failed - %d"), error); + return EFail; + } + + CleanupStack::PushL(plugin); + + { + // check Capability + TUint value = plugin->Capability(EFalse); + if (value!=0) + { + INFO_PRINTF2(_L("Capability(EFalse): expected 0 got - %d"), value); + result = EFail; + } + value = plugin->Capability(ETrue); + if (value!=0xffff) + { + INFO_PRINTF2(_L("Capability(ETrue): expected -1 got - %d"), value); + result = EFail; + } + } + + // check settings by des, uid or value + HBufC8* tempDes = NULL; + TUid tempUid; + TInt tempInt; + TPckg tempPackage (tempInt); + { + // initially (stage 1) nothing set, so SettingsByUidL() and ExtractValuesL() + // should leave KErrNotSupported, and SettingsByDesL() should return "1234" + + TRAP(error, tempDes = plugin->SettingsByDesL()); + if (error==KErrNone) + { + CleanupStack::PushL(tempDes); + if (*tempDes!=_L8("1234")) + { + HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length()); + tempDes16->Des().Copy(*tempDes); + INFO_PRINTF2(_L("Stage1: SettingsByDesL() expected \"1234\" got \"%S\""), tempDes16); + result = EFail; + CleanupStack::PopAndDestroy(tempDes16); + } + CleanupStack::PopAndDestroy(tempDes); + tempDes = NULL; + } + else + { + INFO_PRINTF2(_L("Stage1: SettingsByDesL() returned %d"), error); + result = EFail; + } + + TRAP(error, tempUid = plugin->SettingsByUidL()); + if (error!=KErrNotSupported) + { + INFO_PRINTF3(_L("Stage1: SettingsByUidL() expected KErrNotSupported got %d(0x%x)"), error, tempUid.iUid); + result = EFail; + } + + TRAP(error, plugin->ExtractValuesL(tempPackage)); + if (error!=KErrNotSupported) + { + INFO_PRINTF3(_L("Stage1: ExtractValuesL() expected KErrNotSupported got %d(%d)"), error, tempInt); + result = EFail; + } + + } + + { + // at stage 2, we set a value by UID, so now SettingsByUid returns something sensible + TUid sampleUid = {0x1234567}; // any silly value will do + plugin->SetSettingsByUidL(sampleUid); + + TRAP(error, tempDes = plugin->SettingsByDesL()); + if (error==KErrNone) + { + CleanupStack::PushL(tempDes); + if (*tempDes!=_L8("1234")) + { + HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length()); + tempDes16->Des().Copy(*tempDes); + INFO_PRINTF2(_L("Stage2: SettingsByDesL() expected \"1234\" got \"%S\""), tempDes16); + result = EFail; + CleanupStack::PopAndDestroy(tempDes16); + } + CleanupStack::PopAndDestroy(tempDes); + tempDes = NULL; + } + else + { + INFO_PRINTF2(_L("Stage2: SettingsByDesL() returned %d"), error); + result = EFail; + } + + TRAP(error, tempUid = plugin->SettingsByUidL()); + if (error!=KErrNone) + { + INFO_PRINTF3(_L("Stage2: SettingsByUidL() expected KErrNone got %d(0x%x)"), error, tempUid.iUid); + result = EFail; + } + else if (tempUid != sampleUid) + { + INFO_PRINTF3(_L("Stage2: SettingsByUidL() expected return of 0x%x got 0x%x"), sampleUid.iUid, tempUid.iUid); + } + + TRAP(error, plugin->ExtractValuesL(tempPackage)); + if (error!=KErrNotSupported) + { + INFO_PRINTF3(_L("Stage2: ExtractValuesL() expected KErrNotSupported got %d(%d)"), error, tempInt); + result = EFail; + } + + } + + { + // at stage 3, we set a value by des, so again only SettingsByDesL() gives valid results + _LIT8(KSampleDes, "89a"); + plugin->SetSettingsByDesL(KSampleDes); + + TRAP(error, tempDes = plugin->SettingsByDesL()); + if (error==KErrNone) + { + CleanupStack::PushL(tempDes); + if (*tempDes!=KSampleDes) + { + HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length()); + tempDes16->Des().Copy(*tempDes); + INFO_PRINTF2(_L("Stage3: SettingsByDesL() expected \"89a\" got \"%S\""), tempDes16); + result = EFail; + CleanupStack::PopAndDestroy(tempDes16); + } + CleanupStack::PopAndDestroy(tempDes); + tempDes = NULL; + } + else + { + INFO_PRINTF2(_L("Stage3: SettingsByDesL() returned %d"), error); + result = EFail; + } + + TRAP(error, tempUid = plugin->SettingsByUidL()); + if (error!=KErrNotSupported) + { + INFO_PRINTF3(_L("Stage3: SettingsByUidL() expected KErrNotSupported got %d(0x%x)"), error, tempUid.iUid); + result = EFail; + } + + TRAP(error, plugin->ExtractValuesL(tempPackage)); + if (error!=KErrNotSupported) + { + INFO_PRINTF3(_L("Stage3: ExtractValuesL() expected KErrNotSupported got %d(%d)"), error, tempInt); + result = EFail; + } + } + + { + // at stage 4, we set a value by package buffer, so only that way returns valid value + const TInt sampleInt = 10; + TPckgC sampleBuffer (sampleInt); + plugin->SetByValuesL(sampleBuffer); + + TRAP(error, tempDes = plugin->SettingsByDesL()); + if (error==KErrNone) + { + CleanupStack::PushL(tempDes); + HBufC* tempDes16 = HBufC::NewMaxLC(tempDes->Length()); + tempDes16->Des().Copy(*tempDes); + INFO_PRINTF2(_L("Stage4: SettingsByDesL() expected KErrNotSupported got \"%S\""), tempDes16); + result = EFail; + CleanupStack::PopAndDestroy(2, tempDes); + tempDes = NULL; + } + else if (error!=KErrNotSupported) + { + INFO_PRINTF2(_L("Stage4: SettingsByDesL() expected KErrNotSupported returned %d"), error); + result = EFail; + } + + TRAP(error, tempUid = plugin->SettingsByUidL()); + if (error!=KErrNotSupported) + { + INFO_PRINTF3(_L("Stage4: SettingsByUidL() expected KErrNotSupported got %d(0x%x)"), error, tempUid.iUid); + result = EFail; + } + + TRAP(error, plugin->ExtractValuesL(tempPackage)); + if (error!=KErrNone) + { + INFO_PRINTF3(_L("Stage4: ExtractValuesL() expected KErrNone got %d(%d)"), error, tempInt); + result = EFail; + } + else if (tempInt!=sampleInt) + { + INFO_PRINTF3(_L("Stage4: ExtractValuesL() expected %d got %d"), sampleInt, tempInt); + result = EFail; + } + } + + { + // Check for Enabled() and IsActive() - should be false to start. poke value and show have + // changed. Have to use custom command for SetActive() since not really the way to drive + // - this should relate to the underlying implementation + TBool enabled = plugin->IsEnabled(); + TBool active = plugin->IsActive(); + if (enabled!=EFalse || active!=EFalse) + { + INFO_PRINTF3(_L("Check1: active(%d) and enabled(%d) should have been false"), active, enabled); + result = EFail; + } + plugin->SetEnabledL(ETrue); + plugin->SetActive(ETrue); + enabled = plugin->IsEnabled(); + active = plugin->IsActive(); + if (enabled==EFalse || active==EFalse) + { + INFO_PRINTF3(_L("Check2: active(%d) and enabled(%d) should have been true"), active, enabled); + result = EFail; + } + } + + { + // check preset - for test this ties up with the test plugin + const TInt KPresetsCount = 3; + MMmfGlobalAudioPresetList* list = plugin->KnownPresetsL(); + + // reproduce what the plugin will do and check + if (list->MdcaCount()!=KPresetsCount) + { + INFO_PRINTF3(_L("Expected %d presets, got %d"), KPresetsCount, list->MdcaCount()); + result = EFail; + } + else + { + for (TInt index=0; index name; + name.Num(index); + TUid tempUid={index}; + + TUid foundUid = list->GAPUidPoint(index); + const TPtrC foundName = list->MdcaPoint(index); + + if (foundUid!=tempUid) + { + INFO_PRINTF4(_L("Index %d, expected %x found %x"), index, tempUid.iUid, foundUid.iUid); + result = EFail; + } + if (foundName != name) + { + INFO_PRINTF4(_L("Index %d, expected %S found %S"), index, &name, &foundName); + result = EFail; + } + } + + } + } + + CleanupStack::PopAndDestroy(plugin); + + __MM_HEAP_MARKEND; + + return result; + } + +// +// RGlobalEffectCallbackTest +// + +const TUid KUidTestGlbNotification = {KUidTestGlbNotificationDefine}; + + +RGlobalEffectCallbackTest* RGlobalEffectCallbackTest::NewL(TBool aAllocTest) + { + RGlobalEffectCallbackTest* self = new (ELeave) RGlobalEffectCallbackTest(aAllocTest); + return self; + } + +RGlobalEffectCallbackTest::RGlobalEffectCallbackTest(TBool /*aAllocTest*/) + { + iTestStepName = _L("MM-MMF-GEF-U-004"); + } + +void RGlobalEffectCallbackTest::GAEEventNotificationL(CMmfGlobalAudioEffect* aEffect, + TUid aEventUid, + const TDesC8& aParam) + { + INFO_PRINTF1(_L("Callback")); + if (aEffect!=iEffect) + { + INFO_PRINTF3(_L("Effect is %x, expected %d"), aEffect, iEffect); + iResult = EFail; + } + if (KUidTestGlbNotification != aEventUid) + { + INFO_PRINTF3(_L("Uid is %x, expected %x"), aEventUid.iUid, KUidTestGlbNotification.iUid); + iResult = EFail; + } + if (aParam != KNullDesC8) + { + INFO_PRINTF2(_L("Param=\"%S\", expected \"\""), &aParam); + iResult = EFail; + } + iCalledBack = ETrue; + } + + +TVerdict RGlobalEffectCallbackTest::DoTestStepL() + { + INFO_PRINTF1(_L("Check notification callback")); + iResult = EPass; + + __MM_HEAP_MARK; + + iEffect = CTestGlobalEffect::NewL(this); + CleanupStack::PushL(iEffect); + + // for test, just generate test synchronously + iEffect->RequestNotificationL(KUidTestGlbNotification); + iEffect->GenCallbackL(); + + if (!iCalledBack) + { + INFO_PRINTF1(_L("Callback seemingly did not happen")); + iResult = EFail; + } + + CleanupStack::PopAndDestroy(iEffect); + + __MM_HEAP_MARKEND; + + return iResult; + } +