Beispiel #1
0
mm::Piece::Piece(std::string const& s)
    : mRotation(0)
    , mMaxRotations(0)
    , mPosX(InvalidPosition.first)
    , mPosY(InvalidPosition.second)
    , isSpecial(false)
    , originalStr(s)
{
    mStr[0] = CharToInt(s[3]);
    mStr[1] = CharToInt(s[0]);
    mStr[2] = CharToInt(s[1]);
    mStr[3] = CharToInt(s[2]);

    mL[0] = 100*BL() + 10*TL() + TR();
    mL[1] = 100*TL() + 10*TR() + BR();
    mL[2] = 100*TR() + 10*BR() + BL();
    mL[3] = 100*BR() + 10*BL() + TL();

    if      (mStr[0] == mStr[1] && mStr[1] == mStr[2] && mStr[0] == mStr[3]) { mMaxRotations = 1; }
    else if (mStr[0] == mStr[2] && mStr[1] == mStr[3])                       { mMaxRotations = 2; }
    else                                                                     { mMaxRotations = 4; }

    if (s == "GGGG" || s == "BBBB" || s == "YYYY" || s == "YRBG")
    {
        isSpecial = true;
    }
}
// -----------------------------------------------------------------------------
// CMdETestScripter::NameL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::NameL( CStifItemParser& aItem )
    {
    TInt mode;
    TPtrC name;

    User::LeaveIfError( aItem.GetNextInt( mode ));
    if ( mode == EPropertyDef )
        {
        CMdEPropertyDef* propDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );
        aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );
        User::LeaveIfError( aItem.GetNextString( name ));
        TL( name.Compare( propDef->Name()) == 0 );           
        }
    else if ( mode == ENamespaceDef )
        {
        CMdENamespaceDef* spaceDef = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
        aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );
        User::LeaveIfError( aItem.GetNextString( name ));
        TL( name.Compare( spaceDef->Name()) == 0 );
        }
    else
        {
        User::Leave( KErrArgument );
        }

    return KErrNone;
    }
// -----------------------------------------------------------------------------
// Tests CAiwDialDataExt setting and getting values.
// -----------------------------------------------------------------------------
//
TInt CAiwDialDataTests::ExtSetAndGetTestL( TTestResult& /*aResult*/ )
    {
    _LIT( KPhoneNumber, "1234567890");
    _LIT8( KContactLink, "ContactLink");
    _LIT( KName, "Mr Smith" );
    
    CAiwDialDataExt* dialData = CAiwDialDataExt::NewLC();
    
    dialData->SetPhoneNumberL( KPhoneNumber );
    dialData->SetCallType( CAiwDialData::EAIWVideo );
    dialData->SetWindowGroup( 1 );
    dialData->SetInitiateCall( ETrue );
    dialData->SetNameL( KName );
    
    dialData->SetRedial( AIWDialDataExt::KAIWRedialOff );
    dialData->SetShowNumber( EFalse );
    dialData->SetContactLinkL( KContactLink );
    
    TL(  dialData->PhoneNumber() == KPhoneNumber() );
    T1L( dialData->CallType(), CAiwDialData::EAIWVideo );
    T1L( dialData->WindowGroup(), 1 );
    TL( dialData->InitiateCall() );
    TL( dialData->Name() == KName() );
    T1L( dialData->Redial(), AIWDialDataExt::KAIWRedialOff );
    TL( !dialData->ShowNumber() );        
    TL( dialData->ContactLink() == KContactLink() );
    
    
    CAiwGenericParamList* list = CAiwGenericParamList::NewLC();
    dialData->FillInParamListL( *list );
    
    CleanupStack::PopAndDestroy( 2, dialData );

    return KErrNone;
    }
TInt CTestHistoryLog::AddNewJobEntryL( CStifItemParser& /*aItem*/ )
	{
	TInt arrayCount = iHistoryArray->Count() + 1;
	TInt profileId(1);	
	RArray<TInt> tasks;
	tasks.Append(KTaskId1);
	tasks.Append(KTaskId2);
	
	CSyncMLHistoryJob * entry = CSyncMLHistoryJob::NewL(profileId, tasks );
	CleanupStack::PushL(entry);
	
	tasks.Reset();
	tasks.Close();

	iHistoryArray->AppendEntryL(entry);
	
	TL(iHistoryArray->Count() == arrayCount);
	
	if (iOwnerShip)
		{
		CleanupStack::Pop(entry);
		}
	else
		{
		CleanupStack::PopAndDestroy(entry);		
		}	
	return KErrNone;
	}
