/*

* Copyright (c) 2002-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:  ?Description

*

*/

// [INCLUDE FILES] - do not remove

#include <mdeobject.h>

#include <mdeconstants.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include <StifTestEventInterface.h>

#include "MdETestScripter.h"

#include "MdETestScripterAO.h"

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

// CMdETestScripter::BelongsToSessionL

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

//

TInt CMdETestScripter::BelongsToSessionL( CStifItemParser& aItem )

    {

    TInt mode;

    TInt state;

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

    CMdEInstanceItem* instanceItem = GetInstanceItemByArrayIndexL( mode, aItem );

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

    TL( instanceItem->BelongsToSession() == (TBool)state );

    return KErrNone;

    }

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

// CMdETestScripter::SessionL

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

//

TInt CMdETestScripter::SessionL( CStifItemParser& aItem )

    {

    TInt mode;

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

    CMdEInstanceItem* instanceItem = GetInstanceItemByArrayIndexL( mode, aItem );

    TL( iMdeSession == &instanceItem->Session());

    return KErrNone;

    }

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

// CMdETestScripter::InDatabaseL

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

//

TInt CMdETestScripter::InDatabaseL( CStifItemParser& aItem )

    {

    TInt mode;

    TInt state;

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

    CMdEInstanceItem* instanceItem = GetInstanceItemByArrayIndexL( mode, aItem );

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

    TL( instanceItem->InDatabase() == (TBool)state );

    return KErrNone;

    }

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

// CMdETestScripter::AddItemsL

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

//

TInt CMdETestScripter::AddItemsL( CStifItemParser& aItem )

    {

    TInt mode1, err = KErrNone;

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

    if ( mode1 == KSync )

        {

        RPointerArray<CMdEInstanceItem> itemArray;

        FormInstanceItemArrayL( aItem, itemArray );

        err = iMdeSession->AddItemsL( itemArray );

        }

    else if ( mode1 == KAsync )

        {

        FormInstanceItemArrayL( aItem, iItemArray );

        TEventIf event( TEventIf::ESetEvent, TName( KMdEItemsAsyncAdd ) );

        iAsyncHandler->Start( this, event );

        iMdEDataBuf.Close();// make sure the last async request buffer cleaned before using again.

        iMdeSession->AddItemsAsyncL( iItemArray, iAsyncHandler->iStatus, iMdEDataBuf );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return err;

    }

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

// CMdETestScripter::UpdateItemsL

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

//

TInt CMdETestScripter::UpdateItemsL( CStifItemParser& aItem )

    {

    TInt mode1, err = KErrNone;

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

    if ( mode1 == KSync )

        {

        RPointerArray<CMdEInstanceItem> itemArray;

        FormInstanceItemArrayL( aItem, itemArray );

        err = iMdeSession->UpdateItemsL( itemArray );

        }

    else if ( mode1 == KAsync )

        {

        FormInstanceItemArrayL( aItem, iItemArray );

        TEventIf event( TEventIf::ESetEvent, TName( KMdEItemsAsyncUpdate ) );

        iAsyncHandler->Start( this, event );

        iMdEDataBuf.Close();// make sure the last async request buffer cleaned before using again.

        iMdeSession->UpdateItemsAsyncL( iItemArray, iAsyncHandler->iStatus, iMdEDataBuf );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return err;

    }

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

// CMdETestScripter::AddRelationDefL

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

//

TInt CMdETestScripter::AddRelationDefL( CStifItemParser& aItem )

    {

    TPtrC relationString;

    CMdENamespaceDef* namespaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( relationString ));

    TRAPD( err, iMdeSession->AddRelationDefL( *namespaceDef, relationString ) );

    if( KErrAlreadyExists == err )

        {

        TEventIf event( TEventIf::ESetEvent, TName( KMdESchemaModified ) );

        TestModuleIf().Event( event );

        }

    return err;

    }

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

// CMdETestScripter::AddEventDefL

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

//

TInt CMdETestScripter::AddEventDefL( CStifItemParser& aItem )

    {

    TPtrC eventString;

    CMdENamespaceDef* namespaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( eventString ));

    TRAPD( err, iMdeSession->AddEventDefL( *namespaceDef, eventString ) );

    if( KErrAlreadyExists == err )

        {

        TEventIf event( TEventIf::ESetEvent, TName( KMdESchemaModified ) );

        TestModuleIf().Event( event );

       	}

    return err;

    }

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

