35 namespace NUnitTesting_USBDI |
31 namespace NUnitTesting_USBDI |
36 { |
32 { |
37 |
33 |
38 CTestCaseController* CTestCaseController::NewL(CTestEngine& aTestEngine,TBool aHostRole) |
34 CTestCaseController* CTestCaseController::NewL(CTestEngine& aTestEngine,TBool aHostRole) |
39 { |
35 { |
40 OstTraceFunctionEntryExt( CTESTCASECONTROLLER_NEWL_ENTRY, 0 ); |
|
41 CTestCaseController* self = new (ELeave) CTestCaseController(aTestEngine,aHostRole); |
36 CTestCaseController* self = new (ELeave) CTestCaseController(aTestEngine,aHostRole); |
42 CleanupStack::PushL(self); |
37 CleanupStack::PushL(self); |
43 self->ConstructL(); |
38 self->ConstructL(); |
44 CleanupStack::Pop(self); |
39 CleanupStack::Pop(self); |
45 OstTraceFunctionExit1( CTESTCASECONTROLLER_NEWL_EXIT, ( TUint )( self ) ); |
|
46 return self; |
40 return self; |
47 } |
41 } |
48 |
42 |
49 |
43 |
50 CTestCaseController::CTestCaseController(CTestEngine& aTestEngine,TBool aHostRole) |
44 CTestCaseController::CTestCaseController(CTestEngine& aTestEngine,TBool aHostRole) |
51 : CActive(EPriorityStandard), |
45 : CActive(EPriorityStandard), |
52 iTestEngine(aTestEngine), |
46 iTestEngine(aTestEngine), |
53 iHostRole(aHostRole) |
47 iHostRole(aHostRole) |
54 { |
48 { |
55 OstTraceFunctionEntryExt( CTESTCASECONTROLLER_CTESTCASECONTROLLER_ENTRY, this ); |
|
56 // Add to current threads active scheduler |
49 // Add to current threads active scheduler |
57 CActiveScheduler::Add(this); |
50 CActiveScheduler::Add(this); |
58 OstTraceFunctionExit1( CTESTCASECONTROLLER_CTESTCASECONTROLLER_EXIT, this ); |
|
59 } |
51 } |
60 |
52 |
61 |
53 |
62 CTestCaseController::~CTestCaseController() |
54 CTestCaseController::~CTestCaseController() |
63 { |
55 { |
64 OstTraceFunctionEntry1( CTESTCASECONTROLLER_CTESTCASECONTROLLER_ENTRY_DUP01, this ); |
56 LOG_FUNC |
65 |
57 |
66 Cancel(); // Cancels any oustanding test cases |
58 Cancel(); // Cancels any oustanding test cases |
67 |
59 |
68 delete iTestPolicy; |
60 delete iTestPolicy; |
69 |
61 |
70 if(iHostRole) |
62 if(iHostRole) |
71 { |
63 { |
72 TInt err = User::FreeLogicalDevice(KHostDeviceInterfaceDriverName); |
64 TInt err = User::FreeLogicalDevice(KHostDeviceInterfaceDriverName); |
73 if(err != KErrNone) |
65 if(err != KErrNone) |
74 { |
66 { |
75 OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER, "<Error %d> Unable to unload driver: %S",err,KHostDeviceInterfaceDriverName()); |
67 RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KHostDeviceInterfaceDriverName); |
76 } |
68 } |
77 |
69 |
78 err = User::FreeLogicalDevice(KHostDeviceDriverName); |
70 err = User::FreeLogicalDevice(KHostDeviceDriverName); |
79 if(err != KErrNone) |
71 if(err != KErrNone) |
80 { |
72 { |
81 OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER_DUP01, "<Error %d> Unable to unload driver: %S",err,KHostDeviceDriverName()); |
73 RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KHostDeviceDriverName); |
82 } |
74 } |
83 |
75 |
84 err = User::FreeLogicalDevice(KOtgdiLddFileName); |
76 err = User::FreeLogicalDevice(KOtgdiLddFileName); |
85 if(err != KErrNone) |
77 if(err != KErrNone) |
86 { |
78 { |
87 OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER_DUP02, "<Error %d> Unable to unload driver: %S",err,KHostDeviceDriverName()); |
79 RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KHostDeviceDriverName); |
88 } |
80 } |
89 } |
81 } |
90 else |
82 else |
91 { |
83 { |
92 TInt err(User::FreeLogicalDevice(KClientDeviceDriverName)); |
84 TInt err(User::FreeLogicalDevice(KClientDeviceDriverName)); |
93 if(err != KErrNone) |
85 if(err != KErrNone) |
94 { |
86 { |
95 OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_DCTESTCASECONTROLLER_DUP03, "<Error %d> Unable to unload driver: %S",err,KClientDeviceDriverName()); |
87 RDebug::Printf("<Error %d> Unable to unload driver: %S",err,&KClientDeviceDriverName); |
96 } |
88 } |
97 } |
89 } |
98 OstTraceFunctionExit1( CTESTCASECONTROLLER_CTESTCASECONTROLLER_EXIT_DUP01, this ); |
|
99 } |
90 } |
100 |
91 |
101 void CTestCaseController::ConstructL() |
92 void CTestCaseController::ConstructL() |
102 { |
93 { |
103 OstTraceFunctionEntry1( CTESTCASECONTROLLER_CONSTRUCTL_ENTRY, this ); |
94 LOG_FUNC |
104 TInt err = KErrNone; |
95 TInt err = KErrNone; |
105 |
96 |
106 _LIT(KLoadingNamedDriverString,"loading driver: %S\n"); |
97 _LIT(KLoadingNamedDriverString,"loading driver: %S\n"); |
107 _LIT(KLoadedNamedDriverString,"loaded driver: %S\n"); |
98 _LIT(KLoadedNamedDriverString,"loaded driver: %S\n"); |
108 |
99 |
109 // loading drivers |
100 // loading drivers |
110 if(iHostRole) |
101 if(iHostRole) |
111 { |
102 { |
112 gtest.Printf(KLoadingNamedDriverString,&KHostDeviceDriverName); |
103 gtest.Printf(KLoadingNamedDriverString,&KHostDeviceDriverName); |
113 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL, "loading driver: %S\n", KHostDeviceDriverName()); |
|
114 // Load both Host USB device drivers |
104 // Load both Host USB device drivers |
115 err = User::LoadLogicalDevice(KHostDeviceDriverName); |
105 err = User::LoadLogicalDevice(KHostDeviceDriverName); |
116 gtest((err == KErrNone) || (err == KErrAlreadyExists)); |
106 gtest((err == KErrNone) || (err == KErrAlreadyExists)); |
117 gtest.Printf(KLoadedNamedDriverString,&KHostDeviceDriverName); |
107 gtest.Printf(KLoadedNamedDriverString,&KHostDeviceDriverName); |
118 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP01, "loaded driver: %S\n",KHostDeviceDriverName()); |
108 |
119 |
109 RDebug::Print(KLoadingNamedDriverString,&KHostDeviceInterfaceDriverName); |
120 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP02, "loading driver: %S\n",KHostDeviceInterfaceDriverName()); |
|
121 err = User::LoadLogicalDevice(KHostDeviceInterfaceDriverName); |
110 err = User::LoadLogicalDevice(KHostDeviceInterfaceDriverName); |
122 gtest((err == KErrNone) || (err == KErrAlreadyExists)); |
111 gtest((err == KErrNone) || (err == KErrAlreadyExists)); |
123 gtest.Printf(KLoadedNamedDriverString,&KHostDeviceInterfaceDriverName); |
112 gtest.Printf(KLoadedNamedDriverString,&KHostDeviceInterfaceDriverName); |
124 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP03, "loaded driver: %S\n",KHostDeviceInterfaceDriverName()); |
|
125 |
113 |
126 // If test cases are running USB host side actions |
114 // If test cases are running USB host side actions |
127 // then run each test case in its own thread |
115 // then run each test case in its own thread |
128 iTestPolicy = CThreadTestPolicy::NewL(); |
116 iTestPolicy = CThreadTestPolicy::NewL(); |
129 } |
117 } |
130 else |
118 else |
131 { |
119 { |
132 |
120 |
133 // Load the USB client driver |
121 // Load the USB client driver |
134 gtest.Printf(KLoadingNamedDriverString,&KClientDeviceDriverName); |
122 gtest.Printf(KLoadingNamedDriverString,&KClientDeviceDriverName); |
135 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP04, "loading driver: %S\n",KClientDeviceDriverName()); |
|
136 err = User::LoadLogicalDevice(KClientDeviceDriverName); |
123 err = User::LoadLogicalDevice(KClientDeviceDriverName); |
137 gtest((err == KErrNone) || (err == KErrAlreadyExists)); |
124 gtest((err == KErrNone) || (err == KErrAlreadyExists)); |
138 gtest.Printf(KLoadedNamedDriverString,&KClientDeviceDriverName); |
125 gtest.Printf(KLoadedNamedDriverString,&KClientDeviceDriverName); |
139 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_CONSTRUCTL_DUP05, "loaded driver: %S\n",KClientDeviceDriverName()); |
|
140 |
126 |
141 // Run each test case in the main thread as its not new API |
127 // Run each test case in the main thread as its not new API |
142 // and not expected to panic |
128 // and not expected to panic |
143 iTestPolicy = CBasicTestPolicy::NewL(); |
129 iTestPolicy = CBasicTestPolicy::NewL(); |
144 } |
130 } |
148 gtest.Next(iTestCaseId); |
134 gtest.Next(iTestCaseId); |
149 |
135 |
150 // Run the test case |
136 // Run the test case |
151 iTestPolicy->RunTestCaseL(iTestCaseId,iStatus); |
137 iTestPolicy->RunTestCaseL(iTestCaseId,iStatus); |
152 SetActive(); |
138 SetActive(); |
153 OstTraceFunctionExit1( CTESTCASECONTROLLER_CONSTRUCTL_EXIT, this ); |
|
154 } |
139 } |
155 |
140 |
156 |
141 |
157 void CTestCaseController::DoCancel() |
142 void CTestCaseController::DoCancel() |
158 { |
143 { |
159 OstTraceFunctionEntry1( CTESTCASECONTROLLER_DOCANCEL_ENTRY, this ); |
|
160 // Cancel the outstanding test case running |
144 // Cancel the outstanding test case running |
161 |
145 |
162 iTestPolicy->Cancel(); |
146 iTestPolicy->Cancel(); |
163 OstTraceFunctionExit1( CTESTCASECONTROLLER_DOCANCEL_EXIT, this ); |
|
164 } |
147 } |
165 |
148 |
166 |
149 |
167 void CTestCaseController::RunL() |
150 void CTestCaseController::RunL() |
168 { |
151 { |
169 OstTraceFunctionEntry1( CTESTCASECONTROLLER_RUNL_ENTRY, this ); |
152 LOG_FUNC |
170 |
153 |
171 // Retrieve the completion code of the last test case run |
154 // Retrieve the completion code of the last test case run |
172 TInt err(iStatus.Int()); |
155 TInt err(iStatus.Int()); |
173 |
156 |
174 TBuf<64> log; |
157 TBuf<64> log; |
175 if(err != KErrNone) |
158 if(err != KErrNone) |
176 { |
159 { |
177 iTestCasesResults.Append(EFalse); |
160 iTestCasesResults.Append(EFalse); |
178 gtest.Printf(_L("FAILED err=%d\n"),err); |
161 gtest.Printf(_L("FAILED err=%d\n"),err); |
179 OstTrace1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL, "FAILED err=%d\n",err); |
|
180 } |
162 } |
181 else |
163 else |
182 { |
164 { |
183 iTestCasesResults.Append(ETrue); |
165 iTestCasesResults.Append(ETrue); |
184 gtest.Printf(_L("PASSED\n")); |
166 gtest.Printf(_L("PASSED\n")); |
185 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP01, "PASSED\n"); |
|
186 } |
167 } |
187 |
168 |
188 // Get the identity of the next test case to run |
169 // Get the identity of the next test case to run |
189 |
170 |
190 err = iTestEngine.NextTestCaseId(iTestCaseId); |
171 err = iTestEngine.NextTestCaseId(iTestCaseId); |
191 if(err == KErrNone) |
172 if(err == KErrNone) |
192 { |
173 { |
193 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP02, "\n"); |
174 RDebug::Printf("\n"); |
194 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP03, "\n"); |
175 RDebug::Printf("\n"); |
195 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP04, "\n"); |
176 RDebug::Printf("\n"); |
196 gtest.Next(iTestCaseId); |
177 gtest.Next(iTestCaseId); |
197 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP05, " --------------------"); |
178 RDebug::Printf(" --------------------"); |
198 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP06, "\n"); |
179 RDebug::Printf("\n"); |
199 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP07, "\n"); |
180 RDebug::Printf("\n"); |
200 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP08, "\n"); |
181 RDebug::Printf("\n"); |
201 |
182 |
202 // Run the next test case |
183 // Run the next test case |
203 |
184 |
204 iTestPolicy->RunTestCaseL(iTestCaseId,iStatus); |
185 iTestPolicy->RunTestCaseL(iTestCaseId,iStatus); |
205 SetActive(); |
186 SetActive(); |
206 } |
187 } |
207 else if(err == KErrNotFound) |
188 else if(err == KErrNotFound) |
208 { |
189 { |
209 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP09, "All specified test cases performed"); |
190 RDebug::Printf("All specified test cases performed"); |
210 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP10, "----------------------------------"); |
191 RDebug::Printf("----------------------------------"); |
211 |
192 |
212 |
193 |
213 // count nb failures |
194 // count nb failures |
214 TUint nbFailures = 0; |
195 TUint nbFailures = 0; |
215 for(TInt test = 0; test < iTestCasesResults.Count() ; test++) |
196 for(TInt test = 0; test < iTestCasesResults.Count() ; test++) |
219 // ...even if it is a repeat. |
200 // ...even if it is a repeat. |
220 { |
201 { |
221 nbFailures++; |
202 nbFailures++; |
222 } |
203 } |
223 } |
204 } |
224 OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP11, "There are %d test case results, %d failures", iTestCasesResults.Count(), nbFailures); |
205 RDebug::Printf("There are %d test case results, %d failures", iTestCasesResults.Count(), nbFailures); |
225 |
206 |
226 // Number of tests that should have been run (including repeats) |
207 // Number of tests that should have been run (including repeats) |
227 TUint nbTests = iTestEngine.TestCasesIdentities().Count() * iTestEngine.NumRepeats(); |
208 TUint nbTests = iTestEngine.TestCasesIdentities().Count() * iTestEngine.NumRepeats(); |
228 if(nbTests!=iTestCasesResults.Count()) |
209 if(nbTests!=iTestCasesResults.Count()) |
229 { |
210 { |
230 OstTraceExt2(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP12, "The number of tests that should have been run (%d) DOES NOT EQUAL the actual number of tests run (%d).", |
211 RDebug::Printf("The number of tests that should have been run (%d) DOES NOT EQUAL the actual number of tests run (%d).", |
231 nbTests, iTestCasesResults.Count()); |
212 nbTests, iTestCasesResults.Count()); |
232 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP13, "This test suite will now PANIC!"); |
213 RDebug::Printf("This test suite will now PANIC!"); |
233 } |
214 } |
234 ASSERT((nbTests==iTestCasesResults.Count())); |
215 ASSERT((nbTests==iTestCasesResults.Count())); |
235 |
216 |
236 |
217 |
237 for(TInt repeat = 0; repeat < iTestEngine.NumRepeats() ; repeat++) |
218 for(TInt repeat = 0; repeat < iTestEngine.NumRepeats() ; repeat++) |
238 { |
219 { |
239 if(iTestEngine.NumRepeats() > 1) |
220 if(iTestEngine.NumRepeats() > 1) |
240 { |
221 { |
241 OstTrace1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP14, "Test Case Loop %d..........", repeat+1); |
222 RDebug::Printf("Test Case Loop %d..........", repeat+1); |
242 } |
223 } |
243 for(TInt testIndex = 0; testIndex < iTestEngine.TestCasesIdentities().Count() ; testIndex++) |
224 for(TInt testIndex = 0; testIndex < iTestEngine.TestCasesIdentities().Count() ; testIndex++) |
244 { |
225 { |
245 if(iTestCasesResults[testIndex]) |
226 if(iTestCasesResults[testIndex]) |
246 { |
227 { |
247 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP15, "Test Case: %S : PASSED", *(iTestEngine.TestCasesIdentities())[testIndex]); |
228 RDebug::Print(_L("Test Case: %S : PASSED"), (iTestEngine.TestCasesIdentities())[testIndex]); |
248 } |
229 } |
249 else |
230 else |
250 { |
231 { |
251 OstTraceExt1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP16, "Test Case: %S : FAILED", *(iTestEngine.TestCasesIdentities())[testIndex]); |
232 RDebug::Print(_L("Test Case: %S : FAILED"), (iTestEngine.TestCasesIdentities())[testIndex]); |
252 } |
233 } |
253 } |
234 } |
254 } |
235 } |
255 |
236 |
256 OstTrace0(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP17, "CActiveScheduler::Stop CTestCaseController::RunL"); |
237 RDebug::Printf("CActiveScheduler::Stop CTestCaseController::RunL"); |
257 CActiveScheduler::Stop(); |
238 CActiveScheduler::Stop(); |
258 } |
239 } |
259 else |
240 else |
260 { |
241 { |
261 OstTrace1(TRACE_NORMAL, CTESTCASECONTROLLER_RUNL_DUP18, "<Error %d> Unknown error from CTestEngine::NextTestCaseId",err); |
242 RDebug::Printf("<Error %d> Unknown error from CTestEngine::NextTestCaseId",err); |
262 User::Leave(err); |
243 User::Leave(err); |
263 } |
244 } |
264 OstTraceFunctionExit1( CTESTCASECONTROLLER_RUNL_EXIT, this ); |
|
265 } |
245 } |
266 |
246 |
267 |
247 |
268 TInt CTestCaseController::RunError(TInt aError) |
248 TInt CTestCaseController::RunError(TInt aError) |
269 { |
249 { |
270 OstTraceFunctionEntryExt( CTESTCASECONTROLLER_RUNERROR_ENTRY, this ); |
250 LOG_FUNC |
271 |
251 |
272 switch(aError) |
252 switch(aError) |
273 { |
253 { |
274 case KErrNoMemory: //follow through |
254 case KErrNoMemory: //follow through |
275 default: |
255 default: |
276 // Panic the test module |
256 // Panic the test module |
277 gtest(EFalse); |
257 gtest(EFalse); |
278 break; |
258 break; |
279 } |
259 } |
280 OstTraceFunctionExitExt( CTESTCASECONTROLLER_RUNERROR_EXIT, this, KErrNone ); |
|
281 return KErrNone; |
260 return KErrNone; |
282 } |
261 } |
283 |
262 |
284 |
263 |
285 } |
264 } |