TInt CTestHistoryLog::AddMoreThanFivePushMsgsL( CStifItemParser& /*aItem*/ )
	{
	
	for (TInt i = 0; i < KMaxMsgSize; i++)
		{
		CSyncMLHistoryPushMsg * entry = CSyncMLHistoryPushMsg::NewL();
		CleanupStack::PushL(entry);
	
		CSmlAlertInfo info;
		info.TaskIds().Append(KOne);
		info.TaskIds().Append(KTwo);
	
		info.TaskSyncTypes().Append( (TSmlSyncType)0);
		info.TaskSyncTypes().Append( (TSmlSyncType)KOne);
	
		iHistoryArray->AppendEntryL(entry);

		if (iOwnerShip)
			{
			CleanupStack::Pop(entry);
			}
		else
			{
			CleanupStack::PopAndDestroy(entry);		
			}	
		}
	TL(iHistoryArray->Count() == KMaxMsgSize);
	
	return KErrNone;
	}
Beispiel #6
0
void GEMENI_charsent() {
	unsigned long r = s->log[s->lc];
	if (UCA0IFG & UCTXIFG) {
		s->nch++;
		switch (s->nch) {
			case 1:
				UCA0TXBUF = SL(r) << 5 |TL(r)<<4|KL(r)<<3|PL(r)<<2|WL(r)<<1|HL(r);
			break;
			case 2:
				UCA0TXBUF = RL(r)<<6 | AL(r)<<5 | OL(r)<<4 | STAR(r)<<3;
			break;
			case 3:
				UCA0TXBUF = ER(r)<<3 | UR(r)<<2 | FR(r)<<1 | RR(r);
			break;
			case 4:
				UCA0TXBUF = PR(r)<<6 | BR(r)<<5 | LR(r)<<4 | GR(r)<<3 | TR(r)<<2 | SR(r)<<1 | DRS(r);
			break;
			case 5:
				UCA0TXBUF = POUND(r)<<1 | ZRS(r);
			break;
			default:
				s->lc++;
				if (s->lc != s->nc-1) {

  					s->nch = 0;
  					UCA0TXBUF = 1 << 7; // first packet, no fn or '#'
				} else {
					s->flags &= ~CSEND;
				}

		}
	}
}
// -----------------------------------------------------------------------------
// CMdETestScripter::GetSchemaVersionL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::GetSchemaVersionL( CStifItemParser& aItem )
    {
    TInt majorVersion;
    TInt minorVersion;
    TInt expectedMajorVersion;
    TInt expectedMinorVersion;

    User::LeaveIfError( aItem.GetNextInt( expectedMajorVersion ));
    User::LeaveIfError( aItem.GetNextInt( expectedMinorVersion ));

    iMdeSession->GetSchemaVersionL( majorVersion, minorVersion );
    TL( majorVersion == expectedMajorVersion );
    TL( minorVersion == expectedMinorVersion );

    return KErrNone;
    }
// -----------------------------------------------------------------------------
// CMdETestScripter::EngineSessionL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::EngineSessionL( CStifItemParser& /* aItem */ )
    {
    RMdEEngineSession& session = iMdeSession->EngineSession();
    TL( &session );

    return KErrNone;
    }
// -----------------------------------------------------------------------------
// CMdETestScripter::ImportMetadataL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::ImportMetadataL( CStifItemParser& aItem )
    {            
    TPtrC path;
    TInt mode;
    TInt ret = KErrNone;

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

    TFileName filePath( iFilePath );
    filePath.Append( path );
    filePath.ZeroTerminate();

    if ( mode == KAsync )
        {
        TRequestStatus status = KRequestPending;
        TPckgBuf<TInt> buf( ret );

        iMdeSession->ImportMetadata( filePath, buf, status );
        User::WaitForRequest( status );
        ret = buf();
        }
    else if ( mode == KSync )
        {
        ret = iMdeSession->ImportMetadataL( filePath );
        }
    else
        {
        User::Leave( KErrArgument );
        }
       iLog->Log( _L( "ImportMetadataL ret: %d" ), ret );
    TL ( ret >= 0 );

    return KErrNone;
    }
