1 /*

     2 * Copyright (c) 2004 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 

    18 

    19 

    20 

    21 #ifndef __UT_CMccCODECINFORMATION_H__

    22 #define __UT_CMccCODECINFORMATION_H__

    23 

    24 //  EXTERNAL INCLUDES

    25 #include <digia/eunit/ceunittestsuiteclass.h>

    26 

    27 //  INTERNAL INCLUDES

    28 #include "mmccinterfacedef.h"

    29 #include "mmccinterface.h"

    30 #include "mmcccodecinformation.h"

    31 #include "mmccevents.h"

    32 

    33 

    34 //  FORWARD DECLARATIONS

    35 class CMccCodecInformation;

    36 

    37 //  CLASS DEFINITION

    38 /**

    39  *

    40  * EUnitWizard generated test class. 

    41  *

    42  */

    43 class UT_CMccCodecInformation

    44      : public CEUnitTestSuiteClass,

    45        public MMccCtrlObserver

    46     {

    47     public:     // Constructors and destructors

    48 

    49         /**

    50          * Two phase construction

    51          */

    52         static UT_CMccCodecInformation* NewL();

    53         static UT_CMccCodecInformation* NewLC();

    54         /**

    55          * Destructor

    56          */

    57         ~UT_CMccCodecInformation();

    58 

    59     private:    // Constructors and destructors

    60 

    61         UT_CMccCodecInformation();

    62         void ConstructL();

    63 

    64 	public: 	// From observer interface

    65 		

    66 		

    67 

    68     private:    // New methods

    69 

    70          void SetupL();

    71         

    72          void Teardown();

    73         

    74          void UT_CMccCodecInformation_CloneDefaultsLL();

    75         

    76         

    77          void UT_CMccCodecInformation_CloneDetailedLL();

    78         

    79         

    80          void UT_CMccCodecInformation_RequireSignallingL();

    81         

    82         

    83          void UT_CMccCodecInformation_SetValuesL();

    84         

    85         

    86          void UT_CMccCodecInformation_GetValuesL();

    87         

    88         

    89          void UT_CMccCodecInformation_TypeL();

    90         

    91         

    92          void UT_CMccCodecInformation_EnableVADL();

    93         

    94         

    95          void UT_CMccCodecInformation_SetBitrateL();

    96         

    97         

    98          void UT_CMccCodecInformation_SetSamplingFreqL();

    99         

   100         

   101          void UT_CMccCodecInformation_SetSdpNameL();

   102         

   103         

   104          void UT_CMccCodecInformation_SetPayloadTypeL();

   105         

   106         

   107          void UT_CMccCodecInformation_SetCodecModeL();

   108         

   109         

   110          void UT_CMccCodecInformation_SetAllowedBitratesL();

   111         

   112         

   113          void UT_CMccCodecInformation_SetPTimeL();

   114         

   115         

   116          void UT_CMccCodecInformation_SetMaxPTimeL();

   117         

   118         

   119          void UT_CMccCodecInformation_SetJitterBufBufferLengthL();

   120         

   121         

   122          void UT_CMccCodecInformation_SetJitterBufThresholdL();

   123         

   124         

   125          void UT_CMccCodecInformation_SetJitterBufInactivityTimeOutL();

   126         

   127         

   128          void UT_CMccCodecInformation_SetMaxBitrateL();

   129         

   130         

   131          void UT_CMccCodecInformation_SetAverageBitrateL();

   132         

   133         

   134          void UT_CMccCodecInformation_SetFramerateL();

   135         

   136         

   137          void UT_CMccCodecInformation_SetFrameHeightL();

   138         

   139         

   140          void UT_CMccCodecInformation_SetFrameWidthL();

   141         

   142         

   143          void UT_CMccCodecInformation_SetAlgoL();

   144         

   145         

   146          void UT_CMccCodecInformation_SetRedCountL();

   147         

   148         

   149          void UT_CMccCodecInformation_SetRedundancyPTL();

   150         

   151         

   152          void UT_CMccCodecInformation_SetPriorityL();

   153         

   154         

   155          void UT_CMccCodecInformation_SetPriorityPreferenceL();

   156         

   157         

   158          void UT_CMccCodecInformation_SetKeepAliveTimerL();

   159         

   160         

   161          void UT_CMccCodecInformation_SetKeepAlivePTL();

   162         

   163         

   164          void UT_CMccCodecInformation_SetKeepAliveDataL();

   165         

   166         

   167          void UT_CMccCodecInformation_SetComfortNoiseGenerationL();

   168         

   169         

   170          void UT_CMccCodecInformation_SetChannelsL();

   171         

   172         

   173          void UT_CMccCodecInformation_SetMaxRedL();

   174         

   175         

   176          void UT_CMccCodecInformation_VADL();

   177         

   178         

   179          void UT_CMccCodecInformation_BitrateL();

   180         

   181         

   182          void UT_CMccCodecInformation_AllowedBitratesL();

   183         

   184         

   185          void UT_CMccCodecInformation_SamplingFreqL();

   186         

   187         

   188          void UT_CMccCodecInformation_SdpNameL();

   189         

   190         

   191          void UT_CMccCodecInformation_PayloadTypeL();

   192         

   193         

   194          void UT_CMccCodecInformation_CodecModeL();

   195         

   196         

   197          void UT_CMccCodecInformation_PTimeL();

   198         

   199         

   200          void UT_CMccCodecInformation_MaxPTimeL();

   201         

   202         

   203          void UT_CMccCodecInformation_GetFmtpLL();

   204         

   205         

   206          void UT_CMccCodecInformation_FourCCL();

   207         

   208         

   209          void UT_CMccCodecInformation_FrameTimeL();

   210         

   211         

   212          void UT_CMccCodecInformation_FrameSizeL();

   213         

   214         

   215          void UT_CMccCodecInformation_AlgoL();

   216         

   217         

   218          void UT_CMccCodecInformation_RedCountL();

   219         

   220         

   221          void UT_CMccCodecInformation_RedundancyPTL();

   222         

   223         

   224          void UT_CMccCodecInformation_JitterBufInactivityTimeOutL();

   225         

   226         

   227          void UT_CMccCodecInformation_JitterBufThresholdL();

   228         

   229         

   230          void UT_CMccCodecInformation_JitterBufBufferLengthL();

   231         

   232         

   233          void UT_CMccCodecInformation_MaxBitrateL();

   234         

   235         

   236          void UT_CMccCodecInformation_AverageBitrateL();

   237         

   238         

   239          void UT_CMccCodecInformation_FramerateL();

   240         

   241         

   242          void UT_CMccCodecInformation_FrameHeightL();

   243         

   244         

   245          void UT_CMccCodecInformation_FrameWidthL();

   246         

   247         

   248          void UT_CMccCodecInformation_PriorityL();

   249         

   250         

   251          void UT_CMccCodecInformation_PriorityPreferenceL();

   252         

   253         

   254          void UT_CMccCodecInformation_KeepAliveTimerL();

   255         

   256         

   257          void UT_CMccCodecInformation_KeepAlivePTL();

   258         

   259         

   260          void UT_CMccCodecInformation_KeepAliveDataL();

   261         

   262         

   263          void UT_CMccCodecInformation_ComfortNoiseGenerationL();

   264         

   265         

   266          void UT_CMccCodecInformation_GetChannelsL();

   267         

   268         

   269          void UT_CMccCodecInformation_MaxRedL();

   270         

   271         

   272          void UT_CMccCodecInformation_SetFmtpAttrLL();

   273         

   274         

   275          void UT_CMccCodecInformation_ParseFmtpAttrLL();

   276         

   277         

   278          void UT_CMccCodecInformation_CreateFmtpAttrListLL();

   279         

   280         

   281          void UT_CMccCodecInformation_CreateFmtpAttrListL_1L();

   282         

   283         

   284          void UT_CMccCodecInformation_SetModeChangePeriodL();

   285         

   286         

   287          void UT_CMccCodecInformation_ModeChangePeriodL();

   288         

   289         

   290          void UT_CMccCodecInformation_SetModeChangeNeighborL();

   291         

   292         

   293          void UT_CMccCodecInformation_ModeChangeNeighborL();

   294         

   295         

   296          void UT_CMccCodecInformation_SetCrcL();

   297         

   298         

   299          void UT_CMccCodecInformation_GetCrcL();

   300         

   301         

   302          void UT_CMccCodecInformation_SetRobustSortingL();

   303         

   304         

   305          void UT_CMccCodecInformation_GetRobustSortingL();

   306         

   307         

   308          void UT_CMccCodecInformation_SetInterleavingL();

   309         

   310         

   311          void UT_CMccCodecInformation_GetInterleavingL();

   312          

   313          void UT_CMccCodecInformation_SetConfigKeyL();

   314          

   315          void UT_CMccCodecInformation_ConfigKeyL();

   316          

   317          void UT_CMccCodecInformation_SetPreferredEncodingDecodingDeviceL();

   318         

   319         

   320     public: //MMccCtrlObserver, pure virtual functions 

   321         /**

   322         * Callback function to receive media signalling

   323         * @param aSignal Received media signal

   324         * @return void

   325         */

   326         void MccEventReceived( const TMccEvent& aEvent );

   327         

   328         /**

   329         * Callback function to receive stream started event.

   330         * @param aSessionId Session ID

   331         * @param aLinkId Link ID

   332         * @param aStreamId Stream ID

   333         */

   334         void MccMediaStarted( TUint32 aSessionId,

   335                                     TUint32 aLinkId,     

   336                                     TUint32 aStreamId,

   337                                     TUint32 aSinkSourceId );

   338         

   339         /**

   340         * Callback function to receive stream stopped event.

   341         * @param aSessionId Session ID

   342         * @param aLinkId Link ID

   343         * @param aStreamId Stream ID

   344         */

   345         void MccMediaStopped( TUint32 aSessionId,

   346                                     TUint32 aLinkId,

   347                                     TUint32 aStreamId,

   348                                     TUint32 aSinkSourceId );

   349 

   350         /**

   351         * Callback function to receive stream paused event.

   352         * @param aSessionId Session ID

   353         * @param aLinkId Link ID

   354         * @param aStreamId Stream ID

   355         */

   356         void MccMediaPaused( TUint32 aSessionId,

   357                                    TUint32 aLinkId,

   358                                     TUint32 aStreamId,

   359                                     TUint32 aSinkSourceId );

   360 

   361         /**

   362         * Callback function to receive stream resumed event.

   363         * @param aSessionId Session ID

   364         * @param aLinkId Link ID

   365         * @param aStreamId Stream ID

   366         */

   367         void MccMediaResumed( TUint32 aSessionId,

   368                                     TUint32 aLinkId,

   369                                     TUint32 aStreamId,

   370                                     TUint32 aSinkSourceId );

   371 

   372         /**

   373         * Callback function to receive stream prepared event.

   374         * @param aSessionId Session ID

   375         * @param aLinkId Link ID

   376         * @param aStreamId Stream ID

   377         */

   378         void MccMediaPrepared( TUint32 aSessionId,

   379                                     TUint32 aLinkId,

   380                                     TUint32 aStreamId,

   381                                     TUint32 aSinkSourceId );

   382 

   383         /**

   384         * Callback function to receive stream inactivity event.

   385         * @param aSessionId Session ID

   386         * @param aLinkId Link ID

   387         * @param aStreamId Stream ID

   388         */

   389         void MccMediaInactive( TUint32 aSessionId,

   390                                     TUint32 aLinkId,

   391                                     TUint32 aStreamId,

   392                                     TUint32 aSinkSourceId );

   393         

   394         /**

   395         * Callback function to receive stream activity event.

   396         * @param aSessionId Session ID

   397         * @param aLinkId Link ID

   398         * @param aStreamId Stream ID

   399         */

   400         void MccMediaActive( TUint32 aSessionId,

   401                                     TUint32 aLinkId,

   402                                     TUint32 aStreamId,

   403                                     TUint32 aSinkSourceId );

   404 

   405         /**

   406         * Callback function to receive error event.

   407         * @param aError Error code

   408         * @return None

   409         */

   410         void MccCtrlError( TInt aError );

   411 

   412         /**

   413         * Callback function to receive error event.

   414         * @param aError Error code

   415         * @param aSessionId Session ID

   416         * @param aLinkId Link ID

   417         */

   418         void MccCtrlError( TInt aError,

   419                                    TUint32 aSessionId,

   420                                    TUint32 aLinkId,

   421                                    TUint32 aStreamId,

   422                                    TUint32 aSinkSourceId );

   423 

   424 

   425     private:

   426     

   427         void GetCapabilitiesL( RPointerArray<CMccCodecInformation>& aCodecArray );

   428         

   429     private:    // Data

   430 

   431 		EUNIT_DECLARE_TEST_TABLE; 

   432 	    CMccInterface* iInterface;	    

   433         RPointerArray<CMccCodecInformation> iCodecArray;

   434         TInt iCount;

   435         

   436     };

   437 

   438 #endif      //  __UT_CMccCODECINFORMATION_H__

   439 

   440 // End of file