24
|
1 |
// Copyright (c) 2008-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 |
//
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
/**
|
|
19 |
@file The TEFUnit test suite for SetUpMenu in the SAT.
|
|
20 |
*/
|
|
21 |
|
|
22 |
#include <cstktsy/bertlv_defs.h>
|
|
23 |
#include <etel.h>
|
|
24 |
#include <etelmm.h>
|
|
25 |
#include <satcs.h>
|
|
26 |
#include <ctsy/ltsy/mltsydispatchsatinterface.h>
|
|
27 |
#include <test/mockltsyindicatorids.h>
|
|
28 |
#include <test/tmockltsydata.h>
|
|
29 |
|
|
30 |
#include "ccsatsetupmenufu.h"
|
|
31 |
|
|
32 |
static const TInt KDelay = 10;
|
|
33 |
|
|
34 |
CTestSuite* CCSatSetUpMenuFU::CreateSuiteL(const TDesC& aName)
|
|
35 |
{
|
|
36 |
SUB_SUITE;
|
|
37 |
|
|
38 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001L);
|
|
39 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001bL);
|
|
40 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001cL);
|
|
41 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001dL);
|
|
42 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001eL);
|
|
43 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001fL);
|
|
44 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001gL);
|
|
45 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001hL);
|
|
46 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001iL);
|
|
47 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0001jL);
|
|
48 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0002L);
|
|
49 |
ADD_TEST_STEP_ISO_CPP(CCSatSetUpMenuFU, TestNotifySetUpMenuPCmd0004L);
|
|
50 |
|
|
51 |
END_SUITE;
|
|
52 |
}
|
|
53 |
|
|
54 |
|
|
55 |
//
|
|
56 |
// Actual test cases
|
|
57 |
//
|
|
58 |
|
|
59 |
|
|
60 |
/**
|
|
61 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001
|
|
62 |
@SYMPREQ 1780
|
|
63 |
@SYMComponent telephony_csat
|
|
64 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd
|
|
65 |
@SYMTestPriority High
|
|
66 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
67 |
@SYMTestExpectedResults Pass
|
|
68 |
@SYMTestType CT
|
|
69 |
*/
|
|
70 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001L()
|
|
71 |
{
|
|
72 |
OpenEtelServerL(EUseExtendedError);
|
|
73 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
74 |
OpenPhoneL();
|
|
75 |
OpenSatL();
|
|
76 |
|
|
77 |
RBuf8 data;
|
|
78 |
CleanupClosePushL(data);
|
|
79 |
|
|
80 |
TUint8 KPCmdNumber = 1;
|
|
81 |
|
|
82 |
// prepare tlv buffer for serialisation
|
|
83 |
TTlv tlv;
|
|
84 |
tlv.Begin(KBerTlvProactiveSimCommandTag);
|
|
85 |
tlv.AddTag(KTlvCommandDetailsTag);
|
|
86 |
tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber
|
|
87 |
tlv.AddByte(KSetUpMenu); //ETLV_TypeOfCommand
|
|
88 |
tlv.AddByte(0); //ETLV_CommandQualifier
|
|
89 |
|
|
90 |
tlv.AddTag(KTlvDeviceIdentityTag);
|
|
91 |
tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity
|
|
92 |
tlv.AddByte(KDisplay); //ETLV_DestinationDeviceIdentity
|
|
93 |
|
|
94 |
tlv.AddTag(KTlvAlphaIdentifierTag);
|
|
95 |
_LIT8(KSetupMenuTest8,"Menu AlphaIdent");
|
|
96 |
tlv.AddData(KSetupMenuTest8);//ETLV_AlphaIdentifier
|
|
97 |
|
|
98 |
tlv.AddTag(KTlvItemTag);
|
|
99 |
tlv.AddByte(77); //item identifier
|
|
100 |
tlv.AddData(_L8("Item AlphaIdent1"));
|
|
101 |
|
|
102 |
TPtrC8 tlvDsc = tlv.End();
|
|
103 |
TDesC8* tlvDscPtr = &tlvDsc;
|
|
104 |
|
|
105 |
TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);
|
|
106 |
|
|
107 |
//-------------------------------------------------------------------------
|
|
108 |
// TEST B: failure on completion of pending request from LTSY->CTSY
|
|
109 |
//-------------------------------------------------------------------------
|
|
110 |
|
|
111 |
// tell Mock about forthcoming RSat::NotifySetUpMenuPCmd
|
|
112 |
TUint8 pcmdCode = KSetUpMenu;
|
|
113 |
TMockLtsyData1<TUint8> expLtsyData(pcmdCode);
|
|
114 |
expLtsyData.SerialiseL(data);
|
|
115 |
iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);
|
|
116 |
data.Close();
|
|
117 |
|
|
118 |
RSat::TSetUpMenuV2 setupMenu;
|
|
119 |
RSat::TSetUpMenuV2Pckg setpPck(setupMenu);
|
|
120 |
TRequestStatus stat;
|
|
121 |
iSat.NotifySetUpMenuPCmd(stat, setpPck);
|
|
122 |
|
|
123 |
tlvDscPack.SerialiseL(data);
|
|
124 |
iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, KErrGeneral, data, KDelay);
|
|
125 |
|
|
126 |
User::WaitForRequest(stat);
|
|
127 |
ASSERT_EQUALS(KErrGeneral, stat.Int());
|
|
128 |
|
|
129 |
AssertMockLtsyStatusL();
|
|
130 |
|
|
131 |
//-------------------------------------------------------------------------
|
|
132 |
// TEST E: Unsolicited completion of RSat::NotifySetUpMenuPCmd from LTSY.
|
|
133 |
//-------------------------------------------------------------------------
|
|
134 |
|
|
135 |
TRequestStatus mockLtsyStatus;
|
|
136 |
iMockLTSY.NotifyTerminated(mockLtsyStatus);
|
|
137 |
|
|
138 |
tlvDscPack.SerialiseL(data);
|
|
139 |
iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, KErrNone, data, KDelay);
|
|
140 |
data.Close();
|
|
141 |
|
|
142 |
RSat::TAdditionalInfo addInfo;
|
|
143 |
addInfo.Zero();
|
|
144 |
addInfo.Append(RSat::KNoSpecificMeProblem);
|
|
145 |
|
|
146 |
PrepareTerminalResponseMockDataL( KPCmdNumber, KSetUpMenu, 0,
|
|
147 |
addInfo, RSat::KMeUnableToProcessCmd, KNullDesC8);
|
|
148 |
|
|
149 |
User::WaitForRequest(mockLtsyStatus);
|
|
150 |
AssertMockLtsyStatusL();
|
|
151 |
ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
|
|
152 |
|
|
153 |
// test C - Successful completion request of
|
|
154 |
// RSat::NotifySetFramesPCmd() - implemented in 0001b()-0001i() functions
|
|
155 |
|
|
156 |
CleanupStack::PopAndDestroy(2, this); // data, this
|
|
157 |
}
|
|
158 |
|
|
159 |
|
|
160 |
/**
|
|
161 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001b
|
|
162 |
@SYMPREQ 1780
|
|
163 |
@SYMComponent telephony_csat
|
|
164 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (help request support) and ENVELOPE MENU SELECTION
|
|
165 |
@SYMTestPriority High
|
|
166 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
167 |
@SYMTestExpectedResults Pass
|
|
168 |
@SYMTestType CT
|
|
169 |
*/
|
|
170 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001bL()
|
|
171 |
{
|
|
172 |
OpenEtelServerL(EUseExtendedError);
|
|
173 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
174 |
OpenPhoneL();
|
|
175 |
OpenSatL();
|
|
176 |
|
|
177 |
// Expected Sequence 2.1
|
|
178 |
//(SET UP MENU and MENU SELECTION, with Help Request, Replace and Remove a Toolkit Menu)
|
|
179 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.2.4.2, Expected Sequence 2.1.
|
|
180 |
|
|
181 |
TUint8 cmdNumber = 1;
|
|
182 |
const TInt KNumItems = 4;
|
|
183 |
|
|
184 |
TUint8 ids[KNumItems] = {1, 2, 3, 4};
|
|
185 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2"), _L8("Item 3"), _L8("Item 4")};
|
|
186 |
|
|
187 |
SetUpMenuL( cmdNumber, KHelpAvailabilityMask, _L8("Toolkit Menu"), KNumItems, ids, idNames );
|
|
188 |
|
|
189 |
//generate the terminal response
|
|
190 |
RSat::TSetUpMenuRspV1 resp;
|
|
191 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
192 |
|
|
193 |
resp.iGeneralResult = RSat::KSuccess;
|
|
194 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
195 |
resp.iAdditionalInfo.Zero();
|
|
196 |
resp.SetPCmdNumber(cmdNumber);
|
|
197 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, KHelpAvailabilityMask, RSat::ESetUpMenu,
|
|
198 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
199 |
AssertMockLtsyStatusL();
|
|
200 |
|
|
201 |
// now end session
|
|
202 |
EndProactiveSimSessionL();
|
|
203 |
AssertMockLtsyStatusL();
|
|
204 |
|
|
205 |
// select 2
|
|
206 |
SelectMenuItemL(ids[1], ETrue);
|
|
207 |
AssertMockLtsyStatusL();
|
|
208 |
|
|
209 |
CleanupStack::PopAndDestroy(1, this);
|
|
210 |
}
|
|
211 |
|
|
212 |
|
|
213 |
/**
|
|
214 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001c
|
|
215 |
@SYMPREQ 1780
|
|
216 |
@SYMComponent telephony_csat
|
|
217 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (next action support) and ENVELOPE MENU SELECTION
|
|
218 |
@SYMTestPriority High
|
|
219 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
220 |
@SYMTestExpectedResults Pass
|
|
221 |
@SYMTestType CT
|
|
222 |
*/
|
|
223 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001cL()
|
|
224 |
{
|
|
225 |
OpenEtelServerL(EUseExtendedError);
|
|
226 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
227 |
OpenPhoneL();
|
|
228 |
OpenSatL();
|
|
229 |
|
|
230 |
// Expected Sequence 3.1
|
|
231 |
//(SET UP MENU, next action indicator "Send SM", "Set Up Call", "LaunchBrowser",
|
|
232 |
//"Provide Local Information", successful)
|
|
233 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.3.4.2, Expected Sequence 3.1.
|
|
234 |
|
|
235 |
TUint8 cmdNumber = 1;
|
|
236 |
TUint8 noPref(0); // no selection preferences
|
|
237 |
const TInt KNumItems = 4;
|
|
238 |
|
|
239 |
TUint8 ids[KNumItems] = {1, 2, 3, 4};
|
|
240 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2"), _L8("Item 3"), _L8("Item 4")};
|
|
241 |
TUint8 actions[KNumItems] = {KSendShortMessage, KSetUpCall, KLaunchBrowser, KProvideLocalInformation};
|
|
242 |
|
|
243 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), KNumItems, ids, idNames, actions );
|
|
244 |
|
|
245 |
//generate the terminal response
|
|
246 |
RSat::TSetUpMenuRspV1 resp;
|
|
247 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
248 |
|
|
249 |
resp.iGeneralResult = RSat::KSuccess;
|
|
250 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
251 |
resp.iAdditionalInfo.Zero();
|
|
252 |
resp.SetPCmdNumber(cmdNumber);
|
|
253 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
254 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
255 |
AssertMockLtsyStatusL();
|
|
256 |
|
|
257 |
// now end session
|
|
258 |
EndProactiveSimSessionL();
|
|
259 |
AssertMockLtsyStatusL();
|
|
260 |
|
|
261 |
// select 2
|
|
262 |
SelectMenuItemL(ids[1], ETrue);
|
|
263 |
AssertMockLtsyStatusL();
|
|
264 |
|
|
265 |
CleanupStack::PopAndDestroy(1, this);
|
|
266 |
}
|
|
267 |
|
|
268 |
|
|
269 |
|
|
270 |
/**
|
|
271 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001d
|
|
272 |
@SYMPREQ 1780
|
|
273 |
@SYMComponent telephony_csat
|
|
274 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (display of icons) and ENVELOPE MENU SELECTION
|
|
275 |
@SYMTestPriority High
|
|
276 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
277 |
@SYMTestExpectedResults Pass
|
|
278 |
@SYMTestType CT
|
|
279 |
*/
|
|
280 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001dL()
|
|
281 |
{
|
|
282 |
OpenEtelServerL(EUseExtendedError);
|
|
283 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
284 |
OpenPhoneL();
|
|
285 |
OpenSatL();
|
|
286 |
|
|
287 |
// Expected Sequence 4.1A
|
|
288 |
//(SET UP MENU, BASIC ICON NOT SELF EXPLANATORY in ALPHA ID and ITEMS DATA OBJECTS, successful)
|
|
289 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.4.4.2, Expected Sequence 4.1A.
|
|
290 |
|
|
291 |
TUint8 cmdNumber = 1;
|
|
292 |
TUint8 noPref(0); // no preferences
|
|
293 |
const TInt KNumItems = 3;
|
|
294 |
|
|
295 |
TUint8 ids[KNumItems] = {1, 2, 3};
|
|
296 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2"), _L8("Item 3")};
|
|
297 |
TUint8 iconList[KNumItems] = {5, 5, 5};
|
|
298 |
|
|
299 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), KNumItems, ids, idNames, NULL,
|
|
300 |
RSat::ENotSelfExplanatory, 1, RSat::ENotSelfExplanatory, iconList );
|
|
301 |
|
|
302 |
//generate the terminal response
|
|
303 |
RSat::TSetUpMenuRspV1 resp;
|
|
304 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
305 |
|
|
306 |
resp.iGeneralResult = RSat::KSuccess;
|
|
307 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
308 |
resp.iAdditionalInfo.Zero();
|
|
309 |
resp.SetPCmdNumber(cmdNumber);
|
|
310 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
311 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
312 |
AssertMockLtsyStatusL();
|
|
313 |
|
|
314 |
// now end session
|
|
315 |
EndProactiveSimSessionL();
|
|
316 |
AssertMockLtsyStatusL();
|
|
317 |
|
|
318 |
// select 2
|
|
319 |
SelectMenuItemL(ids[1], ETrue);
|
|
320 |
AssertMockLtsyStatusL();
|
|
321 |
|
|
322 |
//Expected Sequence 4.1B
|
|
323 |
//(SET UP MENU, BASIC ICON NOT SELF EXPLANATORY in ALPHA ID and ITEMS DATA OBJECTS,
|
|
324 |
//requested icon could not be displayed)
|
|
325 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.4.4.2, Expected Sequence 4.1B.
|
|
326 |
|
|
327 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), KNumItems, ids, idNames, NULL,
|
|
328 |
RSat::ENotSelfExplanatory, 1, RSat::ENotSelfExplanatory, iconList );
|
|
329 |
|
|
330 |
//generate the terminal response
|
|
331 |
resp.iGeneralResult = RSat::KSuccessRequestedIconNotDisplayed;
|
|
332 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
333 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
334 |
AssertMockLtsyStatusL();
|
|
335 |
|
|
336 |
// now end session
|
|
337 |
EndProactiveSimSessionL();
|
|
338 |
AssertMockLtsyStatusL();
|
|
339 |
|
|
340 |
// select 2
|
|
341 |
SelectMenuItemL(ids[1], ETrue);
|
|
342 |
AssertMockLtsyStatusL();
|
|
343 |
|
|
344 |
//Expected Sequence 4.2A (SET UP MENU, BASIC ICON SELF EXPLANATORY in ALPHA ID and ITEMS
|
|
345 |
//DATA OBJECTS, successful)
|
|
346 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.4.4.2, Expected Sequence 4.2A.
|
|
347 |
|
|
348 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), KNumItems, ids, idNames, NULL,
|
|
349 |
RSat::ESelfExplanatory, 1, RSat::ESelfExplanatory, iconList );
|
|
350 |
|
|
351 |
//generate the terminal response
|
|
352 |
resp.iGeneralResult = RSat::KSuccess;
|
|
353 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu, respPck,
|
|
354 |
resp.iAdditionalInfo, resp.iGeneralResult);
|
|
355 |
AssertMockLtsyStatusL();
|
|
356 |
|
|
357 |
// now end session
|
|
358 |
EndProactiveSimSessionL();
|
|
359 |
AssertMockLtsyStatusL();
|
|
360 |
|
|
361 |
// select 2
|
|
362 |
SelectMenuItemL(ids[1], ETrue);
|
|
363 |
AssertMockLtsyStatusL();
|
|
364 |
|
|
365 |
//Expected Sequence 4.2B (SET UP MENU, BASIC ICON SELF EXPLANATORY in ALPHA ID and ITEMS
|
|
366 |
//DATA OBJECTS, requested icon could not be displayed)
|
|
367 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.4.4.2, Expected Sequence 4.2B.
|
|
368 |
|
|
369 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), KNumItems, ids, idNames, NULL,
|
|
370 |
RSat::ESelfExplanatory, 1, RSat::ESelfExplanatory, iconList );
|
|
371 |
|
|
372 |
//generate the terminal response
|
|
373 |
resp.iGeneralResult = RSat::KSuccessRequestedIconNotDisplayed;
|
|
374 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
375 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
376 |
AssertMockLtsyStatusL();
|
|
377 |
|
|
378 |
// now end session
|
|
379 |
EndProactiveSimSessionL();
|
|
380 |
AssertMockLtsyStatusL();
|
|
381 |
|
|
382 |
// select 2
|
|
383 |
SelectMenuItemL(ids[1], ETrue);
|
|
384 |
AssertMockLtsyStatusL();
|
|
385 |
|
|
386 |
CleanupStack::PopAndDestroy(1, this);
|
|
387 |
}
|
|
388 |
|
|
389 |
|
|
390 |
/**
|
|
391 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001e
|
|
392 |
@SYMPREQ 1780
|
|
393 |
@SYMComponent telephony_csat
|
|
394 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (soft keys support) and ENVELOPE MENU SELECTION
|
|
395 |
@SYMTestPriority High
|
|
396 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
397 |
@SYMTestExpectedResults Pass
|
|
398 |
@SYMTestType CT
|
|
399 |
*/
|
|
400 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001eL()
|
|
401 |
{
|
|
402 |
OpenEtelServerL(EUseExtendedError);
|
|
403 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
404 |
OpenPhoneL();
|
|
405 |
OpenSatL();
|
|
406 |
|
|
407 |
// Expected Sequence 5.1 (SET UP MENU, SOFT KEY PREFERRED, successful)
|
|
408 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.5.4.2, Expected Sequence 5.1.
|
|
409 |
|
|
410 |
TUint8 cmdNumber = 1;
|
|
411 |
const TInt KNumItems = 2;
|
|
412 |
|
|
413 |
TUint8 ids[KNumItems] = {1, 2};
|
|
414 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2")};
|
|
415 |
|
|
416 |
SetUpMenuL( cmdNumber, KSelectionUsingSoftKey, _L8("Toolkit Menu"), KNumItems, ids, idNames );
|
|
417 |
|
|
418 |
//generate the terminal response
|
|
419 |
RSat::TSetUpMenuRspV1 resp;
|
|
420 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
421 |
|
|
422 |
resp.iGeneralResult = RSat::KSuccess;
|
|
423 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
424 |
resp.iAdditionalInfo.Zero();
|
|
425 |
resp.SetPCmdNumber(cmdNumber);
|
|
426 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, KSelectionUsingSoftKey, RSat::ESetUpMenu,
|
|
427 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
428 |
AssertMockLtsyStatusL();
|
|
429 |
|
|
430 |
// now end session
|
|
431 |
EndProactiveSimSessionL();
|
|
432 |
|
|
433 |
// select second item
|
|
434 |
SelectMenuItemL(ids[1]);
|
|
435 |
|
|
436 |
AssertMockLtsyStatusL();
|
|
437 |
|
|
438 |
CleanupStack::PopAndDestroy(1, this);
|
|
439 |
}
|
|
440 |
|
|
441 |
|
|
442 |
/**
|
|
443 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001f
|
|
444 |
@SYMPREQ 1780
|
|
445 |
@SYMComponent telephony_csat
|
|
446 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (help request support) and ENVELOPE MENU SELECTION
|
|
447 |
@SYMTestPriority High
|
|
448 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
449 |
@SYMTestExpectedResults Pass
|
|
450 |
@SYMTestType CT
|
|
451 |
*/
|
|
452 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001fL()
|
|
453 |
{
|
|
454 |
OpenEtelServerL(EUseExtendedError);
|
|
455 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
456 |
OpenPhoneL();
|
|
457 |
OpenSatL();
|
|
458 |
|
|
459 |
// Check SATTSY for handling error value
|
|
460 |
|
|
461 |
TUint8 cmdNumber = 1;
|
|
462 |
const TInt KNumItems = 4;
|
|
463 |
|
|
464 |
TUint8 ids[KNumItems] = {1, 2, 3, 4};
|
|
465 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2"), _L8("Item 3"), _L8("Item 4")};
|
|
466 |
|
|
467 |
SetUpMenuL( cmdNumber, KHelpAvailabilityMask, _L8("Toolkit Menu"), KNumItems, ids, idNames );
|
|
468 |
|
|
469 |
//generate the terminal response
|
|
470 |
RSat::TSetUpMenuRspV1 resp;
|
|
471 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
472 |
|
|
473 |
resp.iGeneralResult = RSat::KSuccess;
|
|
474 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
475 |
resp.iAdditionalInfo.Zero();
|
|
476 |
resp.SetPCmdNumber(cmdNumber);
|
|
477 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, KHelpAvailabilityMask, RSat::ESetUpMenu,
|
|
478 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
479 |
AssertMockLtsyStatusL();
|
|
480 |
|
|
481 |
// now end session
|
|
482 |
EndProactiveSimSessionL();
|
|
483 |
AssertMockLtsyStatusL();
|
|
484 |
|
|
485 |
// select 2
|
|
486 |
// now tell Mock to return KErrUnknown when dispatching forthcoming RSat::MenuSelection()
|
|
487 |
SelectMenuItemL(ids[1], ETrue, KErrUnknown);
|
|
488 |
AssertMockLtsyStatusL();
|
|
489 |
|
|
490 |
CleanupStack::PopAndDestroy(1, this);
|
|
491 |
}
|
|
492 |
|
|
493 |
|
|
494 |
/**
|
|
495 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001g
|
|
496 |
@SYMPREQ 1780
|
|
497 |
@SYMComponent telephony_csat
|
|
498 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (UCS2 display in Cyrillic) and ENVELOPE MENU SELECTION
|
|
499 |
@SYMTestPriority High
|
|
500 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
501 |
@SYMTestExpectedResults Pass
|
|
502 |
@SYMTestType CT
|
|
503 |
*/
|
|
504 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001gL()
|
|
505 |
{
|
|
506 |
//"hello" in russian
|
|
507 |
_LIT8(KMenu,
|
|
508 |
"\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15");
|
|
509 |
|
|
510 |
//"hello1", "hello2" etc... in russian
|
|
511 |
TPtrC8 idNames[4] =
|
|
512 |
{_L8("\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15\x00\x31"),
|
|
513 |
_L8("\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15\x00\x32"),
|
|
514 |
_L8("\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15\x00\x33"),
|
|
515 |
_L8("\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15\x00\x34")};
|
|
516 |
|
|
517 |
//"hello5", "hello6" in russian
|
|
518 |
TPtrC8 idNames2[2] =
|
|
519 |
{_L8("\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15\x00\x35"),
|
|
520 |
_L8("\x80\x04\x17\x04\x14\x04\x20\x04\x10\x04\x12\x04\x21\x04\x22\x04\x12\x04\x23\x04\x19\x04\x22\x04\x15\x00\x36")};
|
|
521 |
|
|
522 |
CheckForeignSetUpMenuL(KMenu, idNames, idNames2);
|
|
523 |
}
|
|
524 |
|
|
525 |
|
|
526 |
/**
|
|
527 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001h
|
|
528 |
@SYMPREQ 1780
|
|
529 |
@SYMComponent telephony_csat
|
|
530 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (UCS2 display in Chinese) and ENVELOPE MENU SELECTION
|
|
531 |
@SYMTestPriority High
|
|
532 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
533 |
@SYMTestExpectedResults Pass
|
|
534 |
@SYMTestType CT
|
|
535 |
*/
|
|
536 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001hL()
|
|
537 |
{
|
|
538 |
//"Toolkit menu" in chinese
|
|
539 |
_LIT8(KMenu, "\x80\x5D\xE5\x51\x77\x7B\xB1\x53\x55");
|
|
540 |
|
|
541 |
//"Item 1", "Item 2" etc. in chinese
|
|
542 |
TPtrC8 idNames[4] =
|
|
543 |
{_L8("\x80\x98\x79\x76\xEE\x4E\x00"),
|
|
544 |
_L8("\x80\x98\x79\x76\xEE\x4E\x8C"),
|
|
545 |
_L8("\x80\x98\x79\x76\xEE\x4E\x09"),
|
|
546 |
_L8("\x80\x98\x79\x76\xEE\x56\xDB")};
|
|
547 |
|
|
548 |
//"One", "two" in chinese
|
|
549 |
TPtrC8 idNames2[2] =
|
|
550 |
{_L8("\x80\x4E\x00"),
|
|
551 |
_L8("\x80\x4E\x8C")};
|
|
552 |
|
|
553 |
CheckForeignSetUpMenuL(KMenu, idNames, idNames2);
|
|
554 |
}
|
|
555 |
|
|
556 |
|
|
557 |
/**
|
|
558 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001i
|
|
559 |
@SYMPREQ 1780
|
|
560 |
@SYMComponent telephony_csat
|
|
561 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (UCS2 display in Katakana) and ENVELOPE MENU SELECTION
|
|
562 |
@SYMTestPriority High
|
|
563 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
564 |
@SYMTestExpectedResults Pass
|
|
565 |
@SYMTestType CT
|
|
566 |
*/
|
|
567 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001iL()
|
|
568 |
{
|
|
569 |
//Menu Header and menu items use characters in Katakana
|
|
570 |
_LIT8(KMenu, "\x80\x00\x38\x00\x30\x30\xEB\x00\x30");
|
|
571 |
|
|
572 |
TPtrC8 idNames[4] =
|
|
573 |
{_L8("\x80\x00\x38\x00\x30\x30\xEB\x00\x31"),
|
|
574 |
_L8("\x80\x00\x38\x00\x30\x30\xEB\x00\x32"),
|
|
575 |
_L8("\x80\x00\x38\x00\x30\x30\xEB\x00\x33"),
|
|
576 |
_L8("\x80\x00\x38\x00\x30\x30\xEB\x00\x34")};
|
|
577 |
|
|
578 |
//second menu items use characters in Katakana
|
|
579 |
TPtrC8 idNames2[2] =
|
|
580 |
{_L8("\x80\x00\x38\x00\x30\x30\xEB\x00\x35"),
|
|
581 |
_L8("\x80\x00\x38\x00\x30\x30\xEB\x00\x36")};
|
|
582 |
|
|
583 |
CheckForeignSetUpMenuL(KMenu, idNames, idNames2);
|
|
584 |
}
|
|
585 |
|
|
586 |
|
|
587 |
/**
|
|
588 |
* auxiliary function for testing different types of menu alignment
|
|
589 |
* @param aAlign - type of alignment for tvl text formatting
|
|
590 |
*/
|
|
591 |
void CCSatSetUpMenuFU::CheckMenuAlignmentL(TUint8 aAlign)
|
|
592 |
{
|
|
593 |
TUint8 cmdNumber = 1;
|
|
594 |
TUint8 noPref = 0;
|
|
595 |
const TInt KNumItems = 3;
|
|
596 |
_LIT8(KMenu1, "Toolkit Menu 1");
|
|
597 |
|
|
598 |
TUint8 ids[KNumItems] = {1, 2, 3};
|
|
599 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2"), _L8("Item 3")};
|
|
600 |
TUint8 alphaFormatting[RSat::KTextAttributeBufSize] =
|
|
601 |
{
|
|
602 |
0, //formatting position
|
|
603 |
14, //text length
|
|
604 |
aAlign,
|
|
605 |
0xB4 //Dark Green Foreground(0x04), Bright Yellow Background(0xB0)
|
|
606 |
};
|
|
607 |
TUint8 itemsFormatting[KNumItems][RSat::KTextAttributeBufSize] =
|
|
608 |
{{ 0, 6, aAlign ,0xB4 },
|
|
609 |
{ 0, 6, aAlign ,0xB4 },
|
|
610 |
{ 0, 6, aAlign ,0xB4 }};
|
|
611 |
|
|
612 |
//Text attributes are not parsed in CSatNotifySetUpMenu::CompleteNotifyL()
|
|
613 |
|
|
614 |
ERR_PRINTF2(_L("<font color=Orange>$CSATKnownFailure: defect id = %d</font>"), 6);
|
|
615 |
|
|
616 |
SetUpMenuL( cmdNumber, noPref, KMenu1, KNumItems, ids, idNames, NULL,
|
|
617 |
RSat::EIconQualifierNotSet, 0, RSat::EIconQualifierNotSet, NULL,
|
|
618 |
alphaFormatting, itemsFormatting );
|
|
619 |
|
|
620 |
|
|
621 |
//generate the terminal response
|
|
622 |
RSat::TSetUpMenuRspV1 resp;
|
|
623 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
624 |
|
|
625 |
resp.iGeneralResult = RSat::KSuccess;
|
|
626 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
627 |
resp.iAdditionalInfo.Zero();
|
|
628 |
resp.SetPCmdNumber(cmdNumber);
|
|
629 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
630 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
631 |
AssertMockLtsyStatusL();
|
|
632 |
|
|
633 |
// now end session
|
|
634 |
EndProactiveSimSessionL();
|
|
635 |
|
|
636 |
// select second item
|
|
637 |
SelectMenuItemL(ids[1]);
|
|
638 |
|
|
639 |
AssertMockLtsyStatusL();
|
|
640 |
|
|
641 |
// second menu
|
|
642 |
TUint8 ids2[KNumItems] = {4, 5, 6};
|
|
643 |
TPtrC8 idNames2[KNumItems] = {_L8("Item 4"), _L8("Item 5"), _L8("Item 6") };
|
|
644 |
_LIT8(KMenu2, "Toolkit Menu 2");
|
|
645 |
|
|
646 |
SetUpMenuL( cmdNumber, noPref, KMenu2, KNumItems, ids2, idNames2 );
|
|
647 |
|
|
648 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
649 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
650 |
AssertMockLtsyStatusL();
|
|
651 |
|
|
652 |
// now end session
|
|
653 |
EndProactiveSimSessionL();
|
|
654 |
|
|
655 |
// select second item
|
|
656 |
SelectMenuItemL(ids2[1]);
|
|
657 |
|
|
658 |
AssertMockLtsyStatusL();
|
|
659 |
}
|
|
660 |
|
|
661 |
|
|
662 |
/**
|
|
663 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0001j
|
|
664 |
@SYMPREQ 1780
|
|
665 |
@SYMComponent telephony_csat
|
|
666 |
@SYMTestCaseDesc Test support in CSAT for RSat::NotifySetUpMenuPCmd - SET UP MENU (normal) and ENVELOPE MENU SELECTION
|
|
667 |
@SYMTestPriority High
|
|
668 |
@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd
|
|
669 |
@SYMTestExpectedResults Pass
|
|
670 |
@SYMTestType CT
|
|
671 |
*/
|
|
672 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0001jL()
|
|
673 |
{
|
|
674 |
OpenEtelServerL(EUseExtendedError);
|
|
675 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
676 |
OpenPhoneL();
|
|
677 |
OpenSatL();
|
|
678 |
|
|
679 |
// Expected Sequence 1.1
|
|
680 |
//(SET UP MENU and MENU SELECTION, without Help Request, Replace and Remove a Toolkit Menu)
|
|
681 |
// See ETSI TS 102 384 [26] in subclause 27.22.4.8.1.4.2, Expected Sequence 1.1.
|
|
682 |
|
|
683 |
TUint8 cmdNumber = 1;
|
|
684 |
TUint8 noPref(0); // no selection preferences
|
|
685 |
const TInt KNumItems = 4;
|
|
686 |
|
|
687 |
TUint8 ids[KNumItems] = {1, 2, 3, 4};
|
|
688 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2"), _L8("Item 3"), _L8("Item 4")};
|
|
689 |
|
|
690 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), KNumItems, ids, idNames );
|
|
691 |
|
|
692 |
//generate the terminal response
|
|
693 |
RSat::TSetUpMenuRspV1 resp;
|
|
694 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
695 |
|
|
696 |
resp.iGeneralResult = RSat::KSuccess;
|
|
697 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
698 |
resp.iAdditionalInfo.Zero();
|
|
699 |
resp.SetPCmdNumber(cmdNumber);
|
|
700 |
|
|
701 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
702 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
703 |
AssertMockLtsyStatusL();
|
|
704 |
|
|
705 |
// now end session
|
|
706 |
EndProactiveSimSessionL();
|
|
707 |
|
|
708 |
// select second item
|
|
709 |
SelectMenuItemL(ids[1]);
|
|
710 |
|
|
711 |
// making second menu instead of first
|
|
712 |
const TInt KNumItems2 = 2;
|
|
713 |
|
|
714 |
TUint8 ids2[KNumItems2] = {11, 12};
|
|
715 |
TPtrC8 idNames2[KNumItems2] = {_L8("One"), _L8("Two")};
|
|
716 |
|
|
717 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), KNumItems2, ids2, idNames2 );
|
|
718 |
|
|
719 |
//generate the terminal response
|
|
720 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref,
|
|
721 |
RSat::ESetUpMenu, respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
722 |
AssertMockLtsyStatusL();
|
|
723 |
|
|
724 |
// now end session
|
|
725 |
EndProactiveSimSessionL();
|
|
726 |
|
|
727 |
// select second item
|
|
728 |
SelectMenuItemL(ids2[1]);
|
|
729 |
|
|
730 |
AssertMockLtsyStatusL();
|
|
731 |
|
|
732 |
// remove the menu
|
|
733 |
SetUpMenuL( cmdNumber, noPref, _L8("Toolkit Menu"), 0, NULL, NULL );
|
|
734 |
|
|
735 |
//generate the terminal response
|
|
736 |
GenerateTerminalResponseL(cmdNumber,KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
737 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
738 |
AssertMockLtsyStatusL();
|
|
739 |
|
|
740 |
// now end session
|
|
741 |
EndProactiveSimSessionL();
|
|
742 |
AssertMockLtsyStatusL();
|
|
743 |
|
|
744 |
//Expected Sequence 1.2
|
|
745 |
//(SET UP MENU, Large Menu with many items or with large items or with Large Alpha Identifier)
|
|
746 |
//See ETSI TS 102 384 [26] in subclause 27.22.4.8.1.4.2, Expected Sequence 1.2.
|
|
747 |
|
|
748 |
// setup large menu
|
|
749 |
const TInt KNumItems3 = 30;
|
|
750 |
|
|
751 |
TUint8 ids3[KNumItems3] =
|
|
752 |
{0x50, 0x4f, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48, 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41,
|
|
753 |
0x40, 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38, 0x37, 0x36, 0x35, 0x34, 0x33};
|
|
754 |
TPtrC8 idNames3[KNumItems3] =
|
|
755 |
{_L8("Zero"), _L8("One"), _L8("Two"), _L8("Three"), _L8("Four"), _L8("Five"), _L8("Six"), _L8("Seven"),
|
|
756 |
_L8("Eight"), _L8("Nine"), _L8("Alpha"), _L8("Bravo"), _L8("Charlie"), _L8("Delta"), _L8("Echo"),
|
|
757 |
_L8("Fox-trot"), _L8("Black"), _L8("Brown"), _L8("Red"), _L8("Orange"), _L8("Yellow"), _L8("Green"),
|
|
758 |
_L8("Blue"), _L8("Violet"), _L8("Grey"), _L8("White"), _L8("milli"), _L8("micro"), _L8("nano"), _L8("pico")};
|
|
759 |
|
|
760 |
SetUpMenuL( cmdNumber, noPref, _L8("LargeMenu1"), KNumItems3, ids3, idNames3 );
|
|
761 |
|
|
762 |
//generate the terminal response
|
|
763 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
764 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
765 |
AssertMockLtsyStatusL();
|
|
766 |
|
|
767 |
// now end session
|
|
768 |
EndProactiveSimSessionL();
|
|
769 |
|
|
770 |
// select "Orange" 0x3d
|
|
771 |
SelectMenuItemL(ids3[20]);
|
|
772 |
|
|
773 |
AssertMockLtsyStatusL();
|
|
774 |
|
|
775 |
// setup another large menu
|
|
776 |
const TInt KNumItems4 = 7;
|
|
777 |
|
|
778 |
TUint8 ids4[KNumItems4] = {0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9};
|
|
779 |
TPtrC8 idNames4[KNumItems4] =
|
|
780 |
{_L8("1 Call Forward Unconditional"),
|
|
781 |
_L8("2 Call Forward On User Busy"),
|
|
782 |
_L8("3 Call Forward On No Reply"),
|
|
783 |
_L8("4 Call Forward On User Not Reachable"),
|
|
784 |
_L8("5 Barring Of All Outgoing Calls"),
|
|
785 |
_L8("6 Barring Of All Outgoing Int Calls"),
|
|
786 |
_L8("7 CLI Presentation")};
|
|
787 |
|
|
788 |
SetUpMenuL( cmdNumber, noPref, _L8("LargeMenu2"), KNumItems4, ids4, idNames4 );
|
|
789 |
|
|
790 |
//generate the terminal response
|
|
791 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
792 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
793 |
AssertMockLtsyStatusL();
|
|
794 |
|
|
795 |
// now end session
|
|
796 |
EndProactiveSimSessionL();
|
|
797 |
|
|
798 |
// select 0xfb
|
|
799 |
SelectMenuItemL(ids4[4]);
|
|
800 |
|
|
801 |
AssertMockLtsyStatusL();
|
|
802 |
|
|
803 |
// one more large menu
|
|
804 |
const TInt KNumItems5 = 1;
|
|
805 |
|
|
806 |
_LIT8(KSetupMenuTest8,"The SIM shall supply a set of menu items, which shall be integrated with the\
|
|
807 |
menu system (or other MMI facility) in order to give the user the opportunity to\
|
|
808 |
choose one of these menu items at his own discretion. Each item comprises a sh");
|
|
809 |
|
|
810 |
TUint8 ids5[KNumItems5] = {0x01};
|
|
811 |
TPtrC8 idNames5[KNumItems5] = {_L8("Y")};
|
|
812 |
|
|
813 |
SetUpMenuL( cmdNumber, noPref, KSetupMenuTest8, KNumItems5, ids5, idNames5 );
|
|
814 |
|
|
815 |
//generate the terminal response
|
|
816 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
817 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
818 |
AssertMockLtsyStatusL();
|
|
819 |
|
|
820 |
// now end session
|
|
821 |
EndProactiveSimSessionL();
|
|
822 |
|
|
823 |
// select 1
|
|
824 |
SelectMenuItemL(ids5[0]);
|
|
825 |
|
|
826 |
AssertMockLtsyStatusL();
|
|
827 |
|
|
828 |
CleanupStack::PopAndDestroy(1, this);
|
|
829 |
}
|
|
830 |
|
|
831 |
|
|
832 |
/**
|
|
833 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0002
|
|
834 |
@SYMPREQ 1780
|
|
835 |
@SYMComponent telephony_csat
|
|
836 |
@SYMTestCaseDesc Test support in CSAT for cancelling of RSat::NotifySetUpMenuPCmd
|
|
837 |
@SYMTestPriority High
|
|
838 |
@SYMTestActions Invokes cancelling of RSat::NotifySetUpMenuPCmd
|
|
839 |
@SYMTestExpectedResults Pass
|
|
840 |
@SYMTestType CT
|
|
841 |
*/
|
|
842 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0002L()
|
|
843 |
{
|
|
844 |
OpenEtelServerL(EUseExtendedError);
|
|
845 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
846 |
OpenPhoneL();
|
|
847 |
OpenSatL();
|
|
848 |
|
|
849 |
RBuf8 data;
|
|
850 |
CleanupClosePushL(data);
|
|
851 |
|
|
852 |
TUint8 pcmdCode = KSetUpMenu;
|
|
853 |
TMockLtsyData1<TUint8> expLtsyData(pcmdCode);
|
|
854 |
expLtsyData.SerialiseL(data);
|
|
855 |
iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);
|
|
856 |
|
|
857 |
RSat::TSetUpMenuV2 setupMenu;
|
|
858 |
RSat::TSetUpMenuV2Pckg setpPck(setupMenu);
|
|
859 |
TRequestStatus stat;
|
|
860 |
iSat.NotifySetUpMenuPCmd(stat, setpPck);
|
|
861 |
|
|
862 |
iSat.CancelAsyncRequest(ESatNotifySetUpMenuPCmd);
|
|
863 |
|
|
864 |
User::WaitForRequest(stat);
|
|
865 |
ASSERT_EQUALS(KErrCancel, stat.Int());
|
|
866 |
|
|
867 |
// There is no implementation for RSat::NotifySetUpMenuPCmdCancel(), declared in etelsat.h
|
|
868 |
ERR_PRINTF2(_L("<font color=Orange>$CSATKnownFailure: defect id = %d</font>"), 3);
|
|
869 |
ASSERT_TRUE(EFalse);
|
|
870 |
|
|
871 |
AssertMockLtsyStatusL();
|
|
872 |
CleanupStack::PopAndDestroy(2, this); // data, this
|
|
873 |
}
|
|
874 |
|
|
875 |
|
|
876 |
|
|
877 |
/**
|
|
878 |
@SYMTestCaseID BA-CSAT-SUM-SNSUMPC-0004
|
|
879 |
@SYMPREQ 1780
|
|
880 |
@SYMComponent telephony_csat
|
|
881 |
@SYMTestCaseDesc Test support in CSAT for multiple client requests to RSat::NotifySetUpMenuPCmd
|
|
882 |
@SYMTestPriority High
|
|
883 |
@SYMTestActions Invokes multiple client requests to RSat::NotifySetUpMenuPCmd
|
|
884 |
@SYMTestExpectedResults Pass
|
|
885 |
@SYMTestType CT
|
|
886 |
*/
|
|
887 |
void CCSatSetUpMenuFU::TestNotifySetUpMenuPCmd0004L()
|
|
888 |
{
|
|
889 |
OpenEtelServerL(EUseExtendedError);
|
|
890 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
891 |
OpenPhoneL();
|
|
892 |
OpenSatL();
|
|
893 |
|
|
894 |
RBuf8 data;
|
|
895 |
CleanupClosePushL(data);
|
|
896 |
|
|
897 |
// Open second client
|
|
898 |
RTelServer telServer2;
|
|
899 |
TInt ret = telServer2.Connect();
|
|
900 |
ASSERT_EQUALS(KErrNone, ret);
|
|
901 |
CleanupClosePushL(telServer2);
|
|
902 |
|
|
903 |
RMobilePhone phone2;
|
|
904 |
ret = phone2.Open(telServer2,KMmTsyPhoneName);
|
|
905 |
ASSERT_EQUALS(KErrNone, ret);
|
|
906 |
CleanupClosePushL(phone2);
|
|
907 |
|
|
908 |
RSat sat2;
|
|
909 |
User::LeaveIfError(sat2.Open(phone2));
|
|
910 |
CleanupClosePushL(sat2);
|
|
911 |
|
|
912 |
TUint8 KPCmdNumber = 1;
|
|
913 |
|
|
914 |
TTlv tlv;
|
|
915 |
tlv.Begin(KBerTlvProactiveSimCommandTag);
|
|
916 |
tlv.AddTag(KTlvCommandDetailsTag);
|
|
917 |
tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber
|
|
918 |
tlv.AddByte(KSetUpMenu); //ETLV_TypeOfCommand
|
|
919 |
tlv.AddByte(0); //ETLV_CommandQualifier
|
|
920 |
|
|
921 |
tlv.AddTag(KTlvDeviceIdentityTag);
|
|
922 |
tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity
|
|
923 |
tlv.AddByte(KDisplay); //ETLV_DestinationDeviceIdentity
|
|
924 |
|
|
925 |
tlv.AddTag(KTlvAlphaIdentifierTag);
|
|
926 |
_LIT8(KSetupMenuTest8,"Menu AlphaIdent");
|
|
927 |
_LIT16(KSetupMenuTest16,"Menu AlphaIdent");
|
|
928 |
tlv.AddData(KSetupMenuTest8);//ETLV_AlphaIdentifier
|
|
929 |
|
|
930 |
const TUint8 KItemId = 77;
|
|
931 |
_LIT8(KItem8, "Item AlphaIdent1");
|
|
932 |
_LIT16(KItem16, "Item AlphaIdent1");
|
|
933 |
|
|
934 |
tlv.AddTag(KTlvItemTag);
|
|
935 |
tlv.AddByte(KItemId); //item identifier
|
|
936 |
tlv.AddData(KItem8);
|
|
937 |
|
|
938 |
TPtrC8 tlvDsc = tlv.End();
|
|
939 |
TDesC8* tlvDscPtr = &tlvDsc;
|
|
940 |
|
|
941 |
TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);
|
|
942 |
|
|
943 |
// tell Mock about forthcoming RSat::NotifySetUpMenuPCmd
|
|
944 |
TUint8 pcmdCode = KSetUpMenu;
|
|
945 |
TMockLtsyData1<TUint8> expLtsyData(pcmdCode);
|
|
946 |
expLtsyData.SerialiseL(data);
|
|
947 |
iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);
|
|
948 |
data.Close();
|
|
949 |
|
|
950 |
tlvDscPack.SerialiseL(data);
|
|
951 |
iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, KErrNone, data, KDelay);
|
|
952 |
|
|
953 |
RSat::TSetUpMenuV2 setupMenu;
|
|
954 |
RSat::TSetUpMenuV2 setupMenu2;
|
|
955 |
RSat::TSetUpMenuV2Pckg setpPck(setupMenu);
|
|
956 |
RSat::TSetUpMenuV2Pckg setpPck2(setupMenu2);
|
|
957 |
TRequestStatus stat;
|
|
958 |
TRequestStatus stat2;
|
|
959 |
iSat.NotifySetUpMenuPCmd(stat, setpPck);
|
|
960 |
sat2.NotifySetUpMenuPCmd(stat2, setpPck2);
|
|
961 |
|
|
962 |
User::WaitForRequest(stat);
|
|
963 |
ASSERT_EQUALS(KErrNone, stat.Int());
|
|
964 |
|
|
965 |
ASSERT_EQUALS(KPCmdNumber, setupMenu.PCmdNumber());
|
|
966 |
ASSERT_EQUALS(RSat::ENoSelectionPreference, setupMenu.iPreference);
|
|
967 |
ASSERT_EQUALS((TInt)EFalse, setupMenu.IsRemoveMenu());
|
|
968 |
|
|
969 |
RSat::TItem item;
|
|
970 |
ASSERT_EQUALS( KErrNone, setupMenu.GetItem( 1, item));
|
|
971 |
ASSERT_EQUALS( KItemId, (item.iItemId));
|
|
972 |
ASSERT_EQUALS(0, item.iItemString.Compare(KItem16));
|
|
973 |
ASSERT_EQUALS((TUint)1, setupMenu.NumberOfItems());
|
|
974 |
ASSERT_EQUALS(RSat::ENoHelpAvailable, setupMenu.iHelp);
|
|
975 |
ASSERT_EQUALS( RSat::ENoIconId, setupMenu.iIconId.iQualifier);
|
|
976 |
ASSERT_EQUALS( RSat::ENoIconId, setupMenu.iIconListQualifier);
|
|
977 |
|
|
978 |
ASSERT_EQUALS(0, setupMenu.iAlphaId.iAlphaId.Compare(KSetupMenuTest16));
|
|
979 |
ASSERT_EQUALS(RSat::EAlphaIdProvided, setupMenu.iAlphaId.iStatus);
|
|
980 |
|
|
981 |
User::WaitForRequest(stat2);
|
|
982 |
ASSERT_EQUALS(KErrNone, stat2.Int());
|
|
983 |
|
|
984 |
ASSERT_EQUALS(KPCmdNumber, setupMenu2.PCmdNumber());
|
|
985 |
ASSERT_EQUALS(RSat::ENoSelectionPreference, setupMenu2.iPreference);
|
|
986 |
ASSERT_EQUALS((TInt)EFalse, setupMenu2.IsRemoveMenu());
|
|
987 |
ASSERT_EQUALS( KErrNone, setupMenu2.GetItem( 1, item));
|
|
988 |
ASSERT_EQUALS( KItemId, item.iItemId);
|
|
989 |
ASSERT_EQUALS(0, item.iItemString.Compare(KItem16));
|
|
990 |
ASSERT_EQUALS((TUint)1, setupMenu2.NumberOfItems());
|
|
991 |
ASSERT_EQUALS(RSat::ENoHelpAvailable, setupMenu2.iHelp);
|
|
992 |
ASSERT_EQUALS( RSat::ENoIconId, setupMenu2.iIconId.iQualifier);
|
|
993 |
ASSERT_EQUALS( RSat::ENoIconId, setupMenu2.iIconListQualifier);
|
|
994 |
ASSERT_EQUALS(0, setupMenu2.iAlphaId.iAlphaId.Compare(KSetupMenuTest16));
|
|
995 |
ASSERT_EQUALS(RSat::EAlphaIdProvided, setupMenu2.iAlphaId.iStatus);
|
|
996 |
|
|
997 |
AssertMockLtsyStatusL();
|
|
998 |
CleanupStack::PopAndDestroy(5, this);
|
|
999 |
}
|
|
1000 |
|
|
1001 |
|
|
1002 |
/**
|
|
1003 |
* auxiliary function for testing different fonts in set up menu
|
|
1004 |
* @param aFontParam - type of font for tvl text formatting
|
|
1005 |
*/
|
|
1006 |
void CCSatSetUpMenuFU::CheckMenuFontL(TUint8 aFontParam)
|
|
1007 |
{
|
|
1008 |
TUint8 cmdNumber = 1;
|
|
1009 |
TUint8 noPref = 0;
|
|
1010 |
const TInt KNumItems = 3;
|
|
1011 |
_LIT8(KMenu1, "Toolkit Menu 1");
|
|
1012 |
|
|
1013 |
TUint8 ids[KNumItems] = {1, 2, 3};
|
|
1014 |
TPtrC8 idNames[KNumItems] = {_L8("Item 1"), _L8("Item 2"), _L8("Item 3")};
|
|
1015 |
TUint8 alphaFormatting[RSat::KTextAttributeBufSize] =
|
|
1016 |
{
|
|
1017 |
0, //formatting position
|
|
1018 |
14, //text length
|
|
1019 |
aFontParam,
|
|
1020 |
0xB4 //Dark Green Foreground(0x04), Bright Yellow Background(0xB0)
|
|
1021 |
};
|
|
1022 |
TUint8 itemsFormatting[KNumItems][RSat::KTextAttributeBufSize] =
|
|
1023 |
{{ 0, 6, aFontParam ,0xB4 },
|
|
1024 |
{ 0, 6, aFontParam ,0xB4 },
|
|
1025 |
{ 0, 6, aFontParam ,0xB4 }};
|
|
1026 |
|
|
1027 |
SetUpMenuL( cmdNumber, noPref, KMenu1, KNumItems, ids, idNames, NULL,
|
|
1028 |
RSat::EIconQualifierNotSet, 0, RSat::EIconQualifierNotSet, NULL,
|
|
1029 |
alphaFormatting, itemsFormatting );
|
|
1030 |
|
|
1031 |
|
|
1032 |
//generate the terminal response
|
|
1033 |
RSat::TSetUpMenuRspV1 resp;
|
|
1034 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
1035 |
|
|
1036 |
resp.iGeneralResult = RSat::KSuccess;
|
|
1037 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
1038 |
resp.iAdditionalInfo.Zero();
|
|
1039 |
resp.SetPCmdNumber(cmdNumber);
|
|
1040 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
1041 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
1042 |
AssertMockLtsyStatusL();
|
|
1043 |
|
|
1044 |
// now end session
|
|
1045 |
EndProactiveSimSessionL();
|
|
1046 |
|
|
1047 |
// select second item
|
|
1048 |
SelectMenuItemL(ids[1]);
|
|
1049 |
|
|
1050 |
AssertMockLtsyStatusL();
|
|
1051 |
|
|
1052 |
// second menu
|
|
1053 |
TUint8 ids2[KNumItems] = {4, 5, 6};
|
|
1054 |
TPtrC8 idNames2[KNumItems] = {_L8("Item 4"), _L8("Item 5"), _L8("Item 6") };
|
|
1055 |
_LIT8(KMenu2, "Toolkit Menu 2");
|
|
1056 |
|
|
1057 |
alphaFormatting[2] = 0x00; // normal font
|
|
1058 |
itemsFormatting[0][2] = itemsFormatting[1][2] = itemsFormatting[2][2] = 0x00;
|
|
1059 |
|
|
1060 |
SetUpMenuL( cmdNumber, noPref, KMenu2, KNumItems, ids2, idNames2, NULL,
|
|
1061 |
RSat::EIconQualifierNotSet, 0, RSat::EIconQualifierNotSet, NULL,
|
|
1062 |
alphaFormatting, itemsFormatting );
|
|
1063 |
|
|
1064 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
1065 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
1066 |
AssertMockLtsyStatusL();
|
|
1067 |
|
|
1068 |
// now end session
|
|
1069 |
EndProactiveSimSessionL();
|
|
1070 |
|
|
1071 |
// select second item
|
|
1072 |
SelectMenuItemL(ids2[1]);
|
|
1073 |
|
|
1074 |
AssertMockLtsyStatusL();
|
|
1075 |
|
|
1076 |
// first menu again
|
|
1077 |
alphaFormatting[2] = aFontParam;
|
|
1078 |
itemsFormatting[0][2] = itemsFormatting[1][2] = itemsFormatting[2][2] = aFontParam;
|
|
1079 |
|
|
1080 |
SetUpMenuL( cmdNumber, noPref, KMenu1, KNumItems, ids, idNames, NULL,
|
|
1081 |
RSat::EIconQualifierNotSet, 0, RSat::EIconQualifierNotSet, NULL,
|
|
1082 |
alphaFormatting, itemsFormatting );
|
|
1083 |
|
|
1084 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
1085 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
1086 |
AssertMockLtsyStatusL();
|
|
1087 |
|
|
1088 |
// now end session
|
|
1089 |
EndProactiveSimSessionL();
|
|
1090 |
|
|
1091 |
// select second item
|
|
1092 |
SelectMenuItemL(ids[1]);
|
|
1093 |
|
|
1094 |
AssertMockLtsyStatusL();
|
|
1095 |
|
|
1096 |
// third menu
|
|
1097 |
TUint8 ids3[KNumItems] = {7, 8, 9};
|
|
1098 |
TPtrC8 idNames3[KNumItems] = {_L8("Item 7"), _L8("Item 8"), _L8("Item 9") };
|
|
1099 |
_LIT8(KMenu3, "Toolkit Menu 3");
|
|
1100 |
|
|
1101 |
SetUpMenuL( cmdNumber, noPref, KMenu3, KNumItems, ids3, idNames3 );
|
|
1102 |
|
|
1103 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
1104 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
1105 |
AssertMockLtsyStatusL();
|
|
1106 |
|
|
1107 |
// now end session
|
|
1108 |
EndProactiveSimSessionL();
|
|
1109 |
|
|
1110 |
// select second item
|
|
1111 |
SelectMenuItemL(ids3[1]);
|
|
1112 |
|
|
1113 |
AssertMockLtsyStatusL();
|
|
1114 |
}
|
|
1115 |
|
|
1116 |
|
|
1117 |
/**
|
|
1118 |
* End Proactive Sim Session
|
|
1119 |
*/
|
|
1120 |
void CCSatSetUpMenuFU::EndProactiveSimSessionL()
|
|
1121 |
{
|
|
1122 |
RBuf8 data;
|
|
1123 |
CleanupClosePushL(data);
|
|
1124 |
|
|
1125 |
TRequestStatus reqStatus;
|
|
1126 |
TRequestStatus mockLtsyStatus;
|
|
1127 |
|
|
1128 |
TUint8 proactiveCommandType = KEndOfTheProactiveSession;
|
|
1129 |
|
|
1130 |
//this is as a result of the NotifyProactiveSimSessionEnd call down to the LTSY,
|
|
1131 |
//this tells the LTSY we are interested in a Sim Session End event
|
|
1132 |
//CTSY -> LTSY
|
|
1133 |
TMockLtsyData1<TUint8> proactiveCommandTypeDataPack(proactiveCommandType);
|
|
1134 |
proactiveCommandTypeDataPack.SerialiseL(data);
|
|
1135 |
iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);
|
|
1136 |
data.Close();
|
|
1137 |
|
|
1138 |
//the client side call to be notifed when the Proactive Sim Session has ended.
|
|
1139 |
iSat.NotifyProactiveSimSessionEnd(reqStatus);
|
|
1140 |
|
|
1141 |
//sometime later the Sim Session ends, indicator up
|
|
1142 |
//LTSY -> CTSY
|
|
1143 |
|
|
1144 |
TUint8 statusWord1 = KSw1NormalEnding;
|
|
1145 |
TUint8 statusWord2 = KSw2NormalEnding;
|
|
1146 |
|
|
1147 |
TMockLtsyData2<TUint8,TUint8> notifyProactiveSimSessionEndDataPack(statusWord1,statusWord2);
|
|
1148 |
notifyProactiveSimSessionEndDataPack.SerialiseL(data);
|
|
1149 |
iMockLTSY.CompleteL(KMockLtsyDispatchSatNotifyProactiveSimSessionEndIndId,KErrNone,data, KDelay);
|
|
1150 |
|
|
1151 |
//wait for the client side to be notified
|
|
1152 |
User::WaitForRequest(reqStatus);
|
|
1153 |
ASSERT_EQUALS(KErrNone, reqStatus.Int());
|
|
1154 |
AssertMockLtsyStatusL();
|
|
1155 |
|
|
1156 |
CleanupStack::PopAndDestroy(1);
|
|
1157 |
}
|
|
1158 |
|
|
1159 |
|
|
1160 |
/**
|
|
1161 |
* prepare and call Set Sup Menu proactive command
|
|
1162 |
* @param aCmdNum - command number
|
|
1163 |
* @param aCmdQual - command details
|
|
1164 |
* @param aAlpha - alpha identifier
|
|
1165 |
* @param aNumItems - number of menu items
|
|
1166 |
* @param aItemIds - array of menu items identifier
|
|
1167 |
* @param aItemNames - array of menu items names
|
|
1168 |
* @param aAction - array of next actions
|
|
1169 |
* @param aIconQual - type of icon
|
|
1170 |
* @param aIcon - icon itself
|
|
1171 |
* @param aIconListQual - type of icons for menu items
|
|
1172 |
* @param aIconList- array of icons for menu items
|
|
1173 |
* @param aAlphaFormating- array of KTextAttributeBufSize bytes for alpha identifier formatting
|
|
1174 |
* @param aItemFormating- array for item strings formating
|
|
1175 |
*/
|
|
1176 |
void CCSatSetUpMenuFU::SetUpMenuL(TUint8 aCmdNum,
|
|
1177 |
TUint8 aCmdQual,
|
|
1178 |
const TDesC8& aAlpha,
|
|
1179 |
TUint8 aNumItems,
|
|
1180 |
TUint8 aItemIds[],
|
|
1181 |
TPtrC8 aItemNames[],
|
|
1182 |
TUint8 aAction[],
|
|
1183 |
RSat::TIconQualifier aIconQual,
|
|
1184 |
TUint8 aIcon,
|
|
1185 |
RSat::TIconQualifier aIconListQual,
|
|
1186 |
TUint8 aIconList[],
|
|
1187 |
TUint8 aAlphaFormating[],
|
|
1188 |
TUint8 aItemFormating[][RSat::KTextAttributeBufSize])
|
|
1189 |
{
|
|
1190 |
RBuf8 data;
|
|
1191 |
CleanupClosePushL(data);
|
|
1192 |
|
|
1193 |
// tell Mock about forthcoming RSat::NotifySetUpMenuPCmd
|
|
1194 |
TUint8 pcmdCode = KSetUpMenu;
|
|
1195 |
TMockLtsyData1<TUint8> expLtsyData(pcmdCode);
|
|
1196 |
expLtsyData.SerialiseL(data);
|
|
1197 |
iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data);
|
|
1198 |
|
|
1199 |
TTlv tlv;
|
|
1200 |
tlv.Begin(KBerTlvProactiveSimCommandTag);
|
|
1201 |
tlv.AddTag(KTlvCommandDetailsTag);
|
|
1202 |
tlv.AddByte(aCmdNum);//ETLV_CommandNumber
|
|
1203 |
tlv.AddByte(KSetUpMenu); //ETLV_TypeOfCommand
|
|
1204 |
tlv.AddByte(aCmdQual); //ETLV_CommandQualifier
|
|
1205 |
|
|
1206 |
tlv.AddTag(KTlvDeviceIdentityTag);
|
|
1207 |
tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity
|
|
1208 |
tlv.AddByte(KDisplay); //ETLV_DestinationDeviceIdentity
|
|
1209 |
|
|
1210 |
if(0 < aAlpha.Size())
|
|
1211 |
{
|
|
1212 |
tlv.AddTag(KTlvAlphaIdentifierTag);
|
|
1213 |
tlv.AddData(aAlpha);//ETLV_AlphaIdentifier
|
|
1214 |
}
|
|
1215 |
|
|
1216 |
for( TInt i = 0; i < aNumItems; i++)
|
|
1217 |
{
|
|
1218 |
tlv.AddTag(KTlvItemTag);
|
|
1219 |
tlv.AddByte(aItemIds[i]); //item identifier
|
|
1220 |
tlv.AddData(aItemNames[i]);
|
|
1221 |
}
|
|
1222 |
|
|
1223 |
if(aAction)
|
|
1224 |
{
|
|
1225 |
tlv.AddTag(KTlvItemsNextActionIndicatorTag);
|
|
1226 |
|
|
1227 |
for( TInt i = 0; i < aNumItems; i++)
|
|
1228 |
{
|
|
1229 |
tlv.AddByte(aAction[i]);
|
|
1230 |
}
|
|
1231 |
}
|
|
1232 |
|
|
1233 |
// constants for coding icon details
|
|
1234 |
const TUint8 KSelfExp = 0x00;
|
|
1235 |
const TUint8 KNotSelfExp = 0x01;
|
|
1236 |
|
|
1237 |
if(RSat::EIconQualifierNotSet != aIconQual)
|
|
1238 |
{
|
|
1239 |
tlv.AddTag(KTlvIconIdentifierTag);
|
|
1240 |
tlv.AddByte((RSat::ESelfExplanatory == aIconQual) ? KSelfExp : KNotSelfExp);
|
|
1241 |
tlv.AddByte(aIcon);
|
|
1242 |
}
|
|
1243 |
|
|
1244 |
if(RSat::EIconQualifierNotSet != aIconListQual)
|
|
1245 |
{
|
|
1246 |
tlv.AddTag(KTlvItemIconIdentifierListTag);
|
|
1247 |
tlv.AddByte((RSat::ESelfExplanatory == aIconListQual) ? KSelfExp : KNotSelfExp);
|
|
1248 |
|
|
1249 |
for( TInt i = 0; i < aNumItems; i++)
|
|
1250 |
{
|
|
1251 |
tlv.AddByte(aIconList[i]);
|
|
1252 |
}
|
|
1253 |
}
|
|
1254 |
|
|
1255 |
if(aAlphaFormating)
|
|
1256 |
{
|
|
1257 |
tlv.AddTag(0x50);
|
|
1258 |
tlv.AddByte(aAlphaFormating[0]); // text start
|
|
1259 |
tlv.AddByte(aAlphaFormating[1]); // text length
|
|
1260 |
tlv.AddByte(aAlphaFormating[2]); // formatting
|
|
1261 |
tlv.AddByte(aAlphaFormating[3]); // colors
|
|
1262 |
}
|
|
1263 |
|
|
1264 |
if(aItemFormating)
|
|
1265 |
{
|
|
1266 |
tlv.AddTag(0x51);
|
|
1267 |
|
|
1268 |
for(TInt i = 0; i < aNumItems; i++)
|
|
1269 |
{
|
|
1270 |
tlv.AddByte(aItemFormating[i][0]);
|
|
1271 |
tlv.AddByte(aItemFormating[i][1]);
|
|
1272 |
tlv.AddByte(aItemFormating[i][2]);
|
|
1273 |
tlv.AddByte(aItemFormating[i][3]);
|
|
1274 |
}
|
|
1275 |
}
|
|
1276 |
|
|
1277 |
TPtrC8 tlvDsc = tlv.End();
|
|
1278 |
TDesC8* tlvDscPtr = &tlvDsc;
|
|
1279 |
|
|
1280 |
data.Close();
|
|
1281 |
|
|
1282 |
TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);
|
|
1283 |
tlvDscPack.SerialiseL(data);
|
|
1284 |
iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data, KDelay);
|
|
1285 |
|
|
1286 |
RSat::TSetUpMenuV5 setupMenu;
|
|
1287 |
RSat::TSetUpMenuV5Pckg setpPck(setupMenu);
|
|
1288 |
TRequestStatus requestStatus;
|
|
1289 |
|
|
1290 |
iSat.NotifySetUpMenuPCmd(requestStatus, setpPck);
|
|
1291 |
|
|
1292 |
User::WaitForRequest(requestStatus);
|
|
1293 |
|
|
1294 |
ASSERT_EQUALS(KErrNone, requestStatus.Int());
|
|
1295 |
|
|
1296 |
ASSERT_EQUALS(aCmdNum, setupMenu.PCmdNumber());
|
|
1297 |
|
|
1298 |
if ( aCmdQual & KSelectionUsingSoftKey )
|
|
1299 |
{
|
|
1300 |
ASSERT_EQUALS(RSat::ESoftKeyPreferred, setupMenu.iPreference);
|
|
1301 |
}
|
|
1302 |
else
|
|
1303 |
{
|
|
1304 |
ASSERT_EQUALS(RSat::ENoSelectionPreference, setupMenu.iPreference);
|
|
1305 |
}
|
|
1306 |
|
|
1307 |
if(0 < aNumItems)
|
|
1308 |
{
|
|
1309 |
ASSERT_EQUALS((TInt)EFalse, setupMenu.IsRemoveMenu());
|
|
1310 |
|
|
1311 |
RBuf16 data16;
|
|
1312 |
CleanupClosePushL(data16);
|
|
1313 |
|
|
1314 |
for(TInt i = 0; i < aNumItems; i++)
|
|
1315 |
{
|
|
1316 |
RSat::TItem item;
|
|
1317 |
RSat::TTextAttribute attr;
|
|
1318 |
ASSERT_EQUALS( KErrNone, setupMenu.GetItem( i + 1, item, attr));
|
|
1319 |
ASSERT_EQUALS( aItemIds[i], item.iItemId);
|
|
1320 |
|
|
1321 |
data16.CreateL(aItemNames[i].Length());
|
|
1322 |
|
|
1323 |
TSatUtility::SetAlphaId( aItemNames[i], data16);
|
|
1324 |
|
|
1325 |
ASSERT_EQUALS(0, item.iItemString.Compare(data16));
|
|
1326 |
|
|
1327 |
if(aItemFormating)
|
|
1328 |
{
|
|
1329 |
ASSERT_EQUALS(RSat::ETextAttributeProvided, attr.iStatus);
|
|
1330 |
ASSERT_EQUALS(aItemFormating[i][0], attr.iTextAttributeData[0]);
|
|
1331 |
ASSERT_EQUALS(aItemFormating[i][1], attr.iTextAttributeData[1]);
|
|
1332 |
ASSERT_EQUALS(aItemFormating[i][2], attr.iTextAttributeData[2]);
|
|
1333 |
ASSERT_EQUALS(aItemFormating[i][3], attr.iTextAttributeData[3]);
|
|
1334 |
}
|
|
1335 |
}
|
|
1336 |
CleanupStack::PopAndDestroy(1);
|
|
1337 |
}
|
|
1338 |
else
|
|
1339 |
{
|
|
1340 |
ASSERT_EQUALS((TInt)ETrue, setupMenu.IsRemoveMenu());
|
|
1341 |
}
|
|
1342 |
|
|
1343 |
ASSERT_EQUALS((TUint)aNumItems, setupMenu.NumberOfItems());
|
|
1344 |
|
|
1345 |
if ( aCmdQual & KHelpAvailabilityMask )
|
|
1346 |
{
|
|
1347 |
ASSERT_EQUALS(RSat::EHelpAvailable, setupMenu.iHelp);
|
|
1348 |
}
|
|
1349 |
else
|
|
1350 |
{
|
|
1351 |
ASSERT_EQUALS(RSat::ENoHelpAvailable, setupMenu.iHelp);
|
|
1352 |
}
|
|
1353 |
|
|
1354 |
if(aAlphaFormating)
|
|
1355 |
{
|
|
1356 |
ASSERT_EQUALS(RSat::ETextAttributeProvided, setupMenu.iTextAttribute.iStatus);
|
|
1357 |
ASSERT_EQUALS(aAlphaFormating[0], setupMenu.iTextAttribute.iTextAttributeData[0]);
|
|
1358 |
ASSERT_EQUALS(aAlphaFormating[1], setupMenu.iTextAttribute.iTextAttributeData[1]);
|
|
1359 |
ASSERT_EQUALS(aAlphaFormating[2], setupMenu.iTextAttribute.iTextAttributeData[2]);
|
|
1360 |
ASSERT_EQUALS(aAlphaFormating[3], setupMenu.iTextAttribute.iTextAttributeData[3]);
|
|
1361 |
}
|
|
1362 |
else
|
|
1363 |
{
|
|
1364 |
ASSERT_EQUALS(RSat::ETextAttributeNotSet, setupMenu.iTextAttribute.iStatus);
|
|
1365 |
}
|
|
1366 |
|
|
1367 |
if(RSat::EIconQualifierNotSet != aIconQual)
|
|
1368 |
{
|
|
1369 |
ASSERT_EQUALS( aIconQual, setupMenu.iIconId.iQualifier);
|
|
1370 |
ASSERT_EQUALS( aIcon, setupMenu.iIconId.iIdentifier);
|
|
1371 |
}
|
|
1372 |
else
|
|
1373 |
{
|
|
1374 |
ASSERT_EQUALS( RSat::ENoIconId, setupMenu.iIconId.iQualifier);
|
|
1375 |
}
|
|
1376 |
|
|
1377 |
if(RSat::EIconQualifierNotSet != aIconListQual)
|
|
1378 |
{
|
|
1379 |
RSat::TItem item;
|
|
1380 |
TInt iconId;
|
|
1381 |
|
|
1382 |
for( TInt i = 0; i < aNumItems; i++)
|
|
1383 |
{
|
|
1384 |
setupMenu.GetItemIcon(i+1, item, iconId);
|
|
1385 |
ASSERT_EQUALS((TInt)aIconList[i], iconId);
|
|
1386 |
}
|
|
1387 |
}
|
|
1388 |
else
|
|
1389 |
{
|
|
1390 |
ASSERT_EQUALS( RSat::ENoIconId, setupMenu.iIconListQualifier);
|
|
1391 |
}
|
|
1392 |
|
|
1393 |
if(aAction)
|
|
1394 |
{
|
|
1395 |
RSat::TItem item;
|
|
1396 |
TInt action;
|
|
1397 |
|
|
1398 |
for( TInt i = 0; i < aNumItems; i++)
|
|
1399 |
{
|
|
1400 |
setupMenu.GetItem(i+1, item, action);
|
|
1401 |
ASSERT_EQUALS((TInt)aAction[i], action);
|
|
1402 |
}
|
|
1403 |
}
|
|
1404 |
|
|
1405 |
RBuf16 data16;
|
|
1406 |
CleanupClosePushL(data16);
|
|
1407 |
|
|
1408 |
data16.CreateL(aAlpha.Length());
|
|
1409 |
|
|
1410 |
TSatUtility::SetAlphaId( aAlpha, data16);
|
|
1411 |
|
|
1412 |
ASSERT_EQUALS(0, setupMenu.iAlphaId.iAlphaId.Compare(data16));
|
|
1413 |
ASSERT_EQUALS(RSat::EAlphaIdProvided, setupMenu.iAlphaId.iStatus);
|
|
1414 |
|
|
1415 |
CleanupStack::PopAndDestroy(2);
|
|
1416 |
}
|
|
1417 |
|
|
1418 |
|
|
1419 |
/**
|
|
1420 |
* prepare and make select menu call
|
|
1421 |
* @param aItemId - item to select
|
|
1422 |
* @param aRequestHelp - if help requested
|
|
1423 |
* @param aErrorForExpect - error code to pass and expect
|
|
1424 |
*/
|
|
1425 |
void CCSatSetUpMenuFU::SelectMenuItemL(TUint8 aItemId, TBool aRequestHelp, TInt aErrorForExpect )
|
|
1426 |
{
|
|
1427 |
RBuf8 data;
|
|
1428 |
CleanupClosePushL(data);
|
|
1429 |
|
|
1430 |
TTlv menuSelTlv;
|
|
1431 |
menuSelTlv.Begin( KBerTlvMenuSelectionTag );
|
|
1432 |
menuSelTlv.AddTag( KTlvDeviceIdentityTag );
|
|
1433 |
menuSelTlv.AddByte( KKeypad );
|
|
1434 |
menuSelTlv.AddByte( KSim );
|
|
1435 |
menuSelTlv.AddTag( KTlvItemIdentifierTag );
|
|
1436 |
menuSelTlv.AddByte( aItemId );
|
|
1437 |
if(aRequestHelp)
|
|
1438 |
{
|
|
1439 |
menuSelTlv.AddTag( KTlvHelpRequestTag );
|
|
1440 |
}
|
|
1441 |
|
|
1442 |
TPtrC8 menuSelDsc = menuSelTlv.End();
|
|
1443 |
TDesC8* menuSelPtr = &menuSelDsc;
|
|
1444 |
TMockLtsyData1<TDesC8*> menuSelDescPck(menuSelPtr);
|
|
1445 |
menuSelDescPck.SerialiseL(data);
|
|
1446 |
|
|
1447 |
iMockLTSY.ExpectL(MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId, data, aErrorForExpect);
|
|
1448 |
|
|
1449 |
RSat::TMenuSelectionV1 menuSel;
|
|
1450 |
RSat::TMenuSelectionV1Pckg menuSelPckg(menuSel);
|
|
1451 |
|
|
1452 |
menuSel.iItemId = aItemId;
|
|
1453 |
menuSel.iHelp = aRequestHelp ? RSat::EHelpRequested : RSat::EHelpNotRequested;
|
|
1454 |
|
|
1455 |
TRequestStatus stat;
|
|
1456 |
|
|
1457 |
iSat.MenuSelection(stat, menuSelPckg);
|
|
1458 |
User::WaitForRequest(stat);
|
|
1459 |
ASSERT_EQUALS(aErrorForExpect, stat.Int());
|
|
1460 |
|
|
1461 |
CleanupStack::PopAndDestroy(1);
|
|
1462 |
}
|
|
1463 |
|
|
1464 |
|
|
1465 |
/**
|
|
1466 |
* auxiliary function for testing different languages in set up menu
|
|
1467 |
* @param aTitle - menu header
|
|
1468 |
* @param aItemNames - first menu strings
|
|
1469 |
* @param aItemNames - second menu strings
|
|
1470 |
*/
|
|
1471 |
void CCSatSetUpMenuFU::CheckForeignSetUpMenuL(const TDesC8& aTitle,
|
|
1472 |
TPtrC8 aItemNames[],
|
|
1473 |
TPtrC8 aItemNames2[])
|
|
1474 |
{
|
|
1475 |
OpenEtelServerL(EUseExtendedError);
|
|
1476 |
CleanupStack::PushL(TCleanupItem(Cleanup,this));
|
|
1477 |
OpenPhoneL();
|
|
1478 |
OpenSatL();
|
|
1479 |
|
|
1480 |
//(SET UP MENU and MENU SELECTION, without Help Request, Replace and Remove a Toolkit Menu)
|
|
1481 |
|
|
1482 |
TUint8 cmdNumber = 1;
|
|
1483 |
TUint8 noPref(0); // no selection preferences
|
|
1484 |
const TInt KNumItems = 4;
|
|
1485 |
|
|
1486 |
TUint8 ids[KNumItems] = {1, 2, 3, 4};
|
|
1487 |
|
|
1488 |
SetUpMenuL( cmdNumber, noPref, aTitle, KNumItems, ids, aItemNames );
|
|
1489 |
|
|
1490 |
//generate the terminal response
|
|
1491 |
RSat::TSetUpMenuRspV1 resp;
|
|
1492 |
RSat::TSetUpMenuRspV1Pckg respPck(resp);
|
|
1493 |
|
|
1494 |
resp.iGeneralResult = RSat::KSuccess;
|
|
1495 |
resp.iInfoType = RSat::KNoAdditionalInfo;
|
|
1496 |
resp.iAdditionalInfo.Zero();
|
|
1497 |
resp.SetPCmdNumber(cmdNumber);
|
|
1498 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
1499 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
1500 |
AssertMockLtsyStatusL();
|
|
1501 |
|
|
1502 |
// now end session
|
|
1503 |
EndProactiveSimSessionL();
|
|
1504 |
|
|
1505 |
// select second item
|
|
1506 |
SelectMenuItemL(ids[1]);
|
|
1507 |
|
|
1508 |
// making second menu instead of first
|
|
1509 |
const TInt KNumItems2 = 2;
|
|
1510 |
|
|
1511 |
TUint8 ids2[KNumItems2] = {11, 12};
|
|
1512 |
|
|
1513 |
SetUpMenuL( cmdNumber, noPref, aTitle, KNumItems2, ids2, aItemNames2 );
|
|
1514 |
|
|
1515 |
//generate the terminal response
|
|
1516 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
1517 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
1518 |
AssertMockLtsyStatusL();
|
|
1519 |
|
|
1520 |
// now end session
|
|
1521 |
EndProactiveSimSessionL();
|
|
1522 |
|
|
1523 |
// select second item
|
|
1524 |
SelectMenuItemL(ids2[1]);
|
|
1525 |
|
|
1526 |
AssertMockLtsyStatusL();
|
|
1527 |
|
|
1528 |
// remove the menu
|
|
1529 |
SetUpMenuL( cmdNumber, noPref, aTitle, 0, NULL, NULL );
|
|
1530 |
|
|
1531 |
//generate the terminal response
|
|
1532 |
GenerateTerminalResponseL(cmdNumber, KSetUpMenu, noPref, RSat::ESetUpMenu,
|
|
1533 |
respPck, resp.iAdditionalInfo, resp.iGeneralResult);
|
|
1534 |
AssertMockLtsyStatusL();
|
|
1535 |
|
|
1536 |
// now end session
|
|
1537 |
EndProactiveSimSessionL();
|
|
1538 |
AssertMockLtsyStatusL();
|
|
1539 |
|
|
1540 |
CleanupStack::PopAndDestroy(1, this);
|
|
1541 |
}
|
|
1542 |
|