Beispiel #10
0
void fillWall(struct TILE *map, int sy, int sx, int ft, int wt){
	int y, x;
	for(y = 1; y < sy - 1; y++){
		for(x = 1; x < sx - 1; x++){
			if(map[CM(y,sx,x)].tT == TILE_BLANK){
				if(map[TL(y,sx,x)].tT == ft ||
				map[TM(y,sx,x)].tT == ft ||
				map[TR(y,sx,x)].tT == ft ||
				map[CL(y,sx,x)].tT == ft ||
				map[CR(y,sx,x)].tT == ft ||
				map[BL(y,sx,x)].tT == ft ||
				map[BM(y,sx,x)].tT == ft ||
				map[BR(y,sx,x)].tT == ft){
					map[CM(y,sx,x)].tT = wt;
				}
			}
		}
	}
	for(y = 0; y < sy; y++){
		for(x = 0; x < sx; x++){
			if(y == 0){
				if(map[S(y,sx,x)].tT == ft) map[C(y,sx,x)].tT = wt;
			}
			if(x == 0){
				if(map[E(y,sx,x)].tT == ft) map[C(y,sx,x)].tT = wt;
			}
			if(y == sy - 1){
				if(map[N(y,sx,x)].tT == ft) map[C(y,sx,x)].tT = wt;
			}
			if(x == sx - 1){
				if(map[W(y,sx,x)].tT == ft) map[C(y,sx,x)].tT = wt;
			}
		}
	}
}
TInt CSenServiceManagerBCTest::UT_CSenServiceManager_NewLL( TTestResult& aResult )
    {
    Empty();
    
    CSenServiceManager*     serviceManager = NULL;
    CSenServiceManager*     serviceManager2 = NULL;
    serviceManager = CSenServiceManager::NewL();
    TL(serviceManager != (CSenServiceManager*)NULL);

    __ASSERT_ALWAYS_NO_LEAVE(delete serviceManager );
    
    serviceManager = NULL;

    serviceManager = CSenServiceManager::NewL();
    TRAPD(error, serviceManager2 = CSenServiceManager::NewL());
    RDebug::Print( _L( "WSModTester: CSenServiceManager_NewL 2nd try with status %d" ), error);
    LOCAL_ASSERT(error==KErrNone);

    if (serviceManager != NULL){
        __ASSERT_ALWAYS_NO_LEAVE(delete serviceManager );
        serviceManager = NULL;
    }

    if (serviceManager2 != NULL){
        __ASSERT_ALWAYS_NO_LEAVE(delete serviceManager2 );
        serviceManager2 = NULL;
    }

    Empty();
    return KErrNone;
    }
// -----------------------------------------------------------------------------
// CMdETestScripter::ObjectDefL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::ObjectDefL( CStifItemParser& aItem )
    {
    TInt mode;
    TPtrC name;
    TInt index;
    CMdEObjectDef* objectDef = NULL;

    User::LeaveIfError( aItem.GetNextInt( mode ));
    User::LeaveIfError( aItem.GetNextString( name ));
    if ( mode == ENamespaceDef )
        {
        CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
        User::LeaveIfError( aItem.GetNextInt( index ));
        objectDef = &space->ObjectDefL( index );
        }
    else if ( mode == EPropertyDef )
        {
        CMdEPropertyDef* propDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem );
        objectDef = &propDef->ObjectDef();
        }
    else
        {
        User::Leave( KErrArgument );
        }

    TL( objectDef );
    iObjectDefArray.Append( objectDef );
    AppendNameL( iObjectDefNameArray, name );

    return KErrNone;
    }
