The Tor Browser: dom/system/gonk/tests/test_ril_worker

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* Any copyright is dedicated to the Public Domain.

     2    http://creativecommons.org/publicdomain/zero/1.0/ */

     4 subscriptLoader.loadSubScript("resource://gre/modules/ril_consts.js", this);

     6 function run_test() {

     7   run_next_test();

8 }

    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];

    19   context.Buf.writeUint8 = function(value) {

    20     buf.push(value);

    21   };

    23   context.Buf.readUint8 = function() {

    24     return buf[index++];

    25   };

    27   context.Buf.seekIncoming = function(offset) {

    28     index += offset;

    29   };

    31   worker.debug = do_print;

    33   return worker;

    34 }

    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];

    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     }

    49     context.Buf.outgoingIndex++;

    50   };

    52   context.Buf.readUint8 = function() {

    53     return buf[index++];

    54   };

    56   context.Buf.seekIncoming = function(offset) {

    57     index += offset;

    58   };

    60   worker.debug = do_print;

    62   return worker;

    63 }

    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   };

    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;

    86   context.RIL._processICCStatus(iccStatus);

    88   do_check_eq(profileSend, false);

    90   run_next_test();

    91 });

    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;

   102   ril.sendStkTerminalProfile(STK_SUPPORTED_TERMINAL_PROFILE);

   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   }

   111   run_next_test();

   112 });

   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;

   123   buf.sendParcel = function() {

   124     // Type

   125     do_check_eq(this.readInt32(), REQUEST_STK_SEND_TERMINAL_RESPONSE);

   127     // Token : we don't care

   128     this.readInt32();

   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);

   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);

   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);

   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);

   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");

   164     run_next_test();

   165   };

   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 });

   182 // Test ComprehensionTlvHelper

   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;

   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);

   202   let tag = pduHelper.readHexOctet();

   203   do_check_eq(tag, COMPREHENSIONTLV_TAG_LOCATION_INFO |

   204                    COMPREHENSIONTLV_FLAG_CR);

   206   let length = pduHelper.readHexOctet();

   207   do_check_eq(length, 9);

   209   let mcc_mnc = pduHelper.readSwappedNibbleBcdString(3);

   210   do_check_eq(mcc_mnc, "46692");

   212   let lac = (pduHelper.readHexOctet() << 8) | pduHelper.readHexOctet();

   213   do_check_eq(lac, 10291);

   215   let cellId = (pduHelper.readHexOctet() << 24) |

   216                (pduHelper.readHexOctet() << 16) |

   217                (pduHelper.readHexOctet() << 8)  |

   218                (pduHelper.readHexOctet());

   219   do_check_eq(cellId, 19072823);

   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);

   230   tag = pduHelper.readHexOctet();

   231   do_check_eq(tag, COMPREHENSIONTLV_TAG_LOCATION_INFO |

   232                    COMPREHENSIONTLV_FLAG_CR);

   234   length = pduHelper.readHexOctet();

   235   do_check_eq(length, 7);

   237   mcc_mnc = pduHelper.readSwappedNibbleBcdString(3);

   238   do_check_eq(mcc_mnc, "46602");

   240   lac = (pduHelper.readHexOctet() << 8) | pduHelper.readHexOctet();

   241   do_check_eq(lac, 10291);

   243   cellId = (pduHelper.readHexOctet() << 8) | (pduHelper.readHexOctet());

   244   do_check_eq(cellId, 65534);

   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);

   255   tag = pduHelper.readHexOctet();

   256   do_check_eq(tag, COMPREHENSIONTLV_TAG_LOCATION_INFO |

   257                    COMPREHENSIONTLV_FLAG_CR);

   259   length = pduHelper.readHexOctet();

   260   do_check_eq(length, 7);

   262   mcc_mnc = pduHelper.readSwappedNibbleBcdString(3);

   263   do_check_eq(mcc_mnc, "466222");

   265   lac = (pduHelper.readHexOctet() << 8) | pduHelper.readHexOctet();

   266   do_check_eq(lac, 10291);

   268   cellId = (pduHelper.readHexOctet() << 8) | (pduHelper.readHexOctet());

   269   do_check_eq(cellId, 65534);

   271   run_next_test();

   272 });

   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;

   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);

   293   run_next_test();

   294 });

   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;

   304   let length = 0x70;

   305   do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 1);

   307   length = 0x80;

   308   do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 2);

   310   length = 0x180;

   311   do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 3);

   313   length = 0x18000;

   314   do_check_eq(tlvHelper.getSizeOfLengthOctets(length), 4);

   316   run_next_test();

   317 });

   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;

   328   let length = 0x70;

   329   tlvHelper.writeLength(length);

   330   do_check_eq(pduHelper.readHexOctet(), length);

   332   length = 0x80;

   333   tlvHelper.writeLength(length);

   334   do_check_eq(pduHelper.readHexOctet(), 0x81);

   335   do_check_eq(pduHelper.readHexOctet(), length);

   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);

   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);

   350   run_next_test();

   351 });

   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;

   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];

   373   for (let i = 0; i < tag_test.length; i++) {

   374     pduHelper.writeHexOctet(tag_test[i]);

   375   }

   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");

   382   tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);

   383   do_check_eq(tlv.value.identifier, "alpha id 2");

   385   tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);

   386   do_check_eq(tlv.value.identifier, "alpha id 3");

   388   tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);

   389   do_check_eq(tlv.value.identifier, "alpha id 4");

   391   tlv = stkHelper.searchForNextTag(COMPREHENSIONTLV_TAG_ALPHA_ID, iter);

   392   do_check_eq(tlv.value.identifier, "alpha id 5");

   394   run_next_test();

   395 });

   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;

   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];

   414   for (let i = 0; i < refresh_1.length; i++) {

   415     pduHelper.writeHexOctet(refresh_1[i]);

   416   }

   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);

   425   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_FILE_LIST, ctlvs);

   426   do_check_eq(tlv.value.fileList, "3F002FE2");

   428   run_next_test();

   429 });

   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;

   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];

   450   for (let i = 0; i < tone_1.length; i++) {

   451     pduHelper.writeHexOctet(tone_1[i]);

   452   }

   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);

   461   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);

   462   do_check_eq(tlv.value.identifier, "Dial Tone");

   464   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TONE, ctlvs);

   465   do_check_eq(tlv.value.tone, STK_TONE_TYPE_DIAL_TONE);

   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);

   471   run_next_test();

   472 });

   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;

   484   let poll_1 = [

   485     0xD0,

   486     0x0D,

   487     0x81, 0x03, 0x01, 0x03, 0x00,

   488     0x82, 0x02, 0x81, 0x82,

   489     0x84, 0x02, 0x01, 0x14];

   491   for (let i = 0; i < poll_1.length; i++) {

   492     pduHelper.writeHexOctet(poll_1[i]);

   493   }

   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);

   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);

   506   run_next_test();

   507 });

   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;

   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   ];

   529   for (let i = 0; i < display_text_1.length; i++) {

   530     pduHelper.writeHexOctet(display_text_1[i]);

   531   }

   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. ");

   538   run_next_test();

   539 });

   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;

   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];

   558   for (let i = 0; i < event_1.length; i++) {

   559     pduHelper.writeHexOctet(event_1[i]);

   560   }

   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);

   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   }

   575   run_next_test();

   576 });

   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;

   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];

   598   for (let i = 0; i < get_input_1.length; i++) {

   599     pduHelper.writeHexOctet(get_input_1[i]);

   600   }

   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);

   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");

   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];

   628   for (let i = 0; i < get_input_2.length; i++) {

   629     pduHelper.writeHexOctet(get_input_2[i]);

   630   }

   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);

   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);

   644   run_next_test();

   645 });

   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;

   657   let more_time_1 = [

   658     0xD0,

   659     0x09,

   660     0x81, 0x03, 0x01, 0x02, 0x00,

   661     0x82, 0x02, 0x81, 0x82];

   663   for(let i = 0 ; i < more_time_1.length; i++) {

   664     pduHelper.writeHexOctet(more_time_1[i]);

   665   }

   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);

   674   run_next_test();

   675 });

   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;

   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   ];

   701   for(let i = 0 ; i < select_item_1.length; i++) {

   702     pduHelper.writeHexOctet(select_item_1[i]);

   703   }

   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);

   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);

   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   ];

   738   for(let i = 0 ; i < select_item_2.length; i++) {

   739     pduHelper.writeHexOctet(select_item_2[i]);

   740   }

   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);

   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);

   762   run_next_test();

   763 });

   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;

   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   ];

   788   for(let i = 0 ; i < set_up_menu_1.length; i++) {

   789     pduHelper.writeHexOctet(set_up_menu_1[i]);

   790   }

   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);

   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);

   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   ];

   823   for(let i = 0 ; i < set_up_menu_2.length; i++) {

   824     pduHelper.writeHexOctet(set_up_menu_2[i]);

   825   }

   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);

   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);

   846   run_next_test();

   847 });

   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;

   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];

   869   for (let i = 0 ; i < set_up_call_1.length; i++) {

   870     pduHelper.writeHexOctet(set_up_call_1[i]);

   871   }

   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);

   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");

   884   run_next_test();

   885 });

   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;

   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   ];

   907   for(let i = 0 ; i < timer_management_1.length; i++) {

   908     pduHelper.writeHexOctet(timer_management_1[i]);

   909   }

   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);

   918   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER, ctlvs);

   919   do_check_eq(tlv.value.timerId, 0x01);

   921   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TIMER_VALUE, ctlvs);

   922   do_check_eq(tlv.value.timerValue, (0x01 * 60 * 60) + (0x02 * 60) + 0x03);

   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   ];

   933   for(let i = 0 ; i < timer_management_2.length; i++) {

   934     pduHelper.writeHexOctet(timer_management_2[i]);

   935   }

   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);

   944   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_TIMER_IDENTIFIER, ctlvs);

   945   do_check_eq(tlv.value.timerId, 0x01);

   947   run_next_test();

   948 });

   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;

   960   // Verify IMEI

   961   let local_info_1 = [

   962     0xD0,

   963     0x09,

   964     0x81, 0x03, 0x01, 0x26, 0x01,

   965     0x82, 0x02, 0x81, 0x82];

   967   for (let i = 0; i < local_info_1.length; i++) {

   968     pduHelper.writeHexOctet(local_info_1[i]);

   969   }

   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);

   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];

   985   for (let i = 0; i < local_info_2.length; i++) {

   986     pduHelper.writeHexOctet(local_info_2[i]);

   987   }

   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);

   996   run_next_test();

   997 });

   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;

  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   ];

  1018   for (let i = 0; i < open_channel.length; i++) {

  1019     pduHelper.writeHexOctet(open_channel[i]);

  1020   }

  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);

  1029   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);

  1030   do_check_eq(tlv.value.identifier, "Open");

  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   ];

  1041   for (let i = 0; i < close_channel.length; i++) {

  1042     pduHelper.writeHexOctet(close_channel[i]);

  1043   }

  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);

  1052   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);

  1053   do_check_eq(tlv.value.identifier, "Close");

  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   ];

  1064   for (let i = 0; i < receive_data.length; i++) {

  1065     pduHelper.writeHexOctet(receive_data[i]);

  1066   }

  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);

  1075   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);

  1076   do_check_eq(tlv.value.identifier, "Receive");

  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   ];

  1087   for (let i = 0; i < send_data.length; i++) {

  1088     pduHelper.writeHexOctet(send_data[i]);

  1089   }

  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);

  1098   tlv = stkHelper.searchForTag(COMPREHENSIONTLV_TAG_ALPHA_ID, ctlvs);

  1099   do_check_eq(tlv.value.identifier, "Send");

  1101   run_next_test();

  1102 });

  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;

  1113   buf.sendParcel = function() {

  1114     // Type

  1115     do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);

  1117     // Token : we don't care

  1118     this.readInt32();

  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);

  1126     // BER tag

  1127     do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);

  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);

  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);

  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);

  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);

  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);

  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);

  1167     run_next_test();

  1168   };

  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 });

  1185 // Test Event Download commands.

  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;

  1197   buf.sendParcel = function() {

  1198     // Type

  1199     do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);

  1201     // Token : we don't care

  1202     this.readInt32();

  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);

  1209     // BER tag

  1210     do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);

  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);

  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);

  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);

  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");

  1235     run_next_test();

  1236   };

  1238   let event = {

  1239     eventType: STK_EVENT_TYPE_LANGUAGE_SELECTION,

  1240     language: "zh"

  1241   };

  1242   context.RIL.sendStkEventDownload({

  1243     event: event

  1244   });

  1245 });

  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;

  1256   buf.sendParcel = function() {

  1257     // Type

  1258     do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);

  1260     // Token : we don't care

  1261     this.readInt32();

  1263     // Data Size, 18 = 2 * (2 + TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3))

  1264     do_check_eq(this.readInt32(), 18);

  1266     // BER tag

  1267     do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);

  1269     // BER length, 7 = TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3)

  1270     do_check_eq(pduHelper.readHexOctet(), 7);

  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);

  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);

  1285     run_next_test();

  1286   };

  1288   let event = {

  1289     eventType: STK_EVENT_TYPE_USER_ACTIVITY

  1290   };

  1291   context.RIL.sendStkEventDownload({

  1292     event: event

  1293   });

  1294 });

  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;

  1305   buf.sendParcel = function() {

  1306     // Type

  1307     do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);

  1309     // Token : we don't care

  1310     this.readInt32();

  1312     // Data Size, 18 = 2 * (2 + TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3))

  1313     do_check_eq(this.readInt32(), 18);

  1315     // BER tag

  1316     do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);

  1318     // BER length, 7 = TLV_DEVICE_ID_SIZE(4) + TLV_EVENT_LIST_SIZE(3)

  1319     do_check_eq(pduHelper.readHexOctet(), 7);

  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);

  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);

  1334     run_next_test();

  1335   };

  1337   let event = {

  1338     eventType: STK_EVENT_TYPE_IDLE_SCREEN_AVAILABLE

  1339   };

  1340   context.RIL.sendStkEventDownload({

  1341     event: event

  1342   });

  1343 });

  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;

  1354   buf.sendParcel = function() {

  1355     // Type

  1356     do_check_eq(this.readInt32(), REQUEST_STK_SEND_ENVELOPE_COMMAND);

  1358     // Token : we don't care

  1359     this.readInt32();

  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);

  1365     // BER tag

  1366     do_check_eq(pduHelper.readHexOctet(), BER_EVENT_DOWNLOAD_TAG);

  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);

  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);

  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);

  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);

  1391     run_next_test();

  1392   };

  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 });

The Tor Browser / file revision

dom/system/gonk/tests/test_ril_worker_stk.js@6474c204b198

dom/system/gonk/tests/test_ril_worker_stk.js