|
1 /* |
|
2 * Copyright (c) 2010 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 <nkern.h> |
|
18 |
|
19 #include "TraceCompilerTesterBasic.h" |
|
20 #include "TraceCompilerTesterCommon1.h" |
|
21 #include "TraceCompilerTesterCommon2.h" |
|
22 |
|
23 #include "OstTraceDefinitions.h" |
|
24 #ifdef OST_TRACE_COMPILER_IN_USE |
|
25 #include "TraceCompilerTesterBasicTraces.h" |
|
26 #include "TraceCompilerTesterCommon2Traces.h" |
|
27 #endif |
|
28 |
|
29 // Define group IDs. If TraceCompiler is missing, define these to get the code to compile. |
|
30 // However, component still won't work properly. |
|
31 #ifdef OST_TRACE_COMPILER_IN_USE |
|
32 #define BASIC_OK_TEST TEST_BASIC_INT8 >> 16 |
|
33 #define ARRAY_OK_TEST TEST_ARRAY_INT8 >> 16 |
|
34 #define BASIC_TWO_SIMILAR_OK_TEST TEST_BASIC_SIMILAR2_INT8 >> 16 |
|
35 #define ARRAY_TWO_SIMILAR_OK_TEST TEST_ARRAY_SIMILAR2_INT8 >> 16 |
|
36 #define ENUM_OK_TEST TEST_ENUM_OK >> 16 |
|
37 #define TRACE_PERFORMANCE 0x4 |
|
38 #define TRACE_FLOW 0x7 |
|
39 #define INCLUDED_NON_SOURCE_FILE_TEST NON_SOURCE_FILE_TRACE1 >> 16 |
|
40 #define KEKKONEN TEXT1 >> 16 |
|
41 #else |
|
42 #define BASIC_OK_TEST |
|
43 #define ARRAY_OK_TEST |
|
44 #define BASIC_TWO_SIMILAR_OK_TEST |
|
45 #define ARRAY_TWO_SIMILAR_OK_TEST |
|
46 #define ENUM_OK_TEST |
|
47 #define EVENT_NO_VALUE_OK_TEST |
|
48 #define EVENT_WITH_VALUE_OK_TEST |
|
49 #define TRACE_PERFORMANCE |
|
50 #define TRACE_FLOW |
|
51 #define INCLUDED_NON_SOURCE_FILE_TEST |
|
52 #define KEKKONEN |
|
53 #endif |
|
54 |
|
55 //- Local constants --------------------------------------------------------- |
|
56 |
|
57 const TUint32 KComponentID = 0x20011112; |
|
58 |
|
59 //- Macros ------------------------------------------------------------------ |
|
60 |
|
61 |
|
62 //- Member Functions -------------------------------------------------------- |
|
63 |
|
64 /** |
|
65 * Constructor |
|
66 */ |
|
67 DTraceCompilerTesterBasic::DTraceCompilerTesterBasic() |
|
68 { |
|
69 } |
|
70 |
|
71 /** |
|
72 * EnergyMonitor Destructor |
|
73 */ |
|
74 DTraceCompilerTesterBasic::~DTraceCompilerTesterBasic() |
|
75 { |
|
76 |
|
77 } |
|
78 |
|
79 /** |
|
80 * EnergyMonitor second-phase constructor |
|
81 * |
|
82 * @param |
|
83 * @return System-wide error code |
|
84 */ |
|
85 TInt DTraceCompilerTesterBasic::Construct() |
|
86 { |
|
87 |
|
88 TInt ret(KErrNone); |
|
89 |
|
90 Kern::Printf( "-------------- DTraceCompilerTesterBasic::Construct ----------------" ); |
|
91 |
|
92 // Register notification receivers by using component ID and group IDs |
|
93 RegisterNotificationReceiver(KComponentID, BASIC_OK_TEST ); |
|
94 RegisterNotificationReceiver(KComponentID, ARRAY_OK_TEST ); |
|
95 RegisterNotificationReceiver(KComponentID, BASIC_TWO_SIMILAR_OK_TEST ); |
|
96 RegisterNotificationReceiver(KComponentID, ARRAY_TWO_SIMILAR_OK_TEST ); |
|
97 RegisterNotificationReceiver(KComponentID, ENUM_OK_TEST ); |
|
98 RegisterNotificationReceiver(KComponentID, TRACE_PERFORMANCE ); |
|
99 RegisterNotificationReceiver(KComponentID, TRACE_FLOW ); |
|
100 RegisterNotificationReceiver(KComponentID, INCLUDED_NON_SOURCE_FILE_TEST ); |
|
101 RegisterNotificationReceiver(KComponentID, KEKKONEN ); |
|
102 |
|
103 return ret; |
|
104 } |
|
105 |
|
106 /** |
|
107 * Callback function for Trace Activation |
|
108 * |
|
109 * @param aComponentId |
|
110 * @param aGroupId |
|
111 */ |
|
112 void DTraceCompilerTesterBasic::TraceActivated(TUint32 aComponentId, |
|
113 TUint16 aGroupId) |
|
114 { |
|
115 Kern::Printf( |
|
116 "DTraceCompilerTesterBasic::TraceActivated - ComponentId = 0x%x, GroupId = 0x%x", |
|
117 aComponentId, aGroupId); |
|
118 |
|
119 if (aGroupId == BASIC_OK_TEST) |
|
120 { |
|
121 Kern::Printf( |
|
122 "--------------TraceCompilerTesterBasic Array Basic START----------------"); |
|
123 TUint8 unicodeStr[10]; |
|
124 unicodeStr[0] = 'S'; |
|
125 unicodeStr[1] = '\0'; |
|
126 unicodeStr[2] = 'T'; |
|
127 unicodeStr[3] = '\0'; |
|
128 unicodeStr[4] = 'R'; |
|
129 unicodeStr[5] = '\0'; |
|
130 unicodeStr[6] = '1'; |
|
131 unicodeStr[7] = '\0'; |
|
132 unicodeStr[8] = '6'; |
|
133 unicodeStr[9] = '\0'; |
|
134 TPtrC8 unicodePtr(unicodeStr, 10); |
|
135 |
|
136 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_INT8, "int8: %hhd", ( TInt8 )1 ); |
|
137 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_INT16, "int16: %hd", ( TInt16 )2 ); |
|
138 OstTrace1( BASIC_OK_TEST, TEST_BASIC_INT32, "int32: %d", ( TInt )3 ); |
|
139 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_INT64, "int64: %Ld", ( TInt64 )4 ); |
|
140 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_UINT8, "uint8: %hhu", ( TUint16 )5 ); |
|
141 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_UINT16, "uint16: %hu", ( TUint16 )6 ); |
|
142 OstTrace1( BASIC_OK_TEST, TEST_BASIC_UINT32, "uint32: %u", ( TUint32 )7 ); |
|
143 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_UINT64, "uint64: %Lu", ( TUint64 )8 ); |
|
144 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_HEX8, "hex8: %hhx", ( TUint8 )9 ); |
|
145 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_HEX16, "hex16: %hx", ( TUint16 )10 ); |
|
146 OstTrace1( BASIC_OK_TEST, TEST_BASIC_HEX32, "hex32: %x", ( TUint32 )11 ); |
|
147 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_HEX64, "hex64: %Lx", ( TUint64 )12 ); |
|
148 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_STRING8, "ascii: %s", _L8( "STR8" ) ); |
|
149 // In kernel unicode strings do not exist -> This uses const TDesC8& |
|
150 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_STRING16, "unicode: %S", unicodePtr ); |
|
151 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_FFIX, "ffix: %f", 0.1 ); |
|
152 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_FEXP, "fexp: %e", 0.2 ); |
|
153 OstTraceExt1( BASIC_OK_TEST, TEST_BASIC_FOPT, "fopt: %g", 0.3 ); |
|
154 Kern::Printf( "--------------TraceCompilerTesterBasic Array Basic END----------------" ); |
|
155 } |
|
156 else if (aGroupId == ARRAY_OK_TEST) |
|
157 { |
|
158 |
|
159 |
|
160 Kern::Printf( "--------------TraceCompilerTesterBasic Array Test START----------------" ); |
|
161 TInt buf8Len = 29; |
|
162 TInt8 buf8[ 29 ]; |
|
163 TInt index = 0; |
|
164 TInt value = -17; |
|
165 while ( index < buf8Len ) |
|
166 { |
|
167 buf8[ index++ ] = value; |
|
168 value++; |
|
169 } |
|
170 TInt buf16Len = 11; |
|
171 TInt16 buf16[ 11 ]; |
|
172 index = 0; |
|
173 value = -3; |
|
174 while ( index < buf16Len ) |
|
175 { |
|
176 buf16[ index++ ] = value; |
|
177 value += 7; |
|
178 } |
|
179 TInt buf32Len = 7; |
|
180 TInt buf32[ 7 ]; |
|
181 index = 0; |
|
182 value = -73; |
|
183 while ( index < buf32Len ) |
|
184 { |
|
185 buf32[ index++ ] = value; |
|
186 value += 150; |
|
187 } |
|
188 TInt buf64Len = 5; |
|
189 TInt64 buf64[ 5 ]; |
|
190 index = 0; |
|
191 value = -100000000L; |
|
192 while ( index < buf64Len ) |
|
193 { |
|
194 buf64[ index++ ] = value; |
|
195 value += 100000000L; |
|
196 } |
|
197 |
|
198 #ifdef __WINS__ |
|
199 TInt bufFloatLen = 7; |
|
200 TReal bufFloat[ 7 ]; |
|
201 index = 0; |
|
202 TReal val = -0.5; |
|
203 while ( index < bufFloatLen ) |
|
204 { |
|
205 bufFloat[ index++ ] = val; |
|
206 val += 1.5; |
|
207 } |
|
208 #endif |
|
209 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT8, "int8 array: %{int8[]}", |
|
210 TOstArray< TInt8>( ( TInt8* )buf8, buf8Len ) ); |
|
211 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT16, "int16 array: %{int16[]}", |
|
212 TOstArray< TInt16>( ( TInt16* )buf16, buf16Len ) ); |
|
213 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT32, "int32 array: %{int32[]}", |
|
214 TOstArray< TInt>( ( TInt* )buf32, buf32Len ) ); |
|
215 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_INT64, "int64 array: %{int64[]}", |
|
216 TOstArray< TInt64>( ( TInt64* )buf64, buf64Len ) ); |
|
217 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT8, "uint8 array: %{uint8[]}", |
|
218 TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) ); |
|
219 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT16, "uint16 array: %{uint16[]}", |
|
220 TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) ); |
|
221 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT32, "uint32 array: %{uint32[]}", |
|
222 TOstArray< TUint>( ( TUint* )buf32, buf32Len ) ); |
|
223 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_UINT64, "uint64 array: %{uint64[]}", |
|
224 TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) ); |
|
225 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX8, "hex8 array: %{hex8[]}", |
|
226 TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) ); |
|
227 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX16, "hex16 array: %{hex16[]}", |
|
228 TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) ); |
|
229 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX32, "hex32 array: %{hex32[]}", |
|
230 TOstArray< TUint>( ( TUint* )buf32, buf32Len ) ); |
|
231 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_HEX64, "hex64 array: %{hex64[]}", |
|
232 TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) ); |
|
233 |
|
234 #ifdef __WINS__ |
|
235 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_FFIX, "ffix array: %{ffix[]}", |
|
236 TOstArray< TReal>( bufFloat, bufFloatLen ) ); |
|
237 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_FEXP, "fexp array: %{fexp[]}", |
|
238 TOstArray< TReal>( bufFloat, bufFloatLen ) ); |
|
239 OstTraceExt1( ARRAY_OK_TEST, TEST_ARRAY_FOPT, "fopt array: %{fopt[]}", |
|
240 TOstArray< TReal>( bufFloat, bufFloatLen ) ); |
|
241 #endif |
|
242 Kern::Printf( "--------------TraceCompilerTesterBasic Array Test END----------------" ); |
|
243 } |
|
244 else if (aGroupId == BASIC_TWO_SIMILAR_OK_TEST) |
|
245 { |
|
246 Kern::Printf( "--------------TraceCompilerTesterBasic Basic Two Similar Test START----------------" ); |
|
247 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT8, |
|
248 "int8: %hhd %hhd", ( TInt8 )1, ( TInt8 )1 ); |
|
249 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT16, |
|
250 "int16: %hd, %hd", ( TInt16 )2, ( TInt16 )2 ); |
|
251 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT32, |
|
252 "int32: %d, %d", ( TInt )3, ( TInt )3 ); |
|
253 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_INT64, |
|
254 "int64: %Ld, %Ld", ( TInt64 )4, ( TInt64 )4 ); |
|
255 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT8, |
|
256 "uint8: %hhu, %hhu", ( TUint8 )5, ( TUint8 )5 ); |
|
257 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT16, |
|
258 "uint16: %hu, %hu", ( TUint16 )6, ( TUint16 )6 ); |
|
259 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT32, |
|
260 "uint32: %u, %u", ( TUint )7, ( TUint )7 ); |
|
261 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_UINT64, |
|
262 "uint64: %Lu, %Lu", ( TUint64 )8, ( TUint64 )8 ); |
|
263 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX8, |
|
264 "hex8: %hhx, %hhx", ( TUint8 )9, ( TUint8 )9 ); |
|
265 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX16, |
|
266 "hex16: %hx, %hx", ( TUint16 )10, ( TUint16 )10 ); |
|
267 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX32, |
|
268 "hex32: %x, %x", ( TUint )11, ( TUint )11 ); |
|
269 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_HEX64, |
|
270 "hex64: %Lx, %Lx", ( TUint64 )12, ( TUint64 )12 ); |
|
271 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_STRING8, |
|
272 "ascii: %s, %s", _L8( "STR8" ), _L8( "STR8" ) ); |
|
273 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_FFIX, |
|
274 "ffix: %f, %f", 0.1, 0.1 ); |
|
275 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_FEXP, |
|
276 "fexp: %e, %f", 0.2, 0.2 ); |
|
277 OstTraceExt2( BASIC_TWO_SIMILAR_OK_TEST, TEST_BASIC_SIMILAR2_FOPT, |
|
278 "fopt: %g, %g", 0.3, 0.3 ); |
|
279 Kern::Printf( "--------------TraceCompilerTesterBasic Basic Two Similar Test END----------------" ); |
|
280 } |
|
281 else if (aGroupId == ARRAY_TWO_SIMILAR_OK_TEST) |
|
282 { |
|
283 Kern::Printf( "--------------TraceCompilerTesterBasic Array Two Similar Test START----------------" ); |
|
284 TInt buf8Len = 29; |
|
285 TInt8 buf8[ 29 ]; |
|
286 TInt index = 0; |
|
287 TInt value = -17; |
|
288 while ( index < buf8Len ) |
|
289 { |
|
290 buf8[ index++ ] = value; |
|
291 value++; |
|
292 } |
|
293 TInt buf16Len = 11; |
|
294 TInt16 buf16[ 11 ]; |
|
295 index = 0; |
|
296 value = -3; |
|
297 while ( index < buf16Len ) |
|
298 { |
|
299 buf16[ index++ ] = value; |
|
300 value += 7; |
|
301 } |
|
302 TInt buf32Len = 7; |
|
303 TInt buf32[ 7 ]; |
|
304 index = 0; |
|
305 value = -73; |
|
306 while ( index < buf32Len ) |
|
307 { |
|
308 buf32[ index++ ] = value; |
|
309 value += 150; |
|
310 } |
|
311 TInt buf64Len = 5; |
|
312 TInt64 buf64[ 5 ]; |
|
313 index = 0; |
|
314 value = -100000000L; |
|
315 while ( index < buf64Len ) |
|
316 { |
|
317 buf64[ index++ ] = value; |
|
318 value += 100000000L; |
|
319 } |
|
320 |
|
321 #ifdef __WINS__ |
|
322 TInt bufFloatLen = 7; |
|
323 TReal bufFloat[ 7 ]; |
|
324 index = 0; |
|
325 TReal val = -0.5; |
|
326 while ( index < bufFloatLen ) |
|
327 { |
|
328 bufFloat[ index++ ] = val; |
|
329 val += 1.5; |
|
330 } |
|
331 #endif |
|
332 |
|
333 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT8, "int8: %{int8[]} %{int8[]}", |
|
334 TOstArray< TInt8>( ( TInt8* )buf8, buf8Len ), TOstArray< TInt8>( ( TInt8* )buf8, buf8Len ) ); |
|
335 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT16, "int16: %{int16[]} %{int16[]}", |
|
336 TOstArray< TInt16>( ( TInt16* )buf16, buf16Len ), TOstArray< TInt16>( ( TInt16* )buf16, buf16Len ) ); |
|
337 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT32, "int32: %{int32[]} %{int32[]}", |
|
338 TOstArray< TInt>( ( TInt* )buf32, buf32Len ), TOstArray< TInt>( ( TInt* )buf32, buf32Len ) ); |
|
339 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_INT64, "int64: %{int64[]} %{int64[]}", |
|
340 TOstArray< TInt64>( ( TInt64* )buf64, buf64Len ), TOstArray< TInt64>( ( TInt64* )buf64, buf64Len ) ); |
|
341 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT8, "uint8: %{uint8[]} %{uint8[]}", |
|
342 TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ), TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) ); |
|
343 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT16, "uint16: %{uint16[]} %{uint16[]}", |
|
344 TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ), TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) ); |
|
345 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT32, "uint32: %{uint32[]} %{uint32[]}", |
|
346 TOstArray< TUint>( ( TUint* )buf32, buf32Len ), TOstArray< TUint>( ( TUint* )buf32, buf32Len ) ); |
|
347 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_UINT64, "uint64: %{uint64[]} %{uint64[]}", |
|
348 TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ), TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) ); |
|
349 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX8, "hex8: %{hex8[]} %{hex8[]}", |
|
350 TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ), TOstArray< TUint8>( ( TUint8* )buf8, buf8Len ) ); |
|
351 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX16, "hex16: %{hex16[]} %{hex16[]}", |
|
352 TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ), TOstArray< TUint16>( ( TUint16* )buf16, buf16Len ) ); |
|
353 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX32, "hex32: %{hex32[]} %{hex32[]}", |
|
354 TOstArray< TUint>( ( TUint* )buf32, buf32Len ), TOstArray< TUint>( ( TUint* )buf32, buf32Len ) ); |
|
355 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_HEX64, "hex64: %{hex64[]} %{hex64[]}", |
|
356 TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ), TOstArray< TUint64>( ( TUint64* )buf64, buf64Len ) ); |
|
357 |
|
358 #ifdef __WINS__ |
|
359 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_FFIX, "ffix: %{ffix[]} %{ffix[]}", |
|
360 TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ), TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ) ); |
|
361 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_FEXP, "fexp: %{fexp[]} %{fexp[]}", |
|
362 TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ), TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ) ); |
|
363 OstTraceExt2( ARRAY_TWO_SIMILAR_OK_TEST, TEST_ARRAY_SIMILAR2_FOPT, "fopt: %{fopt[]} %{fopt[]}", |
|
364 TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ), TOstArray< TReal>( ( TReal* )bufFloat, bufFloatLen ) ); |
|
365 |
|
366 #endif |
|
367 Kern::Printf( "--------------TraceCompilerTesterBasic Array Two Similar Test END----------------" ); |
|
368 } |
|
369 else if (aGroupId == ENUM_OK_TEST) |
|
370 { |
|
371 Kern::Printf( "--------------TraceCompilerTesterBasic Enum Test START----------------" ); |
|
372 TInt buf[3]; |
|
373 buf[0] = KErrNone; |
|
374 buf[1] = KErrNotFound; |
|
375 buf[2] = KErrGeneral; |
|
376 TInt ret = KErrGeneral; |
|
377 OstTrace1( ENUM_OK_TEST, TEST_ENUM_OK, "Enum: %{TErrorCodes}", ret ); |
|
378 OstTraceExt1( ENUM_OK_TEST, TEST_ENUM_ARRAY_OK, "Enum Array: %{TErrorCodes[]}", |
|
379 TOstArray< TInt>( ( TInt* )buf, 3 ) ); |
|
380 Kern::Printf( "--------------TraceCompilerTesterBasic Enum Test END----------------" ); |
|
381 } |
|
382 else if (aGroupId == TRACE_PERFORMANCE) |
|
383 { |
|
384 Kern::Printf( "--------------TraceCompilerTesterBasic Event Test START----------------" ); |
|
385 |
|
386 OstTraceEventStart0( EVENT_MY_EVENT_TRACE1_START, "Event1" ); |
|
387 OstTraceEventStop( EVENT_MY_EVENT_TRACE1_STOP, "Event1", EVENT_MY_EVENT_TRACE1_START ); |
|
388 |
|
389 OstTraceEventStart1( EVENT_MY_EVENT_TRACE2_START, "Event2", 123 ); |
|
390 OstTraceEventStop( EVENT_MY_EVENT_TRACE2_STOP, "Event2", EVENT_MY_EVENT_TRACE2_START ); |
|
391 |
|
392 Kern::Printf( "--------------TraceCompilerTesterBasic Event Test END----------------" ); |
|
393 } |
|
394 else if (aGroupId == TRACE_FLOW) |
|
395 { |
|
396 // This test can also use to test function parameters |
|
397 Kern::Printf( "--------------TraceCompilerTesterBasic Common Source File Test START----------------"); |
|
398 DTraceCompilerTesterCommon1* common1 = new DTraceCompilerTesterCommon1(); |
|
399 TInt32 sum = common1->SumValues(1, 2, 3, 4); |
|
400 delete common1; |
|
401 Kern::Printf( "--------------TraceCompilerTesterBasic Common Source File Test END----------------"); |
|
402 } |
|
403 else if (aGroupId == INCLUDED_NON_SOURCE_FILE_TEST) |
|
404 { |
|
405 // Print out traces from included non-source file that is defined in trace.properties file |
|
406 Kern::Printf( "--------------TraceCompilerTesterBasic Included Non-Source File Test START----------------" ); |
|
407 |
|
408 TUint32 value1 = GetBigValue1000(); |
|
409 TUint32 value2 = GetBigValue2000(); |
|
410 |
|
411 Kern::Printf( "--------------TraceCompilerTesterBasic Included Non-Source File Test END----------------" ); |
|
412 } |
|
413 else if (aGroupId == KEKKONEN) |
|
414 { |
|
415 Kern::Printf( "--------------TraceCompilerTesterBasic Kekkonen START----------------" ); |
|
416 DTraceCompilerTesterCommon2* common2 = new DTraceCompilerTesterCommon2(); |
|
417 common2->Kekkonen(); |
|
418 delete common2; |
|
419 Kern::Printf( "--------------TraceCompilerTesterBasic Kekkonen END----------------" ); |
|
420 } |
|
421 } |
|
422 |
|
423 /** |
|
424 * Callback function for Trace Deactivation |
|
425 * |
|
426 * @param aComponentId |
|
427 * @param aGroupId |
|
428 */ |
|
429 void DTraceCompilerTesterBasic::TraceDeactivated(TUint32 aComponentId, |
|
430 TUint16 aGroupId) |
|
431 { |
|
432 Kern::Printf( |
|
433 "DTraceCompilerTesterBasic::TraceDeactivated - ComponentId = 0x%x, GroupId = 0x%x", |
|
434 aComponentId, aGroupId); |
|
435 } |
|
436 /** |
|
437 * The entry point for a standard extension. Creates Long Trace Tester extension. |
|
438 * |
|
439 * @return KErrNone, if successful |
|
440 */ |
|
441 DECLARE_STANDARD_EXTENSION() |
|
442 { |
|
443 |
|
444 TInt ret(KErrNone); |
|
445 |
|
446 DTraceCompilerTesterBasic* longTraceTester = |
|
447 new DTraceCompilerTesterBasic(); |
|
448 |
|
449 if (longTraceTester == NULL) |
|
450 { |
|
451 ret = KErrNoMemory; |
|
452 } |
|
453 |
|
454 if (ret == KErrNone) |
|
455 { |
|
456 // construct instance |
|
457 ret = longTraceTester->Construct(); |
|
458 } |
|
459 |
|
460 return ret; |
|
461 } |
|
462 // End of File |