// CMdETestScripter::PropertyDefCountL

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

//

TInt CMdETestScripter::PropertyDefCountL( CStifItemParser& aItem )

    {

    TInt count;

    CMdEObjectDef* objectDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem);

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

    TL( objectDef->PropertyDefCount() == count );

    return KErrNone;

    }

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

// CMdETestScripter::PropertyDefL

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

//

TInt CMdETestScripter::PropertyDefL( CStifItemParser& aItem )

    {

    TInt index;

    TPtrC name;

    User::LeaveIfError( aItem.GetNextString( name ));   

    CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem);

    CMdEObjectDef* objectDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem);

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

    CMdEPropertyDef& propertyDef = objectDef->PropertyDefL( index );

    TL( &propertyDef );

    iPropertyDefArray.Append( &propertyDef );

    AppendNameL( iPropertyDefNameArray, name );

    return KErrNone;

    }

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

// CMdETestScripter::GetPropertyDefL

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

//

TInt CMdETestScripter::GetPropertyDefL( CStifItemParser& aItem )

    {

    TPtrC propertyString;

    TPtrC name;

    User::LeaveIfError( aItem.GetNextString( name ));   

    CMdEObjectDef* objectDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem);

    User::LeaveIfError( aItem.GetNextString( propertyString ));

    CMdEPropertyDef& propertyDef = objectDef->GetPropertyDefL( propertyString );

    iPropertyDefArray.Append( &propertyDef );

    AppendNameL( iPropertyDefNameArray, name );

    return KErrNone;

    }

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

// CMdETestScripter::CompareL

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

//

TInt CMdETestScripter::CompareL( CStifItemParser& aItem )

    {

    TInt mode;

    TInt expected;

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

    TInt result( -1 );

    if ( mode == EObjectDef )

        {

        CMdEObjectDef* item1 = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

        CMdEObjectDef* item2 = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );

        result = item1->Compare( *item2 );

        }

    else if ( mode == ERelationDef )

        {

        CMdERelationDef* item1 = SanitizeArrayIndexL( iRelationDefArray, *iRelationDefNameArray, aItem );

        CMdERelationDef* item2 = SanitizeArrayIndexL( iRelationDefArray, *iRelationDefNameArray, aItem );

        result = item1->Compare( *item2 );

        }

    else if ( mode == EEventDef )

        {

        CMdEEventDef* item1 = SanitizeArrayIndexL( iEventDefArray, *iEventDefNameArray, aItem );

        CMdEEventDef* item2 = SanitizeArrayIndexL( iEventDefArray, *iEventDefNameArray, aItem );

        result = item1->Compare( *item2 );

        }

    else if ( mode == EPropertyDef )

        {

        CMdEPropertyDef* item1 = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

        CMdEPropertyDef* item2 = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

        result = item1->Compare( *item2 );

        }

    else if ( mode == ENamespaceDef )

        {

        CMdENamespaceDef* item1 = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

        CMdENamespaceDef* item2 = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

        result = item1->Compare( *item2 );

        }

    else

        {

        User::Leave( KErrArgument );

        }

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

    TL( result == expected );

    return KErrNone;

    }

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

// CMdETestScripter::ReadOnlyL

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

//

TInt CMdETestScripter::ReadOnlyL( CStifItemParser& aItem )

    {

    TInt mode;

    TBool state;

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

    if ( mode == EPropertyDef )

        {

        CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

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

        TL( propertyDef->ReadOnly() == (TBool)state );

        }

    else if ( mode == ENamespaceDef )

        {

        CMdENamespaceDef* namespaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

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

        TL( namespaceDef->ReadOnly() == state );

        }

    return KErrNone;

    }

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