TInt CTestHistoryLog::AddMoreThanFiveJobsL( CStifItemParser& /*aItem*/ )
	{
	for (TInt i = 0; i < KMaxMsgSize; i++)
		{
		RArray<TInt> tasks;
		tasks.Append(KTaskId1);
		tasks.Append(KTaskId2);
	
		CSyncMLHistoryJob * entry = CSyncMLHistoryJob::NewL(i, tasks );
		CleanupStack::PushL(entry);
	
		tasks.Reset();
		tasks.Close();

		iHistoryArray->AppendEntryL(entry);

	if (iOwnerShip)
		{
		CleanupStack::Pop(entry);
		}
	else
		{
		CleanupStack::PopAndDestroy(entry);
		}
		}
	TL(iHistoryArray->Count() == KMaxMsgSize);
	
	return KErrNone;
	}
// -----------------------------------------------------------------------------
// CMdETestScripter::ParentL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::ParentL( CStifItemParser& aItem )
    {
    CMdEObjectDef* objectDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );
    CMdEObjectDef* parentDef = SanitizeArrayIndexL( iObjectDefArray, *iObjectDefNameArray, aItem );
    TL( objectDef->ParentL() == parentDef );

    return KErrNone;
    }
Beispiel #15
0
static Temp_tempList F_make_calle_saves(void)
{
	Temp_temp rbx = Temp_newtemp(), r12 = Temp_newtemp(),
		r13 = Temp_newtemp(), r14 = Temp_newtemp(), r15 = Temp_newtemp();
	F_add_to_map("rbx", rbx); F_add_to_map("r12", r12); F_add_to_map("r13", r13);
	F_add_to_map("r14", r14); F_add_to_map("r15", r15);
	return TL(F_SP(), TL(F_FP(), TL(rbx, TL(r12, TL(r13, TL(r14, TL(r15, NULL)))))));
}
// -----------------------------------------------------------------------------
// CMdETestScripter::VerifyObserverNotificationTypeL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::VerifyObserverNotificationTypeL( CStifItemParser& aItem )
    {
    TInt type;

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

    TL( iNotificationType == type );

    return KErrNone;
    }
// -----------------------------------------------------------------------------
// CMdETestScripter::NamespaceDefCountL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::NamespaceDefCountL( CStifItemParser& aItem )
    {
    TInt count;

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

    TInt state = iMdeSession->NamespaceDefCount();
    TL( count == state );

    return KErrNone;
    }
// -----------------------------------------------------------------------------
// CMdETestScripter::EventDefCountL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::EventDefCountL( CStifItemParser& aItem )
    {
    TInt count;

    CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
    User::LeaveIfError( aItem.GetNextInt( count ));

    TL( space->EventDefCount() == count );

    return KErrNone;
    }
TInt CSenServiceManagerBCTest::UT_CSenServiceManager_NewLCL( TTestResult& aResult )
    {
    Empty();
    
    CSenServiceManager*     serviceManager = NULL;
    serviceManager = CSenServiceManager::NewLC();
    TL(serviceManager != (CSenServiceManager*)NULL);
    CleanupStack::PopAndDestroy();
    serviceManager = NULL;
    Empty();
	return KErrNone;
    }
TInt CsenservicemanagerTester::UT_CSenServiceManager_NewLCL( CStifItemParser& aItem )
    {
    Empty();
    
    CSenServiceManager*     serviceManager = NULL;
    serviceManager = CSenServiceManager::NewLC();
    TL(serviceManager != (CSenServiceManager*)NULL);
    CleanupStack::PopAndDestroy();
    serviceManager = NULL;
    Empty();
	return KErrNone;
    }
TInt CTestHistoryLog::RemoveEntry( CStifItemParser& /*aItem*/ )
	{
	CSyncMLHistoryEntry* tempPtrToHistoryArray;

	TL(iHistoryArray->Count() == KTwo);
	tempPtrToHistoryArray = iHistoryArray->RemoveEntry(1);
	delete tempPtrToHistoryArray;
	tempPtrToHistoryArray = NULL;
	
	TL(iHistoryArray->Count() == 1);
	tempPtrToHistoryArray = iHistoryArray->RemoveEntry(0);
	delete tempPtrToHistoryArray;
	tempPtrToHistoryArray = NULL;
	
	TL(iHistoryArray->Count() == 0);
	tempPtrToHistoryArray = iHistoryArray->RemoveEntry(-1);
	delete tempPtrToHistoryArray;
	tempPtrToHistoryArray = NULL;
	
	return KErrNone;
	}
