sdks/wasm/runtime-tests.js

   1
   2 //glue code to deal with the differences between ch, d8, jsc and sm.
   3 if (typeof print === "undefined")
   4         print = console.log;
   5
   6 // JavaScript core does not have a console defined
   7 if (typeof console === "undefined") {
   8         var Console = function () {
   9                 this.log = function(msg){ print(msg) };
  10         };
  11         console = new Console();
  12 }
  13
  14 if (typeof console !== "undefined") {
  15         var has_console_warn = false;
  16         try {
  17                 if (typeof console.warn !== "undefined")
  18                         has_console_warn = true;
  19         } catch(e) {}
  20
  21         if (!has_console_warn)
  22                 console.warn = console.log;
  23 }
  24
  25 fail_exec = function(reason) {
  26         print (reason);
  27         wasm_exit (1);
  28 }
  29
  30 try {
  31         arguments = WScript.Arguments;
  32         load = WScript.LoadScriptFile;
  33         read = WScript.LoadBinaryFile;
  34         fail_exec = function(reason) {
  35                 print (reason);
  36                 wasm_exit (1);
  37         }
  38 } catch(e) {}
  39
  40 try {
  41         if (typeof scriptArgs !== "undefined")
  42                 arguments = scriptArgs;
  43 } catch(e) {}
  44 //end of all the nice shell glue code.
  45
  46 // set up a global variable to be accessed in the App.init
  47 var testArguments = arguments;
  48
  49 function inspect_object (o){
  50     var r="";
  51     for(var p in o) {
  52         var t = typeof o[p];
  53         r += "'" + p + "' => '" + t + "', ";
  54     }
  55     return r;
  56 }
  57
  58 // Preprocess arguments
  59 var args = testArguments;
  60 print("Arguments: " + testArguments);
  61 profilers = [];
  62 setenv = {};
  63 while (true) {
  64         if (args [0].startsWith ("--profile=")) {
  65                 var arg = args [0].substring ("--profile=".length);
  66
  67                 profilers.push (arg);
  68
  69                 args = args.slice (1);
  70         } else if (args [0].startsWith ("--setenv=")) {
  71                 var arg = args [0].substring ("--setenv=".length);
  72                 var parts = arg.split ('=');
  73                 if (parts.length != 2)
  74                         fail_exec ("Error: malformed argument: '" + args [0]);
  75                 setenv [parts [0]] = parts [1];
  76                 args = args.slice (1);
  77         } else {
  78                 break;
  79         }
  80 }
  81
  82 load ("mono-config.js");
  83
  84 var Module = {
  85         print: function(x) { print ("WASM: " + x) },
  86         printErr: function(x) { print ("WASM-ERR: " + x) },
  87
  88         onRuntimeInitialized: function () {
  89                 // Have to set env vars here to enable setting MONO_LOG_LEVEL etc.
  90                 var wasm_setenv = Module.cwrap ('mono_wasm_setenv', 'void', ['string', 'string']);
  91                 for (var variable in setenv) {
  92                         wasm_setenv (variable, setenv [variable]);
  93                 }
  94
  95                 MONO.mono_load_runtime_and_bcl (
  96                         config.vfs_prefix,
  97                         config.deploy_prefix,
  98                         config.enable_debugging,
  99                         config.file_list,
 100                         function () {
 101                                 config.add_bindings ();
 102                                 App.init ();
 103                         },
 104                         function (asset )
 105                         {
 106                                 // The default mono_load_runtime_and_bcl defaults to using
 107                                 // fetch to load the assets.  It also provides a way to set a
 108                                 // fetch promise callback.
 109                                 // Here we wrap the file read in a promise and fake a fetch response
 110                                 // structure.
 111                                 return new Promise((resolve, reject) => {
 112                                          var response = { ok: true, url: asset,
 113                                                         arrayBuffer: function() {
 114                                                                 return new Promise((resolve2, reject2) => {
 115                                                                         resolve2(new Uint8Array (read (asset, 'binary')));
 116                                                         }
 117                                                 )}
 118                                         }
 119                                    resolve(response)
 120                                  })
 121                         }
 122                 );
 123         },
 124 };
 125
 126 load ("mono.js");
 127
 128 var assembly_load = Module.cwrap ('mono_wasm_assembly_load', 'number', ['string'])
 129 var find_class = Module.cwrap ('mono_wasm_assembly_find_class', 'number', ['number', 'string', 'string'])
 130 var find_method = Module.cwrap ('mono_wasm_assembly_find_method', 'number', ['number', 'string', 'number'])
 131 var runtime_invoke = Module.cwrap ('mono_wasm_invoke_method', 'number', ['number', 'number', 'number', 'number']);
 132 var string_from_js = Module.cwrap ('mono_wasm_string_from_js', 'number', ['string']);
 133 var assembly_get_entry_point = Module.cwrap ('mono_wasm_assembly_get_entry_point', 'number', ['number']);
 134 var string_get_utf8 = Module.cwrap ('mono_wasm_string_get_utf8', 'string', ['number']);
 135 var string_array_new = Module.cwrap ('mono_wasm_string_array_new', 'number', ['number']);
 136 var obj_array_set = Module.cwrap ('mono_wasm_obj_array_set', 'void', ['number', 'number', 'number']);
 137 var wasm_exit = Module.cwrap ('mono_wasm_exit', 'void', ['number']);
 138 var wasm_setenv = Module.cwrap ('mono_wasm_setenv', 'void', ['string', 'string']);
 139
 140 const IGNORE_PARAM_COUNT = -1;
 141
 142 var App = {
 143     init: function () {
 144
 145                 Module.print("Initializing.....");
 146
 147                 for (var i = 0; i < profilers.length; ++i) {
 148                         var init = Module.cwrap ('mono_wasm_load_profiler_' + profilers [i], 'void', ['string'])
 149
 150                         init ("");
 151                 }
 152
 153                 if (args[0] == "--regression") {
 154                         var exec_regresion = Module.cwrap ('mono_wasm_exec_regression', 'number', ['number', 'string'])
 155
 156                         var res = 0;
 157                                 try {
 158                                         res = exec_regresion (10, args[1]);
 159                                         Module.print ("REGRESSION RESULT: " + res);
 160                                 } catch (e) {
 161                                         Module.print ("ABORT: " + e);
 162                                         res = 1;
 163                                 }
 164
 165                         if (res)
 166                                 fail_exec ("REGRESSION TEST FAILED");
 167
 168                         return;
 169                 }
 170
 171                 if (args[0] == "--run") {
 172                         // Run an exe
 173                         if (args.length == 1)
 174                                 fail_exec ("Error: Missing main executable argument.");
 175                         main_assembly = assembly_load (args[1]);
 176                         if (main_assembly == 0)
 177                                 fail_exec ("Error: Unable to load main executable '" + args[1] + "'");
 178                         main_method = assembly_get_entry_point (main_assembly);
 179                         if (main_method == 0)
 180                                 fail_exec ("Error: Main (string[]) method not found.");
 181
 182                         var app_args = string_array_new (args.length - 2);
 183                         for (var i = 2; i < args.length; ++i) {
 184                                 obj_array_set (app_args, i - 2, string_from_js (args [i]));
 185                         }
 186
 187                         var invoke_args = Module._malloc (4);
 188                         Module.setValue (invoke_args, app_args, "i32");
 189                         var eh_throw = Module._malloc (4);
 190                         Module.setValue (eh_throw, 0, "i32");
 191                         var res = runtime_invoke (main_method, 0, invoke_args, eh_throw);
 192                         var eh_res = Module.getValue (eh_throw, "i32");
 193                         if (eh_res == 1) {
 194                                 print ("Exception:" + string_get_utf8 (res));
 195                         }
 196                         return;
 197                 }
 198
 199                 Module.print("Initializing Binding Test Suite support.....");
 200
 201                 //binding test suite support code
 202                 binding_test_module = assembly_load ("binding_tests");
 203                 if (!binding_test_module)
 204                 {
 205                         Module.printErr("Binding tests module 'binding_tests' not found.  Exiting Tests.")
 206                         throw new Error("Binding tests module 'binding_tests' not found.  Exiting Tests.");
 207                 }
 208
 209                 binding_test_class = find_class (binding_test_module, "", "TestClass");
 210                 if (!binding_test_class)
 211                 {
 212                         Module.printErr("Binding tests class 'TestClass' not found.  Exiting Tests.")
 213                         throw new Error("Binding tests class 'TestClass' not found.  Exiting Tests.");
 214                 }
 215
 216                 Module.print("Binding support complete.");
 217
 218
 219                 Module.print("Checking for [main]Driver:Send ....");
 220
 221                 var send_message = undefined;
 222
 223                 try
 224                 {
 225                         send_message = BINDING.bind_static_method("[main]Driver:Send");
 226                 }
 227                 catch (e)
 228                 {
 229                         Module.printErr("[main]Driver:Send not found: " + e);
 230                         throw e;
 231
 232                 }
 233
 234                 Module.print("Driver binding complete.");
 235
 236                 var bad_send_msg_detected = false;
 237                 for (var i = 0; i < testArguments.length; ++i) {
 238
 239                         var res = "";
 240                         try
 241                         {
 242                                 res = send_message("start-test", testArguments [i])
 243                         } catch (e) {
 244                                 printErr ("BAD SEND MSG: " + e);
 245                                 bad_send_msg_detected = true;
 246                         }
 247                         print ("-----STARTED " + testArguments [i] + "---- " + res);
 248
 249                         if (res == "SUCCESS") {
 250                                 while (send_message ("pump-test", testArguments [i]) != "DONE")
 251                                 {
 252                                         Module.pump_message ();
 253                                         print ("|");
 254                                 }
 255                                 print ("\nDONE")
 256                         }
 257                 }
 258
 259                 var status = send_message ("test-result", "");
 260                 print ("Test status " + status)
 261                 if (status != "PASS")
 262                         fail_exec ("BAD TEST STATUS");
 263
 264                 if (bad_send_msg_detected)
 265                         fail_exec ("BAD MSG SEND DETECTED");
 266     },
 267 };
 268
 269 //binding test suite support code
 270 var binding_test_module = undefined;
 271 var binding_test_class = undefined;
 272
 273 // This function is called from the binding test suite
 274 function call_test_method(method_name, signature, args)
 275 {
 276         var target_method = find_method (binding_test_class, method_name, IGNORE_PARAM_COUNT)
 277         if (!target_method)
 278                 throw "Could not find " + method_name;
 279
 280         return Module.mono_method_invoke (target_method, null, signature, args);
 281 }