// CMdETestScripter::MandatoryL

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

//

TInt CMdETestScripter::MandatoryL( CStifItemParser& aItem )

    {

    TBool state;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

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

    TL( propertyDef->Mandatory() == (TBool)state );

    return KErrNone;

    }    

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

// CMdETestScripter::MinInt32ValueL

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

//

TInt CMdETestScripter::MinInt32ValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TInt32 valueU;

    lex.BoundedVal( valueU, 0x7FFFFFFF );

    TL( propertyDef->MinInt32ValueL() == valueU );

    return KErrNone;

    }

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

// CMdETestScripter::MaxInt32ValueL

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

//

TInt CMdETestScripter::MaxInt32ValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TInt32 valueU;

    lex.BoundedVal( valueU, 0x7FFFFFFF );

    TL( propertyDef->MaxInt32ValueL() == valueU );

    return KErrNone;

    }

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

// CMdETestScripter::MinUint32ValueL

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

//

TInt CMdETestScripter::MinUint32ValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TUint32 valueU;

    lex.BoundedVal( valueU, EDecimal, 0xFFFFFFFF );

    TL( propertyDef->MinUint32ValueL() == valueU );

    return KErrNone;

    }

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

// CMdETestScripter::MaxUint32ValueL

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

//

TInt CMdETestScripter::MaxUint32ValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TUint32 valueU;

    lex.BoundedVal( valueU, EDecimal, 0xFFFFFFFF );

    TL( propertyDef->MaxUint32ValueL() == valueU );

    return KErrNone;

    }

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

// CMdETestScripter::MinInt64ValueL

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

//

TInt CMdETestScripter::MinInt64ValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TInt64 value64;

    lex.Val( value64, 0x7FFFFFFFFFFFFFFF );

    TL( propertyDef->MinInt64ValueL() == value64 );

    return KErrNone;

    }

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

// CMdETestScripter::MaxInt64ValueL

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

//

TInt CMdETestScripter::MaxInt64ValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TInt64 value64;

    lex.Val( value64, 0x7FFFFFFFFFFFFFFF );

    TL( propertyDef->MaxInt64ValueL() == value64 );

    return KErrNone;

    }

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

// CMdETestScripter::MinRealValueL

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

//

TInt CMdETestScripter::MinRealValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TReal valueR;

    lex.Val( valueR );

    TL( propertyDef->MinRealValueL() == valueR );

    return KErrNone;

    }

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

// CMdETestScripter::MaxRealValueL

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

//

TInt CMdETestScripter::MaxRealValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

    User::LeaveIfError( aItem.GetNextString( value ));

    TLex lex( value );

    TReal valueR;

    lex.Val( valueR );

    TL( propertyDef->MaxRealValueL() == valueR );

    return KErrNone;

    }

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

// CMdETestScripter::MinTimeValueL

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

//

TInt CMdETestScripter::MinTimeValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TTime time;

    TL( time.Set( value ) == KErrNone );

    TL( propertyDef->MinTimeValueL() == time );

    return KErrNone;

    }

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

// CMdETestScripter::MaxTimeValueL

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

//

TInt CMdETestScripter::MaxTimeValueL( CStifItemParser& aItem )

    {

    TPtrC value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( value ));

    TTime time;

    TL( time.Set( value ) == KErrNone );

    TL( propertyDef->MaxTimeValueL() == time );

    return KErrNone;

    }

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

// CMdETestScripter::MinTextLengthL

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

//

TInt CMdETestScripter::MinTextLengthL( CStifItemParser& aItem )

    {

    TInt value;

    CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );

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

    TL( propertyDef->MinTextLengthL() == value );

    return KErrNone;

    }

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

// CMdETestScripter::MaxTextLengthL

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

//

TInt CMdETestScripter::MaxTextLengthL( CStifItemParser& aItem )