Beispiel #22
0
void CEquivManager::Read(void) {
    struct_stat NewStat;
    base_stat((const char *) m_Filename.GetBuffer(), &NewStat);
    if (GetSize() && (m_Stat.st_mtime == NewStat.st_mtime))
        return;

    m_LoadMutex.Lock();
    m_Stat = NewStat;
    RemoveAll();
    (* (CTSStringTable *) this) = m_PersistentTable;
    CLocalFile File(m_Filename);
    if (File.OpenReadBinary()) {
        CVector<CString> Lines;
        File.ReadLines(&Lines);
        CString Line;
        for (register int i=0; i<(int) Lines.GetSize(); i++) {
            Line = Lines[i];
            //// _L_DEBUG(6, cout << "CEquivManager::Read() - parsing " << Line << endl);
            if (!Line.GetLength()) continue;
            if (Line[0] == '#') {
                Line.Delete(0, 1);
                if ((Line.Pos('<')>=0)&&(Line.Pos('>')> Line.Pos('<'))) m_EmailVector += Line;
            } else {
                CVector<CString> Tokens;
                CString::StrToVector(Line, ',', &Tokens);
                if ((Tokens.GetSize() == 2)&&(Tokens[0].GetLength())&&(Tokens[1].GetLength())) {
                    // complex equivalences
                    CVector<CString> TokensLeft;
                    CString::StrToVector(Tokens[0], '+', &TokensLeft);
                    CVector<CString> TokensRight;
                    CString::StrToVector(Tokens[1], '+', &TokensRight);
                    if ((int) TokensLeft.GetSize() > 1) {
                        if (TokensLeft.GetSize() > TokensRight.GetSize()) {
                            cout << "Dropping malformed equivalence at " << Tokens[0] << "=" << Tokens[1] << endl;
                        } else {
                            for (int ii=1; ii<(int)TokensLeft.GetSize(); ii++) {
                                CString TL(TokensLeft[0]);
                                TL+=TokensLeft[ii];
                                CString TR(TokensRight[0]);
                                TR+=TokensRight[ii];
                                CTSStringTable::Set(TL, TR);
                            }
                        }
                    } else {
                        CTSStringTable::Set(Tokens[0], Tokens[1]);
                    }
                }
            }
        }
    }
    m_LoadMutex.UnLock();
}
TInt CsenservicemanagerTester::UT_CSenServiceManager_NewL_1CL( CStifItemParser& aItem )
    {
    Empty();
    CSenServiceManager*     serviceManager = NULL;
    MSenAuthenticationProvider aProvider;
    serviceManager = CSenServiceManager::NewLC(aProvider);
    TL(serviceManager != (CSenServiceManager*)NULL);
    CleanupStack::PopAndDestroy();
    serviceManager = NULL;
    Empty();
	return KErrNone;
    
    }
// -----------------------------------------------------------------------------
// CMdETestScripter::GetEventDefL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::GetEventDefL( CStifItemParser& aItem )
    {
    TPtrC name;
    User::LeaveIfError( aItem.GetNextString( name ));   
    TPtrC eventString;

    CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
    User::LeaveIfError( aItem.GetNextString( eventString ));
    CMdEEventDef& eventDef = space->GetEventDefL( eventString );
    TL( &eventDef );
    iEventDefArray.Append( &eventDef );
    AppendNameL( iEventDefNameArray, name );
    return KErrNone;
    }
