1 files changed, 415 insertions, 0 deletions
diff --git a/src/tests/efl_js/eina_js_suite.js b/src/tests/efl_js/eina_js_suite.js
new file mode 100755
index 0000000000..87cebafba9
--- /dev/null
+++ b/src/tests/efl_js/eina_js_suite.js
@@ -0,0 +1,415 @@
+#!/usr/bin/env node
+
+// Preamble
+function assert(condition, message) {
+  if (!condition) {
+      print("Assertion failed ", message);
+      throw new Error(message || "Assertion failed");
+  }
+}
+
+if(typeof process !== 'undefined')
+{
+    console.log('running from nodejs');
+    console.log('path', process.env.NODE_PATH);
+    console.log("teste1");
+
+    efl = require('efl');
+    assert(efl != null, "could not load efl node module");
+
+    // Setup output aliases
+    print = console.log;
+    print_error = function() {
+        if (process.argv.indexOf("--supress-errors") == -1)
+            console.error.apply(null, arguments);
+    };
+    print_info = function() {
+        if (process.argv.indexOf("--verbose") != -1)
+            console.info.apply(null, arguments);
+    };
+    exit = efl.ecore_mainloop_quit;
+}
+else
+{
+    assert = function(test, message) { if (test !== true) throw message; };
+    print('running from libv8')
+    //FIXME Add levels to v8 tests
+    print_error = print
+    print_info = print
+    exit = function() {}
+}
+
+// Global flag for suite success //
+suite_success = true;
+// Global test summary
+suite_ok = 0;
+suite_fail = []; // Will store the name of the failures
+
+// Basic test function //
+function start_test(test_name, test_func) {
+  print("[ RUN         ]  eina_js_suite: " + test_name);
+  var test_result = true;
+  try {
+    test_func();
+  } catch (e) {
+    suite_success = false;
+    test_result = false;
+    print_error("Error: ", e, e.stack);
+  }
+  print("[        " + (test_result ? "PASS" : "FAIL") + " ]  eina_js_suite: " + test_name);
+  if (test_result)
+    suite_ok += 1;
+  else
+    suite_fail.push(test_name);
+}
+
+function array_equal(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.length != b.length) return false;
+
+  for (var i = 0; i < a.length; ++i) {
+    if (a[i] !== b[i]
+        && (Object.prototype.toString.call(a[i]) === '[object Array]'
+             && Object.prototype.toString.call(b[i] === '[object Array]')
+             && !array_equal(a[i], b[i])))
+      return false;
+  }
+  return true;
+}
+// end Preamble
+
+// eina Preamble
+// Functions to get the line in NodeJS and V8
+Object.defineProperty(global, '__stack', {
+get: function() {
+        var orig = Error.prepareStackTrace;
+        Error.prepareStackTrace = function(_, stack) {
+            return stack;
+        };
+        var err = new Error;
+        Error.captureStackTrace(err, arguments.callee);
+        var stack = err.stack;
+        Error.prepareStackTrace = orig;
+        return stack;
+    }
+});
+
+Object.defineProperty(global, '__line', {
+get: function() {
+        return __stack[1].getLineNumber();
+    }
+});
+
+Object.defineProperty(global, '__function', {
+get: function() {
+        return __stack[1].getFunctionName();
+    }
+});
+// end eina Preamble
+
+// error tests
+
+start_test("error test clear_eina_error should not throw error", function () {
+    var captured = false;
+    print_info("#1");
+    try {
+        print_info("#2");
+        efl.clear_eina_error();
+        print_info("#3");
+    } catch(e) {
+        print_info("#4");
+        print_error("Exception ", e.toString());
+        print_info("#5");
+        captured = true;
+    }
+    print_info("#6");
+    assert(captured === false, 'captured must be false');
+    print_info("#7");
+});
+
+start_test("error test setting eina error", function() {
+    captured = false;
+    try {
+        print_info("#1");
+        efl.set_eina_error();
+        print_info("#2");
+    } catch(e) {
+        print_info("#3");
+        print_error("Exception ", e.toString());
+        print_info("#4");
+        assert(e.code === 'Eina_Error', 'exception code is different from Eina_Error');
+        print_info("#5");
+        assert(e.value === 'foobar', 'exception value is different from foobar');
+        print_info("#6");
+        captured = true;
+        print_info("#7");
+    }
+    print_info("#8");
+    assert(captured === true, 'captured was expected to be true.');
+
+    print_info("Finished error setting test");
+});
+
+// accessor tests
+start_test("accessor test", function () {
+    assert(efl.acc.get(0) === 42, 'accessor #1');
+    assert(efl.acc.get(1) === 24, 'accessor #2');
+});
+
+// iterator tests
+start_test("iterator tests", function () {
+    assert(efl.it.next().value === 42, 'iterator #1');
+    assert(efl.it.next().value === 24, 'iterator #2');
+});
+
+// value tests
+start_test("value tests int get test", function () {
+    print_info("x");
+
+    var my_value = new efl.value(1);
+    print_info("x");
+    var wrapped = my_value.get();
+    print_info("x");
+    assert(typeof(wrapped) === 'number', 'typeof wrapped is not number');
+    print_info("x");
+    assert(wrapped === 1, 'wrapped should be 1');
+    print_info("x");
+});
+
+start_test("value tests int set test", function(){
+    var my_value = new efl.value(1);
+    var wrapped = my_value.get();
+    my_value.set(2);
+    print_info("x");
+    assert(wrapped === 1, 'Setting a value should not change a previous wrapped result');
+    print_info("x");
+    wrapped = my_value.get();
+    print_info("x");
+    assert(typeof(wrapped) === 'number', 'wrapped value after setting to number should be a number');
+    print_info("x");
+    assert(wrapped === 2, 'wrapped is different from value set');
+    print_info("x");
+});
+
+start_test("value tests int set to bool", function(){
+    var my_value = new efl.value(2);
+    var wrapped = my_value.get();
+    my_value.set(true);
+    print_info("x");
+    assert(wrapped === 2, 'Setting a value should not change a previous wrapped result');
+    print_info("x");
+    wrapped = my_value.get();
+    print_info("x");
+    // boolean is represented as integer in the efl::eina::value layer
+    print_info("x");
+    assert(typeof(wrapped) === 'number', 'value.get from bool value should be a number');
+    print_info("x");
+    assert(wrapped === 1, 'value.get from a true boolean should be 1');
+    print_info("x");
+});
+
+start_test("value tests set value to complex object", function() {
+    var my_value = new efl.value(1);
+    print_info("x");
+    var captured = false;
+    print_info("x");
+    try {
+        print_info("x");
+        my_value.set({type: 'complex object'});
+        print_info("x");
+    } catch(e) {
+        print_info("x");
+        assert(e.code === 'std::bad_cast', 'Trying to set a complex object to a value should raise std::bad_cast');
+        print_info("x");
+        captured = true;
+        print_info("x");
+    }
+    print_info("x");
+    assert(captured === true, 'Trying to set a complex object should raise an exception');
+    print_info("x");
+});
+
+start_test("value tests create value from complex object", function() {
+    print_info("x");
+    var captured = false;
+    print_info("x");
+    try {
+        print_info("x");
+        my_value = new efl.value({type: 'complex object'});
+        print_info("x");
+    } catch(e) {
+        print_info("e.code ", e.code, ' ', typeof e);
+        assert(e.code === 'std::bad_cast', 'Trying to create a value from a complex object should raise std::bad_cast');
+        print_info("x");
+        captured = true;
+        print_info("x");
+    }
+    assert(captured === true, 'Trying to create a value from a complex object should raise an exception');
+});
+// log
+
+start_test("log tests basic", function () {
+    function f1(){ efl.logPrint(efl.LOG_DOMAIN_GLOBAL, efl.LOG_LEVEL_DBG, 'I changed again'); }; f1();
+    efl.logPrint(efl.LOG_DOMAIN_GLOBAL, efl.LOG_LEVEL_CRITICAL, 'Cool to Hate');
+    function f2(){ efl.logPrint(efl.LOG_DOMAIN_GLOBAL, efl.LOG_LEVEL_WARN, 'One Fine Day'); }; f2();
+    function f3(){ efl.logPrint(efl.mydomain, efl.LOG_LEVEL_INFO, 'Never Gonna Find Me'); }; f3();
+});
+
+start_test("log tests domains", function() {
+    var mydomain2 = efl.registerLogDomain('mydomain2', '');
+    efl.setLogDomainRegisteredLevel(mydomain2, efl.LOG_LEVEL_DBG);
+    assert(efl.getLogDomainRegisteredLevel(mydomain2) === efl.LOG_LEVEL_DBG, 'Level set is not LEVEL_DBG');
+    efl.logPrint(mydomain2, efl.LOG_LEVEL_ERR, "The Kids Aren't Alright");
+
+    efl.unregisterLogDomain(mydomain2);
+});
+
+start_test("log tests properties", function() {
+    efl.setLogColorDisable(true);
+    assert(efl.getLogColorDisable() === true, 'getLogColorDisable is false after setting to true');
+    efl.setLogColorDisable(false);
+    assert(efl.getLogColorDisable() === false, 'getLogColorDisable is true after setting to false');
+
+    efl.setLogFileDisable(true);
+    assert(efl.getLogFileDisable() === true, 'getLogFileDisable is false after setting to true');
+    efl.setLogFileDisable(false);
+    assert(efl.getLogFileDisable() === false, 'getLogFileDisable is true after setting to false');
+
+    efl.setLogFunctionDisable(true);
+    assert(efl.getLogFunctionDisable() === true, 'getLogFunctionDisable is false after setting to true');
+    efl.setLogFunctionDisable(false);
+    assert(efl.getLogFunctionDisable() === false, 'getLogFunctionDisable is true after setting to false');
+
+    efl.setLogAbortOnCritical(true);
+    assert(efl.getLogAbortOnCritical() === true, 'getLogAbortOnCritical is false after setting to true');
+    efl.setLogAbortOnCritical(false);
+    assert(efl.getLogAbortOnCritical() === false, 'getLogAbortOnCritical is true after setting to false');
+
+});
+
+start_test("log tests print callback", function() {
+    var entered = false;
+    var line_number = 0;
+
+    // Setup
+    var mydomain = efl.registerLogDomain('mydomain', 'deadbeef');
+    efl.setLogDomainRegisteredLevel(mydomain, efl.LOG_LEVEL_WARN);
+
+    efl.setLogPrintCb(function(domain, color, level, file, func, line, msg) {
+        assert(domain === 'mydomain', 'log print callback incorrect domain');
+        assert(color === 'deadbeef', 'log print callback incorrect color');
+        assert(level === efl.LOG_LEVEL_WARN, 'log print callback incorrect level');
+        assert(function(){ var components = file.split('/'); return components[components.length - 1]; }() === 'eina_js_suite.js'
+               , 'log print callback incorrect file');
+        assert(func === 'f4', 'log print callback incorrect func');
+        assert(line === line_number, 'log print callback incorrect line');
+        assert(msg === 'What Happened To You', 'log print callback incorrect message');
+        entered = true;
+    });
+
+    function f4() {
+      line_number = __line + 1;
+      efl.logPrint(mydomain, efl.LOG_LEVEL_WARN, 'What Happened To You');
+    };
+    f4();
+    assert(entered === true, 'log_print callback was not called');
+
+});
+
+start_test("log tests levels", function(){
+    efl.setLogLevel(efl.LOG_LEVEL_DBG);
+    assert(efl.getLogLevel() === efl.LOG_LEVEL_DBG, 'log level was not DBG');
+    assert(efl.checkLogLevel(efl.LOG_LEVEL_INFO) === true, 'log level INFO was not accepted when DBG level set');
+    efl.setLogLevel(efl.LOG_LEVEL_CRITICAL);
+    assert(efl.getLogLevel() === efl.LOG_LEVEL_CRITICAL, 'log level was not CRITICAL');
+    assert(efl.checkLogLevel(efl.LOG_LEVEL_INFO) === false, 'log level INFO was accepted when CRITICAL level set');
+
+    assert(efl.getLogAbortOnCritical() === false, 'log abort on critical get should not be true');
+    efl.setLogAbortOnCritical(true);
+    assert(efl.getLogAbortOnCritical() === true, 'log abort on critical should be true');
+
+    efl.setLogAbortOnCriticalLevel(efl.LOG_LEVEL_CRITICAL);
+    assert(efl.getLogAbortOnCriticalLevel() == efl.LOG_LEVEL_CRITICAL, 'log critical trigger level is not CRITICAL');
+    efl.setLogAbortOnCriticalLevel(efl.LOG_LEVEL_ERR);
+    assert(efl.getLogAbortOnCriticalLevel() == efl.LOG_LEVEL_ERR, 'log critical trigger level is not ERR');
+
+    efl.setLogDomainLevel('mydomain', efl.LOG_LEVEL_WARN);
+    assert(efl.getLogDomainLevel('mydomain') === efl.LOG_LEVEL_WARN, 'log level for mydomain is not WARN');
+    efl.setLogDomainLevel('mydomain', efl.LOG_LEVEL_INFO);
+    assert(efl.getLogDomainLevel('mydomain') === efl.LOG_LEVEL_INFO, 'log level for mydomain is not INFO');
+
+    assert(typeof(efl.LOG_STATE_START) === 'number', 'type of LOG_STATE_START is not number');
+    assert(typeof(efl.LOG_STATE_STOP) === 'number', 'type of LOG_STATE_STOP is not number');
+    assert(typeof(efl.logTiming) === 'function', 'type of log_timing is not function');
+});
+
+start_test("log helper functions", function(){
+    var messages = [
+        [efl.LOG_LEVEL_CRITICAL, "critical"],
+        [efl.LOG_LEVEL_ERR, "error"],
+        [efl.LOG_LEVEL_WARN, "warning"],
+        [efl.LOG_LEVEL_INFO, "info"],
+        [efl.LOG_LEVEL_DBG, "debug"]
+    ];
+    var caught_messages = [];
+
+    efl.setLogLevel(efl.LOG_LEVEL_WARN);
+    efl.setLogAbortOnCritical(false);
+
+    efl.setLogPrintCb(function(domain, color, level, file, func, line, msg) {
+        caught_messages.push([level, msg]);
+    });
+
+    efl.logCritical(messages[0][1]);
+    efl.logError(messages[1][1]);
+    efl.logWarning(messages[2][1]);
+    efl.logInfo(messages[3][1]);
+    efl.logDebug(messages[4][1]);
+
+    assert(array_equal(messages.slice(0, 3), caught_messages), "Must received only the messages above the desired level.");
+});
+
+start_test("log helper wrong type", function(){
+    var raised = false;
+    try {
+        efl.log_info(442);
+    } catch (err) {
+        raised = true;
+        assert(err.name == "TypeError", "Raised exception must be TypeError.");
+    }
+    assert(raised, "Passing anything other than a string must raise TypeError.");
+});
+
+start_test("log color constants", function(){
+    assert(typeof efl.COLOR_LIGHTRED == "string", "efl.COLOR_LIGHTRED must be a string.");
+    assert(typeof efl.COLOR_RED == "string", "efl.COLOR_RED must be a string.");
+    assert(typeof efl.COLOR_LIGHTBLUE == "string", "efl.COLOR_LIGHTBLUE must be a string.");
+    assert(typeof efl.COLOR_BLUE == "string", "efl.COLOR_BLUE must be a string.");
+    assert(typeof efl.COLOR_GREEN == "string", "efl.COLOR_GREEN must be a string.");
+    assert(typeof efl.COLOR_YELLOW == "string", "efl.COLOR_YELLOW must be a string.");
+    assert(typeof efl.COLOR_ORANGE == "string", "efl.COLOR_ORANGE must be a string.");
+    assert(typeof efl.COLOR_WHITE == "string", "efl.COLOR_WHITE must be a string.");
+    assert(typeof efl.COLOR_LIGHTCYAN == "string", "efl.COLOR_LIGHTCYAN must be a string.");
+    assert(typeof efl.COLOR_CYAN == "string", "efl.COLOR_CYAN must be a string.");
+    assert(typeof efl.COLOR_RESET == "string", "efl.COLOR_RESET must be a string.");
+    assert(typeof efl.COLOR_HIGH == "string", "efl.COLOR_HIGH must be a string.");
+});
+
+// footer
+
+if (!suite_success) {
+  print ("[ Total tests run: %s ]", suite_ok + suite_fail.length);
+  print ("[ Total successful: %s ]", suite_ok);
+  print ("[ Total failures: %s ]", suite_fail.length);
+  print ("[ Tests failed: ]");
+  for (var i = 0; i < suite_fail.length; i++) {
+    print ("[    %s]", suite_fail[i]);
+  };
+  assert(false, "[ Test suite fail ]");
+} else {
+  print ("[ Test execution with success ]");
+  print ("[ Total tests run: %s ]", suite_ok);
+}
+
+exit();