Symaptic: os/persistentdata/traceservices/commsdebugutility/TE_commsdebugutility/inc/step_028

     1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    15 #include <comms-infras/commsdebugutility.h>

    19 #if (!defined __STEP_028_XX_H__)

    20 #define __STEP_028_XX_H__

    22 class CFloggerTest028_Sync_Setup : public CTestStepFlogger

    23 	{

    24 	public:

    25 	CFloggerTest028_Sync_Setup();

    26 	~CFloggerTest028_Sync_Setup();

    29 	virtual enum TVerdict doTestStepL( void );

    30 	TInt executeStepL();

    31 	TInt executeStepL(TBool);

    32 	};

    36 class CFloggerTest028_Sync_ConWriteUni : public CTestStepFlogger

    37 	{

    38 	public:

    39 	CFloggerTest028_Sync_ConWriteUni();

    40 	~CFloggerTest028_Sync_ConWriteUni();

    42 	TInt DoTestCheckWriteL();

    44 	virtual enum TVerdict doTestStepL( void );

    45 	TInt executeStepL();

    46 	TInt executeStepL(TBool);

    47 	};

    49 class CFloggerTest028_Sync_ConWriteUniBound : public CTestStepFlogger

    50 	{

    51 	public:

    52 	CFloggerTest028_Sync_ConWriteUniBound();

    53 	~CFloggerTest028_Sync_ConWriteUniBound();

    55 	TInt DoTestCheckWriteL();

    57 	virtual enum TVerdict doTestStepL( void );

    58 	TInt executeStepL();

    59 	TInt executeStepL(TBool);

    60 	};

    63 class CFloggerTest028_Sync_ConWriteFormatEUni : public CTestStepFlogger

    64 	{

    65 	public:

    66 	CFloggerTest028_Sync_ConWriteFormatEUni();

    67 	~CFloggerTest028_Sync_ConWriteFormatEUni();

    69 	TInt DoTestCheckWriteL();

    71 	virtual enum TVerdict doTestStepL( void );

    72 	TInt executeStepL();

    73 	TInt executeStepL(TBool);

    74 	};

    76 class CFloggerTest028_Sync_ConWriteFormatEUniBound : public CTestStepFlogger

    77 	{

    78 	public:

    79 	CFloggerTest028_Sync_ConWriteFormatEUniBound();

    80 	~CFloggerTest028_Sync_ConWriteFormatEUniBound();

    82 	TInt DoTestCheckWriteL();

    84 	virtual enum TVerdict doTestStepL( void );

    85 	TInt executeStepL();

    86 	TInt executeStepL(TBool);

    87 	};

    90 class CFloggerTest028_Sync_ConWriteFormatV8Bit : public CTestStepFlogger

    91 	{

    92 	public:

    93 	CFloggerTest028_Sync_ConWriteFormatV8Bit();

    94 	~CFloggerTest028_Sync_ConWriteFormatV8Bit();

    96     void DoTestWriteFormat(TRefByValue<const TDesC8> aFmt,...);

    97 	TInt DoTestCheckWriteL();

    99 	virtual enum TVerdict doTestStepL( void );

   100 	TInt executeStepL();

   101 	TInt executeStepL(TBool);

   102 	private:

   103 	RFileLogger flogger;

   105 	};

   107 class CFloggerTest028_Sync_ConWriteFormatV8BitBound : public CTestStepFlogger

   108 	{

   109 	public:

   110 	CFloggerTest028_Sync_ConWriteFormatV8BitBound();

   111 	~CFloggerTest028_Sync_ConWriteFormatV8BitBound();

   113     void DoTestWriteFormat(TRefByValue<const TDesC8> aFmt,...);

   114 	TInt DoTestCheckWriteL();

   116 	virtual enum TVerdict doTestStepL( void );

   117 	TInt executeStepL();

   118 	TInt executeStepL(TBool);

   119 	private:

   120 	RFileLogger flogger;

   121 	};

   123 class CFloggerTest028_Sync_Static_WriteUni : public CTestStepFlogger

   124 	{

   125 	public:

   126 	CFloggerTest028_Sync_Static_WriteUni();

   127 	~CFloggerTest028_Sync_Static_WriteUni();

   129 	TInt DoTestCheckWriteL();

   131 	virtual enum TVerdict doTestStepL( void );

   132 	TInt executeStepL();

   133 	TInt executeStepL(TBool);

   134 	private:

   135 	RFileLogger flogger;

   137 	};

   139 class CFloggerTest028_Sync_Static_WriteUniBound : public CTestStepFlogger

   140 	{

   141 	public:

   142 	CFloggerTest028_Sync_Static_WriteUniBound();

   143 	~CFloggerTest028_Sync_Static_WriteUniBound();

   145 	TInt DoTestCheckWriteL();

   147 	virtual enum TVerdict doTestStepL( void );

   148 	TInt executeStepL();

   149 	TInt executeStepL(TBool);

   150 	private:

   151 	RFileLogger flogger;

   152 	};

   155 class CFloggerTest028_Sync_Static_WriteFormatVUni : public CTestStepFlogger

   156 	{

   157 	public:

   158 	CFloggerTest028_Sync_Static_WriteFormatVUni();

   159 	~CFloggerTest028_Sync_Static_WriteFormatVUni();

   161     void DoTestWriteFormat(TRefByValue<const TDesC16> aFmt,...);

   162 	TInt DoTestCheckWriteL();

   164 	virtual enum TVerdict doTestStepL( void );

   165 	TInt executeStepL();

   166 	TInt executeStepL(TBool);

   167 	private:

   168 	RFileLogger flogger;

   170 	};

   172 class CFloggerTest028_Sync_Static_WriteFormatVUniBound : public CTestStepFlogger

   173 	{

   174 	public:

   175 	CFloggerTest028_Sync_Static_WriteFormatVUniBound();

   176 	~CFloggerTest028_Sync_Static_WriteFormatVUniBound();

   178     void DoTestWriteFormat(TRefByValue<const TDesC16> aFmt,...);

   179 	TInt DoTestCheckWriteL();

   181 	virtual enum TVerdict doTestStepL( void );

   182 	TInt executeStepL();

   183 	TInt executeStepL(TBool);

   184 	private:

   185 	RFileLogger flogger;

   186 	};

   190 class CFloggerTest028_Sync_Static_HexDump : public CTestStepFlogger

   191 	{

   192 	public:

   193 	CFloggerTest028_Sync_Static_HexDump();

   194 	~CFloggerTest028_Sync_Static_HexDump();

   196 	TInt DoTestCheckWriteL();

   198 	virtual enum TVerdict doTestStepL( void );

   199 	TInt executeStepL();

   200 	TInt executeStepL(TBool);

   201 	private:

   202 	RFileLogger flogger;

   204 	};

   207 class CFloggerTest028_Sync_ClearLog : public CTestStepFlogger

   208 	{

   209 	public:

   210 	CFloggerTest028_Sync_ClearLog();

   211 	~CFloggerTest028_Sync_ClearLog();

   213 	TInt DoTestCheckWriteL();

   215 	virtual enum TVerdict doTestStepL( void );

   216 	TInt executeStepL();

   217 	TInt executeStepL(TBool);

   218 	private:

   219 	RFileLogger flogger;

   221 	};

   224 class CFloggerTest028_Sync_Binary : public CTestStepFlogger

   225 	{

   226 	public:

   227 	CFloggerTest028_Sync_Binary();

   228 	~CFloggerTest028_Sync_Binary();

   230 	TInt DoTestCheckWriteL();

   232 	virtual enum TVerdict doTestStepL( void );

   233 	TInt executeStepL();

   234 	TInt executeStepL(TBool);

   235 	private:

   236 	RFileLogger flogger;

   238 	};

   241 class CFloggerTest028_Sync_ConMultiple : public CTestStepFlogger

   242 	{

   243 	public:

   244 	CFloggerTest028_Sync_ConMultiple();

   245 	~CFloggerTest028_Sync_ConMultiple();

   247     void DoTestWriteFormat(TRefByValue<const TDesC8> aFmt,...);

   248    	TInt DoTestCheckWriteL();

   250 	virtual enum TVerdict doTestStepL( void );

   251 	TInt executeStepL();

   252 	TInt executeStepL(TBool);

   253 	private:

   254 	RFileLogger flogger;   // a member so we don't have to pass to "DoTestWriteFormat"

   256 	};

   259 class CFloggerTest028_Sync_Static_Multiple : public CTestStepFlogger

   260 	{

   261 	public:

   262 	CFloggerTest028_Sync_Static_Multiple();

   263 	~CFloggerTest028_Sync_Static_Multiple();

   265     void DoTestWriteFormat(TRefByValue<const TDesC16> aFmt,...);

   266    	TInt DoTestCheckWriteL();

   268 	virtual enum TVerdict doTestStepL( void );

   269 	TInt executeStepL();

   270 	TInt executeStepL(TBool);

   272 	};

   274 class CFloggerTest028_Sync_ConMultiple2 : public CTestStepFlogger

   275 	{

   276 	public:

   277 	CFloggerTest028_Sync_ConMultiple2();

   278 	~CFloggerTest028_Sync_ConMultiple2();

   280     void DoTestWriteFormat(TRefByValue<const TDesC8> aFmt,...);

   281    	TInt DoTestCheckWriteL();

   283 	virtual enum TVerdict doTestStepL( void );

   284 	TInt executeStepL();

   285 	TInt executeStepL(TBool);

   286 	private:

   287 	RFileLogger flogger;   // a member so we don't have to pass to "DoTestWriteFormat"

   289 	};

   291 class CFloggerTest028_Sync_Static_Multiple2 : public CTestStepFlogger

   292 	{

   293 	public:

   294 	CFloggerTest028_Sync_Static_Multiple2();

   295 	~CFloggerTest028_Sync_Static_Multiple2();

   297     void DoTestWriteFormat(TRefByValue<const TDesC16> aFmt,...);

   298    	TInt DoTestCheckWriteL();

   300 	virtual enum TVerdict doTestStepL( void );

   301 	TInt executeStepL();

   302 	TInt executeStepL(TBool);

   304 	};

   305 #endif //(__STEP_028_XX_H__)

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--