Beispiel #25
0
Poly *prim_polys(Prim *s, Poly *p)
{
  int i;
  Poly *l = plist_alloc(7, p->n);

  for (i = 0; i < p->n; i++) {
    PL(l)->v[i] = SL(l)->v[i] = prim_point(s, p->v[i].x, p->v[i].y);
    NL(l)->v[i] = prim_normal(s, p->v[i].x, p->v[i].y);
    TL(l)->v[i] = prim_texc(s, p->v[i].x, p->v[i].y);
    DUL(l)->v[i] = v3_unit(prim_du(s, p->v[i].x, p->v[i].y));
    DVL(l)->v[i] = v3_unit(prim_dv(s, p->v[i].x, p->v[i].y));
  }
  return l;
}
Beispiel #26
0
static Temp_tempList F_make_arg_regs(void)
{
	Temp_temp rdi = Temp_newtemp(), rsi = Temp_newtemp(),
		rdx = Temp_newtemp(), rcx = Temp_newtemp(), r8 = Temp_newtemp(),
		r9 = Temp_newtemp();
	F_add_to_map("rdi", rdi); F_add_to_map("rsi", rsi); F_add_to_map("rdx", rdx);
	F_add_to_map("rcx", rcx); F_add_to_map("r8", r8); F_add_to_map("r9", r9);
	return TL(rdi, TL(rsi, TL(rdx, TL(rcx, TL(r8, TL(r9, NULL))))));
}
TInt CsenservicemanagerTester::UT_CSenServiceManager_NewL_1L( CStifItemParser& aItem )
    {
    Empty();
    CSenServiceManager*     serviceManager = NULL;
    MSenAuthenticationProvider aProvider;
    serviceManager = CSenServiceManager::NewL(aProvider);
    TL(serviceManager != (CSenServiceManager*)NULL);
    if (serviceManager != NULL){
        __ASSERT_ALWAYS_NO_LEAVE(delete serviceManager );
        serviceManager = NULL;
    }
    Empty();
	return KErrNone;
    
    }
// -----------------------------------------------------------------------------
// Tests CAiwDialDataExt construction
// -----------------------------------------------------------------------------
//    
TInt CAiwDialDataTests::ExtConstructionTestL( TTestResult& /*aResult*/ )
    {
    CAiwDialDataExt* dialData = CAiwDialDataExt::NewL();
    delete dialData;
    
    dialData = CAiwDialDataExt::NewLC();
    
    TL(  dialData->PhoneNumber() == KNullDesC() );
    T1L( dialData->CallType(), CAiwDialData::EAIWVoice );
    T1L( dialData->WindowGroup(), 0 );
    TL( !dialData->InitiateCall() );
    TL( dialData->Name() == KNullDesC() );
    T1L( dialData->Redial(), AIWDialDataExt::KAIWRedialDefault );
    TL( dialData->ShowNumber() );        
    TL( dialData->ContactLink() == KNullDesC8() );
    
    CAiwGenericParamList* list = CAiwGenericParamList::NewLC();
    dialData->FillInParamListL( *list );
    
    CleanupStack::PopAndDestroy( 2, dialData );

    return KErrNone;

    }
void P_fun()
{
		scanf("%d", &next_angle);
		if(M)
		{
			G();
			return;
		}
		else
		{
			if(next_angle == 0)TL();
			else
			{
				if(next_angle >= 160)
				{
					backward(X);
					return;
				}
				if(next_angle <= -160)
				{
					backward(X);
					return;
				}
				if(next_angle <= 20 && next_angle >= -20)
				{
					front(X);
					return;
				}
				if(next_angle > 20 && next_angle < 160)
				{
					if(next_angle > 20 && next_angle < 90)
						left(X);
					if(next_angle >= 90 && next_angle < 160)
						right(X);
					return;
				}

				if((next_angle < -20) && (next_angle > -160))
				{
					if((next_angle < -20) && (next_angle > -90))
						right(X);
					if((next_angle <= -90) && (next_angle > -160))
						left(X);
					return;
				}
			}
		}
}
// -----------------------------------------------------------------------------
// CMdETestScripter::RelationDefL
// -----------------------------------------------------------------------------
//
TInt CMdETestScripter::RelationDefL( CStifItemParser& aItem )
    {

    TPtrC name;
    User::LeaveIfError( aItem.GetNextString( name ));  
    TInt index;

    CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );
    User::LeaveIfError( aItem.GetNextInt( index ));
    
    CMdERelationDef& relationDef = space->RelationDefL( index );
    TL( &relationDef );
    iRelationDefArray.Append( &relationDef );
    AppendNameL( iRelationDefNameArray, name );
    return KErrNone;
    }