telutils/keysequencerecognitionservice/tsrc/shared/mock_etel.cpp
changeset 27 7eb70891911c
equal deleted inserted replaced
23:427125ac6cb8 27:7eb70891911c
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 #include <smcmockclassincludes.h>
       
    18 #include <f32file.h>
       
    19 #include "etel.h"
       
    20 
       
    21 // ============================ MEMBER FUNCTIONS ===============================
       
    22 
       
    23 // -----------------------------------------------------------------------------
       
    24 // RPhone::RPhone
       
    25 // -----------------------------------------------------------------------------
       
    26 //
       
    27 RPhone::RPhone(  )
       
    28     {
       
    29     
       
    30     }
       
    31 
       
    32 
       
    33 // -----------------------------------------------------------------------------
       
    34 // RPhone::ConstructL
       
    35 // -----------------------------------------------------------------------------
       
    36 //
       
    37 void RPhone::ConstructL(  )
       
    38     {
       
    39     
       
    40     }
       
    41 
       
    42 
       
    43 // -----------------------------------------------------------------------------
       
    44 // RPhone::Open
       
    45 // -----------------------------------------------------------------------------
       
    46 //
       
    47 TInt RPhone::Open( 
       
    48         RTelServer & aSession,
       
    49         const TDesC & aName )
       
    50     {
       
    51     SMC_MOCK_METHOD2( TInt, RTelServer &, aSession, 
       
    52         const TDesC &, aName )
       
    53     }
       
    54 
       
    55 
       
    56 // -----------------------------------------------------------------------------
       
    57 // RPhone::Close
       
    58 // -----------------------------------------------------------------------------
       
    59 //
       
    60 void RPhone::Close(  )
       
    61     {
       
    62     SMC_MOCK_METHOD0( void )
       
    63     }
       
    64 
       
    65 
       
    66 // -----------------------------------------------------------------------------
       
    67 // RPhone::Initialise
       
    68 // -----------------------------------------------------------------------------
       
    69 //
       
    70 TInt RPhone::Initialise(  )
       
    71     {
       
    72     SMC_MOCK_METHOD0( TInt )
       
    73     }
       
    74 
       
    75 
       
    76 // -----------------------------------------------------------------------------
       
    77 // RPhone::Initialise
       
    78 // -----------------------------------------------------------------------------
       
    79 //
       
    80 void RPhone::Initialise( 
       
    81         TRequestStatus & aStatus )
       
    82     {
       
    83     SMC_MOCK_METHOD1( void, TRequestStatus &, aStatus )
       
    84     }
       
    85 
       
    86 
       
    87 // -----------------------------------------------------------------------------
       
    88 // RPhone::InitialiseCancel
       
    89 // -----------------------------------------------------------------------------
       
    90 //
       
    91 void RPhone::InitialiseCancel(  )
       
    92     {
       
    93     SMC_MOCK_METHOD0( void )
       
    94     }
       
    95 
       
    96 
       
    97 // -----------------------------------------------------------------------------
       
    98 // RPhone::GetCaps
       
    99 // -----------------------------------------------------------------------------
       
   100 //
       
   101 TInt RPhone::GetCaps( 
       
   102         TCaps & aCaps ) const
       
   103     {
       
   104     SMC_MOCK_METHOD1( TInt, TCaps &, aCaps )
       
   105     }
       
   106 
       
   107 
       
   108 // -----------------------------------------------------------------------------
       
   109 // RPhone::NotifyCapsChange
       
   110 // -----------------------------------------------------------------------------
       
   111 //
       
   112 void RPhone::NotifyCapsChange( 
       
   113         TRequestStatus & aStatus,
       
   114         TCaps & aCaps )
       
   115     {
       
   116     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   117         TCaps &, aCaps )
       
   118     }
       
   119 
       
   120 
       
   121 // -----------------------------------------------------------------------------
       
   122 // RPhone::NotifyCapsChangeCancel
       
   123 // -----------------------------------------------------------------------------
       
   124 //
       
   125 void RPhone::NotifyCapsChangeCancel(  ) const
       
   126     {
       
   127     SMC_MOCK_METHOD0( void )
       
   128     }
       
   129 
       
   130 
       
   131 // -----------------------------------------------------------------------------
       
   132 // RPhone::GetStatus
       
   133 // -----------------------------------------------------------------------------
       
   134 //
       
   135 TInt RPhone::GetStatus( 
       
   136         TStatus & aStatus ) const
       
   137     {
       
   138     SMC_MOCK_METHOD1( TInt, TStatus &, aStatus )
       
   139     }
       
   140 
       
   141 
       
   142 // -----------------------------------------------------------------------------
       
   143 // RPhone::EnumerateLines
       
   144 // -----------------------------------------------------------------------------
       
   145 //
       
   146 TInt RPhone::EnumerateLines( 
       
   147         TInt & aCount ) const
       
   148     {
       
   149     SMC_MOCK_METHOD1( TInt, TInt &, aCount )
       
   150     }
       
   151 
       
   152 
       
   153 // -----------------------------------------------------------------------------
       
   154 // RPhone::GetLineInfo
       
   155 // -----------------------------------------------------------------------------
       
   156 //
       
   157 TInt RPhone::GetLineInfo( 
       
   158         const TInt aIndex,
       
   159         TLineInfo & aLineInfo ) const
       
   160     {
       
   161     SMC_MOCK_METHOD2( TInt, const TInt, aIndex, 
       
   162         TLineInfo &, aLineInfo )
       
   163     }
       
   164 
       
   165 
       
   166 // -----------------------------------------------------------------------------
       
   167 // RPhone::GetInfo
       
   168 // -----------------------------------------------------------------------------
       
   169 //
       
   170 TInt RPhone::GetInfo( 
       
   171         TPhoneInfo & aPhoneInfo ) const
       
   172     {
       
   173     SMC_MOCK_METHOD1( TInt, TPhoneInfo &, aPhoneInfo )
       
   174     }
       
   175 
       
   176 
       
   177 // -----------------------------------------------------------------------------
       
   178 // RPhone::NotifyModemDetected
       
   179 // -----------------------------------------------------------------------------
       
   180 //
       
   181 void RPhone::NotifyModemDetected( 
       
   182         TRequestStatus & aStatus,
       
   183         TModemDetection & aDetection )
       
   184     {
       
   185     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   186         TModemDetection &, aDetection )
       
   187     }
       
   188 
       
   189 
       
   190 // -----------------------------------------------------------------------------
       
   191 // RPhone::NotifyModemDetectedCancel
       
   192 // -----------------------------------------------------------------------------
       
   193 //
       
   194 void RPhone::NotifyModemDetectedCancel(  ) const
       
   195     {
       
   196     SMC_MOCK_METHOD0( void )
       
   197     }
       
   198 
       
   199 
       
   200 // -----------------------------------------------------------------------------
       
   201 // RPhone::SetEmergencyClient
       
   202 // -----------------------------------------------------------------------------
       
   203 //
       
   204 TInt RPhone::SetEmergencyClient( 
       
   205         const TUint32 aEmergencyRequest ) const
       
   206     {
       
   207     SMC_MOCK_METHOD1( TInt, const TUint32, aEmergencyRequest )
       
   208     }
       
   209 
       
   210 
       
   211 // -----------------------------------------------------------------------------
       
   212 // RPhone::Destruct
       
   213 // -----------------------------------------------------------------------------
       
   214 //
       
   215 void RPhone::Destruct(  )
       
   216     {
       
   217     SMC_MOCK_METHOD0( void )
       
   218     }
       
   219 
       
   220 
       
   221 // -----------------------------------------------------------------------------
       
   222 // RCall::RCall
       
   223 // -----------------------------------------------------------------------------
       
   224 //
       
   225 RCall::RCall(  )
       
   226     {
       
   227     
       
   228     }
       
   229 
       
   230 
       
   231 // -----------------------------------------------------------------------------
       
   232 // RCall::ConstructL
       
   233 // -----------------------------------------------------------------------------
       
   234 //
       
   235 void RCall::ConstructL(  )
       
   236     {
       
   237     
       
   238     }
       
   239 
       
   240 
       
   241 // -----------------------------------------------------------------------------
       
   242 // RCall::OpenNewCall
       
   243 // -----------------------------------------------------------------------------
       
   244 //
       
   245 TInt RCall::OpenNewCall( 
       
   246         RTelServer & aServer,
       
   247         const TDesC & aName,
       
   248         TDes & aNewName )
       
   249     {
       
   250     SMC_MOCK_METHOD3( TInt, RTelServer &, aServer, 
       
   251         const TDesC &, aName, 
       
   252         TDes &, aNewName )
       
   253     }
       
   254 
       
   255 
       
   256 // -----------------------------------------------------------------------------
       
   257 // RCall::OpenNewCall
       
   258 // -----------------------------------------------------------------------------
       
   259 //
       
   260 TInt RCall::OpenNewCall( 
       
   261         RTelServer & aServer,
       
   262         const TDesC & aName )
       
   263     {
       
   264     SMC_MOCK_METHOD2( TInt, RTelServer &, aServer, 
       
   265         const TDesC &, aName )
       
   266     }
       
   267 
       
   268 
       
   269 // -----------------------------------------------------------------------------
       
   270 // RCall::OpenNewCall
       
   271 // -----------------------------------------------------------------------------
       
   272 //
       
   273 TInt RCall::OpenNewCall( 
       
   274         RPhone & aPhone,
       
   275         const TDesC & aName,
       
   276         TDes & aNewName )
       
   277     {
       
   278     SMC_MOCK_METHOD3( TInt, RPhone &, aPhone, 
       
   279         const TDesC &, aName, 
       
   280         TDes &, aNewName )
       
   281     }
       
   282 
       
   283 
       
   284 // -----------------------------------------------------------------------------
       
   285 // RCall::OpenNewCall
       
   286 // -----------------------------------------------------------------------------
       
   287 //
       
   288 TInt RCall::OpenNewCall( 
       
   289         RPhone & aPhone,
       
   290         const TDesC & aName )
       
   291     {
       
   292     SMC_MOCK_METHOD2( TInt, RPhone &, aPhone, 
       
   293         const TDesC &, aName )
       
   294     }
       
   295 
       
   296 
       
   297 // -----------------------------------------------------------------------------
       
   298 // RCall::OpenNewCall
       
   299 // -----------------------------------------------------------------------------
       
   300 //
       
   301 TInt RCall::OpenNewCall( 
       
   302         RLine & aLine,
       
   303         TDes & aNewName )
       
   304     {
       
   305     SMC_MOCK_METHOD2( TInt, RLine &, aLine, 
       
   306         TDes &, aNewName )
       
   307     }
       
   308 
       
   309 
       
   310 // -----------------------------------------------------------------------------
       
   311 // RCall::OpenNewCall
       
   312 // -----------------------------------------------------------------------------
       
   313 //
       
   314 TInt RCall::OpenNewCall( 
       
   315         RLine & aLine )
       
   316     {
       
   317     SMC_MOCK_METHOD1( TInt, RLine &, aLine )
       
   318     }
       
   319 
       
   320 
       
   321 // -----------------------------------------------------------------------------
       
   322 // RCall::OpenExistingCall
       
   323 // -----------------------------------------------------------------------------
       
   324 //
       
   325 TInt RCall::OpenExistingCall( 
       
   326         RTelServer & aServer,
       
   327         const TDesC & aName )
       
   328     {
       
   329     SMC_MOCK_METHOD2( TInt, RTelServer &, aServer, 
       
   330         const TDesC &, aName )
       
   331     }
       
   332 
       
   333 
       
   334 // -----------------------------------------------------------------------------
       
   335 // RCall::OpenExistingCall
       
   336 // -----------------------------------------------------------------------------
       
   337 //
       
   338 TInt RCall::OpenExistingCall( 
       
   339         RPhone & aPhone,
       
   340         const TDesC & aName )
       
   341     {
       
   342     SMC_MOCK_METHOD2( TInt, RPhone &, aPhone, 
       
   343         const TDesC &, aName )
       
   344     }
       
   345 
       
   346 
       
   347 // -----------------------------------------------------------------------------
       
   348 // RCall::OpenExistingCall
       
   349 // -----------------------------------------------------------------------------
       
   350 //
       
   351 TInt RCall::OpenExistingCall( 
       
   352         RLine & aLine,
       
   353         const TDesC & aName )
       
   354     {
       
   355     SMC_MOCK_METHOD2( TInt, RLine &, aLine, 
       
   356         const TDesC &, aName )
       
   357     }
       
   358 
       
   359 
       
   360 // -----------------------------------------------------------------------------
       
   361 // RCall::Close
       
   362 // -----------------------------------------------------------------------------
       
   363 //
       
   364 void RCall::Close(  )
       
   365     {
       
   366     SMC_MOCK_METHOD0( void )
       
   367     }
       
   368 
       
   369 
       
   370 // -----------------------------------------------------------------------------
       
   371 // RCall::GetStatus
       
   372 // -----------------------------------------------------------------------------
       
   373 //
       
   374 TInt RCall::GetStatus( 
       
   375         TStatus & aStatus ) const
       
   376     {
       
   377     SMC_MOCK_METHOD1( TInt, TStatus &, aStatus )
       
   378     }
       
   379 
       
   380 
       
   381 // -----------------------------------------------------------------------------
       
   382 // RCall::GetCaps
       
   383 // -----------------------------------------------------------------------------
       
   384 //
       
   385 TInt RCall::GetCaps( 
       
   386         TCaps & aCaps ) const
       
   387     {
       
   388     SMC_MOCK_METHOD1( TInt, TCaps &, aCaps )
       
   389     }
       
   390 
       
   391 
       
   392 // -----------------------------------------------------------------------------
       
   393 // RCall::NotifyCapsChange
       
   394 // -----------------------------------------------------------------------------
       
   395 //
       
   396 void RCall::NotifyCapsChange( 
       
   397         TRequestStatus & aStatus,
       
   398         TCaps & aCaps )
       
   399     {
       
   400     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   401         TCaps &, aCaps )
       
   402     }
       
   403 
       
   404 
       
   405 // -----------------------------------------------------------------------------
       
   406 // RCall::NotifyCapsChangeCancel
       
   407 // -----------------------------------------------------------------------------
       
   408 //
       
   409 void RCall::NotifyCapsChangeCancel(  ) const
       
   410     {
       
   411     SMC_MOCK_METHOD0( void )
       
   412     }
       
   413 
       
   414 
       
   415 // -----------------------------------------------------------------------------
       
   416 // RCall::GetBearerServiceInfo
       
   417 // -----------------------------------------------------------------------------
       
   418 //
       
   419 TInt RCall::GetBearerServiceInfo( 
       
   420         TBearerService & aBearerService ) const
       
   421     {
       
   422     SMC_MOCK_METHOD1( TInt, TBearerService &, aBearerService )
       
   423     }
       
   424 
       
   425 
       
   426 // -----------------------------------------------------------------------------
       
   427 // RCall::GetInfo
       
   428 // -----------------------------------------------------------------------------
       
   429 //
       
   430 TInt RCall::GetInfo( 
       
   431         TCallInfo & aCallInfo ) const
       
   432     {
       
   433     SMC_MOCK_METHOD1( TInt, TCallInfo &, aCallInfo )
       
   434     }
       
   435 
       
   436 
       
   437 // -----------------------------------------------------------------------------
       
   438 // RCall::NotifyHookChange
       
   439 // -----------------------------------------------------------------------------
       
   440 //
       
   441 void RCall::NotifyHookChange( 
       
   442         TRequestStatus & aStatus,
       
   443         THookStatus & aHookStatus )
       
   444     {
       
   445     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   446         THookStatus &, aHookStatus )
       
   447     }
       
   448 
       
   449 
       
   450 // -----------------------------------------------------------------------------
       
   451 // RCall::NotifyHookChangeCancel
       
   452 // -----------------------------------------------------------------------------
       
   453 //
       
   454 void RCall::NotifyHookChangeCancel(  ) const
       
   455     {
       
   456     SMC_MOCK_METHOD0( void )
       
   457     }
       
   458 
       
   459 
       
   460 // -----------------------------------------------------------------------------
       
   461 // RCall::NotifyStatusChange
       
   462 // -----------------------------------------------------------------------------
       
   463 //
       
   464 void RCall::NotifyStatusChange( 
       
   465         TRequestStatus & aStatus,
       
   466         TStatus & aCallStatus )
       
   467     {
       
   468     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   469         TStatus &, aCallStatus )
       
   470     }
       
   471 
       
   472 
       
   473 // -----------------------------------------------------------------------------
       
   474 // RCall::NotifyStatusChangeCancel
       
   475 // -----------------------------------------------------------------------------
       
   476 //
       
   477 void RCall::NotifyStatusChangeCancel(  ) const
       
   478     {
       
   479     SMC_MOCK_METHOD0( void )
       
   480     }
       
   481 
       
   482 
       
   483 // -----------------------------------------------------------------------------
       
   484 // RCall::NotifyCallDurationChange
       
   485 // -----------------------------------------------------------------------------
       
   486 //
       
   487 void RCall::NotifyCallDurationChange( 
       
   488         TRequestStatus & aStatus,
       
   489         TTimeIntervalSeconds & aTime )
       
   490     {
       
   491     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   492         TTimeIntervalSeconds &, aTime )
       
   493     }
       
   494 
       
   495 
       
   496 // -----------------------------------------------------------------------------
       
   497 // RCall::NotifyCallDurationChangeCancel
       
   498 // -----------------------------------------------------------------------------
       
   499 //
       
   500 void RCall::NotifyCallDurationChangeCancel(  ) const
       
   501     {
       
   502     SMC_MOCK_METHOD0( void )
       
   503     }
       
   504 
       
   505 
       
   506 // -----------------------------------------------------------------------------
       
   507 // RCall::GetCallDuration
       
   508 // -----------------------------------------------------------------------------
       
   509 //
       
   510 TInt RCall::GetCallDuration( 
       
   511         TTimeIntervalSeconds & aTime ) const
       
   512     {
       
   513     SMC_MOCK_METHOD1( TInt, TTimeIntervalSeconds &, aTime )
       
   514     }
       
   515 
       
   516 
       
   517 // -----------------------------------------------------------------------------
       
   518 // RCall::Dial
       
   519 // -----------------------------------------------------------------------------
       
   520 //
       
   521 TInt RCall::Dial( 
       
   522         const TTelNumberC & aTelNumber ) const
       
   523     {
       
   524     SMC_MOCK_METHOD1( TInt, const TTelNumberC &, aTelNumber )
       
   525     }
       
   526 
       
   527 
       
   528 // -----------------------------------------------------------------------------
       
   529 // RCall::Dial
       
   530 // -----------------------------------------------------------------------------
       
   531 //
       
   532 TInt RCall::Dial( 
       
   533         const TDesC8 & aCallParams,
       
   534         const TTelNumberC & aTelNumber ) const
       
   535     {
       
   536     SMC_MOCK_METHOD2( TInt, const TDesC8 &, aCallParams, 
       
   537         const TTelNumberC &, aTelNumber )
       
   538     }
       
   539 
       
   540 
       
   541 // -----------------------------------------------------------------------------
       
   542 // RCall::Dial
       
   543 // -----------------------------------------------------------------------------
       
   544 //
       
   545 void RCall::Dial( 
       
   546         TRequestStatus & aStatus,
       
   547         const TTelNumberC & aTelNumber )
       
   548     {
       
   549     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   550         const TTelNumberC &, aTelNumber )
       
   551     }
       
   552 
       
   553 
       
   554 // -----------------------------------------------------------------------------
       
   555 // RCall::Dial
       
   556 // -----------------------------------------------------------------------------
       
   557 //
       
   558 void RCall::Dial( 
       
   559         TRequestStatus & aStatus,
       
   560         const TDesC8 & aCallParams,
       
   561         const TTelNumberC & aTelNumber )
       
   562     {
       
   563     SMC_MOCK_METHOD3( void, TRequestStatus &, aStatus, 
       
   564         const TDesC8 &, aCallParams, 
       
   565         const TTelNumberC &, aTelNumber )
       
   566     }
       
   567 
       
   568 
       
   569 // -----------------------------------------------------------------------------
       
   570 // RCall::DialCancel
       
   571 // -----------------------------------------------------------------------------
       
   572 //
       
   573 void RCall::DialCancel(  ) const
       
   574     {
       
   575     SMC_MOCK_METHOD0( void )
       
   576     }
       
   577 
       
   578 
       
   579 // -----------------------------------------------------------------------------
       
   580 // RCall::Connect
       
   581 // -----------------------------------------------------------------------------
       
   582 //
       
   583 TInt RCall::Connect(  ) const
       
   584     {
       
   585     SMC_MOCK_METHOD0( TInt )
       
   586     }
       
   587 
       
   588 
       
   589 // -----------------------------------------------------------------------------
       
   590 // RCall::Connect
       
   591 // -----------------------------------------------------------------------------
       
   592 //
       
   593 TInt RCall::Connect( 
       
   594         const TDesC8 & aCallParams ) const
       
   595     {
       
   596     SMC_MOCK_METHOD1( TInt, const TDesC8 &, aCallParams )
       
   597     }
       
   598 
       
   599 
       
   600 // -----------------------------------------------------------------------------
       
   601 // RCall::Connect
       
   602 // -----------------------------------------------------------------------------
       
   603 //
       
   604 void RCall::Connect( 
       
   605         TRequestStatus & aStatus )
       
   606     {
       
   607     SMC_MOCK_METHOD1( void, TRequestStatus &, aStatus )
       
   608     }
       
   609 
       
   610 
       
   611 // -----------------------------------------------------------------------------
       
   612 // RCall::Connect
       
   613 // -----------------------------------------------------------------------------
       
   614 //
       
   615 void RCall::Connect( 
       
   616         TRequestStatus & aStatus,
       
   617         const TDesC8 & aCallParams )
       
   618     {
       
   619     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   620         const TDesC8 &, aCallParams )
       
   621     }
       
   622 
       
   623 
       
   624 // -----------------------------------------------------------------------------
       
   625 // RCall::ConnectCancel
       
   626 // -----------------------------------------------------------------------------
       
   627 //
       
   628 void RCall::ConnectCancel(  ) const
       
   629     {
       
   630     SMC_MOCK_METHOD0( void )
       
   631     }
       
   632 
       
   633 
       
   634 // -----------------------------------------------------------------------------
       
   635 // RCall::AnswerIncomingCall
       
   636 // -----------------------------------------------------------------------------
       
   637 //
       
   638 TInt RCall::AnswerIncomingCall(  ) const
       
   639     {
       
   640     SMC_MOCK_METHOD0( TInt )
       
   641     }
       
   642 
       
   643 
       
   644 // -----------------------------------------------------------------------------
       
   645 // RCall::AnswerIncomingCall
       
   646 // -----------------------------------------------------------------------------
       
   647 //
       
   648 TInt RCall::AnswerIncomingCall( 
       
   649         const TDesC8 & aCallParams ) const
       
   650     {
       
   651     SMC_MOCK_METHOD1( TInt, const TDesC8 &, aCallParams )
       
   652     }
       
   653 
       
   654 
       
   655 // -----------------------------------------------------------------------------
       
   656 // RCall::AnswerIncomingCall
       
   657 // -----------------------------------------------------------------------------
       
   658 //
       
   659 void RCall::AnswerIncomingCall( 
       
   660         TRequestStatus & aStatus )
       
   661     {
       
   662     SMC_MOCK_METHOD1( void, TRequestStatus &, aStatus )
       
   663     }
       
   664 
       
   665 
       
   666 // -----------------------------------------------------------------------------
       
   667 // RCall::AnswerIncomingCall
       
   668 // -----------------------------------------------------------------------------
       
   669 //
       
   670 void RCall::AnswerIncomingCall( 
       
   671         TRequestStatus & aStatus,
       
   672         const TDesC8 & aCallParams )
       
   673     {
       
   674     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   675         const TDesC8 &, aCallParams )
       
   676     }
       
   677 
       
   678 
       
   679 // -----------------------------------------------------------------------------
       
   680 // RCall::AnswerIncomingCallCancel
       
   681 // -----------------------------------------------------------------------------
       
   682 //
       
   683 void RCall::AnswerIncomingCallCancel(  ) const
       
   684     {
       
   685     SMC_MOCK_METHOD0( void )
       
   686     }
       
   687 
       
   688 
       
   689 // -----------------------------------------------------------------------------
       
   690 // RCall::HangUp
       
   691 // -----------------------------------------------------------------------------
       
   692 //
       
   693 TInt RCall::HangUp(  ) const
       
   694     {
       
   695     SMC_MOCK_METHOD0( TInt )
       
   696     }
       
   697 
       
   698 
       
   699 // -----------------------------------------------------------------------------
       
   700 // RCall::HangUp
       
   701 // -----------------------------------------------------------------------------
       
   702 //
       
   703 void RCall::HangUp( 
       
   704         TRequestStatus & aStatus ) const
       
   705     {
       
   706     SMC_MOCK_METHOD1( void, TRequestStatus &, aStatus )
       
   707     }
       
   708 
       
   709 
       
   710 // -----------------------------------------------------------------------------
       
   711 // RCall::HangUpCancel
       
   712 // -----------------------------------------------------------------------------
       
   713 //
       
   714 void RCall::HangUpCancel(  ) const
       
   715     {
       
   716     SMC_MOCK_METHOD0( void )
       
   717     }
       
   718 
       
   719 
       
   720 // -----------------------------------------------------------------------------
       
   721 // RCall::LoanDataPort
       
   722 // -----------------------------------------------------------------------------
       
   723 //
       
   724 TInt RCall::LoanDataPort( 
       
   725         TCommPort & aDataPort ) const
       
   726     {
       
   727     SMC_MOCK_METHOD1( TInt, TCommPort &, aDataPort )
       
   728     }
       
   729 
       
   730 
       
   731 // -----------------------------------------------------------------------------
       
   732 // RCall::LoanDataPort
       
   733 // -----------------------------------------------------------------------------
       
   734 //
       
   735 void RCall::LoanDataPort( 
       
   736         TRequestStatus & aStatus,
       
   737         TCommPort & aDataPort )
       
   738     {
       
   739     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   740         TCommPort &, aDataPort )
       
   741     }
       
   742 
       
   743 
       
   744 // -----------------------------------------------------------------------------
       
   745 // RCall::LoanDataPortCancel
       
   746 // -----------------------------------------------------------------------------
       
   747 //
       
   748 void RCall::LoanDataPortCancel(  ) const
       
   749     {
       
   750     SMC_MOCK_METHOD0( void )
       
   751     }
       
   752 
       
   753 
       
   754 // -----------------------------------------------------------------------------
       
   755 // RCall::RecoverDataPort
       
   756 // -----------------------------------------------------------------------------
       
   757 //
       
   758 TInt RCall::RecoverDataPort(  ) const
       
   759     {
       
   760     SMC_MOCK_METHOD0( TInt )
       
   761     }
       
   762 
       
   763 
       
   764 // -----------------------------------------------------------------------------
       
   765 // RCall::TransferOwnership
       
   766 // -----------------------------------------------------------------------------
       
   767 //
       
   768 TInt RCall::TransferOwnership(  ) const
       
   769     {
       
   770     SMC_MOCK_METHOD0( TInt )
       
   771     }
       
   772 
       
   773 
       
   774 // -----------------------------------------------------------------------------
       
   775 // RCall::AcquireOwnership
       
   776 // -----------------------------------------------------------------------------
       
   777 //
       
   778 void RCall::AcquireOwnership( 
       
   779         TRequestStatus & aStatus ) const
       
   780     {
       
   781     SMC_MOCK_METHOD1( void, TRequestStatus &, aStatus )
       
   782     }
       
   783 
       
   784 
       
   785 // -----------------------------------------------------------------------------
       
   786 // RCall::AcquireOwnershipCancel
       
   787 // -----------------------------------------------------------------------------
       
   788 //
       
   789 void RCall::AcquireOwnershipCancel(  ) const
       
   790     {
       
   791     SMC_MOCK_METHOD0( void )
       
   792     }
       
   793 
       
   794 
       
   795 // -----------------------------------------------------------------------------
       
   796 // RCall::GetOwnershipStatus
       
   797 // -----------------------------------------------------------------------------
       
   798 //
       
   799 TInt RCall::GetOwnershipStatus( 
       
   800         TOwnershipStatus & aOwnershipStatus ) const
       
   801     {
       
   802     SMC_MOCK_METHOD1( TInt, TOwnershipStatus &, aOwnershipStatus )
       
   803     }
       
   804 
       
   805 
       
   806 // -----------------------------------------------------------------------------
       
   807 // RCall::GetCallParams
       
   808 // -----------------------------------------------------------------------------
       
   809 //
       
   810 TInt RCall::GetCallParams( 
       
   811         TDes8 & aParams ) const
       
   812     {
       
   813     SMC_MOCK_METHOD1( TInt, TDes8 &, aParams )
       
   814     }
       
   815 
       
   816 
       
   817 // -----------------------------------------------------------------------------
       
   818 // RCall::GetFaxSettings
       
   819 // -----------------------------------------------------------------------------
       
   820 //
       
   821 TInt RCall::GetFaxSettings( 
       
   822         TFaxSessionSettings & aSettings ) const
       
   823     {
       
   824     SMC_MOCK_METHOD1( TInt, TFaxSessionSettings &, aSettings )
       
   825     }
       
   826 
       
   827 
       
   828 // -----------------------------------------------------------------------------
       
   829 // RCall::SetFaxSettings
       
   830 // -----------------------------------------------------------------------------
       
   831 //
       
   832 TInt RCall::SetFaxSettings( 
       
   833         const TFaxSessionSettings & aSettings ) const
       
   834     {
       
   835     SMC_MOCK_METHOD1( TInt, const TFaxSessionSettings &, aSettings )
       
   836     }
       
   837 
       
   838 
       
   839 // -----------------------------------------------------------------------------
       
   840 // RCall::AdoptFaxSharedHeaderFile
       
   841 // -----------------------------------------------------------------------------
       
   842 //
       
   843 TInt RCall::AdoptFaxSharedHeaderFile( 
       
   844         const RFile & aSharedFile ) const
       
   845     {
       
   846     SMC_MOCK_METHOD1( TInt, const RFile &, aSharedFile )
       
   847     }
       
   848 
       
   849 
       
   850 // -----------------------------------------------------------------------------
       
   851 // RCall::ReferenceCount
       
   852 // -----------------------------------------------------------------------------
       
   853 //
       
   854 TInt RCall::ReferenceCount(  ) const
       
   855     {
       
   856     SMC_MOCK_METHOD0( TInt )
       
   857     }
       
   858 
       
   859 
       
   860 // -----------------------------------------------------------------------------
       
   861 // RCall::Destruct
       
   862 // -----------------------------------------------------------------------------
       
   863 //
       
   864 void RCall::Destruct(  )
       
   865     {
       
   866     SMC_MOCK_METHOD0( void )
       
   867     }
       
   868 
       
   869 
       
   870 // -----------------------------------------------------------------------------
       
   871 // RFax::RFax
       
   872 // -----------------------------------------------------------------------------
       
   873 //
       
   874 RFax::RFax(  )
       
   875     {
       
   876     
       
   877     }
       
   878 
       
   879 
       
   880 // -----------------------------------------------------------------------------
       
   881 // RFax::ConstructL
       
   882 // -----------------------------------------------------------------------------
       
   883 //
       
   884 void RFax::ConstructL(  )
       
   885     {
       
   886     
       
   887     }
       
   888 
       
   889 
       
   890 // -----------------------------------------------------------------------------
       
   891 // RFax::Open
       
   892 // -----------------------------------------------------------------------------
       
   893 //
       
   894 TInt RFax::Open( 
       
   895         RCall & aCall )
       
   896     {
       
   897     SMC_MOCK_METHOD1( TInt, RCall &, aCall )
       
   898     }
       
   899 
       
   900 
       
   901 // -----------------------------------------------------------------------------
       
   902 // RFax::Close
       
   903 // -----------------------------------------------------------------------------
       
   904 //
       
   905 void RFax::Close(  )
       
   906     {
       
   907     SMC_MOCK_METHOD0( void )
       
   908     }
       
   909 
       
   910 
       
   911 // -----------------------------------------------------------------------------
       
   912 // RFax::Read
       
   913 // -----------------------------------------------------------------------------
       
   914 //
       
   915 void RFax::Read( 
       
   916         TRequestStatus & aStatus,
       
   917         TDes8 & aDes )
       
   918     {
       
   919     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   920         TDes8 &, aDes )
       
   921     }
       
   922 
       
   923 
       
   924 // -----------------------------------------------------------------------------
       
   925 // RFax::Write
       
   926 // -----------------------------------------------------------------------------
       
   927 //
       
   928 void RFax::Write( 
       
   929         TRequestStatus & aStatus,
       
   930         const TDesC8 & aDes )
       
   931     {
       
   932     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
   933         const TDesC8 &, aDes )
       
   934     }
       
   935 
       
   936 
       
   937 // -----------------------------------------------------------------------------
       
   938 // RFax::WaitForEndOfPage
       
   939 // -----------------------------------------------------------------------------
       
   940 //
       
   941 void RFax::WaitForEndOfPage( 
       
   942         TRequestStatus & aStatus ) const
       
   943     {
       
   944     SMC_MOCK_METHOD1( void, TRequestStatus &, aStatus )
       
   945     }
       
   946 
       
   947 
       
   948 // -----------------------------------------------------------------------------
       
   949 // RFax::TerminateFaxSession
       
   950 // -----------------------------------------------------------------------------
       
   951 //
       
   952 TInt RFax::TerminateFaxSession(  ) const
       
   953     {
       
   954     SMC_MOCK_METHOD0( TInt )
       
   955     }
       
   956 
       
   957 
       
   958 // -----------------------------------------------------------------------------
       
   959 // RFax::GetProgress
       
   960 // -----------------------------------------------------------------------------
       
   961 //
       
   962 TInt RFax::GetProgress( 
       
   963         TProgress & aProgress )
       
   964     {
       
   965     SMC_MOCK_METHOD1( TInt, TProgress &, aProgress )
       
   966     }
       
   967 
       
   968 
       
   969 // -----------------------------------------------------------------------------
       
   970 // RFax::Destruct
       
   971 // -----------------------------------------------------------------------------
       
   972 //
       
   973 void RFax::Destruct(  )
       
   974     {
       
   975     SMC_MOCK_METHOD0( void )
       
   976     }
       
   977 
       
   978 
       
   979 // -----------------------------------------------------------------------------
       
   980 // RLine::RLine
       
   981 // -----------------------------------------------------------------------------
       
   982 //
       
   983 RLine::RLine(  )
       
   984     {
       
   985     
       
   986     }
       
   987 
       
   988 
       
   989 // -----------------------------------------------------------------------------
       
   990 // RLine::ConstructL
       
   991 // -----------------------------------------------------------------------------
       
   992 //
       
   993 void RLine::ConstructL(  )
       
   994     {
       
   995     
       
   996     }
       
   997 
       
   998 
       
   999 // -----------------------------------------------------------------------------
       
  1000 // RLine::Open
       
  1001 // -----------------------------------------------------------------------------
       
  1002 //
       
  1003 TInt RLine::Open( 
       
  1004         RPhone & aPhone,
       
  1005         const TDesC & aName )
       
  1006     {
       
  1007     SMC_MOCK_METHOD2( TInt, RPhone &, aPhone, 
       
  1008         const TDesC &, aName )
       
  1009     }
       
  1010 
       
  1011 
       
  1012 // -----------------------------------------------------------------------------
       
  1013 // RLine::Open
       
  1014 // -----------------------------------------------------------------------------
       
  1015 //
       
  1016 TInt RLine::Open( 
       
  1017         RTelServer & aServer,
       
  1018         const TDesC & aName )
       
  1019     {
       
  1020     SMC_MOCK_METHOD2( TInt, RTelServer &, aServer, 
       
  1021         const TDesC &, aName )
       
  1022     }
       
  1023 
       
  1024 
       
  1025 // -----------------------------------------------------------------------------
       
  1026 // RLine::Close
       
  1027 // -----------------------------------------------------------------------------
       
  1028 //
       
  1029 void RLine::Close(  )
       
  1030     {
       
  1031     SMC_MOCK_METHOD0( void )
       
  1032     }
       
  1033 
       
  1034 
       
  1035 // -----------------------------------------------------------------------------
       
  1036 // RLine::GetCaps
       
  1037 // -----------------------------------------------------------------------------
       
  1038 //
       
  1039 TInt RLine::GetCaps( 
       
  1040         TCaps & aCaps ) const
       
  1041     {
       
  1042     SMC_MOCK_METHOD1( TInt, TCaps &, aCaps )
       
  1043     }
       
  1044 
       
  1045 
       
  1046 // -----------------------------------------------------------------------------
       
  1047 // RLine::NotifyCapsChange
       
  1048 // -----------------------------------------------------------------------------
       
  1049 //
       
  1050 void RLine::NotifyCapsChange( 
       
  1051         TRequestStatus & aStatus,
       
  1052         TCaps & aCaps )
       
  1053     {
       
  1054     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
  1055         TCaps &, aCaps )
       
  1056     }
       
  1057 
       
  1058 
       
  1059 // -----------------------------------------------------------------------------
       
  1060 // RLine::NotifyCapsChangeCancel
       
  1061 // -----------------------------------------------------------------------------
       
  1062 //
       
  1063 void RLine::NotifyCapsChangeCancel(  ) const
       
  1064     {
       
  1065     SMC_MOCK_METHOD0( void )
       
  1066     }
       
  1067 
       
  1068 
       
  1069 // -----------------------------------------------------------------------------
       
  1070 // RLine::GetStatus
       
  1071 // -----------------------------------------------------------------------------
       
  1072 //
       
  1073 TInt RLine::GetStatus( 
       
  1074         RCall::TStatus & aStatus ) const
       
  1075     {
       
  1076     SMC_MOCK_METHOD1( TInt, RCall::TStatus &, aStatus )
       
  1077     }
       
  1078 
       
  1079 
       
  1080 // -----------------------------------------------------------------------------
       
  1081 // RLine::GetHookStatus
       
  1082 // -----------------------------------------------------------------------------
       
  1083 //
       
  1084 TInt RLine::GetHookStatus( 
       
  1085         RCall::THookStatus & aHookStatus ) const
       
  1086     {
       
  1087     SMC_MOCK_METHOD1( TInt, RCall::THookStatus &, aHookStatus )
       
  1088     }
       
  1089 
       
  1090 
       
  1091 // -----------------------------------------------------------------------------
       
  1092 // RLine::EnumerateCall
       
  1093 // -----------------------------------------------------------------------------
       
  1094 //
       
  1095 TInt RLine::EnumerateCall( 
       
  1096         TInt & aCount ) const
       
  1097     {
       
  1098     SMC_MOCK_METHOD1( TInt, TInt &, aCount )
       
  1099     }
       
  1100 
       
  1101 
       
  1102 // -----------------------------------------------------------------------------
       
  1103 // RLine::GetCallInfo
       
  1104 // -----------------------------------------------------------------------------
       
  1105 //
       
  1106 TInt RLine::GetCallInfo( 
       
  1107         TInt aIndex,
       
  1108         TCallInfo & aCallInfo ) const
       
  1109     {
       
  1110     SMC_MOCK_METHOD2( TInt, TInt, aIndex, 
       
  1111         TCallInfo &, aCallInfo )
       
  1112     }
       
  1113 
       
  1114 
       
  1115 // -----------------------------------------------------------------------------
       
  1116 // RLine::GetInfo
       
  1117 // -----------------------------------------------------------------------------
       
  1118 //
       
  1119 TInt RLine::GetInfo( 
       
  1120         TLineInfo & aLineInfo ) const
       
  1121     {
       
  1122     SMC_MOCK_METHOD1( TInt, TLineInfo &, aLineInfo )
       
  1123     }
       
  1124 
       
  1125 
       
  1126 // -----------------------------------------------------------------------------
       
  1127 // RLine::NotifyIncomingCall
       
  1128 // -----------------------------------------------------------------------------
       
  1129 //
       
  1130 void RLine::NotifyIncomingCall( 
       
  1131         TRequestStatus & aStatus,
       
  1132         TName & aName )
       
  1133     {
       
  1134     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
  1135         TName &, aName )
       
  1136     }
       
  1137 
       
  1138 
       
  1139 // -----------------------------------------------------------------------------
       
  1140 // RLine::NotifyIncomingCallCancel
       
  1141 // -----------------------------------------------------------------------------
       
  1142 //
       
  1143 void RLine::NotifyIncomingCallCancel(  ) const
       
  1144     {
       
  1145     SMC_MOCK_METHOD0( void )
       
  1146     }
       
  1147 
       
  1148 
       
  1149 // -----------------------------------------------------------------------------
       
  1150 // RLine::NotifyHookChange
       
  1151 // -----------------------------------------------------------------------------
       
  1152 //
       
  1153 void RLine::NotifyHookChange( 
       
  1154         TRequestStatus & aStatus,
       
  1155         RCall::THookStatus & aHookStatus )
       
  1156     {
       
  1157     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
  1158         RCall::THookStatus &, aHookStatus )
       
  1159     }
       
  1160 
       
  1161 
       
  1162 // -----------------------------------------------------------------------------
       
  1163 // RLine::NotifyHookChangeCancel
       
  1164 // -----------------------------------------------------------------------------
       
  1165 //
       
  1166 void RLine::NotifyHookChangeCancel(  ) const
       
  1167     {
       
  1168     SMC_MOCK_METHOD0( void )
       
  1169     }
       
  1170 
       
  1171 
       
  1172 // -----------------------------------------------------------------------------
       
  1173 // RLine::NotifyStatusChange
       
  1174 // -----------------------------------------------------------------------------
       
  1175 //
       
  1176 void RLine::NotifyStatusChange( 
       
  1177         TRequestStatus & aStatus,
       
  1178         RCall::TStatus & aLineStatus )
       
  1179     {
       
  1180     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
  1181         RCall::TStatus &, aLineStatus )
       
  1182     }
       
  1183 
       
  1184 
       
  1185 // -----------------------------------------------------------------------------
       
  1186 // RLine::NotifyStatusChangeCancel
       
  1187 // -----------------------------------------------------------------------------
       
  1188 //
       
  1189 void RLine::NotifyStatusChangeCancel(  ) const
       
  1190     {
       
  1191     SMC_MOCK_METHOD0( void )
       
  1192     }
       
  1193 
       
  1194 
       
  1195 // -----------------------------------------------------------------------------
       
  1196 // RLine::NotifyCallAdded
       
  1197 // -----------------------------------------------------------------------------
       
  1198 //
       
  1199 void RLine::NotifyCallAdded( 
       
  1200         TRequestStatus & aStatus,
       
  1201         TName & aName )
       
  1202     {
       
  1203     SMC_MOCK_METHOD2( void, TRequestStatus &, aStatus, 
       
  1204         TName &, aName )
       
  1205     }
       
  1206 
       
  1207 
       
  1208 // -----------------------------------------------------------------------------
       
  1209 // RLine::NotifyCallAddedCancel
       
  1210 // -----------------------------------------------------------------------------
       
  1211 //
       
  1212 void RLine::NotifyCallAddedCancel(  ) const
       
  1213     {
       
  1214     SMC_MOCK_METHOD0( void )
       
  1215     }
       
  1216 
       
  1217 
       
  1218 // -----------------------------------------------------------------------------
       
  1219 // RLine::Destruct
       
  1220 // -----------------------------------------------------------------------------
       
  1221 //
       
  1222 void RLine::Destruct(  )
       
  1223     {
       
  1224     SMC_MOCK_METHOD0( void )
       
  1225     }
       
  1226 
       
  1227 
       
  1228 // -----------------------------------------------------------------------------
       
  1229 // RTelSubSessionBase::RTelSubSessionBase
       
  1230 // -----------------------------------------------------------------------------
       
  1231 //
       
  1232 RTelSubSessionBase::RTelSubSessionBase(  )
       
  1233     {
       
  1234     
       
  1235     }
       
  1236 
       
  1237 
       
  1238 // -----------------------------------------------------------------------------
       
  1239 // RTelSubSessionBase::CancelAsyncRequest
       
  1240 // -----------------------------------------------------------------------------
       
  1241 //
       
  1242 void RTelSubSessionBase::CancelAsyncRequest( 
       
  1243         TInt aReqToCancel ) const
       
  1244     {
       
  1245     SMC_MOCK_METHOD1( void, TInt, aReqToCancel )
       
  1246     }
       
  1247 
       
  1248 
       
  1249 // -----------------------------------------------------------------------------
       
  1250 // RTelSubSessionBase::Blank
       
  1251 // -----------------------------------------------------------------------------
       
  1252 //
       
  1253 TInt RTelSubSessionBase::Blank( 
       
  1254         const TInt aIpc,
       
  1255         TReqPriorityType aType ) const
       
  1256     {
       
  1257     SMC_MOCK_METHOD2( TInt, const TInt, aIpc, 
       
  1258         TReqPriorityType, aType )
       
  1259     }
       
  1260 
       
  1261 
       
  1262 // -----------------------------------------------------------------------------
       
  1263 // RTelSubSessionBase::Blank
       
  1264 // -----------------------------------------------------------------------------
       
  1265 //
       
  1266 void RTelSubSessionBase::Blank( 
       
  1267         const TInt aIpc,
       
  1268         TRequestStatus & aStatus,
       
  1269         TReqPriorityType aType ) const
       
  1270     {
       
  1271     SMC_MOCK_METHOD3( void, const TInt, aIpc, 
       
  1272         TRequestStatus &, aStatus, 
       
  1273         TReqPriorityType, aType )
       
  1274     }
       
  1275 
       
  1276 
       
  1277 // -----------------------------------------------------------------------------
       
  1278 // RTelSubSessionBase::Set
       
  1279 // -----------------------------------------------------------------------------
       
  1280 //
       
  1281 TInt RTelSubSessionBase::Set( 
       
  1282         const TInt aIpc,
       
  1283         const TDesC8 & aDes,
       
  1284         TReqPriorityType aType ) const
       
  1285     {
       
  1286     SMC_MOCK_METHOD3( TInt, const TInt, aIpc, 
       
  1287         const TDesC8 &, aDes, 
       
  1288         TReqPriorityType, aType )
       
  1289     }
       
  1290 
       
  1291 
       
  1292 // -----------------------------------------------------------------------------
       
  1293 // RTelSubSessionBase::Set
       
  1294 // -----------------------------------------------------------------------------
       
  1295 //
       
  1296 void RTelSubSessionBase::Set( 
       
  1297         const TInt aIpc,
       
  1298         TRequestStatus & aStatus,
       
  1299         const TDesC8 & aDes,
       
  1300         TReqPriorityType aType ) const
       
  1301     {
       
  1302     SMC_MOCK_METHOD4( void, const TInt, aIpc, 
       
  1303         TRequestStatus &, aStatus, 
       
  1304         const TDesC8 &, aDes, 
       
  1305         TReqPriorityType, aType )
       
  1306     }
       
  1307 
       
  1308 
       
  1309 // -----------------------------------------------------------------------------
       
  1310 // RTelSubSessionBase::Get
       
  1311 // -----------------------------------------------------------------------------
       
  1312 //
       
  1313 TInt RTelSubSessionBase::Get( 
       
  1314         const TInt aIpc,
       
  1315         TDes8 & aDes,
       
  1316         TReqPriorityType aType ) const
       
  1317     {
       
  1318     SMC_MOCK_METHOD3( TInt, const TInt, aIpc, 
       
  1319         TDes8 &, aDes, 
       
  1320         TReqPriorityType, aType )
       
  1321     }
       
  1322 
       
  1323 
       
  1324 // -----------------------------------------------------------------------------
       
  1325 // RTelSubSessionBase::Get
       
  1326 // -----------------------------------------------------------------------------
       
  1327 //
       
  1328 void RTelSubSessionBase::Get( 
       
  1329         const TInt aIpc,
       
  1330         TRequestStatus & aStatus,
       
  1331         TDes8 & aDes,
       
  1332         TReqPriorityType aType ) const
       
  1333     {
       
  1334     SMC_MOCK_METHOD4( void, const TInt, aIpc, 
       
  1335         TRequestStatus &, aStatus, 
       
  1336         TDes8 &, aDes, 
       
  1337         TReqPriorityType, aType )
       
  1338     }
       
  1339 
       
  1340 
       
  1341 // -----------------------------------------------------------------------------
       
  1342 // RTelSubSessionBase::Set
       
  1343 // -----------------------------------------------------------------------------
       
  1344 //
       
  1345 TInt RTelSubSessionBase::Set( 
       
  1346         const TInt aIpc,
       
  1347         const TDesC8 & aDes1,
       
  1348         const TDesC8 & aDes2,
       
  1349         TReqPriorityType aType ) const
       
  1350     {
       
  1351     SMC_MOCK_METHOD4( TInt, const TInt, aIpc, 
       
  1352         const TDesC8 &, aDes1, 
       
  1353         const TDesC8 &, aDes2, 
       
  1354         TReqPriorityType, aType )
       
  1355     }
       
  1356 
       
  1357 
       
  1358 // -----------------------------------------------------------------------------
       
  1359 // RTelSubSessionBase::Set
       
  1360 // -----------------------------------------------------------------------------
       
  1361 //
       
  1362 void RTelSubSessionBase::Set( 
       
  1363         const TInt aIpc,
       
  1364         TRequestStatus & aStatus,
       
  1365         const TDesC8 & aDes1,
       
  1366         const TDesC8 & aDes2,
       
  1367         TReqPriorityType aType ) const
       
  1368     {
       
  1369     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1370         TRequestStatus &, aStatus, 
       
  1371         const TDesC8 &, aDes1, 
       
  1372         const TDesC8 &, aDes2, 
       
  1373         TReqPriorityType, aType )
       
  1374     }
       
  1375 
       
  1376 
       
  1377 // -----------------------------------------------------------------------------
       
  1378 // RTelSubSessionBase::Get
       
  1379 // -----------------------------------------------------------------------------
       
  1380 //
       
  1381 TInt RTelSubSessionBase::Get( 
       
  1382         const TInt aIpc,
       
  1383         TDes8 & aDes1,
       
  1384         TDes8 & aDes2,
       
  1385         TReqPriorityType aType ) const
       
  1386     {
       
  1387     SMC_MOCK_METHOD4( TInt, const TInt, aIpc, 
       
  1388         TDes8 &, aDes1, 
       
  1389         TDes8 &, aDes2, 
       
  1390         TReqPriorityType, aType )
       
  1391     }
       
  1392 
       
  1393 
       
  1394 // -----------------------------------------------------------------------------
       
  1395 // RTelSubSessionBase::Get
       
  1396 // -----------------------------------------------------------------------------
       
  1397 //
       
  1398 void RTelSubSessionBase::Get( 
       
  1399         const TInt aIpc,
       
  1400         TRequestStatus & aStatus,
       
  1401         TDes8 & aDes1,
       
  1402         TDes8 & aDes2,
       
  1403         TReqPriorityType aType ) const
       
  1404     {
       
  1405     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1406         TRequestStatus &, aStatus, 
       
  1407         TDes8 &, aDes1, 
       
  1408         TDes8 &, aDes2, 
       
  1409         TReqPriorityType, aType )
       
  1410     }
       
  1411 
       
  1412 
       
  1413 // -----------------------------------------------------------------------------
       
  1414 // RTelSubSessionBase::Set
       
  1415 // -----------------------------------------------------------------------------
       
  1416 //
       
  1417 TInt RTelSubSessionBase::Set( 
       
  1418         const TInt aIpc,
       
  1419         const TDesC16 & aDes,
       
  1420         TReqPriorityType aType ) const
       
  1421     {
       
  1422     SMC_MOCK_METHOD3( TInt, const TInt, aIpc, 
       
  1423         const TDesC16 &, aDes, 
       
  1424         TReqPriorityType, aType )
       
  1425     }
       
  1426 
       
  1427 
       
  1428 // -----------------------------------------------------------------------------
       
  1429 // RTelSubSessionBase::Set
       
  1430 // -----------------------------------------------------------------------------
       
  1431 //
       
  1432 void RTelSubSessionBase::Set( 
       
  1433         const TInt aIpc,
       
  1434         TRequestStatus & aStatus,
       
  1435         const TDesC16 & aDes,
       
  1436         TReqPriorityType aType ) const
       
  1437     {
       
  1438     SMC_MOCK_METHOD4( void, const TInt, aIpc, 
       
  1439         TRequestStatus &, aStatus, 
       
  1440         const TDesC16 &, aDes, 
       
  1441         TReqPriorityType, aType )
       
  1442     }
       
  1443 
       
  1444 
       
  1445 // -----------------------------------------------------------------------------
       
  1446 // RTelSubSessionBase::Get
       
  1447 // -----------------------------------------------------------------------------
       
  1448 //
       
  1449 TInt RTelSubSessionBase::Get( 
       
  1450         const TInt aIpc,
       
  1451         TDes16 & aDes,
       
  1452         TReqPriorityType aType ) const
       
  1453     {
       
  1454     SMC_MOCK_METHOD3( TInt, const TInt, aIpc, 
       
  1455         TDes16 &, aDes, 
       
  1456         TReqPriorityType, aType )
       
  1457     }
       
  1458 
       
  1459 
       
  1460 // -----------------------------------------------------------------------------
       
  1461 // RTelSubSessionBase::Get
       
  1462 // -----------------------------------------------------------------------------
       
  1463 //
       
  1464 void RTelSubSessionBase::Get( 
       
  1465         const TInt aIpc,
       
  1466         TRequestStatus & aStatus,
       
  1467         TDes16 & aDes,
       
  1468         TReqPriorityType aType ) const
       
  1469     {
       
  1470     SMC_MOCK_METHOD4( void, const TInt, aIpc, 
       
  1471         TRequestStatus &, aStatus, 
       
  1472         TDes16 &, aDes, 
       
  1473         TReqPriorityType, aType )
       
  1474     }
       
  1475 
       
  1476 
       
  1477 // -----------------------------------------------------------------------------
       
  1478 // RTelSubSessionBase::Set
       
  1479 // -----------------------------------------------------------------------------
       
  1480 //
       
  1481 TInt RTelSubSessionBase::Set( 
       
  1482         const TInt aIpc,
       
  1483         const TDesC16 & aDes1,
       
  1484         const TDesC16 & aDes2,
       
  1485         TReqPriorityType aType ) const
       
  1486     {
       
  1487     SMC_MOCK_METHOD4( TInt, const TInt, aIpc, 
       
  1488         const TDesC16 &, aDes1, 
       
  1489         const TDesC16 &, aDes2, 
       
  1490         TReqPriorityType, aType )
       
  1491     }
       
  1492 
       
  1493 
       
  1494 // -----------------------------------------------------------------------------
       
  1495 // RTelSubSessionBase::Set
       
  1496 // -----------------------------------------------------------------------------
       
  1497 //
       
  1498 void RTelSubSessionBase::Set( 
       
  1499         const TInt aIpc,
       
  1500         TRequestStatus & aStatus,
       
  1501         const TDesC16 & aDes1,
       
  1502         const TDesC16 & aDes2,
       
  1503         TReqPriorityType aType ) const
       
  1504     {
       
  1505     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1506         TRequestStatus &, aStatus, 
       
  1507         const TDesC16 &, aDes1, 
       
  1508         const TDesC16 &, aDes2, 
       
  1509         TReqPriorityType, aType )
       
  1510     }
       
  1511 
       
  1512 
       
  1513 // -----------------------------------------------------------------------------
       
  1514 // RTelSubSessionBase::Set
       
  1515 // -----------------------------------------------------------------------------
       
  1516 //
       
  1517 TInt RTelSubSessionBase::Set( 
       
  1518         const TInt aIpc,
       
  1519         const TDesC8 & aDes1,
       
  1520         const TDesC16 & aDes2,
       
  1521         TReqPriorityType aType ) const
       
  1522     {
       
  1523     SMC_MOCK_METHOD4( TInt, const TInt, aIpc, 
       
  1524         const TDesC8 &, aDes1, 
       
  1525         const TDesC16 &, aDes2, 
       
  1526         TReqPriorityType, aType )
       
  1527     }
       
  1528 
       
  1529 
       
  1530 // -----------------------------------------------------------------------------
       
  1531 // RTelSubSessionBase::Set
       
  1532 // -----------------------------------------------------------------------------
       
  1533 //
       
  1534 void RTelSubSessionBase::Set( 
       
  1535         const TInt aIpc,
       
  1536         TRequestStatus & aStatus,
       
  1537         const TDesC8 & aDes1,
       
  1538         const TDesC16 & aDes2,
       
  1539         TReqPriorityType aType ) const
       
  1540     {
       
  1541     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1542         TRequestStatus &, aStatus, 
       
  1543         const TDesC8 &, aDes1, 
       
  1544         const TDesC16 &, aDes2, 
       
  1545         TReqPriorityType, aType )
       
  1546     }
       
  1547 
       
  1548 
       
  1549 // -----------------------------------------------------------------------------
       
  1550 // RTelSubSessionBase::Get
       
  1551 // -----------------------------------------------------------------------------
       
  1552 //
       
  1553 TInt RTelSubSessionBase::Get( 
       
  1554         const TInt aIpc,
       
  1555         TDes16 & aDes1,
       
  1556         TDes16 & aDes2,
       
  1557         TReqPriorityType aType ) const
       
  1558     {
       
  1559     SMC_MOCK_METHOD4( TInt, const TInt, aIpc, 
       
  1560         TDes16 &, aDes1, 
       
  1561         TDes16 &, aDes2, 
       
  1562         TReqPriorityType, aType )
       
  1563     }
       
  1564 
       
  1565 
       
  1566 // -----------------------------------------------------------------------------
       
  1567 // RTelSubSessionBase::Get
       
  1568 // -----------------------------------------------------------------------------
       
  1569 //
       
  1570 void RTelSubSessionBase::Get( 
       
  1571         const TInt aIpc,
       
  1572         TRequestStatus & aStatus,
       
  1573         TDes16 & aDes1,
       
  1574         TDes16 & aDes2,
       
  1575         TReqPriorityType aType ) const
       
  1576     {
       
  1577     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1578         TRequestStatus &, aStatus, 
       
  1579         TDes16 &, aDes1, 
       
  1580         TDes16 &, aDes2, 
       
  1581         TReqPriorityType, aType )
       
  1582     }
       
  1583 
       
  1584 
       
  1585 // -----------------------------------------------------------------------------
       
  1586 // RTelSubSessionBase::Get
       
  1587 // -----------------------------------------------------------------------------
       
  1588 //
       
  1589 TInt RTelSubSessionBase::Get( 
       
  1590         const TInt aIpc,
       
  1591         TDes8 & aDes1,
       
  1592         TDes16 & aDes2,
       
  1593         TReqPriorityType aType ) const
       
  1594     {
       
  1595     SMC_MOCK_METHOD4( TInt, const TInt, aIpc, 
       
  1596         TDes8 &, aDes1, 
       
  1597         TDes16 &, aDes2, 
       
  1598         TReqPriorityType, aType )
       
  1599     }
       
  1600 
       
  1601 
       
  1602 // -----------------------------------------------------------------------------
       
  1603 // RTelSubSessionBase::Get
       
  1604 // -----------------------------------------------------------------------------
       
  1605 //
       
  1606 void RTelSubSessionBase::Get( 
       
  1607         const TInt aIpc,
       
  1608         TRequestStatus & aStatus,
       
  1609         TDes8 & aDes1,
       
  1610         TDes16 & aDes2,
       
  1611         TReqPriorityType aType ) const
       
  1612     {
       
  1613     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1614         TRequestStatus &, aStatus, 
       
  1615         TDes8 &, aDes1, 
       
  1616         TDes16 &, aDes2, 
       
  1617         TReqPriorityType, aType )
       
  1618     }
       
  1619 
       
  1620 
       
  1621 // -----------------------------------------------------------------------------
       
  1622 // RTelSubSessionBase::SetAndGet
       
  1623 // -----------------------------------------------------------------------------
       
  1624 //
       
  1625 void RTelSubSessionBase::SetAndGet( 
       
  1626         const TInt aIpc,
       
  1627         TRequestStatus & aStatus,
       
  1628         const TDesC8 & aDes1,
       
  1629         TDes8 & aDes2,
       
  1630         TReqPriorityType aType ) const
       
  1631     {
       
  1632     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1633         TRequestStatus &, aStatus, 
       
  1634         const TDesC8 &, aDes1, 
       
  1635         TDes8 &, aDes2, 
       
  1636         TReqPriorityType, aType )
       
  1637     }
       
  1638 
       
  1639 
       
  1640 // -----------------------------------------------------------------------------
       
  1641 // RTelSubSessionBase::SetAndGet
       
  1642 // -----------------------------------------------------------------------------
       
  1643 //
       
  1644 void RTelSubSessionBase::SetAndGet( 
       
  1645         const TInt aIpc,
       
  1646         TRequestStatus & aStatus,
       
  1647         TDes8 & aDes1,
       
  1648         const TDesC16 & aDes2,
       
  1649         TReqPriorityType aType ) const
       
  1650     {
       
  1651     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1652         TRequestStatus &, aStatus, 
       
  1653         TDes8 &, aDes1, 
       
  1654         const TDesC16 &, aDes2, 
       
  1655         TReqPriorityType, aType )
       
  1656     }
       
  1657 
       
  1658 
       
  1659 // -----------------------------------------------------------------------------
       
  1660 // RTelSubSessionBase::SetAndGet
       
  1661 // -----------------------------------------------------------------------------
       
  1662 //
       
  1663 void RTelSubSessionBase::SetAndGet( 
       
  1664         const TInt aIpc,
       
  1665         TRequestStatus & aStatus,
       
  1666         const TDesC8 & aDummyValue,
       
  1667         TDes16 & aDes2,
       
  1668         TReqPriorityType aType ) const
       
  1669     {
       
  1670     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1671         TRequestStatus &, aStatus, 
       
  1672         const TDesC8&, aDummyValue, 
       
  1673         TDes16 &, aDes2, 
       
  1674         TReqPriorityType, aType )
       
  1675     }
       
  1676 
       
  1677 
       
  1678 // -----------------------------------------------------------------------------
       
  1679 // RTelSubSessionBase::SetAndGet
       
  1680 // -----------------------------------------------------------------------------
       
  1681 //
       
  1682 void RTelSubSessionBase::SetAndGet( 
       
  1683         const TInt aIpc,
       
  1684         TRequestStatus & aStatus,
       
  1685         const TDesC16 & aDes1,
       
  1686         TDes16 & aDes2,
       
  1687         TReqPriorityType aType ) const
       
  1688     {
       
  1689     SMC_MOCK_METHOD5( void, const TInt, aIpc, 
       
  1690         TRequestStatus &, aStatus, 
       
  1691         const TDesC16 &, aDes1, 
       
  1692         TDes16 &, aDes2, 
       
  1693         TReqPriorityType, aType )
       
  1694     }
       
  1695 
       
  1696 
       
  1697 // -----------------------------------------------------------------------------
       
  1698 // RTelSubSessionBase::Set
       
  1699 // -----------------------------------------------------------------------------
       
  1700 //
       
  1701 TInt RTelSubSessionBase::Set( 
       
  1702         const TInt aIpc,
       
  1703         const RFile & aFile,
       
  1704         TReqPriorityType aType ) const
       
  1705     {
       
  1706     SMC_MOCK_METHOD3( TInt, const TInt, aIpc, 
       
  1707         const RFile &, aFile, 
       
  1708         TReqPriorityType, aType )
       
  1709     }
       
  1710 
       
  1711 
       
  1712 // -----------------------------------------------------------------------------
       
  1713 // RTelSubSessionBase::CancelReq
       
  1714 // -----------------------------------------------------------------------------
       
  1715 //
       
  1716 TInt RTelSubSessionBase::CancelReq( 
       
  1717         const TInt aIpc,
       
  1718         const TInt aIpcToCancel ) const
       
  1719     {
       
  1720     SMC_MOCK_METHOD2( TInt, const TInt, aIpc, 
       
  1721         const TInt, aIpcToCancel )
       
  1722     }
       
  1723 
       
  1724 
       
  1725 // -----------------------------------------------------------------------------
       
  1726 // RTelSubSessionBase::CancelSubSession
       
  1727 // -----------------------------------------------------------------------------
       
  1728 //
       
  1729 TInt RTelSubSessionBase::CancelSubSession(  ) const
       
  1730     {
       
  1731     SMC_MOCK_METHOD0( TInt )
       
  1732     }
       
  1733 
       
  1734 
       
  1735 // -----------------------------------------------------------------------------
       
  1736 // RTelServer::RTelServer
       
  1737 // -----------------------------------------------------------------------------
       
  1738 //
       
  1739 RTelServer::RTelServer(  )
       
  1740     {
       
  1741     
       
  1742     }
       
  1743 
       
  1744 
       
  1745 // -----------------------------------------------------------------------------
       
  1746 // RTelServer::Connect
       
  1747 // -----------------------------------------------------------------------------
       
  1748 //
       
  1749 TInt RTelServer::Connect( 
       
  1750         TInt aMessageSlots )
       
  1751     {
       
  1752     SMC_MOCK_METHOD1( TInt, TInt, aMessageSlots )
       
  1753     }
       
  1754 
       
  1755 
       
  1756 // -----------------------------------------------------------------------------
       
  1757 // RTelServer::EnumeratePhones
       
  1758 // -----------------------------------------------------------------------------
       
  1759 //
       
  1760 TInt RTelServer::EnumeratePhones( 
       
  1761         TInt & aNoOfPhones ) const
       
  1762     {
       
  1763     SMC_MOCK_METHOD1( TInt, TInt &, aNoOfPhones )
       
  1764     }
       
  1765 
       
  1766 
       
  1767 // -----------------------------------------------------------------------------
       
  1768 // RTelServer::GetPhoneInfo
       
  1769 // -----------------------------------------------------------------------------
       
  1770 //
       
  1771 TInt RTelServer::GetPhoneInfo( 
       
  1772         const TInt aIndex,
       
  1773         TPhoneInfo & aInfo ) const
       
  1774     {
       
  1775     SMC_MOCK_METHOD2( TInt, const TInt, aIndex, 
       
  1776         TPhoneInfo &, aInfo )
       
  1777     }
       
  1778 
       
  1779 
       
  1780 // -----------------------------------------------------------------------------
       
  1781 // RTelServer::GetTsyName
       
  1782 // -----------------------------------------------------------------------------
       
  1783 //
       
  1784 TInt RTelServer::GetTsyName( 
       
  1785         const TInt aIndexOfPhone,
       
  1786         TDes & aTsyName ) const
       
  1787     {
       
  1788     SMC_MOCK_METHOD2( TInt, const TInt, aIndexOfPhone, 
       
  1789         TDes &, aTsyName )
       
  1790     }
       
  1791 
       
  1792 
       
  1793 // -----------------------------------------------------------------------------
       
  1794 // RTelServer::LoadPhoneModule
       
  1795 // -----------------------------------------------------------------------------
       
  1796 //
       
  1797 TInt RTelServer::LoadPhoneModule( 
       
  1798         const TDesC & aFileName ) const
       
  1799     {
       
  1800     SMC_MOCK_METHOD1( TInt, const TDesC &, aFileName )
       
  1801     }
       
  1802 
       
  1803 
       
  1804 // -----------------------------------------------------------------------------
       
  1805 // RTelServer::UnloadPhoneModule
       
  1806 // -----------------------------------------------------------------------------
       
  1807 //
       
  1808 TInt RTelServer::UnloadPhoneModule( 
       
  1809         const TDesC & aFileName ) const
       
  1810     {
       
  1811     SMC_MOCK_METHOD1( TInt, const TDesC &, aFileName )
       
  1812     }
       
  1813 
       
  1814 
       
  1815 // -----------------------------------------------------------------------------
       
  1816 // RTelServer::IsSupportedByModule
       
  1817 // -----------------------------------------------------------------------------
       
  1818 //
       
  1819 TInt RTelServer::IsSupportedByModule( 
       
  1820         const TDesC & aTsyName,
       
  1821         const TInt aMixin,
       
  1822         TBool & aResult ) const
       
  1823     {
       
  1824     SMC_MOCK_METHOD3( TInt, const TDesC &, aTsyName, 
       
  1825         const TInt, aMixin, 
       
  1826         TBool &, aResult )
       
  1827     }
       
  1828 
       
  1829 
       
  1830 // -----------------------------------------------------------------------------
       
  1831 // RTelServer::GetTsyVersionNumber
       
  1832 // -----------------------------------------------------------------------------
       
  1833 //
       
  1834 TInt RTelServer::GetTsyVersionNumber( 
       
  1835         const TDesC & aTsyName,
       
  1836         TVersion & aVersion ) const
       
  1837     {
       
  1838     SMC_MOCK_METHOD2( TInt, const TDesC &, aTsyName, 
       
  1839         TVersion &, aVersion )
       
  1840     }
       
  1841 
       
  1842 
       
  1843 // -----------------------------------------------------------------------------
       
  1844 // RTelServer::SetPriorityClient
       
  1845 // -----------------------------------------------------------------------------
       
  1846 //
       
  1847 TInt RTelServer::SetPriorityClient(  ) const
       
  1848     {
       
  1849     SMC_MOCK_METHOD0( TInt )
       
  1850     }
       
  1851 
       
  1852 
       
  1853 // -----------------------------------------------------------------------------
       
  1854 // RTelServer::SetExtendedErrorGranularity
       
  1855 // -----------------------------------------------------------------------------
       
  1856 //
       
  1857 TInt RTelServer::SetExtendedErrorGranularity( 
       
  1858         const TErrorGranularity aGranularity ) const
       
  1859     {
       
  1860     SMC_MOCK_METHOD1( TInt, const TErrorGranularity, aGranularity )
       
  1861     }
       
  1862 
       
  1863 
       
  1864 // -----------------------------------------------------------------------------
       
  1865 // RTelServer::__DbgMarkHeap
       
  1866 // -----------------------------------------------------------------------------
       
  1867 //
       
  1868 TInt RTelServer::__DbgMarkHeap(  )
       
  1869     {
       
  1870     SMC_MOCK_METHOD0( TInt )
       
  1871     }
       
  1872 
       
  1873 
       
  1874 // -----------------------------------------------------------------------------
       
  1875 // RTelServer::__DbgCheckHeap
       
  1876 // -----------------------------------------------------------------------------
       
  1877 //
       
  1878 TInt RTelServer::__DbgCheckHeap( 
       
  1879         TInt aCount )
       
  1880     {
       
  1881     SMC_MOCK_METHOD1( TInt, TInt, aCount )
       
  1882     }
       
  1883 
       
  1884 
       
  1885 // -----------------------------------------------------------------------------
       
  1886 // RTelServer::__DbgMarkEnd
       
  1887 // -----------------------------------------------------------------------------
       
  1888 //
       
  1889 TInt RTelServer::__DbgMarkEnd( 
       
  1890         TInt aCount )
       
  1891     {
       
  1892     SMC_MOCK_METHOD1( TInt, TInt, aCount )
       
  1893     }
       
  1894 
       
  1895 
       
  1896 // -----------------------------------------------------------------------------
       
  1897 // RTelServer::__DbgFailNext
       
  1898 // -----------------------------------------------------------------------------
       
  1899 //
       
  1900 TInt RTelServer::__DbgFailNext( 
       
  1901         TInt aCount )
       
  1902     {
       
  1903     SMC_MOCK_METHOD1( TInt, TInt, aCount )
       
  1904     }
       
  1905 
       
  1906 
       
  1907 // -----------------------------------------------------------------------------
       
  1908 // RTelServer::__DbgFailNextAvailable
       
  1909 // -----------------------------------------------------------------------------
       
  1910 //
       
  1911 TInt RTelServer::__DbgFailNextAvailable( 
       
  1912         TBool & aResult )
       
  1913     {
       
  1914     SMC_MOCK_METHOD1( TInt, TBool &, aResult )
       
  1915     }
       
  1916 
       
  1917 
       
  1918 // -----------------------------------------------------------------------------
       
  1919 // RTelServer::SetPriorityClientV2
       
  1920 // -----------------------------------------------------------------------------
       
  1921 //
       
  1922 TInt RTelServer::SetPriorityClientV2(  ) const
       
  1923     {
       
  1924     SMC_MOCK_METHOD0( TInt )
       
  1925     }
       
  1926 
       
  1927