|
1 // Copyright (c) 2007-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: |
|
14 // Example CTestStep derived implementation |
|
15 // |
|
16 |
|
17 |
|
18 |
|
19 /** |
|
20 @file filewriterteststeps.cpp |
|
21 */ |
|
22 |
|
23 #include "filewriterteststeps.h" |
|
24 #include <crashdatasave.h> |
|
25 |
|
26 TInt getFileWriter(CTestStep* logger, CCrashDataSave **dataSave) |
|
27 { |
|
28 TUid dataSaveUid = { 0x102831e4 }; |
|
29 TRAPD(err, *dataSave = CCrashDataSave::NewL(dataSaveUid)); |
|
30 switch(err) |
|
31 { |
|
32 case KErrNoMemory: |
|
33 logger->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrErr, (_L("KErrNoMemory\n"))); |
|
34 RDebug::Print(_L("KErrNoMemory\n")); |
|
35 break; |
|
36 |
|
37 case KErrNotFound: |
|
38 logger->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrErr, (_L("KErrNotFound\n"))); |
|
39 RDebug::Print(_L("KErrNotFound\n")); |
|
40 break; |
|
41 |
|
42 case KErrArgument: |
|
43 logger->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrErr, (_L("KErrArgument\n"))); |
|
44 RDebug::Print(_L("KErrArgument\n")); |
|
45 break; |
|
46 |
|
47 case KErrPermissionDenied: |
|
48 logger->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrErr, (_L("KErrPermissionDenied\n"))); |
|
49 RDebug::Print(_L("KErrPermissionDenied\n")); |
|
50 break; |
|
51 } |
|
52 |
|
53 return err; |
|
54 } |
|
55 |
|
56 CFileWriterTestStep1::~CFileWriterTestStep1() |
|
57 /** |
|
58 * Destructor |
|
59 */ |
|
60 { |
|
61 } |
|
62 |
|
63 CFileWriterTestStep1::CFileWriterTestStep1() |
|
64 /** |
|
65 * Constructor |
|
66 */ |
|
67 { |
|
68 // Call base class method to set up the human readable name for logging |
|
69 SetTestStepName(KFileWriterTestStep1); |
|
70 SetTestStepResult(EPass); |
|
71 } |
|
72 |
|
73 TVerdict CFileWriterTestStep1::doTestStepPreambleL() |
|
74 /** |
|
75 * @return - TVerdict code |
|
76 * Override of base class virtual |
|
77 */ |
|
78 { |
|
79 return TestStepResult(); |
|
80 } |
|
81 |
|
82 TVerdict CFileWriterTestStep1::doTestStepL() |
|
83 /** |
|
84 * @return - TVerdict code |
|
85 * Override of base class pure virtual |
|
86 */ |
|
87 { |
|
88 /* |
|
89 INFO_PRINTF1(_L("Testing GetFormattingPromptL")); |
|
90 RBuf format; |
|
91 CleanupClosePushL(format); |
|
92 |
|
93 format.Create(255); |
|
94 |
|
95 CCrashDataSave *writer = 0; |
|
96 testBooleanTrueL(getFileWriter(this, &writer) == KErrNone, (TText8*)__FILE__, __LINE__); |
|
97 CleanupStack::PushL(writer); |
|
98 INFO_PRINTF1(_L("File writer created")); |
|
99 |
|
100 TRAPD(err, writer->GetFormattingPromptL(format)); |
|
101 |
|
102 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
103 |
|
104 INFO_PRINTF1(_L("Got the format from GetFormattingPromptL")); |
|
105 INFO_PRINTF2(_L("The format is: %S"), &format); |
|
106 |
|
107 _LIT(KPluginDescription, "Symbian Elf Core Dump Writer"); |
|
108 testBooleanTrue(format == KPluginDescription, (TText8*)__FILE__, __LINE__); |
|
109 |
|
110 CleanupStack::PopAndDestroy(writer); |
|
111 INFO_PRINTF1(_L("File writer destroyed and popped")); |
|
112 |
|
113 CleanupStack::PopAndDestroy(); |
|
114 |
|
115 */ |
|
116 return TestStepResult(); |
|
117 } |
|
118 |
|
119 TVerdict CFileWriterTestStep1::doTestStepPostambleL() |
|
120 /** |
|
121 * @return - TVerdict code |
|
122 * Override of base class virtual |
|
123 */ |
|
124 { |
|
125 return TestStepResult(); |
|
126 } |
|
127 |
|
128 // |
|
129 |
|
130 CFileWriterTestStep2::~CFileWriterTestStep2() |
|
131 /** |
|
132 * Destructor |
|
133 */ |
|
134 { |
|
135 } |
|
136 CFileWriterTestStep2::CFileWriterTestStep2() |
|
137 /** |
|
138 * Constructor |
|
139 */ |
|
140 { |
|
141 // Call base class method to set up the human readable name for logging |
|
142 SetTestStepName(KFileWriterTestStep2); |
|
143 SetTestStepResult(EPass); |
|
144 } |
|
145 |
|
146 TVerdict CFileWriterTestStep2::doTestStepPreambleL() |
|
147 /** |
|
148 * @return - TVerdict code |
|
149 * Override of base class virtual |
|
150 */ |
|
151 { |
|
152 return TestStepResult(); |
|
153 } |
|
154 |
|
155 TVerdict CFileWriterTestStep2::doTestStepL() |
|
156 /** |
|
157 * @return - TVerdict code |
|
158 * Override of base class pure virtual |
|
159 */ |
|
160 { |
|
161 /* |
|
162 INFO_PRINTF1(_L("Testing FormatL")); |
|
163 |
|
164 CCrashDataSave *writer = 0; |
|
165 testBooleanTrueL(getFileWriter(this, &writer) == KErrNone, (TText8*)__FILE__, __LINE__); |
|
166 CleanupStack::PushL(writer); |
|
167 INFO_PRINTF1(_L("File writer created")); |
|
168 |
|
169 _LIT(KNewFormat, "New format"); |
|
170 |
|
171 TRAPD(err, writer->FormatL(KNewFormat)); |
|
172 INFO_PRINTF1(_L("Set new format")); |
|
173 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
174 |
|
175 RBuf format; |
|
176 format.Create(255); |
|
177 CleanupClosePushL(format); |
|
178 |
|
179 TRAP(err, writer->GetFormattingPromptL(format)); |
|
180 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
181 testBooleanTrue(format.Compare(KNewFormat) == 0, (TText8*)__FILE__, __LINE__); |
|
182 |
|
183 CleanupStack::PopAndDestroy(); |
|
184 CleanupStack::PopAndDestroy(writer); |
|
185 |
|
186 */ |
|
187 return TestStepResult(); |
|
188 } |
|
189 |
|
190 TVerdict CFileWriterTestStep2::doTestStepPostambleL() |
|
191 /** |
|
192 * @return - TVerdict code |
|
193 * Override of base class virtual |
|
194 */ |
|
195 { |
|
196 return TestStepResult(); |
|
197 } |
|
198 // |
|
199 |
|
200 CFileWriterTestStep3::~CFileWriterTestStep3() |
|
201 /** |
|
202 * Destructor |
|
203 */ |
|
204 { |
|
205 } |
|
206 |
|
207 CFileWriterTestStep3::CFileWriterTestStep3() |
|
208 /** |
|
209 * Constructor |
|
210 */ |
|
211 { |
|
212 // Call base class method to set up the human readable name for logging |
|
213 SetTestStepName(KFileWriterTestStep3); |
|
214 SetTestStepResult(EPass); |
|
215 } |
|
216 |
|
217 TVerdict CFileWriterTestStep3::doTestStepPreambleL() |
|
218 /** |
|
219 * @return - TVerdict code |
|
220 * Override of base class virtual |
|
221 */ |
|
222 { |
|
223 return TestStepResult(); |
|
224 } |
|
225 |
|
226 TVerdict CFileWriterTestStep3::doTestStepL() |
|
227 /** |
|
228 * @return - TVerdict code |
|
229 * Override of base class pure virtual |
|
230 */ |
|
231 { |
|
232 INFO_PRINTF1(_L("Testing OpenL")); |
|
233 CCrashDataSave *writer = 0; |
|
234 testBooleanTrueL(getFileWriter(this, &writer) == KErrNone, (TText8*)__FILE__, __LINE__); |
|
235 CleanupStack::PushL(writer); |
|
236 INFO_PRINTF1(_L("File writer created")); |
|
237 |
|
238 TRAPD(err, writer->OpenL(_L("c:\\dumpfiles\\file1"))); |
|
239 INFO_PRINTF2(_L("Opened file c:\\dumpfiles\\file1 and the error code back was (should be 0): %d"), err); |
|
240 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
241 TRAP(err, writer->CloseL()); |
|
242 |
|
243 User::After(500000); |
|
244 INFO_PRINTF1(_L("Create 10 more files")); |
|
245 |
|
246 for (TInt i = 0; i < 10; i++) |
|
247 { |
|
248 TBuf<255> filename; |
|
249 filename.Format(_L("C:\\dumpfiles\\file%d"), i); |
|
250 TRAP(err, writer->OpenL(filename)); |
|
251 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
252 INFO_PRINTF2(_L("Opened file %d"), i ); |
|
253 |
|
254 TRAP(err, writer->CloseL() ); |
|
255 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
256 INFO_PRINTF2(_L("Closed file %d"), i); |
|
257 } |
|
258 |
|
259 CleanupStack::PopAndDestroy(writer); |
|
260 return TestStepResult(); |
|
261 } |
|
262 |
|
263 TVerdict CFileWriterTestStep3::doTestStepPostambleL() |
|
264 /** |
|
265 * @return - TVerdict code |
|
266 * Override of base class virtual |
|
267 */ |
|
268 { |
|
269 return TestStepResult(); |
|
270 } |
|
271 |
|
272 |
|
273 CFileWriterTestStep4::~CFileWriterTestStep4() |
|
274 /** |
|
275 * Destructor |
|
276 */ |
|
277 { |
|
278 } |
|
279 |
|
280 CFileWriterTestStep4::CFileWriterTestStep4() |
|
281 /** |
|
282 * Constructor |
|
283 */ |
|
284 { |
|
285 // Call base class method to set up the human readable name for logging |
|
286 SetTestStepName(KFileWriterTestStep4); |
|
287 } |
|
288 |
|
289 TVerdict CFileWriterTestStep4::doTestStepPreambleL() |
|
290 /** |
|
291 * @return - TVerdict code |
|
292 * Override of base class virtual |
|
293 */ |
|
294 { |
|
295 return TestStepResult(); |
|
296 } |
|
297 |
|
298 TVerdict CFileWriterTestStep4::doTestStepL() |
|
299 /** |
|
300 * @return - TVerdict code |
|
301 * Override of base class pure virtual |
|
302 */ |
|
303 { |
|
304 INFO_PRINTF1(_L("Testing CloseL")); |
|
305 CCrashDataSave *writer = 0; |
|
306 testBooleanTrueL(getFileWriter(this, &writer) == KErrNone, (TText8*)__FILE__, __LINE__); |
|
307 CleanupStack::PushL(writer); |
|
308 INFO_PRINTF1(_L("File writer created")); |
|
309 |
|
310 |
|
311 TRAPD(err, writer->OpenL(_L("c:\\dumpfiles\\file1"))); |
|
312 INFO_PRINTF2(_L("Opened file file 1 and the error code back was (should be 0): %d"), err); |
|
313 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
314 |
|
315 |
|
316 TRAP(err, writer->CloseL()); |
|
317 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
318 INFO_PRINTF1(_L("Closed file")); |
|
319 |
|
320 CleanupStack::PopAndDestroy(writer); |
|
321 return TestStepResult(); |
|
322 } |
|
323 |
|
324 TVerdict CFileWriterTestStep4::doTestStepPostambleL() |
|
325 /** |
|
326 * @return - TVerdict code |
|
327 * Override of base class virtual |
|
328 */ |
|
329 { |
|
330 return TestStepResult(); |
|
331 } |
|
332 |
|
333 |
|
334 CFileWriterTestStep5::~CFileWriterTestStep5() |
|
335 /** |
|
336 * Destructor |
|
337 */ |
|
338 { |
|
339 } |
|
340 |
|
341 CFileWriterTestStep5::CFileWriterTestStep5() |
|
342 /** |
|
343 * Constructor |
|
344 */ |
|
345 { |
|
346 // Call base class method to set up the human readable name for logging |
|
347 SetTestStepName(KFileWriterTestStep5); |
|
348 } |
|
349 |
|
350 TVerdict CFileWriterTestStep5::doTestStepPreambleL() |
|
351 /** |
|
352 * @return - TVerdict code |
|
353 * Override of base class virtual |
|
354 */ |
|
355 { |
|
356 return TestStepResult(); |
|
357 } |
|
358 |
|
359 TVerdict CFileWriterTestStep5::doTestStepL() |
|
360 /** |
|
361 * @return - TVerdict code |
|
362 * Override of base class pure virtual |
|
363 */ |
|
364 { |
|
365 INFO_PRINTF1(_L("Testing WriteL")); |
|
366 CCrashDataSave *writer = 0; |
|
367 testBooleanTrueL(getFileWriter(this, &writer) == KErrNone, (TText8*)__FILE__, __LINE__); |
|
368 CleanupStack::PushL(writer); |
|
369 INFO_PRINTF1(_L("File writer created")); |
|
370 |
|
371 TRAPD(err, writer->OpenL(_L("c:\\dumpfiles\\file1") )); |
|
372 INFO_PRINTF2(_L("Opened file file 1 and the error code back was (should be 0): %d"), err); |
|
373 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
374 |
|
375 RBuf8 buf; |
|
376 CleanupClosePushL(buf); |
|
377 buf.Create(100); |
|
378 buf = _L8("1234567890123456789012345678901234567890123456789012345678901234567890"); |
|
379 |
|
380 TAny* ptr = static_cast<TAny*>(const_cast<TUint8*>(buf.Ptr())); |
|
381 |
|
382 TRAP(err, writer->WriteL( 0, ptr, buf.Length())); |
|
383 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
384 INFO_PRINTF1(_L("Wrote 70 bytes")); |
|
385 |
|
386 TRAP(err, writer->WriteL( 0x100, ptr, buf.Length())); |
|
387 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
388 INFO_PRINTF1(_L("Wrote 70 bytes start at pos 100")); |
|
389 |
|
390 TRAP(err, writer->WriteL( -1, ptr, buf.Length())); |
|
391 testBooleanTrue(err != KErrNone, (TText8*)__FILE__, __LINE__); |
|
392 INFO_PRINTF2(_L("Negative test: Tried to write 70 bytes start at -1, leave code %d"), err); |
|
393 |
|
394 TRAP(err, writer->CloseL()); |
|
395 testBooleanTrue(err == KErrNone, (TText8*)__FILE__, __LINE__); |
|
396 INFO_PRINTF1(_L("Closed file")); |
|
397 |
|
398 CleanupStack::PopAndDestroy(); // buf |
|
399 CleanupStack::PopAndDestroy(writer); |
|
400 return TestStepResult(); |
|
401 } |
|
402 |
|
403 TVerdict CFileWriterTestStep5::doTestStepPostambleL() |
|
404 /** |
|
405 * @return - TVerdict code |
|
406 * Override of base class virtual |
|
407 */ |
|
408 { |
|
409 return TestStepResult(); |
|
410 } |