The Tor Browser / file comparison

comparison: dom/system/gonk/tests/test_ril_worker_stk.js

dom/system/gonk/tests/test_ril_worker_stk.js

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:1605b7a4538c
1 /* Any copyright is dedicated to the Public Domain.
2 http://creativecommons.org/publicdomain/zero/1.0/ */
3
4 subscriptLoader.loadSubScript("resource://gre/modules/ril_consts.js", this);
5
6 function run_test() {
7 run_next_test();
8 }
9
10 /**
11 * Helper function.
12 */
13 function newUint8Worker() {
14 let worker = newWorker();
15 let index = 0; // index for read
16 let buf = [];
17 let context = worker.ContextPool._contexts[0];
18
19 context.Buf.writeUint8 = function(value) {
20 buf.push(value);
21 };
22
23 context.Buf.readUint8 = function() {
24 return buf[index++];
25 };
26
27 context.Buf.seekIncoming = function(offset) {
28 index += offset;
29 };
30
31 worker.debug = do_print;
32
33 return worker;
34 }
35
36 function newUint8SupportOutgoingIndexWorker() {
37 let worker = newWorker();
38 let index = 4; // index for read
39 let buf = [0, 0, 0, 0]; // Preserved parcel size
40 let context = worker.ContextPool._contexts[0];
41
42 context.Buf.writeUint8 = function(value) {
43 if (context.Buf.outgoingIndex >= buf.length) {
44 buf.push(value);
45 } else {
46 buf[context.Buf.outgoingIndex] = value;
47 }
48
49 context.Buf.outgoingIndex++;
50 };
51
52 context.Buf.readUint8 = function() {
53 return buf[index++];
54 };
55
56 context.Buf.seekIncoming = function(offset) {
57 index += offset;
58 };
59
60 worker.debug = do_print;
61
62 return worker;
63 }
64
65 // Test RIL requests related to STK.
66 /**
67 * Verify if RIL.sendStkTerminalProfile be called.
68 */
69 add_test(function test_if_send_stk_terminal_profile() {
70 let worker = newUint8Worker();
71 let context = worker.ContextPool._contexts[0];
72 let profileSend = false;
73 context.RIL.sendStkTerminalProfile = function(data) {
74 profileSend = true;
75 };
76
77 let iccStatus = {
78 gsmUmtsSubscriptionAppIndex: 0,
79 apps: [{
80 app_state: CARD_APPSTATE_READY,
81 app_type: CARD_APPTYPE_USIM
82 }],
83 };
84 worker.RILQUIRKS_SEND_STK_PROFILE_DOWNLOAD = false;
85
86 context.RIL._processICCStatus(iccStatus);
87
88 do_check_eq(profileSend, false);
89
90 run_next_test();
91 });
92
93 /**
94 * Verify RIL.sendStkTerminalProfile
95 */
96 add_test(function test_send_stk_terminal_profile() {
97 let worker = newUint8Worker();
98 let context = worker.ContextPool._contexts[0];
99 let ril = context.RIL;
100 let buf = context.Buf;
101
102 ril.sendStkTerminalProfile(STK_SUPPORTED_TERMINAL_PROFILE);
103
104 buf.seekIncoming(8);
105 let profile = buf.readString();
106 for (let i = 0; i < STK_SUPPORTED_TERMINAL_PROFILE.length; i++) {
107 do_check_eq(parseInt(profile.substring(2 * i, 2 * i + 2), 16),
108 STK_SUPPORTED_TERMINAL_PROFILE[i]);
109 }
110
111 run_next_test();
112 });
113
114 /**
115 * Verify STK terminal response
116 */
117 add_test(function test_stk_terminal_response() {
118 let worker = newUint8SupportOutgoingIndexWorker();
119 let context = worker.ContextPool._contexts[0];
120 let buf = context.Buf;
121 let pduHelper = context.GsmPDUHelper;
122
123 buf.sendParcel = function() {
124 // Type
125 do_check_eq(this.readInt32(), REQUEST_STK_SEND_TERMINAL_RESPONSE);
126
127 // Token : we don't care
128 this.readInt32();
129
130 // Data Size, 44 = 2 * (TLV_COMMAND_DETAILS_SIZE(5) +
131 // TLV_DEVICE_ID_SIZE(4) +
132 // TLV_RESULT_SIZE(3) +
133 // TEXT LENGTH(10))
134 do_check_eq(this.readInt32(), 44);
135
136 // Command Details, Type-Length-Value
137 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_COMMAND_DETAILS |
138 COMPREHENSIONTLV_FLAG_CR);
139 do_check_eq(pduHelper.readHexOctet(), 3);
140 do_check_eq(pduHelper.readHexOctet(), 0x01);
141 do_check_eq(pduHelper.readHexOctet(), STK_CMD_PROVIDE_LOCAL_INFO);
142 do_check_eq(pduHelper.readHexOctet(), STK_LOCAL_INFO_NNA);
143
144 // Device Identifies, Type-Length-Value(Source ID-Destination ID)
145 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_DEVICE_ID);
146 do_check_eq(pduHelper.readHexOctet(), 2);
147 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_ME);
148 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_SIM);
149
150 // Result
151 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_RESULT |
152 COMPREHENSIONTLV_FLAG_CR);
153 do_check_eq(pduHelper.readHexOctet(), 1);
154 do_check_eq(pduHelper.readHexOctet(), STK_RESULT_OK);
155
156 // Text
157 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_TEXT_STRING |
158 COMPREHENSIONTLV_FLAG_CR);
159 do_check_eq(pduHelper.readHexOctet(), 8);
160 do_check_eq(pduHelper.readHexOctet(), STK_TEXT_CODING_GSM_7BIT_PACKED);
161 do_check_eq(pduHelper.readSeptetsToString(7, 0, PDU_NL_IDENTIFIER_DEFAULT,
162 PDU_NL_IDENTIFIER_DEFAULT), "Mozilla");
163
164 run_next_test();
165 };
166
167 let response = {
168 command: {
169 commandNumber: 0x01,
170 typeOfCommand: STK_CMD_PROVIDE_LOCAL_INFO,
171 commandQualifier: STK_LOCAL_INFO_NNA,
172 options: {
173 isPacked: true
174 }
175 },
176 input: "Mozilla",
177 resultCode: STK_RESULT_OK
178 };
179 context.RIL.sendStkTerminalResponse(response);
180 });
181
182 // Test ComprehensionTlvHelper
183
184 /**
185 * Verify ComprehensionTlvHelper.writeLocationInfoTlv
186 */
187 add_test(function test_write_location_info_tlv() {
188 let worker = newUint8Worker();
189 let context = worker.ContextPool._contexts[0];
190 let pduHelper = context.GsmPDUHelper;
191 let tlvHelper = context.ComprehensionTlvHelper;
192
193 // Test with 2-digit mnc, and gsmCellId obtained from UMTS network.
194 let loc = {
195 mcc: "466",
196 mnc: "92",
197 gsmLocationAreaCode : 10291,
198 gsmCellId: 19072823
199 };
200 tlvHelper.writeLocationInfoTlv(loc);
201
202 let tag = pduHelper.readHexOctet();
203 do_check_eq(tag, COMPREHENSIONTLV_TAG_LOCATION_INFO |
204 COMPREHENSIONTLV_FLAG_CR);
205
206 let length = pduHelper.readHexOctet();
207 do_check_eq(length, 9);
208
209 let mcc_mnc = pduHelper.readSwappedNibbleBcdString(3);
210 do_check_eq(mcc_mnc, "46692");
211
212 let lac = (pduHelper.readHexOctet() << 8) | pduHelper.readHexOctet();
213 do_check_eq(lac, 10291);
214
215 let cellId = (pduHelper.readHexOctet() << 24) |
216 (pduHelper.readHexOctet() << 16) |
217 (pduHelper.readHexOctet() << 8) |
218 (pduHelper.readHexOctet());
219 do_check_eq(cellId, 19072823);
220
221 // Test with 1-digit mnc, and gsmCellId obtained from GSM network.
222 loc = {
223 mcc: "466",
224 mnc: "02",
225 gsmLocationAreaCode : 10291,
226 gsmCellId: 65534
227 };
228 tlvHelper.writeLocationInfoTlv(loc);
229
230 tag = pduHelper.readHexOctet();
231 do_check_eq(tag, COMPREHENSIONTLV_TAG_LOCATION_INFO |
232 COMPREHENSIONTLV_FLAG_CR);
233
234 length = pduHelper.readHexOctet();
235 do_check_eq(length, 7);
236
237 mcc_mnc = pduHelper.readSwappedNibbleBcdString(3);
238 do_check_eq(mcc_mnc, "46602");
239
240 lac = (pduHelper.readHexOctet() << 8) | pduHelper.readHexOctet();
241 do_check_eq(lac, 10291);
242
243 cellId = (pduHelper.readHexOctet() << 8) | (pduHelper.readHexOctet());
244 do_check_eq(cellId, 65534);
245
246 // Test with 3-digit mnc, and gsmCellId obtained from GSM network.
247 loc = {
248 mcc: "466",
249 mnc: "222",
250 gsmLocationAreaCode : 10291,
251 gsmCellId: 65534
252 };
253 tlvHelper.writeLocationInfoTlv(loc);
254
255 tag = pduHelper.readHexOctet();
256 do_check_eq(tag, COMPREHENSIONTLV_TAG_LOCATION_INFO |
257 COMPREHENSIONTLV_FLAG_CR);
258
259 length = pduHelper.readHexOctet();
260 do_check_eq(length, 7);
261
262 mcc_mnc = pduHelper.readSwappedNibbleBcdString(3);
263 do_check_eq(mcc_mnc, "466222");
264
265 lac = (pduHelper.readHexOctet() << 8) | pduHelper.readHexOctet();
266 do_check_eq(lac, 10291);
267
268 cellId = (pduHelper.readHexOctet() << 8) | (pduHelper.readHexOctet());
269 do_check_eq(cellId, 65534);
270
271 run_next_test();
272 });
273
274 /**
275 * Verify ComprehensionTlvHelper.writeErrorNumber
276 */
277 add_test(function test_write_disconnecting_cause() {
278 let worker = newUint8Worker();
279 let context = worker.ContextPool._contexts[0];
280 let pduHelper = context.GsmPDUHelper;
281 let tlvHelper = context.ComprehensionTlvHelper;
282
283 tlvHelper.writeCauseTlv(RIL_ERROR_TO_GECKO_ERROR[ERROR_GENERIC_FAILURE]);
284 let tag = pduHelper.readHexOctet();
285 do_check_eq(tag, COMPREHENSIONTLV_TAG_CAUSE | COMPREHENSIONTLV_FLAG_CR);
286 let len = pduHelper.readHexOctet();
287 do_check_eq(len, 2); // We have one cause.
288 let standard = pduHelper.readHexOctet();
289 do_check_eq(standard, 0x60);
290 let cause = pduHelper.readHexOctet();
291 do_check_eq(cause, 0x80 | ERROR_GENERIC_FAILURE);
292
293 run_next_test();
294 });
295
296 /**
297 * Verify ComprehensionTlvHelper.getSizeOfLengthOctets
298 */
299 add_test(function test_get_size_of_length_octets() {
300 let worker = newUint8Worker();
301 let context = worker.ContextPool._contexts[0];
302 let tlvHelper = context.ComprehensionTlvHelper;
303
304 let length = 0x70;
305 do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 1);
306
307 length = 0x80;
308 do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 2);
309
310 length = 0x180;
311 do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 3);
312
313 length = 0x18000;
314 do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 4);
315
316 run_next_test();
317 });
318
319 /**
320 * Verify ComprehensionTlvHelper.writeLength
321 */
322 add_test(function test_write_length() {
323 let worker = newUint8Worker();
324 let context = worker.ContextPool._contexts[0];
325 let pduHelper = context.GsmPDUHelper;
326 let tlvHelper = context.ComprehensionTlvHelper;
327
328 let length = 0x70;
329 tlvHelper.writeLength(length);
330 do_check_eq(pduHelper.readHexOctet(), length);
331
332 length = 0x80;
333 tlvHelper.writeLength(length);
334 do_check_eq(pduHelper.readHexOctet(), 0x81);
335 do_check_eq(pduHelper.readHexOctet(), length);
336
337 length = 0x180;
338 tlvHelper.writeLength(length);
339 do_check_eq(pduHelper.readHexOctet(), 0x82);
340 do_check_eq(pduHelper.readHexOctet(), (length >> 8) & 0xff);
341 do_check_eq(pduHelper.readHexOctet(), length & 0xff);
342
343 length = 0x18000;
344 tlvHelper.writeLength(length);
345 do_check_eq(pduHelper.readHexOctet(), 0x83);
346 do_check_eq(pduHelper.readHexOctet(), (length >> 16) & 0xff);
347 do_check_eq(pduHelper.readHexOctet(), (length >> 8) & 0xff);
348 do_check_eq(pduHelper.readHexOctet(), length & 0xff);
349
350 run_next_test();
351 });
352
353 // Test Proactive commands.
354 /**
355 * Verify Proactive command helper : searchForNextTag
356 */
357 add_test(function test_stk_proactive_command_search_next_tag() {
358 let worker = newUint8Worker();
359 let context = worker.ContextPool._contexts[0];
360 let pduHelper = context.GsmPDUHelper;
361 let berHelper = context.BerTlvHelper;
362 let stkHelper = context.StkProactiveCmdHelper;
363
364 let tag_test = [
365 0xD0,
366 0x3C,
367 0x85, 0x0A, 0x61, 0x6C, 0x70, 0x68, 0x61, 0x20, 0x69, 0x64, 0x20, 0x31,
368 0x85, 0x0A, 0x61, 0x6C, 0x70, 0x68, 0x61, 0x20, 0x69, 0x64, 0x20, 0x32,
369 0x85, 0x0A, 0x61, 0x6C, 0x70, 0x68, 0x61, 0x20, 0x69, 0x64, 0x20, 0x33,
370 0x85, 0x0A, 0x61, 0x6C, 0x70, 0x68, 0x61, 0x20, 0x69, 0x64, 0x20, 0x34,
371 0x85, 0x0A, 0x61, 0x6C, 0x70, 0x68, 0x61, 0x20, 0x69, 0x64, 0x20, 0x35];
372
373 for (let i = 0; i < tag_test.length; i++) {
374 pduHelper.writeHexOctet(tag_test[i]);
375 }
376
377 let berTlv = berHelper.decode(tag_test.length);
378 let iter = Iterator(berTlv.value);
379 let tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);
380 do_check_eq(tlv.value.identifier, "alpha id 1");
381
382 tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);
383 do_check_eq(tlv.value.identifier, "alpha id 2");
384
385 tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);
386 do_check_eq(tlv.value.identifier, "alpha id 3");
387
388 tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);
389 do_check_eq(tlv.value.identifier, "alpha id 4");
390
391 tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);
392 do_check_eq(tlv.value.identifier, "alpha id 5");
393
394 run_next_test();
395 });
396
397 /**
398 * Verify Proactive Command : Refresh
399 */
400 add_test(function test_stk_proactive_command_refresh() {
401 let worker = newUint8Worker();
402 let context = worker.ContextPool._contexts[0];
403 let pduHelper = context.GsmPDUHelper;
404 let berHelper = context.BerTlvHelper;
405 let stkHelper = context.StkProactiveCmdHelper;
406
407 let refresh_1 = [
408 0xD0,
409 0x10,
410 0x81, 0x03, 0x01, 0x01, 0x01,
411 0x82, 0x02, 0x81, 0x82,
412 0x92, 0x05, 0x01, 0x3F, 0x00, 0x2F, 0xE2];
413
414 for (let i = 0; i < refresh_1.length; i++) {
415 pduHelper.writeHexOctet(refresh_1[i]);
416 }
417
418 let berTlv = berHelper.decode(refresh_1.length);
419 let ctlvs = berTlv.value;
420 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
421 do_check_eq(tlv.value.commandNumber, 0x01);
422 do_check_eq(tlv.value.typeOfCommand, 0x01);
423 do_check_eq(tlv.value.commandQualifier, 0x01);
424
425 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_FILE_LIST, ctlvs);
426 do_check_eq(tlv.value.fileList, "3F002FE2");
427
428 run_next_test();
429 });
430
431 /**
432 * Verify Proactive Command : Play Tone
433 */
434 add_test(function test_stk_proactive_command_play_tone() {
435 let worker = newUint8Worker();
436 let context = worker.ContextPool._contexts[0];
437 let pduHelper = context.GsmPDUHelper;
438 let berHelper = context.BerTlvHelper;
439 let stkHelper = context.StkProactiveCmdHelper;
440
441 let tone_1 = [
442 0xD0,
443 0x1B,
444 0x81, 0x03, 0x01, 0x20, 0x00,
445 0x82, 0x02, 0x81, 0x03,
446 0x85, 0x09, 0x44, 0x69, 0x61, 0x6C, 0x20, 0x54, 0x6F, 0x6E, 0x65,
447 0x8E, 0x01, 0x01,
448 0x84, 0x02, 0x01, 0x05];
449
450 for (let i = 0; i < tone_1.length; i++) {
451 pduHelper.writeHexOctet(tone_1[i]);
452 }
453
454 let berTlv = berHelper.decode(tone_1.length);
455 let ctlvs = berTlv.value;
456 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
457 do_check_eq(tlv.value.commandNumber, 0x01);
458 do_check_eq(tlv.value.typeOfCommand, 0x20);
459 do_check_eq(tlv.value.commandQualifier, 0x00);
460
461 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);
462 do_check_eq(tlv.value.identifier, "Dial Tone");
463
464 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TONE, ctlvs);
465 do_check_eq(tlv.value.tone, STK_TONE_TYPE_DIAL_TONE);
466
467 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_DURATION, ctlvs);
468 do_check_eq(tlv.value.timeUnit, STK_TIME_UNIT_SECOND);
469 do_check_eq(tlv.value.timeInterval, 5);
470
471 run_next_test();
472 });
473
474 /**
475 * Verify Proactive Command : Poll Interval
476 */
477 add_test(function test_stk_proactive_command_poll_interval() {
478 let worker = newUint8Worker();
479 let context = worker.ContextPool._contexts[0];
480 let pduHelper = context.GsmPDUHelper;
481 let berHelper = context.BerTlvHelper;
482 let stkHelper = context.StkProactiveCmdHelper;
483
484 let poll_1 = [
485 0xD0,
486 0x0D,
487 0x81, 0x03, 0x01, 0x03, 0x00,
488 0x82, 0x02, 0x81, 0x82,
489 0x84, 0x02, 0x01, 0x14];
490
491 for (let i = 0; i < poll_1.length; i++) {
492 pduHelper.writeHexOctet(poll_1[i]);
493 }
494
495 let berTlv = berHelper.decode(poll_1.length);
496 let ctlvs = berTlv.value;
497 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
498 do_check_eq(tlv.value.commandNumber, 0x01);
499 do_check_eq(tlv.value.typeOfCommand, 0x03);
500 do_check_eq(tlv.value.commandQualifier, 0x00);
501
502 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_DURATION, ctlvs);
503 do_check_eq(tlv.value.timeUnit, STK_TIME_UNIT_SECOND);
504 do_check_eq(tlv.value.timeInterval, 0x14);
505
506 run_next_test();
507 });
508
509 /**
510 * Verify Proactive Command: Display Text
511 */
512 add_test(function test_read_septets_to_string() {
513 let worker = newUint8Worker();
514 let context = worker.ContextPool._contexts[0];
515 let pduHelper = context.GsmPDUHelper;
516 let berHelper = context.BerTlvHelper;
517 let stkHelper = context.StkProactiveCmdHelper;
518
519 let display_text_1 = [
520 0xd0,
521 0x28,
522 0x81, 0x03, 0x01, 0x21, 0x80,
523 0x82, 0x02, 0x81, 0x02,
524 0x0d, 0x1d, 0x00, 0xd3, 0x30, 0x9b, 0xfc, 0x06, 0xc9, 0x5c, 0x30, 0x1a,
525 0xa8, 0xe8, 0x02, 0x59, 0xc3, 0xec, 0x34, 0xb9, 0xac, 0x07, 0xc9, 0x60,
526 0x2f, 0x58, 0xed, 0x15, 0x9b, 0xb9, 0x40,
527 ];
528
529 for (let i = 0; i < display_text_1.length; i++) {
530 pduHelper.writeHexOctet(display_text_1[i]);
531 }
532
533 let berTlv = berHelper.decode(display_text_1.length);
534 let ctlvs = berTlv.value;
535 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TEXT_STRING, ctlvs);
536 do_check_eq(tlv.value.textString, "Saldo 2.04 E. Validez 20/05/13. ");
537
538 run_next_test();
539 });
540
541 /**
542 * Verify Proactive Command: Set Up Event List.
543 */
544 add_test(function test_stk_proactive_command_event_list() {
545 let worker = newUint8Worker();
546 let context = worker.ContextPool._contexts[0];
547 let pduHelper = context.GsmPDUHelper;
548 let berHelper = context.BerTlvHelper;
549 let stkHelper = context.StkProactiveCmdHelper;
550
551 let event_1 = [
552 0xD0,
553 0x0F,
554 0x81, 0x03, 0x01, 0x05, 0x00,
555 0x82, 0x02, 0x81, 0x82,
556 0x99, 0x04, 0x00, 0x01, 0x02, 0x03];
557
558 for (let i = 0; i < event_1.length; i++) {
559 pduHelper.writeHexOctet(event_1[i]);
560 }
561
562 let berTlv = berHelper.decode(event_1.length);
563 let ctlvs = berTlv.value;
564 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
565 do_check_eq(tlv.value.commandNumber, 0x01);
566 do_check_eq(tlv.value.typeOfCommand, 0x05);
567 do_check_eq(tlv.value.commandQualifier, 0x00);
568
569 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_EVENT_LIST, ctlvs);
570 do_check_eq(Array.isArray(tlv.value.eventList), true);
571 for (let i = 0; i < tlv.value.eventList.length; i++) {
572 do_check_eq(tlv.value.eventList[i], i);
573 }
574
575 run_next_test();
576 });
577
578 /**
579 * Verify Proactive Command : Get Input
580 */
581 add_test(function test_stk_proactive_command_get_input() {
582 let worker = newUint8Worker();
583 let context = worker.ContextPool._contexts[0];
584 let pduHelper = context.GsmPDUHelper;
585 let berHelper = context.BerTlvHelper;
586 let stkHelper = context.StkProactiveCmdHelper;
587 let stkCmdHelper = context.StkCommandParamsFactory;
588
589 let get_input_1 = [
590 0xD0,
591 0x1E,
592 0x81, 0x03, 0x01, 0x23, 0x8F,
593 0x82, 0x02, 0x81, 0x82,
594 0x8D, 0x05, 0x04, 0x54, 0x65, 0x78, 0x74,
595 0x91, 0x02, 0x01, 0x10,
596 0x17, 0x08, 0x04, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74];
597
598 for (let i = 0; i < get_input_1.length; i++) {
599 pduHelper.writeHexOctet(get_input_1[i]);
600 }
601
602 let berTlv = berHelper.decode(get_input_1.length);
603 let ctlvs = berTlv.value;
604 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
605 do_check_eq(tlv.value.commandNumber, 0x01);
606 do_check_eq(tlv.value.typeOfCommand, STK_CMD_GET_INPUT);
607
608 let input = stkCmdHelper.createParam(tlv.value, ctlvs);
609 do_check_eq(input.text, "Text");
610 do_check_eq(input.isAlphabet, true);
611 do_check_eq(input.isUCS2, true);
612 do_check_eq(input.hideInput, true);
613 do_check_eq(input.isPacked, true);
614 do_check_eq(input.isHelpAvailable, true);
615 do_check_eq(input.minLength, 0x01);
616 do_check_eq(input.maxLength, 0x10);
617 do_check_eq(input.defaultText, "Default");
618
619 let get_input_2 = [
620 0xD0,
621 0x11,
622 0x81, 0x03, 0x01, 0x23, 0x00,
623 0x82, 0x02, 0x81, 0x82,
624 0x8D, 0x00,
625 0x91, 0x02, 0x01, 0x10,
626 0x17, 0x00];
627
628 for (let i = 0; i < get_input_2.length; i++) {
629 pduHelper.writeHexOctet(get_input_2[i]);
630 }
631
632 berTlv = berHelper.decode(get_input_2.length);
633 ctlvs = berTlv.value;
634 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
635 do_check_eq(tlv.value.commandNumber, 0x01);
636 do_check_eq(tlv.value.typeOfCommand, STK_CMD_GET_INPUT);
637
638 input = stkCmdHelper.createParam(tlv.value, ctlvs);
639 do_check_eq(input.text, null);
640 do_check_eq(input.minLength, 0x01);
641 do_check_eq(input.maxLength, 0x10);
642 do_check_eq(input.defaultText, null);
643
644 run_next_test();
645 });
646
647 /**
648 * Verify Proactive Command : More Time
649 */
650 add_test(function test_stk_proactive_command_more_time() {
651 let worker = newUint8Worker();
652 let context = worker.ContextPool._contexts[0];
653 let pduHelper = context.GsmPDUHelper;
654 let berHelper = context.BerTlvHelper;
655 let stkHelper = context.StkProactiveCmdHelper;
656
657 let more_time_1 = [
658 0xD0,
659 0x09,
660 0x81, 0x03, 0x01, 0x02, 0x00,
661 0x82, 0x02, 0x81, 0x82];
662
663 for(let i = 0 ; i < more_time_1.length; i++) {
664 pduHelper.writeHexOctet(more_time_1[i]);
665 }
666
667 let berTlv = berHelper.decode(more_time_1.length);
668 let ctlvs = berTlv.value;
669 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
670 do_check_eq(tlv.value.commandNumber, 0x01);
671 do_check_eq(tlv.value.typeOfCommand, STK_CMD_MORE_TIME);
672 do_check_eq(tlv.value.commandQualifier, 0x00);
673
674 run_next_test();
675 });
676
677 /**
678 * Verify Proactive Command : Select Item
679 */
680 add_test(function test_stk_proactive_command_select_item() {
681 let worker = newUint8Worker();
682 let context = worker.ContextPool._contexts[0];
683 let pduHelper = context.GsmPDUHelper;
684 let berHelper = context.BerTlvHelper;
685 let stkHelper = context.StkProactiveCmdHelper;
686 let stkFactory = context.StkCommandParamsFactory;
687
688 let select_item_1 = [
689 0xD0,
690 0x33,
691 0x81, 0x03, 0x01, 0x24, 0x00,
692 0x82, 0x02, 0x81, 0x82,
693 0x85, 0x05, 0x54, 0x69, 0x74, 0x6C, 0x65,
694 0x8F, 0x07, 0x01, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x31,
695 0x8F, 0x07, 0x02, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x32,
696 0x8F, 0x07, 0x03, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x33,
697 0x18, 0x03, 0x10, 0x15, 0x20,
698 0x90, 0x01, 0x01
699 ];
700
701 for(let i = 0 ; i < select_item_1.length; i++) {
702 pduHelper.writeHexOctet(select_item_1[i]);
703 }
704
705 let berTlv = berHelper.decode(select_item_1.length);
706 let ctlvs = berTlv.value;
707 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
708 do_check_eq(tlv.value.commandNumber, 0x01);
709 do_check_eq(tlv.value.typeOfCommand, STK_CMD_SELECT_ITEM);
710 do_check_eq(tlv.value.commandQualifier, 0x00);
711
712 let menu = stkFactory.createParam(tlv.value, ctlvs);
713 do_check_eq(menu.title, "Title");
714 do_check_eq(menu.items[0].identifier, 1);
715 do_check_eq(menu.items[0].text, "item 1");
716 do_check_eq(menu.items[1].identifier, 2);
717 do_check_eq(menu.items[1].text, "item 2");
718 do_check_eq(menu.items[2].identifier, 3);
719 do_check_eq(menu.items[2].text, "item 3");
720 do_check_eq(menu.nextActionList[0], STK_CMD_SET_UP_CALL);
721 do_check_eq(menu.nextActionList[1], STK_CMD_LAUNCH_BROWSER);
722 do_check_eq(menu.nextActionList[2], STK_CMD_PLAY_TONE);
723 do_check_eq(menu.defaultItem, 0x00);
724
725 let select_item_2 = [
726 0xD0,
727 0x33,
728 0x81, 0x03, 0x01, 0x24, 0x00,
729 0x82, 0x02, 0x81, 0x82,
730 0x85, 0x05, 0x54, 0x69, 0x74, 0x6C, 0x65,
731 0x8F, 0x07, 0x01, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x31,
732 0x8F, 0x07, 0x02, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x32,
733 0x8F, 0x07, 0x03, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x33,
734 0x18, 0x03, 0x00, 0x15, 0x81,
735 0x90, 0x01, 0x03
736 ];
737
738 for(let i = 0 ; i < select_item_2.length; i++) {
739 pduHelper.writeHexOctet(select_item_2[i]);
740 }
741
742 berTlv = berHelper.decode(select_item_2.length);
743 ctlvs = berTlv.value;
744 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
745 do_check_eq(tlv.value.commandNumber, 0x01);
746 do_check_eq(tlv.value.typeOfCommand, STK_CMD_SELECT_ITEM);
747 do_check_eq(tlv.value.commandQualifier, 0x00);
748
749 menu = stkFactory.createParam(tlv.value, ctlvs);
750 do_check_eq(menu.title, "Title");
751 do_check_eq(menu.items[0].identifier, 1);
752 do_check_eq(menu.items[0].text, "item 1");
753 do_check_eq(menu.items[1].identifier, 2);
754 do_check_eq(menu.items[1].text, "item 2");
755 do_check_eq(menu.items[2].identifier, 3);
756 do_check_eq(menu.items[2].text, "item 3");
757 do_check_eq(menu.nextActionList[0], STK_NEXT_ACTION_NULL);
758 do_check_eq(menu.nextActionList[1], STK_CMD_LAUNCH_BROWSER);
759 do_check_eq(menu.nextActionList[2], STK_NEXT_ACTION_END_PROACTIVE_SESSION);
760 do_check_eq(menu.defaultItem, 0x02);
761
762 run_next_test();
763 });
764
765 /**
766 * Verify Proactive Command : Set Up Menu
767 */
768 add_test(function test_stk_proactive_command_set_up_menu() {
769 let worker = newUint8Worker();
770 let context = worker.ContextPool._contexts[0];
771 let pduHelper = context.GsmPDUHelper;
772 let berHelper = context.BerTlvHelper;
773 let stkHelper = context.StkProactiveCmdHelper;
774 let stkFactory = context.StkCommandParamsFactory;
775
776 let set_up_menu_1 = [
777 0xD0,
778 0x30,
779 0x81, 0x03, 0x01, 0x25, 0x00,
780 0x82, 0x02, 0x81, 0x82,
781 0x85, 0x05, 0x54, 0x69, 0x74, 0x6C, 0x65,
782 0x8F, 0x07, 0x01, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x31,
783 0x8F, 0x07, 0x02, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x32,
784 0x8F, 0x07, 0x03, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x33,
785 0x18, 0x03, 0x10, 0x15, 0x20
786 ];
787
788 for(let i = 0 ; i < set_up_menu_1.length; i++) {
789 pduHelper.writeHexOctet(set_up_menu_1[i]);
790 }
791
792 let berTlv = berHelper.decode(set_up_menu_1.length);
793 let ctlvs = berTlv.value;
794 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
795 do_check_eq(tlv.value.commandNumber, 0x01);
796 do_check_eq(tlv.value.typeOfCommand, STK_CMD_SET_UP_MENU);
797 do_check_eq(tlv.value.commandQualifier, 0x00);
798
799 let menu = stkFactory.createParam(tlv.value, ctlvs);
800 do_check_eq(menu.title, "Title");
801 do_check_eq(menu.items[0].identifier, 1);
802 do_check_eq(menu.items[0].text, "item 1");
803 do_check_eq(menu.items[1].identifier, 2);
804 do_check_eq(menu.items[1].text, "item 2");
805 do_check_eq(menu.items[2].identifier, 3);
806 do_check_eq(menu.items[2].text, "item 3");
807 do_check_eq(menu.nextActionList[0], STK_CMD_SET_UP_CALL);
808 do_check_eq(menu.nextActionList[1], STK_CMD_LAUNCH_BROWSER);
809 do_check_eq(menu.nextActionList[2], STK_CMD_PLAY_TONE);
810
811 let set_up_menu_2 = [
812 0xD0,
813 0x30,
814 0x81, 0x03, 0x01, 0x25, 0x00,
815 0x82, 0x02, 0x81, 0x82,
816 0x85, 0x05, 0x54, 0x69, 0x74, 0x6C, 0x65,
817 0x8F, 0x07, 0x01, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x31,
818 0x8F, 0x07, 0x02, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x32,
819 0x8F, 0x07, 0x03, 0x69, 0x74, 0x65, 0x6D, 0x20, 0x33,
820 0x18, 0x03, 0x81, 0x00, 0x00
821 ];
822
823 for(let i = 0 ; i < set_up_menu_2.length; i++) {
824 pduHelper.writeHexOctet(set_up_menu_2[i]);
825 }
826
827 berTlv = berHelper.decode(set_up_menu_2.length);
828 ctlvs = berTlv.value;
829 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
830 do_check_eq(tlv.value.commandNumber, 0x01);
831 do_check_eq(tlv.value.typeOfCommand, STK_CMD_SET_UP_MENU);
832 do_check_eq(tlv.value.commandQualifier, 0x00);
833
834 let menu = stkFactory.createParam(tlv.value, ctlvs);
835 do_check_eq(menu.title, "Title");
836 do_check_eq(menu.items[0].identifier, 1);
837 do_check_eq(menu.items[0].text, "item 1");
838 do_check_eq(menu.items[1].identifier, 2);
839 do_check_eq(menu.items[1].text, "item 2");
840 do_check_eq(menu.items[2].identifier, 3);
841 do_check_eq(menu.items[2].text, "item 3");
842 do_check_eq(menu.nextActionList[0], STK_NEXT_ACTION_END_PROACTIVE_SESSION);
843 do_check_eq(menu.nextActionList[1], STK_NEXT_ACTION_NULL);
844 do_check_eq(menu.nextActionList[2], STK_NEXT_ACTION_NULL);
845
846 run_next_test();
847 });
848
849 /**
850 * Verify Proactive Command : Set Up Call
851 */
852 add_test(function test_stk_proactive_command_set_up_call() {
853 let worker = newUint8Worker();
854 let context = worker.ContextPool._contexts[0];
855 let pduHelper = context.GsmPDUHelper;
856 let berHelper = context.BerTlvHelper;
857 let stkHelper = context.StkProactiveCmdHelper;
858 let cmdFactory = context.StkCommandParamsFactory;
859
860 let set_up_call_1 = [
861 0xD0,
862 0x29,
863 0x81, 0x03, 0x01, 0x10, 0x04,
864 0x82, 0x02, 0x81, 0x82,
865 0x05, 0x0A, 0x44, 0x69, 0x73, 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74,
866 0x86, 0x09, 0x81, 0x10, 0x32, 0x04, 0x21, 0x43, 0x65, 0x1C, 0x2C,
867 0x05, 0x07, 0x4D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65];
868
869 for (let i = 0 ; i < set_up_call_1.length; i++) {
870 pduHelper.writeHexOctet(set_up_call_1[i]);
871 }
872
873 let berTlv = berHelper.decode(set_up_call_1.length);
874 let ctlvs = berTlv.value;
875 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
876 do_check_eq(tlv.value.commandNumber, 0x01);
877 do_check_eq(tlv.value.typeOfCommand, STK_CMD_SET_UP_CALL);
878
879 let setupCall = cmdFactory.createParam(tlv.value, ctlvs);
880 do_check_eq(setupCall.address, "012340123456,1,2");
881 do_check_eq(setupCall.confirmMessage, "Disconnect");
882 do_check_eq(setupCall.callMessage, "Message");
883
884 run_next_test();
885 });
886
887 /**
888 * Verify Proactive Command : Timer Management
889 */
890 add_test(function test_stk_proactive_command_timer_management() {
891 let worker = newUint8Worker();
892 let context = worker.ContextPool._contexts[0];
893 let pduHelper = context.GsmPDUHelper;
894 let berHelper = context.BerTlvHelper;
895 let stkHelper = context.StkProactiveCmdHelper;
896
897 // Timer Management - Start
898 let timer_management_1 = [
899 0xD0,
900 0x11,
901 0x81, 0x03, 0x01, 0x27, 0x00,
902 0x82, 0x02, 0x81, 0x82,
903 0xA4, 0x01, 0x01,
904 0xA5, 0x03, 0x10, 0x20, 0x30
905 ];
906
907 for(let i = 0 ; i < timer_management_1.length; i++) {
908 pduHelper.writeHexOctet(timer_management_1[i]);
909 }
910
911 let berTlv = berHelper.decode(timer_management_1.length);
912 let ctlvs = berTlv.value;
913 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
914 do_check_eq(tlv.value.commandNumber, 0x01);
915 do_check_eq(tlv.value.typeOfCommand, STK_CMD_TIMER_MANAGEMENT);
916 do_check_eq(tlv.value.commandQualifier, STK_TIMER_START);
917
918 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER, ctlvs);
919 do_check_eq(tlv.value.timerId, 0x01);
920
921 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TIMER_VALUE, ctlvs);
922 do_check_eq(tlv.value.timerValue, (0x01 * 60 * 60) + (0x02 * 60) + 0x03);
923
924 // Timer Management - Deactivate
925 let timer_management_2 = [
926 0xD0,
927 0x0C,
928 0x81, 0x03, 0x01, 0x27, 0x01,
929 0x82, 0x02, 0x81, 0x82,
930 0xA4, 0x01, 0x01
931 ];
932
933 for(let i = 0 ; i < timer_management_2.length; i++) {
934 pduHelper.writeHexOctet(timer_management_2[i]);
935 }
936
937 berTlv = berHelper.decode(timer_management_2.length);
938 ctlvs = berTlv.value;
939 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
940 do_check_eq(tlv.value.commandNumber, 0x01);
941 do_check_eq(tlv.value.typeOfCommand, STK_CMD_TIMER_MANAGEMENT);
942 do_check_eq(tlv.value.commandQualifier, STK_TIMER_DEACTIVATE);
943
944 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER, ctlvs);
945 do_check_eq(tlv.value.timerId, 0x01);
946
947 run_next_test();
948 });
949
950 /**
951 * Verify Proactive Command : Provide Local Information
952 */
953 add_test(function test_stk_proactive_command_provide_local_information() {
954 let worker = newUint8Worker();
955 let context = worker.ContextPool._contexts[0];
956 let pduHelper = context.GsmPDUHelper;
957 let berHelper = context.BerTlvHelper;
958 let stkHelper = context.StkProactiveCmdHelper;
959
960 // Verify IMEI
961 let local_info_1 = [
962 0xD0,
963 0x09,
964 0x81, 0x03, 0x01, 0x26, 0x01,
965 0x82, 0x02, 0x81, 0x82];
966
967 for (let i = 0; i < local_info_1.length; i++) {
968 pduHelper.writeHexOctet(local_info_1[i]);
969 }
970
971 let berTlv = berHelper.decode(local_info_1.length);
972 let ctlvs = berTlv.value;
973 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
974 do_check_eq(tlv.value.commandNumber, 0x01);
975 do_check_eq(tlv.value.typeOfCommand, STK_CMD_PROVIDE_LOCAL_INFO);
976 do_check_eq(tlv.value.commandQualifier, STK_LOCAL_INFO_IMEI);
977
978 // Verify Date and Time Zone
979 let local_info_2 = [
980 0xD0,
981 0x09,
982 0x81, 0x03, 0x01, 0x26, 0x03,
983 0x82, 0x02, 0x81, 0x82];
984
985 for (let i = 0; i < local_info_2.length; i++) {
986 pduHelper.writeHexOctet(local_info_2[i]);
987 }
988
989 berTlv = berHelper.decode(local_info_2.length);
990 ctlvs = berTlv.value;
991 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
992 do_check_eq(tlv.value.commandNumber, 0x01);
993 do_check_eq(tlv.value.typeOfCommand, STK_CMD_PROVIDE_LOCAL_INFO);
994 do_check_eq(tlv.value.commandQualifier, STK_LOCAL_INFO_DATE_TIME_ZONE);
995
996 run_next_test();
997 });
998
999 /**
1000 * Verify Proactive command : BIP Messages
1001 */
1002 add_test(function test_stk_proactive_command_open_channel() {
1003 let worker = newUint8Worker();
1004 let context = worker.ContextPool._contexts[0];
1005 let pduHelper = context.GsmPDUHelper;
1006 let berHelper = context.BerTlvHelper;
1007 let stkHelper = context.StkProactiveCmdHelper;
1008
1009 // Open Channel
1010 let open_channel = [
1011 0xD0,
1012 0x0F,
1013 0x81, 0x03, 0x01, 0x40, 0x00,
1014 0x82, 0x02, 0x81, 0x82,
1015 0x85, 0x04, 0x4F, 0x70, 0x65, 0x6E //alpha id: "Open"
1016 ];
1017
1018 for (let i = 0; i < open_channel.length; i++) {
1019 pduHelper.writeHexOctet(open_channel[i]);
1020 }
1021
1022 let berTlv = berHelper.decode(open_channel.length);
1023 let ctlvs = berTlv.value;
1024 let tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
1025 do_check_eq(tlv.value.commandNumber, 0x01);
1026 do_check_eq(tlv.value.typeOfCommand, STK_CMD_OPEN_CHANNEL);
1027 do_check_eq(tlv.value.commandQualifier, 0x00);
1028
1029 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);
1030 do_check_eq(tlv.value.identifier, "Open");
1031
1032 // Close Channel
1033 let close_channel = [
1034 0xD0,
1035 0x10,
1036 0x81, 0x03, 0x01, 0x41, 0x00,
1037 0x82, 0x02, 0x81, 0x82,
1038 0x85, 0x05, 0x43, 0x6C, 0x6F, 0x73, 0x65 //alpha id: "Close"
1039 ];
1040
1041 for (let i = 0; i < close_channel.length; i++) {
1042 pduHelper.writeHexOctet(close_channel[i]);
1043 }
1044
1045 berTlv = berHelper.decode(close_channel.length);
1046 ctlvs = berTlv.value;
1047 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
1048 do_check_eq(tlv.value.commandNumber, 0x01);
1049 do_check_eq(tlv.value.typeOfCommand, STK_CMD_CLOSE_CHANNEL);
1050 do_check_eq(tlv.value.commandQualifier, 0x00);
1051
1052 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);
1053 do_check_eq(tlv.value.identifier, "Close");
1054
1055 // Receive Data
1056 let receive_data = [
1057 0XD0,
1058 0X12,
1059 0x81, 0x03, 0x01, 0x42, 0x00,
1060 0x82, 0x02, 0x81, 0x82,
1061 0x85, 0x07, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65 //alpha id: "Receive"
1062 ];
1063
1064 for (let i = 0; i < receive_data.length; i++) {
1065 pduHelper.writeHexOctet(receive_data[i]);
1066 }
1067
1068 berTlv = berHelper.decode(receive_data.length);
1069 ctlvs = berTlv.value;
1070 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
1071 do_check_eq(tlv.value.commandNumber, 0x01);
1072 do_check_eq(tlv.value.typeOfCommand, STK_CMD_RECEIVE_DATA);
1073 do_check_eq(tlv.value.commandQualifier, 0x00);
1074
1075 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);
1076 do_check_eq(tlv.value.identifier, "Receive");
1077
1078 // Send Data
1079 let send_data = [
1080 0xD0,
1081 0x0F,
1082 0x81, 0x03, 0x01, 0x43, 0x00,
1083 0x82, 0x02, 0x81, 0x82,
1084 0x85, 0x04, 0x53, 0x65, 0x6E, 0x64 //alpha id: "Send"
1085 ];
1086
1087 for (let i = 0; i < send_data.length; i++) {
1088 pduHelper.writeHexOctet(send_data[i]);
1089 }
1090
1091 berTlv = berHelper.decode(send_data.length);
1092 ctlvs = berTlv.value;
1093 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_COMMAND_DETAILS, ctlvs);
1094 do_check_eq(tlv.value.commandNumber, 0x01);
1095 do_check_eq(tlv.value.typeOfCommand, STK_CMD_SEND_DATA);
1096 do_check_eq(tlv.value.commandQualifier, 0x00);
1097
1098 tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);
1099 do_check_eq(tlv.value.identifier, "Send");
1100
1101 run_next_test();
1102 });
1103
1104 /**
1105 * Verify Event Download Command : Location Status
1106 */
1107 add_test(function test_stk_event_download_location_status() {
1108 let worker = newUint8SupportOutgoingIndexWorker();
1109 let context = worker.ContextPool._contexts[0];
1110 let buf = context.Buf;
1111 let pduHelper = context.GsmPDUHelper;
1112
1113 buf.sendParcel = function() {
1114 // Type
1115 do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);
1116
1117 // Token : we don't care
1118 this.readInt32();
1119
1120 // Data Size, 42 = 2 * (2 + TLV_DEVICE_ID_SIZE(4) +
1121 // TLV_EVENT_LIST_SIZE(3) +
1122 // TLV_LOCATION_STATUS_SIZE(3) +
1123 // TLV_LOCATION_INFO_GSM_SIZE(9))
1124 do_check_eq(this.readInt32(), 42);
1125
1126 // BER tag
1127 do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);
1128
1129 // BER length, 19 = TLV_DEVICE_ID_SIZE(4) +
1130 // TLV_EVENT_LIST_SIZE(3) +
1131 // TLV_LOCATION_STATUS_SIZE(3) +
1132 // TLV_LOCATION_INFO_GSM_SIZE(9)
1133 do_check_eq(pduHelper.readHexOctet(), 19);
1134
1135 // Device Identifies, Type-Length-Value(Source ID-Destination ID)
1136 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_DEVICE_ID |
1137 COMPREHENSIONTLV_FLAG_CR);
1138 do_check_eq(pduHelper.readHexOctet(), 2);
1139 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_ME);
1140 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_SIM);
1141
1142 // Event List, Type-Length-Value
1143 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_EVENT_LIST |
1144 COMPREHENSIONTLV_FLAG_CR);
1145 do_check_eq(pduHelper.readHexOctet(), 1);
1146 do_check_eq(pduHelper.readHexOctet(), STK_EVENT_TYPE_LOCATION_STATUS);
1147
1148 // Location Status, Type-Length-Value
1149 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_LOCATION_STATUS |
1150 COMPREHENSIONTLV_FLAG_CR);
1151 do_check_eq(pduHelper.readHexOctet(), 1);
1152 do_check_eq(pduHelper.readHexOctet(), STK_SERVICE_STATE_NORMAL);
1153
1154 // Location Info, Type-Length-Value
1155 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_LOCATION_INFO |
1156 COMPREHENSIONTLV_FLAG_CR);
1157 do_check_eq(pduHelper.readHexOctet(), 7);
1158
1159 do_check_eq(pduHelper.readHexOctet(), 0x21); // MCC + MNC
1160 do_check_eq(pduHelper.readHexOctet(), 0x63);
1161 do_check_eq(pduHelper.readHexOctet(), 0x54);
1162 do_check_eq(pduHelper.readHexOctet(), 0); // LAC
1163 do_check_eq(pduHelper.readHexOctet(), 0);
1164 do_check_eq(pduHelper.readHexOctet(), 0); // Cell ID
1165 do_check_eq(pduHelper.readHexOctet(), 0);
1166
1167 run_next_test();
1168 };
1169
1170 let event = {
1171 eventType: STK_EVENT_TYPE_LOCATION_STATUS,
1172 locationStatus: STK_SERVICE_STATE_NORMAL,
1173 locationInfo: {
1174 mcc: "123",
1175 mnc: "456",
1176 gsmLocationAreaCode: 0,
1177 gsmCellId: 0
1178 }
1179 };
1180 context.RIL.sendStkEventDownload({
1181 event: event
1182 });
1183 });
1184
1185 // Test Event Download commands.
1186
1187 /**
1188 * Verify Event Download Command : Language Selection
1189 */
1190 add_test(function test_stk_event_download_language_selection() {
1191 let worker = newUint8SupportOutgoingIndexWorker();
1192 let context = worker.ContextPool._contexts[0];
1193 let buf = context.Buf;
1194 let pduHelper = context.GsmPDUHelper;
1195 let iccHelper = context.ICCPDUHelper;
1196
1197 buf.sendParcel = function() {
1198 // Type
1199 do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);
1200
1201 // Token : we don't care
1202 this.readInt32();
1203
1204 // Data Size, 26 = 2 * (2 + TLV_DEVICE_ID_SIZE(4) +
1205 // TLV_EVENT_LIST_SIZE(3) +
1206 // TLV_LANGUAGE(4))
1207 do_check_eq(this.readInt32(), 26);
1208
1209 // BER tag
1210 do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);
1211
1212 // BER length, 19 = TLV_DEVICE_ID_SIZE(4) +
1213 // TLV_EVENT_LIST_SIZE(3) +
1214 // TLV_LANGUAGE(4)
1215 do_check_eq(pduHelper.readHexOctet(), 11);
1216
1217 // Device Identifies, Type-Length-Value(Source ID-Destination ID)
1218 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_DEVICE_ID |
1219 COMPREHENSIONTLV_FLAG_CR);
1220 do_check_eq(pduHelper.readHexOctet(), 2);
1221 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_ME);
1222 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_SIM);
1223
1224 // Event List, Type-Length-Value
1225 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_EVENT_LIST |
1226 COMPREHENSIONTLV_FLAG_CR);
1227 do_check_eq(pduHelper.readHexOctet(), 1);
1228 do_check_eq(pduHelper.readHexOctet(), STK_EVENT_TYPE_LANGUAGE_SELECTION);
1229
1230 // Language, Type-Length-Value
1231 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_LANGUAGE);
1232 do_check_eq(pduHelper.readHexOctet(), 2);
1233 do_check_eq(iccHelper.read8BitUnpackedToString(2), "zh");
1234
1235 run_next_test();
1236 };
1237
1238 let event = {
1239 eventType: STK_EVENT_TYPE_LANGUAGE_SELECTION,
1240 language: "zh"
1241 };
1242 context.RIL.sendStkEventDownload({
1243 event: event
1244 });
1245 });
1246
1247 /**
1248 * Verify Event Download Command : User Activity
1249 */
1250 add_test(function test_stk_event_download_user_activity() {
1251 let worker = newUint8SupportOutgoingIndexWorker();
1252 let context = worker.ContextPool._contexts[0];
1253 let buf = context.Buf;
1254 let pduHelper = context.GsmPDUHelper;
1255
1256 buf.sendParcel = function() {
1257 // Type
1258 do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);
1259
1260 // Token : we don't care
1261 this.readInt32();
1262
1263 // Data Size, 18 = 2 * (2 + TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3))
1264 do_check_eq(this.readInt32(), 18);
1265
1266 // BER tag
1267 do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);
1268
1269 // BER length, 7 = TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3)
1270 do_check_eq(pduHelper.readHexOctet(), 7);
1271
1272 // Device Identities, Type-Length-Value(Source ID-Destination ID)
1273 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_DEVICE_ID |
1274 COMPREHENSIONTLV_FLAG_CR);
1275 do_check_eq(pduHelper.readHexOctet(), 2);
1276 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_ME);
1277 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_SIM);
1278
1279 // Event List, Type-Length-Value
1280 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_EVENT_LIST |
1281 COMPREHENSIONTLV_FLAG_CR);
1282 do_check_eq(pduHelper.readHexOctet(), 1);
1283 do_check_eq(pduHelper.readHexOctet(), STK_EVENT_TYPE_USER_ACTIVITY);
1284
1285 run_next_test();
1286 };
1287
1288 let event = {
1289 eventType: STK_EVENT_TYPE_USER_ACTIVITY
1290 };
1291 context.RIL.sendStkEventDownload({
1292 event: event
1293 });
1294 });
1295
1296 /**
1297 * Verify Event Download Command : Idle Screen Available
1298 */
1299 add_test(function test_stk_event_download_idle_screen_available() {
1300 let worker = newUint8SupportOutgoingIndexWorker();
1301 let context = worker.ContextPool._contexts[0];
1302 let buf = context.Buf;
1303 let pduHelper = context.GsmPDUHelper;
1304
1305 buf.sendParcel = function() {
1306 // Type
1307 do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);
1308
1309 // Token : we don't care
1310 this.readInt32();
1311
1312 // Data Size, 18 = 2 * (2 + TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3))
1313 do_check_eq(this.readInt32(), 18);
1314
1315 // BER tag
1316 do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);
1317
1318 // BER length, 7 = TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3)
1319 do_check_eq(pduHelper.readHexOctet(), 7);
1320
1321 // Device Identities, Type-Length-Value(Source ID-Destination ID)
1322 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_DEVICE_ID |
1323 COMPREHENSIONTLV_FLAG_CR);
1324 do_check_eq(pduHelper.readHexOctet(), 2);
1325 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_DISPLAY);
1326 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_SIM);
1327
1328 // Event List, Type-Length-Value
1329 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_EVENT_LIST |
1330 COMPREHENSIONTLV_FLAG_CR);
1331 do_check_eq(pduHelper.readHexOctet(), 1);
1332 do_check_eq(pduHelper.readHexOctet(), STK_EVENT_TYPE_IDLE_SCREEN_AVAILABLE);
1333
1334 run_next_test();
1335 };
1336
1337 let event = {
1338 eventType: STK_EVENT_TYPE_IDLE_SCREEN_AVAILABLE
1339 };
1340 context.RIL.sendStkEventDownload({
1341 event: event
1342 });
1343 });
1344
1345 /**
1346 * Verify Event Downloaded Command :Browser Termination
1347 */
1348 add_test(function test_stk_event_download_browser_termination() {
1349 let worker = newUint8SupportOutgoingIndexWorker();
1350 let context = worker.ContextPool._contexts[0];
1351 let buf = context.Buf;
1352 let pduHelper = context.GsmPDUHelper;
1353
1354 buf.sendParcel = function() {
1355 // Type
1356 do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);
1357
1358 // Token : we don't care
1359 this.readInt32();
1360
1361 // Data Size, 24 = 2 * ( 2+TLV_DEVICE_ID(4)+TLV_EVENT_LIST_SIZE(3)
1362 // +TLV_BROWSER_TERMINATION_CAUSE(3) )
1363 do_check_eq(this.readInt32(), 24);
1364
1365 // BER tag
1366 do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);
1367
1368 // BER length, 10 = TLV_DEVICE_ID(4)+TLV_EVENT_LIST_SIZE(3)
1369 // ++TLV_BROWSER_TERMINATION_CAUSE(3)
1370 do_check_eq(pduHelper.readHexOctet(), 10);
1371
1372 // Device Identities, Type-Length-Value(Source ID-Destination ID)
1373 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_DEVICE_ID |
1374 COMPREHENSIONTLV_FLAG_CR);
1375 do_check_eq(pduHelper.readHexOctet(), 2);
1376 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_ME);
1377 do_check_eq(pduHelper.readHexOctet(), STK_DEVICE_ID_SIM);
1378
1379 // Event List, Type-Length-Value
1380 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_EVENT_LIST |
1381 COMPREHENSIONTLV_FLAG_CR);
1382 do_check_eq(pduHelper.readHexOctet(), 1);
1383 do_check_eq(pduHelper.readHexOctet(), STK_EVENT_TYPE_BROWSER_TERMINATION);
1384
1385 // Browser Termination Case, Type-Length-Value
1386 do_check_eq(pduHelper.readHexOctet(), COMPREHENSIONTLV_TAG_BROWSER_TERMINATION_CAUSE |
1387 COMPREHENSIONTLV_FLAG_CR);
1388 do_check_eq(pduHelper.readHexOctet(), 1);
1389 do_check_eq(pduHelper.readHexOctet(), STK_BROWSER_TERMINATION_CAUSE_USER);
1390
1391 run_next_test();
1392 };
1393
1394 let event = {
1395 eventType: STK_EVENT_TYPE_BROWSER_TERMINATION,
1396 terminationCause: STK_BROWSER_TERMINATION_CAUSE_USER
1397 };
1398 context.RIL.sendStkEventDownload({
1399 event: event
1400 });
1401 });

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial