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

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     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 function parseMMI(mmi) {

    11   let worker = newWorker({

    12     postRILMessage: function(data) {

    13       // Do nothing

    14     },

    15     postMessage: function(message) {

    16       // Do nothing

    17     }

    18   });

    19   let context = worker.ContextPool._contexts[0];

    20   return context.RIL._parseMMI(mmi);

    21 }

    23 function getWorker() {

    24   let _postedMessage;

    25   let _worker = newWorker({

    26     postRILMessage: function(data) {

    27     },

    28     postMessage: function(message) {

    29       _postedMessage = message;

    30     },

    31   });

    33   return {

    34     get postedMessage() {

    35       return _postedMessage;

    36     },

    37     get worker() {

    38       return _worker;

    39     }

    40   };

    41 }

    43 function testSendMMI(mmi, error) {

    44   let workerhelper = getWorker();

    45   let worker = workerhelper.worker;

    46   let context = worker.ContextPool._contexts[0];

    48   do_print("worker.postMessage " + worker.postMessage);

    50   context.RIL.radioState = GECKO_RADIOSTATE_READY;

    51   context.RIL.sendMMI({rilMessageType: "sendMMI", mmi: mmi});

    53   let postedMessage = workerhelper.postedMessage;

    55   do_check_eq(postedMessage.rilMessageType, "sendMMI");

    56   do_check_eq(postedMessage.errorMsg, error);

    57 }

    59 add_test(function test_parseMMI_empty() {

    60   let mmi = parseMMI("");

    62   do_check_null(mmi);

    64   run_next_test();

    65 });

    67 add_test(function test_parseMMI_undefined() {

    68   let mmi = parseMMI();

    70   do_check_null(mmi);

    72   run_next_test();

    73 });

    75 add_test(function test_parseMMI_one_digit_short_code() {

    76   let mmi = parseMMI("1");

    78   do_check_eq(mmi.fullMMI, "1");

    79   do_check_eq(mmi.procedure, undefined);

    80   do_check_eq(mmi.serviceCode, undefined);

    81   do_check_eq(mmi.sia, undefined);

    82   do_check_eq(mmi.sib, undefined);

    83   do_check_eq(mmi.sic, undefined);

    84   do_check_eq(mmi.pwd, undefined);

    85   do_check_eq(mmi.dialNumber, undefined);

    87   run_next_test();

    88 });

    90 add_test(function test_parseMMI_invalid_short_code() {

    91   let mmi = parseMMI("11");

    93   do_check_null(mmi);

    95   run_next_test();

    96 });

    98 add_test(function test_parseMMI_short_code() {

    99   let mmi = parseMMI("21");

   101   do_check_eq(mmi.fullMMI, "21");

   102   do_check_eq(mmi.procedure, undefined);

   103   do_check_eq(mmi.serviceCode, undefined);

   104   do_check_eq(mmi.sia, undefined);

   105   do_check_eq(mmi.sib, undefined);

   106   do_check_eq(mmi.sic, undefined);

   107   do_check_eq(mmi.pwd, undefined);

   108   do_check_eq(mmi.dialNumber, undefined);

   110   run_next_test();

   111 });

   113 add_test(function test_parseMMI_dial_string() {

   114   let mmi = parseMMI("12345");

   116   do_check_null(mmi);

   118   run_next_test();

   119 });

   121 add_test(function test_parseMMI_USSD_without_asterisk_prefix() {

   122   let mmi = parseMMI("123#");

   124   do_check_eq(mmi.fullMMI, "123#");

   125   do_check_eq(mmi.procedure, undefined);

   126   do_check_eq(mmi.serviceCode, undefined);

   127   do_check_eq(mmi.sia, undefined);

   128   do_check_eq(mmi.sib, undefined);

   129   do_check_eq(mmi.sic, undefined);

   130   do_check_eq(mmi.pwd, undefined);

   131   do_check_eq(mmi.dialNumber, undefined);

   133   run_next_test();

   134 });

   136 add_test(function test_parseMMI_USSD() {

   137   let mmi = parseMMI("*123#");

   139   do_check_eq(mmi.fullMMI, "*123#");

   140   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   141   do_check_eq(mmi.serviceCode, "123");

   142   do_check_eq(mmi.sia, undefined);

   143   do_check_eq(mmi.sib, undefined);

   144   do_check_eq(mmi.sic, undefined);

   145   do_check_eq(mmi.pwd, undefined);

   146   do_check_eq(mmi.dialNumber, "");

   148   run_next_test();

   149 });

   151 add_test(function test_parseMMI_sia() {

   152   let mmi = parseMMI("*123*1#");

   154   do_check_eq(mmi.fullMMI, "*123*1#");

   155   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   156   do_check_eq(mmi.serviceCode, "123");

   157   do_check_eq(mmi.sia, "1");

   158   do_check_eq(mmi.sib, undefined);

   159   do_check_eq(mmi.sic, undefined);

   160   do_check_eq(mmi.pwd, undefined);

   161   do_check_eq(mmi.dialNumber, "");

   163   run_next_test();

   164 });

   166 add_test(function test_parseMMI_sib() {

   167   let mmi = parseMMI("*123**1#");

   169   do_check_eq(mmi.fullMMI, "*123**1#");

   170   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   171   do_check_eq(mmi.serviceCode, "123");

   172   do_check_eq(mmi.sia, "");

   173   do_check_eq(mmi.sib, "1");

   174   do_check_eq(mmi.sic, undefined);

   175   do_check_eq(mmi.pwd, undefined);

   176   do_check_eq(mmi.dialNumber, "");

   178   run_next_test();

   179 });

   181 add_test(function test_parseMMI_sic() {

   182   let mmi = parseMMI("*123***1#");

   184   do_check_eq(mmi.fullMMI, "*123***1#");

   185   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   186   do_check_eq(mmi.serviceCode, "123");

   187   do_check_eq(mmi.sia, "");

   188   do_check_eq(mmi.sib, "");

   189   do_check_eq(mmi.sic, "1");

   190   do_check_eq(mmi.pwd, undefined);

   191   do_check_eq(mmi.dialNumber, "");

   193   run_next_test();

   194 });

   196 add_test(function test_parseMMI_sia_sib() {

   197   let mmi = parseMMI("*123*1*1#");

   199   do_check_eq(mmi.fullMMI, "*123*1*1#");

   200   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   201   do_check_eq(mmi.serviceCode, "123");

   202   do_check_eq(mmi.sia, "1");

   203   do_check_eq(mmi.sib, "1");

   204   do_check_eq(mmi.sic, undefined);

   205   do_check_eq(mmi.pwd, undefined);

   206   do_check_eq(mmi.dialNumber, "");

   208   run_next_test();

   209 });

   211 add_test(function test_parseMMI_sia_sic() {

   212   let mmi = parseMMI("*123*1**1#");

   214   do_check_eq(mmi.fullMMI, "*123*1**1#");

   215   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   216   do_check_eq(mmi.serviceCode, "123");

   217   do_check_eq(mmi.sia, "1");

   218   do_check_eq(mmi.sib, "");

   219   do_check_eq(mmi.sic, "1");

   220   do_check_eq(mmi.pwd, undefined);

   221   do_check_eq(mmi.dialNumber, "");

   223   run_next_test();

   224 });

   226 add_test(function test_parseMMI_sib_sic() {

   227   let mmi = parseMMI("*123**1*1#");

   229   do_check_eq(mmi.fullMMI, "*123**1*1#");

   230   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   231   do_check_eq(mmi.serviceCode, "123");

   232   do_check_eq(mmi.sia, "");

   233   do_check_eq(mmi.sib, "1");

   234   do_check_eq(mmi.sic, "1");

   235   do_check_eq(mmi.pwd, undefined);

   236   do_check_eq(mmi.dialNumber, "");

   238   run_next_test();

   239 });

   241 add_test(function test_parseMMI_pwd() {

   242   let mmi = parseMMI("*123****1#");

   244   do_check_eq(mmi.fullMMI, "*123****1#");

   245   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   246   do_check_eq(mmi.serviceCode, "123");

   247   do_check_eq(mmi.sia, "");

   248   do_check_eq(mmi.sib, "");

   249   do_check_eq(mmi.sic, "");

   250   do_check_eq(mmi.pwd, "1");

   251   do_check_eq(mmi.dialNumber, "");

   253   run_next_test();

   254 });

   256 add_test(function test_parseMMI_dial_number() {

   257   let mmi = parseMMI("*123#345");

   259   do_check_eq(mmi.fullMMI, "*123#");

   260   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   261   do_check_eq(mmi.serviceCode, "123");

   262   do_check_eq(mmi.sia, undefined);

   263   do_check_eq(mmi.sib, undefined);

   264   do_check_eq(mmi.sic, undefined);

   265   do_check_eq(mmi.pwd, undefined);

   266   do_check_eq(mmi.dialNumber, "345");

   268   run_next_test();

   269 });

   272 /**

   273  * MMI procedures tests

   274  */

   276 add_test(function test_parseMMI_activation() {

   277   let mmi = parseMMI("*00*12*34*56#");

   279   do_check_eq(mmi.fullMMI, "*00*12*34*56#");

   280   do_check_eq(mmi.procedure, MMI_PROCEDURE_ACTIVATION);

   281   do_check_eq(mmi.serviceCode, "00");

   282   do_check_eq(mmi.sia, "12");

   283   do_check_eq(mmi.sib, "34");

   284   do_check_eq(mmi.sic, "56");

   285   do_check_eq(mmi.pwd, undefined);

   286   do_check_eq(mmi.dialNumber, "");

   288   run_next_test();

   289 });

   291 add_test(function test_parseMMI_deactivation() {

   292   let mmi = parseMMI("#00*12*34*56#");

   294   do_check_eq(mmi.fullMMI, "#00*12*34*56#");

   295   do_check_eq(mmi.procedure, MMI_PROCEDURE_DEACTIVATION);

   296   do_check_eq(mmi.serviceCode, "00");

   297   do_check_eq(mmi.sia, "12");

   298   do_check_eq(mmi.sib, "34");

   299   do_check_eq(mmi.sic, "56");

   300   do_check_eq(mmi.pwd, undefined);

   301   do_check_eq(mmi.dialNumber, "");

   303   run_next_test();

   304 });

   306 add_test(function test_parseMMI_interrogation() {

   307   let mmi = parseMMI("*#00*12*34*56#");

   309   do_check_eq(mmi.fullMMI, "*#00*12*34*56#");

   310   do_check_eq(mmi.procedure, MMI_PROCEDURE_INTERROGATION);

   311   do_check_eq(mmi.serviceCode, "00");

   312   do_check_eq(mmi.sia, "12");

   313   do_check_eq(mmi.sib, "34");

   314   do_check_eq(mmi.sic, "56");

   315   do_check_eq(mmi.pwd, undefined);

   316   do_check_eq(mmi.dialNumber, "");

   318   run_next_test();

   319 });

   321 add_test(function test_parseMMI_registration() {

   322   let mmi = parseMMI("**00*12*34*56#");

   324   do_check_eq(mmi.fullMMI, "**00*12*34*56#");

   325   do_check_eq(mmi.procedure, MMI_PROCEDURE_REGISTRATION);

   326   do_check_eq(mmi.serviceCode, "00");

   327   do_check_eq(mmi.sia, "12");

   328   do_check_eq(mmi.sib, "34");

   329   do_check_eq(mmi.sic, "56");

   330   do_check_eq(mmi.pwd, undefined);

   331   do_check_eq(mmi.dialNumber, "");

   333   run_next_test();

   334 });

   336 add_test(function test_parseMMI_erasure() {

   337   let mmi = parseMMI("##00*12*34*56#");

   339   do_check_eq(mmi.fullMMI, "##00*12*34*56#");

   340   do_check_eq(mmi.procedure, MMI_PROCEDURE_ERASURE);

   341   do_check_eq(mmi.serviceCode, "00");

   342   do_check_eq(mmi.sia, "12");

   343   do_check_eq(mmi.sib, "34");

   344   do_check_eq(mmi.sic, "56");

   345   do_check_eq(mmi.pwd, undefined);

   346   do_check_eq(mmi.dialNumber, "");

   348   run_next_test();

   349 });

   351 /**

   352  * sendMMI tests.

   353  */

   355 add_test(function test_sendMMI_empty() {

   356   testSendMMI("", MMI_ERROR_KS_ERROR);

   358   run_next_test();

   359 });

   361 add_test(function test_sendMMI_undefined() {

   362   testSendMMI({}, MMI_ERROR_KS_ERROR);

   364   run_next_test();

   365 });

   367 add_test(function test_sendMMI_invalid() {

   368   testSendMMI("11", MMI_ERROR_KS_ERROR);

   370   run_next_test();

   371 });

   373 add_test(function test_sendMMI_short_code() {

   374   let workerhelper = getWorker();

   375   let worker = workerhelper.worker;

   376   let context = worker.ContextPool._contexts[0];

   378   let ussdOptions;

   380   context.RIL.sendUSSD = function fakeSendUSSD(options){

   381     ussdOptions = options;

   382     context.RIL[REQUEST_SEND_USSD](0, {

   383       rilRequestError: ERROR_SUCCESS

   384     });

   386   };

   388   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   389   context.RIL.sendMMI({mmi: "**"});

   391   let postedMessage = workerhelper.postedMessage;

   392   do_check_eq(ussdOptions.ussd, "**");

   393   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   394   do_check_true(postedMessage.success);

   395   do_check_true(context.RIL._ussdSession);

   397   run_next_test();

   398 });

   400 add_test(function test_sendMMI_dial_string() {

   401   testSendMMI("123", MMI_ERROR_KS_ERROR);

   403   run_next_test();

   404 });

   406 function setCallForwardSuccess(mmi) {

   407   let workerhelper = getWorker();

   408   let worker = workerhelper.worker;

   409   let context = worker.ContextPool._contexts[0];

   411   context.RIL.setCallForward = function fakeSetCallForward(options) {

   412     context.RIL[REQUEST_SET_CALL_FORWARD](0, {

   413       rilRequestError: ERROR_SUCCESS

   414     });

   415   };

   417   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   418   context.RIL.sendMMI({mmi: mmi});

   420   let postedMessage = workerhelper.postedMessage;

   422   do_check_eq(postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   423   do_check_true(postedMessage.success);

   424 }

   426 add_test(function test_sendMMI_call_forwarding_activation() {

   427   setCallForwardSuccess("*21*12345*99*10#");

   429   run_next_test();

   430 });

   432 add_test(function test_sendMMI_call_forwarding_deactivation() {

   433   setCallForwardSuccess("#21*12345*99*10#");

   435   run_next_test();

   436 });

   438 add_test(function test_sendMMI_call_forwarding_interrogation() {

   439   let workerhelper = getWorker();

   440   let worker = workerhelper.worker;

   441   let context = worker.ContextPool._contexts[0];

   443   context.Buf.readInt32 = function fakeReadUint32() {

   444     return context.Buf.int32Array.pop();

   445   };

   447   context.Buf.readString = function fakeReadString() {

   448     return "+34666222333";

   449   };

   451   context.RIL.queryCallForwardStatus = function fakeQueryCallForward(options) {

   452     context.Buf.int32Array = [

   453       0,   // rules.timeSeconds

   454       145, // rules.toa

   455       49,  // rules.serviceClass

   456       Ci.nsIDOMMozMobileCFInfo.CALL_FORWARD_REASON_UNCONDITIONAL, // rules.reason

   457       1,   // rules.active

   458       1    // rulesLength

   459     ];

   460     context.RIL[REQUEST_QUERY_CALL_FORWARD_STATUS](1, {

   461       rilRequestError: ERROR_SUCCESS

   462     });

   463   };

   465   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   466   context.RIL.sendMMI({mmi: "*#21#"});

   468   let postedMessage = workerhelper.postedMessage;

   470   do_check_eq(postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   471   do_check_true(postedMessage.success);

   472   do_check_true(Array.isArray(postedMessage.rules));

   473   do_check_eq(postedMessage.rules.length, 1);

   474   do_check_true(postedMessage.rules[0].active);

   475   do_check_eq(postedMessage.rules[0].reason,

   476               Ci.nsIDOMMozMobileCFInfo.CALL_FORWARD_REASON_UNCONDITIONAL);

   477   do_check_eq(postedMessage.rules[0].number, "+34666222333");

   478   run_next_test();

   479 });

   481 add_test(function test_sendMMI_call_forwarding_interrogation_no_rules() {

   482   let workerhelper = getWorker();

   483   let worker = workerhelper.worker;

   484   let context = worker.ContextPool._contexts[0];

   486   context.Buf.readInt32 = function fakeReadUint32() {

   487     return 0;

   488   };

   490   context.RIL.queryCallForwardStatus = function fakeQueryCallForward(options) {

   491     context.RIL[REQUEST_QUERY_CALL_FORWARD_STATUS](1, {

   492       rilRequestError: ERROR_SUCCESS

   493     });

   494   };

   496   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   497   context.RIL.sendMMI({mmi: "*#21#"});

   499   let postedMessage = workerhelper.postedMessage;

   501   do_check_eq(postedMessage.errorMsg, GECKO_ERROR_GENERIC_FAILURE);

   502   do_check_false(postedMessage.success);

   504   run_next_test();

   505 });

   508 add_test(function test_sendMMI_call_forwarding_registration() {

   509   setCallForwardSuccess("**21*12345*99*10#");

   511   run_next_test();

   512 });

   514 add_test(function test_sendMMI_call_forwarding_erasure() {

   515   setCallForwardSuccess("##21*12345*99#");

   517   run_next_test();

   518 });

   520 add_test(function test_sendMMI_call_forwarding_CFB() {

   521   setCallForwardSuccess("*67*12345*99*10#");

   523   run_next_test();

   524 });

   526 add_test(function test_sendMMI_call_forwarding_CFNRy() {

   527   setCallForwardSuccess("*61*12345*99*10#");

   529   run_next_test();

   530 });

   532 add_test(function test_sendMMI_call_forwarding_CFNRc() {

   533   setCallForwardSuccess("*62*12345*99*10#");

   535   run_next_test();

   536 });

   538 add_test(function test_sendMMI_call_forwarding_CFAll() {

   539   setCallForwardSuccess("*004*12345*99*10#");

   541   run_next_test();

   542 });

   544 add_test(function test_sendMMI_call_forwarding_CFAllConditional() {

   545   setCallForwardSuccess("*002*12345*99*10#");

   547   run_next_test();

   548 });

   550 add_test(function test_sendMMI_change_PIN() {

   551   let workerhelper = getWorker();

   552   let worker = workerhelper.worker;

   553   let context = worker.ContextPool._contexts[0];

   555   context.RIL.changeICCPIN = function fakeChangeICCPIN(options) {

   556     context.RIL[REQUEST_ENTER_SIM_PIN](0, {

   557       rilRequestError: ERROR_SUCCESS

   558     });

   559   };

   561   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   562   context.RIL.sendMMI({mmi: "**04*1234*4567*4567#"});

   564   let postedMessage = workerhelper.postedMessage;

   566   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   567   do_check_true(postedMessage.success);

   569   run_next_test();

   570 });

   572 add_test(function test_sendMMI_change_PIN_no_new_PIN() {

   573   testSendMMI("**04*1234**4567#", MMI_ERROR_KS_ERROR);

   575   run_next_test();

   576 });

   578 add_test(function test_sendMMI_change_PIN_no_old_PIN() {

   579   testSendMMI("**04**1234*4567#", MMI_ERROR_KS_ERROR);

   581   run_next_test();

   582 });

   584 add_test(function test_sendMMI_change_PIN_wrong_procedure() {

   585   testSendMMI("*04*1234*4567*4567#", MMI_ERROR_KS_INVALID_ACTION);

   587   run_next_test();

   588 });

   590 add_test(function test_sendMMI_change_PIN_new_PIN_mismatch() {

   591   testSendMMI("**04*4567*1234*4567#", MMI_ERROR_KS_MISMATCH_PIN);

   593   run_next_test();

   594 });

   596 add_test(function test_sendMMI_change_PIN2() {

   597   let workerhelper = getWorker();

   598   let worker = workerhelper.worker;

   599   let context = worker.ContextPool._contexts[0];

   601   context.RIL.changeICCPIN2 = function fakeChangeICCPIN2(options){

   602     context.RIL[REQUEST_ENTER_SIM_PIN2](0, {

   603       rilRequestError: ERROR_SUCCESS

   604     });

   605   };

   607   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   608   context.RIL.sendMMI({mmi: "**042*1234*4567*4567#"});

   610   let postedMessage = workerhelper.postedMessage;

   612   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   613   do_check_true(postedMessage.success);

   615   run_next_test();

   616 });

   618 add_test(function test_sendMMI_change_PIN2_no_new_PIN2() {

   619   testSendMMI("**042*1234**4567#", MMI_ERROR_KS_ERROR);

   621   run_next_test();

   622 });

   624 add_test(function test_sendMMI_change_PIN2_no_old_PIN2() {

   625   testSendMMI("**042**1234*4567#", MMI_ERROR_KS_ERROR);

   627   run_next_test();

   628 });

   630 add_test(function test_sendMMI_change_PIN2_wrong_procedure() {

   631   testSendMMI("*042*1234*4567*4567#", MMI_ERROR_KS_INVALID_ACTION);

   633   run_next_test();

   634 });

   636 add_test(function test_sendMMI_change_PIN2_new_PIN2_mismatch() {

   637   testSendMMI("**042*4567*1234*4567#", MMI_ERROR_KS_MISMATCH_PIN);

   639   run_next_test();

   640 });

   642 add_test(function test_sendMMI_unblock_PIN() {

   643   let workerhelper = getWorker();

   644   let worker = workerhelper.worker;

   645   let context = worker.ContextPool._contexts[0];

   647   context.RIL.enterICCPUK = function fakeEnterICCPUK(options){

   648     context.RIL[REQUEST_ENTER_SIM_PUK](0, {

   649       rilRequestError: ERROR_SUCCESS

   650     });

   651   };

   653   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   654   context.RIL.sendMMI({mmi: "**05*1234*4567*4567#"});

   656   let postedMessage = workerhelper.postedMessage;

   658   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   659   do_check_true(postedMessage.success);

   661   run_next_test();

   662 });

   664 add_test(function test_sendMMI_unblock_PIN_no_new_PIN() {

   665   testSendMMI("**05*1234**4567#", MMI_ERROR_KS_ERROR);

   667   run_next_test();

   668 });

   670 add_test(function test_sendMMI_unblock_PIN_no_PUK() {

   671   testSendMMI("**05**1234*4567#", MMI_ERROR_KS_ERROR);

   673   run_next_test();

   674 });

   676 add_test(function test_sendMMI_unblock_PIN_wrong_procedure() {

   677   testSendMMI("*05*1234*4567*4567#", MMI_ERROR_KS_INVALID_ACTION);

   679   run_next_test();

   680 });

   682 add_test(function test_sendMMI_unblock_PIN_new_PIN_mismatch() {

   683   testSendMMI("**05*4567*1234*4567#", MMI_ERROR_KS_MISMATCH_PIN);

   685   run_next_test();

   686 });

   688 add_test(function test_sendMMI_unblock_PIN2() {

   689   let workerhelper = getWorker();

   690   let worker = workerhelper.worker;

   691   let context = worker.ContextPool._contexts[0];

   693   context.RIL.enterICCPUK2 = function fakeEnterICCPUK2(options){

   694     context.RIL[REQUEST_ENTER_SIM_PUK2](0, {

   695       rilRequestError: ERROR_SUCCESS

   696     });

   697   };

   699   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   700   context.RIL.sendMMI({mmi: "**052*1234*4567*4567#"});

   702   let postedMessage = workerhelper.postedMessage;

   704   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   705   do_check_true(postedMessage.success);

   707   run_next_test();

   708 });

   710 add_test(function test_sendMMI_unblock_PIN2_no_new_PIN2() {

   711   testSendMMI("**052*1234**4567#", MMI_ERROR_KS_ERROR);

   713   run_next_test();

   714 });

   716 add_test(function test_sendMMI_unblock_PIN2_no_PUK2() {

   717   testSendMMI("**052**1234*4567#", MMI_ERROR_KS_ERROR);

   719   run_next_test();

   720 });

   722 add_test(function test_sendMMI_unblock_PIN2_wrong_procedure() {

   723   testSendMMI("*052*1234*4567*4567#", MMI_ERROR_KS_INVALID_ACTION);

   725   run_next_test();

   726 });

   728 add_test(function test_sendMMI_unblock_PIN2_new_PIN_mismatch() {

   729   testSendMMI("**052*4567*1234*4567#", MMI_ERROR_KS_MISMATCH_PIN);

   731   run_next_test();

   732 });

   734 add_test(function test_sendMMI_get_IMEI() {

   735   let workerhelper = getWorker();

   736   let worker = workerhelper.worker;

   737   let context = worker.ContextPool._contexts[0];

   738   let mmiOptions;

   740   context.RIL.getIMEI = function getIMEI(options){

   741     mmiOptions = options;

   742     context.RIL[REQUEST_SEND_USSD](0, {

   743       rilRequestError: ERROR_SUCCESS,

   744     });

   745   };

   747   context.RIL.sendMMI({mmi: "*#06#"});

   749   let postedMessage = workerhelper.postedMessage;

   751   do_check_neq(mmiOptions.mmi, null);

   752   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   753   do_check_true(postedMessage.success);

   755   run_next_test();

   756 });

   758 add_test(function test_sendMMI_get_IMEI_error() {

   759   let workerhelper = getWorker();

   760   let worker = workerhelper.worker;

   761   let context = worker.ContextPool._contexts[0];

   762   let mmiOptions;

   764   context.RIL.getIMEI = function getIMEI(options){

   765     mmiOptions = options;

   766     context.RIL[REQUEST_SEND_USSD](0, {

   767       rilRequestError: ERROR_RADIO_NOT_AVAILABLE,

   768     });

   769   };

   771   context.RIL.sendMMI({mmi: "*#06#"});

   773   let postedMessage = workerhelper.postedMessage;

   775   do_check_neq(mmiOptions.mmi, null);

   776   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_RADIO_NOT_AVAILABLE);

   777   do_check_false(postedMessage.success);

   779   run_next_test();

   780 });

   782 add_test(function test_sendMMI_call_barring_BAIC_interrogation_voice() {

   783   let workerhelper = getWorker();

   784   let worker = workerhelper.worker;

   785   let context = worker.ContextPool._contexts[0];

   787   context.Buf.readInt32List = function fakeReadUint32List() {

   788     return [1];

   789   };

   791   context.RIL.queryICCFacilityLock =

   792     function fakeQueryICCFacilityLock(options){

   793       context.RIL[REQUEST_QUERY_FACILITY_LOCK](1, {

   794         rilMessageType: "sendMMI",

   795         rilRequestError: ERROR_SUCCESS

   796       });

   797   };

   799   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   800   context.RIL.sendMMI({mmi: "*#33#"});

   802   let postedMessage = workerhelper.postedMessage;

   804   do_check_true(postedMessage.success);

   805   do_check_true(postedMessage.enabled);

   806   do_check_eq(postedMessage.statusMessage,  MMI_SM_KS_SERVICE_ENABLED_FOR);

   807   do_check_true(Array.isArray(postedMessage.additionalInformation));

   808   do_check_eq(postedMessage.additionalInformation[0], "serviceClassVoice");

   810   run_next_test();

   811 });

   813 add_test(function test_sendMMI_call_barring_BAIC_activation() {

   814   let workerhelper = getWorker();

   815   let worker = workerhelper.worker;

   816   let context = worker.ContextPool._contexts[0];

   817   let mmiOptions;

   819   context.RIL.setICCFacilityLock =

   820     function fakeSetICCFacilityLock(options){

   821       mmiOptions = options;

   822       context.RIL[REQUEST_SET_FACILITY_LOCK](0, {

   823         rilMessageType: "sendMMI",

   824         procedure: MMI_PROCEDURE_ACTIVATION,

   825         rilRequestError: ERROR_SUCCESS

   826       });

   827   };

   829   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   830   context.RIL.sendMMI({mmi: "*33#"});

   832   let postedMessage = workerhelper.postedMessage;

   834   do_check_eq(mmiOptions.procedure, MMI_PROCEDURE_ACTIVATION);

   835   do_check_true(postedMessage.success);

   836   do_check_eq(postedMessage.statusMessage,  MMI_SM_KS_SERVICE_ENABLED);

   838   run_next_test();

   839 });

   841 add_test(function test_sendMMI_call_barring_BAIC_deactivation() {

   842   let workerhelper = getWorker();

   843   let worker = workerhelper.worker;

   844   let context = worker.ContextPool._contexts[0];

   845   let mmiOptions;

   847   context.RIL.setICCFacilityLock =

   848     function fakeSetICCFacilityLock(options){

   849       mmiOptions = options;

   850       context.RIL[REQUEST_SET_FACILITY_LOCK](0, {

   851         rilMessageType: "sendMMI",

   852         procedure: MMI_PROCEDURE_DEACTIVATION,

   853         rilRequestError: ERROR_SUCCESS

   854       });

   855   };

   857   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   858   context.RIL.sendMMI({mmi: "#33#"});

   860   let postedMessage = workerhelper.postedMessage;

   862   do_check_eq(mmiOptions.procedure, MMI_PROCEDURE_DEACTIVATION);

   863   do_check_true(postedMessage.success);

   864   do_check_eq(postedMessage.statusMessage,  MMI_SM_KS_SERVICE_DISABLED);

   866   run_next_test();

   867 });

   869 add_test(function test_sendMMI_call_barring_BAIC_procedure_not_supported() {

   870   testSendMMI("**33*0000#", MMI_ERROR_KS_NOT_SUPPORTED);

   872   run_next_test();

   873 });

   875 add_test(function test_sendMMI_USSD() {

   876   let workerhelper = getWorker();

   877   let worker = workerhelper.worker;

   878   let context = worker.ContextPool._contexts[0];

   879   let ussdOptions;

   881   context.RIL.sendUSSD = function fakeSendUSSD(options){

   882     ussdOptions = options;

   883     context.RIL[REQUEST_SEND_USSD](0, {

   884       rilRequestError: ERROR_SUCCESS

   885     });

   886   };

   888   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   889   context.RIL.sendMMI({mmi: "*123#"});

   891   let postedMessage = workerhelper.postedMessage;

   893   do_check_eq(ussdOptions.ussd, "*123#");

   894   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   895   do_check_true(postedMessage.success);

   896   do_check_true(context.RIL._ussdSession);

   898   run_next_test();

   899 });

   901 add_test(function test_sendMMI_USSD_error() {

   902   let workerhelper = getWorker();

   903   let worker = workerhelper.worker;

   904   let context = worker.ContextPool._contexts[0];

   905   let ussdOptions;

   907   context.RIL.sendUSSD = function fakeSendUSSD(options){

   908     ussdOptions = options;

   909     context.RIL[REQUEST_SEND_USSD](0, {

   910       rilRequestError: ERROR_GENERIC_FAILURE

   911     });

   912   };

   914   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   915   context.RIL.sendMMI({mmi: "*123#"});

   917   let postedMessage = workerhelper.postedMessage;

   919   do_check_eq(ussdOptions.ussd, "*123#");

   920   do_check_eq (postedMessage.errorMsg, GECKO_ERROR_GENERIC_FAILURE);

   921   do_check_false(postedMessage.success);

   922   do_check_false(context.RIL._ussdSession);

   924   run_next_test();

   925 });

   927 function setCallWaitingSuccess(mmi) {

   928   let workerhelper = getWorker();

   929   let worker = workerhelper.worker;

   930   let context = worker.ContextPool._contexts[0];

   932   context.RIL.setCallWaiting = function fakeSetCallWaiting(options) {

   933     context.RIL[REQUEST_SET_CALL_WAITING](0, {

   934       rilRequestError: ERROR_SUCCESS

   935     });

   936   };

   938   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   939   context.RIL.sendMMI({mmi: mmi});

   941   let postedMessage = workerhelper.postedMessage;

   943   do_check_eq(postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   944   do_check_true(postedMessage.success);

   945 }

   947 add_test(function test_sendMMI_call_waiting_activation() {

   948   setCallWaitingSuccess("*43*10#");

   950   run_next_test();

   951 });

   953 add_test(function test_sendMMI_call_waiting_deactivation() {

   954   setCallWaitingSuccess("#43#");

   956   run_next_test();

   957 });

   959 add_test(function test_sendMMI_call_waiting_registration() {

   960   testSendMMI("**43#", MMI_ERROR_KS_NOT_SUPPORTED);

   962   run_next_test();

   963 });

   965 add_test(function test_sendMMI_call_waiting_erasure() {

   966   testSendMMI("##43#", MMI_ERROR_KS_NOT_SUPPORTED);

   968   run_next_test();

   969 });

   971 add_test(function test_sendMMI_call_waiting_interrogation() {

   972   let workerhelper = getWorker();

   973   let worker = workerhelper.worker;

   974   let context = worker.ContextPool._contexts[0];

   976   context.Buf.readInt32 = function fakeReadUint32() {

   977     return context.Buf.int32Array.pop();

   978   };

   980   context.RIL.queryCallWaiting = function fakeQueryCallWaiting(options) {

   981     context.Buf.int32Array = [

   982       7,   // serviceClass

   983       1,   // enabled

   984       2    // length

   985     ];

   986     context.RIL[REQUEST_QUERY_CALL_WAITING](1, {

   987       rilRequestError: ERROR_SUCCESS

   988     });

   989   };

   991   context.RIL.radioState = GECKO_RADIOSTATE_READY;

   992   context.RIL.sendMMI({mmi: "*#43#"});

   994   let postedMessage = workerhelper.postedMessage;

   996   do_check_eq(postedMessage.errorMsg, GECKO_ERROR_SUCCESS);

   997   do_check_true(postedMessage.success);

   998   do_check_eq(postedMessage.length, 2);

   999   do_check_true(postedMessage.enabled);

  1000   run_next_test();

  1001 });

The Tor Browser / file revision

dom/system/gonk/tests/test_ril_worker_mmi.js@b8a032363ba2

dom/system/gonk/tests/test_ril_worker_mmi.js