/*

* Copyright (c) 2006-2007 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 FILES

#include <e32svr.h>

#include <stifparser.h>

#include <stiftestinterface.h>

#include <StifTestEventInterface.h>

#include "speechsynthesistest.h"

#include "rubydebug.h"

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void CSpeechSynthesisTest::Delete() 

    {

    delete iTester;

    iTester = NULL;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::RunMethodL( CStifItemParser& aItem ) 

    {

    TStifFunctionInfo const KFunctions[] =

        {

        ENTRY( "Open",                      CSpeechSynthesisTest::OpenL ),

        ENTRY( "Close",                     CSpeechSynthesisTest::CloseL ),

        ENTRY( "InitialiseSynthesis",       CSpeechSynthesisTest::SynthesisInitL ),

        ENTRY( "InitialiseSynthesisFile",   CSpeechSynthesisTest::SynthesisInitFileL ),

        ENTRY( "Synthesise",                CSpeechSynthesisTest::SynthesiseL ),

        ENTRY( "Stop",                      CSpeechSynthesisTest::StopL ),

        ENTRY( "Pause",                     CSpeechSynthesisTest::PauseL ),

        ENTRY( "GetSupportedLangs",         CSpeechSynthesisTest::GetSupportedLanguagesL ),    

        ENTRY( "GetSupportedVoices",        CSpeechSynthesisTest::GetSupportedVoicesL ),

        ENTRY( "Voice",                     CSpeechSynthesisTest::VoiceL ),

        ENTRY( "SetVoice",                  CSpeechSynthesisTest::SetVoiceL ),

        ENTRY( "MaxVolume",                 CSpeechSynthesisTest::MaxVolumeL ),

        ENTRY( "Volume",                    CSpeechSynthesisTest::VolumeL ),

        ENTRY( "SetVolume",                 CSpeechSynthesisTest::SetVolumeL ),

        ENTRY( "MaxSpeakingRate",           CSpeechSynthesisTest::MaxSpeakingRateL ),

        ENTRY( "SpeakingRate",              CSpeechSynthesisTest::SpeakingRateL ),

        ENTRY( "SetSpeakingRate",           CSpeechSynthesisTest::SetSpeakingRateL ),

        ENTRY( "SetAudioPriority",          CSpeechSynthesisTest::SetAudioPriorityL ),

        ENTRY( "CustomCommand",             CSpeechSynthesisTest::CustomCommandL ),

        };

    const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::OpenL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::OpenL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt result = iTester->Open();

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::CloseL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::CloseL( CStifItemParser& aItem )

    {

    // Expected result not used. 

    ReadExpectedResultL( aItem ); 

    iTester->Close();

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SynthesisInitL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SynthesisInitL( CStifItemParser& aItem )

    {

    iExpectedResult = ReadExpectedResultL( aItem ); 

    TPtrC tmp;

    iText.Delete( 0, iText.MaxLength() );

    while ( aItem.GetNextString( tmp ) == KErrNone )

        {

        iText.Append( tmp );

        iText.Append( _L(" ") );

        }

    iTester->SynthesisInit( iText );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SynthesisInitFileL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SynthesisInitFileL( CStifItemParser& aItem )

    {

    iExpectedResult = ReadExpectedResultL( aItem ); 

    TInt result( KErrArgument );

    TPtrC tmp;

    TFileName fileName;

    iText.Delete( 0, iText.MaxLength() );

    while ( aItem.GetNextString( tmp ) == KErrNone )

        {

        if ( tmp != _L("filename:") )

            {

            iText.Append( tmp );

            iText.Append( _L(" ") );

            }

        else

            {

            break;

            }

        }

    if ( aItem.GetNextString( tmp ) == KErrNone )

        {

        fileName.Append( tmp );

        iTester->SynthesisInit( iText, fileName );

        result = KErrNone;

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SynthesiseL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SynthesiseL( CStifItemParser& aItem )

    {

    iExpectedResult = ReadExpectedResultL( aItem ); 

    iTester->Synthesise();

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::StopL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::StopL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TRAPD( result, iTester->StopL() );

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::PauseL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::PauseL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TRAPD( result, iTester->PauseL() );

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::GetSupportedLanguagesL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::GetSupportedLanguagesL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    RArray<TLanguage> languages;

    CleanupClosePushL( languages );

    TRAPD( result, iTester->GetSupportedLanguagesL( languages ) );

    CleanupStack::PopAndDestroy( &languages );

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::GetSupportedVoicesL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::GetSupportedVoicesL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    RArray<TVoice> voices;

    CleanupClosePushL( voices );

    TInt tmp;

    User::LeaveIfError( aItem.GetNextInt( tmp ) );

    TLanguage language( (TLanguage)tmp );

    TRAPD( result, iTester->GetSupportedVoicesL( voices, language ) ); 

    CleanupStack::PopAndDestroy( &voices );

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::VoiceL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::VoiceL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TVoice voice;

    TRAPD( result, voice = iTester->VoiceL() );

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SetVoiceL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SetVoiceL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    // @todo Implement this!

    TInt result = KErrNotSupported;

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::MaxVolumeL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::MaxVolumeL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt maxVolume( -1 );

    TRAPD( result, maxVolume = iTester->MaxVolumeL() );

    CheckResultL( expectedResult, result );

    TestModuleIf().Printf( 0, _L("MaxVolume:"), _L("%d"), maxVolume );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::VolumeL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::VolumeL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt volume( -1 );

    TRAPD( result, volume = iTester->VolumeL() );

    CheckResultL( expectedResult, result );

    TestModuleIf().Printf( 1, _L("Volume:"), _L("%d"), volume );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SetVolumeL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SetVolumeL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt newVolume;

    aItem.GetNextInt( newVolume );

    TRAPD( result, iTester->SetVolumeL( newVolume * iTester->MaxVolumeL() / 10 ) );

    CheckResultL( expectedResult, result ); 

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::MaxSpeakingRateL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::MaxSpeakingRateL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt maxSpeakingRate( -1 ); 

    TRAPD( result, maxSpeakingRate = iTester->MaxSpeakingRateL() ); 

    CheckResultL( expectedResult, result ); 

    TestModuleIf().Printf( 2, _L("maxSpeakingRate:"), _L("%d"), maxSpeakingRate );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SpeakingRateL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SpeakingRateL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt rate( -1 );

    TRAPD( result, rate = iTester->SpeakingRateL() );

    CheckResultL( expectedResult, result ); 

    TestModuleIf().Printf( 3, _L("SpeakingRate:"), _L("%d"), rate );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SetSpeakingRateL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SetSpeakingRateL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt newRate;

    aItem.GetNextInt( newRate );

    TRAPD( result, iTester->SetSpeakingRateL( newRate ) );

    CheckResultL( expectedResult, result ); 

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SetAudioPriorityL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::SetAudioPriorityL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TInt priority( -1 );

    aItem.GetNextInt( priority );

    TInt preference( -1 );

    aItem.GetNextInt( preference );

    TRAPD( result, iTester->SetAudioPriorityL( priority, preference ) );

    CheckResultL( expectedResult, result ); 

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::CustomCommandL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::CustomCommandL( CStifItemParser& aItem )

    {

    TInt expectedResult = ReadExpectedResultL( aItem ); 

    TRAPD( result, iTester->CustomCommandL( 0, 0 ) );

    CheckResultL( expectedResult, result );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SynthesisInitComplete

// 

// -----------------------------------------------------------------------------

//

void CSpeechSynthesisTest::SynthesisInitComplete( TInt aError )

    {

    RUBY_DEBUG0( "SynthesisInitComplete - START" );

    if ( iExpectedResult != aError )

        {

        RUBY_ERROR2( "CSpeechSynthesisTest::SynthesisInitComplete -- %d != %d", 

                     iExpectedResult, aError );

        User::Panic( _L("InitComplete"), aError );

        }

    TEventIf stifEvent( TEventIf::ESetEvent,  _L( "SynthesisInitComplete" ) );

    TestModuleIf().Event( stifEvent );

    RUBY_DEBUG0( "SynthesisInitComplete - EXIT" );

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::SynthesisComplete

// 

// -----------------------------------------------------------------------------

//

void CSpeechSynthesisTest::SynthesisComplete( TInt aError )

    {

    RUBY_DEBUG0( "SynthesisComplete - START" );

    if ( iExpectedResult != aError )

        {

        RUBY_ERROR2( "CSpeechSynthesisTest::SynthesisComplete -- %d != %d", 

                     iExpectedResult, aError );

        User::Panic( _L("Complete"), aError );

        }

    TEventIf stifEvent( TEventIf::ESetEvent,  _L( "SynthesisComplete" ) );

    TestModuleIf().Event( stifEvent );

    RUBY_DEBUG0( "SynthesisComplete - EXIT" );

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::ReadExpectedResultL

// 

// -----------------------------------------------------------------------------

//

TInt CSpeechSynthesisTest::ReadExpectedResultL( CStifItemParser& aItem )

    {

    TInt expectedResult( -1 );

    User::LeaveIfError( aItem.GetNextInt( expectedResult ) );

    return expectedResult;

    }

// -----------------------------------------------------------------------------

// CSpeechSynthesisTest::CheckResultL

// 

// -----------------------------------------------------------------------------

//

void CSpeechSynthesisTest::CheckResultL( TInt aExpectedResult, TInt aResult )

    {