@qooxdoo/framework 7.0.0-beta.6 → 7.0.0

package/source/class/qx/dev/unit/MRequirements.js

@@ -17,7 +17,7 @@
 ************************************************************************ */
 
 /* *********************************************************************
-************************************************************************ */
+ ************************************************************************ */
 
 /**
  * Common requirement checks for unit tests. Example:
@@ -38,19 +38,17 @@
  * @asset(qx/test/xmlhttp/php_version.php)
  */
 qx.Mixin.define("qx.dev.unit.MRequirements", {
-
-  include : [qx.dev.unit.MRequirementsBasic],
+  include: [qx.dev.unit.MRequirementsBasic],
 
   /*
   *****************************************************************************
      STATICS
   *****************************************************************************
   */
-  statics :
-  {
+  statics: {
     /** @type {Boolean} Result of {@link #hasPhp}. Stored as class member to avoid
      * repeating the check. */
-    __hasPhp : null
+    __hasPhp: null
   },
 
   /*
@@ -58,236 +56,212 @@ qx.Mixin.define("qx.dev.unit.MRequirements", {
      MEMBERS
   *****************************************************************************
   */
-  members :
-  {
-
+  members: {
     /**
      * Checks if the application has been loaded over HTTP.
      *
      * @return {Boolean} <code>true</code> if HTTP is currently used
      */
-    hasHttp : function()
-    {
+    hasHttp() {
       return document.location.protocol.indexOf("http") == 0;
     },
 
-
     /**
      * Checks if the server supports PHP.
      *
      * @return {Boolean} <code>true</code> if PHP is supported by the backend
      */
-    hasPhp : function()
-    {
+    hasPhp() {
       if (qx.dev.unit.MRequirements.__hasPhp != null) {
         return qx.dev.unit.MRequirements.__hasPhp;
       }
 
-      var url = qx.util.ResourceManager.getInstance().toUri("qx/test/xmlhttp/php_version.php");
+      var url = qx.util.ResourceManager.getInstance().toUri(
+        "qx/test/xmlhttp/php_version.php"
+      );
+
       var req = new qx.bom.request.Xhr();
 
-      req.onload = qx.lang.Function.bind(function() {
+      req.onload = qx.lang.Function.bind(function () {
         try {
           qx.lang.Json.parse(req.responseText);
           qx.dev.unit.MRequirements.__hasPhp = true;
-        } catch(ex) {
+        } catch (ex) {
           qx.dev.unit.MRequirements.__hasPhp = false;
         }
       }, this);
 
-      req.onerror = req.abort = qx.lang.Function.bind(function() {
+      req.onerror = req.abort = qx.lang.Function.bind(function () {
         qx.dev.unit.MRequirements.__hasPhp = false;
       }, this);
 
       req.open("POST", url, false);
       try {
         req.send();
-      } catch(ex) {
+      } catch (ex) {
         qx.dev.unit.MRequirements.__hasPhp = false;
       }
 
       return qx.dev.unit.MRequirements.__hasPhp;
     },
 
-
     /**
      * Checks if the application extends qx.application.Standalone
      *
      * @return {Boolean} <code>true</code> if the application is a standalone (GUI)
      * application
      */
-    hasGuiApp : function()
-    {
+    hasGuiApp() {
       try {
-        return qx.core.Init.getApplication() instanceof qx.application.Standalone;
-      } catch(ex) {
+        return (
+          qx.core.Init.getApplication() instanceof qx.application.Standalone
+        );
+      } catch (ex) {
         return false;
       }
     },
 
-
     /**
      * Checks if the application extends qx.application.Inline
      *
      * @return {Boolean} <code>true</code> if the application is an inline application
      */
-    hasInlineApp : function()
-    {
+    hasInlineApp() {
       try {
         return qx.core.Init.getApplication() instanceof qx.application.Inline;
-      } catch(ex) {
+      } catch (ex) {
         return false;
       }
     },
 
-
     /**
      * Checks if the application extends qx.application.Native
      *
      * @return {Boolean} <code>true</code> if the application is a native application
      */
-    hasNativeApp : function()
-    {
+    hasNativeApp() {
       try {
         return qx.core.Init.getApplication() instanceof qx.application.Native;
-      } catch(ex) {
+      } catch (ex) {
         return false;
       }
     },
 
-
     /**
      * Checks if the application is running in Google Chrome
      *
      * @return {Boolean} <code>true</code> if the browser is Google Chrome
      */
-    hasChrome : function()
-    {
+    hasChrome() {
       return qx.core.Environment.get("browser.name") === "chrome";
     },
 
-
     /**
      * Checks if the application is running in Firefox
      *
      * @return {Boolean} <code>true</code> if the browser is Firefox
      */
-    hasFirefox : function()
-    {
+    hasFirefox() {
       return qx.core.Environment.get("browser.name") === "firefox";
     },
 
-
     /**
      * Checks if the application is running in a browser using the Gecko engine
      *
      * @return {Boolean} <code>true</code> if the browser engine is Mozilla Gecko
      */
-    hasGecko : function()
-    {
+    hasGecko() {
       return qx.core.Environment.get("engine.name") == "gecko";
     },
 
-
     /**
      * Checks if the application is running in Internet Explorer
      *
      * @return {Boolean} <code>true</code> if the browser is Internet Explorer
      */
-    hasIe : function()
-    {
+    hasIe() {
       return qx.core.Environment.get("browser.name") === "ie";
     },
 
-
     /**
      * Checks if the application is running in a browser using the MSHTML engine
      *
      * @return {Boolean} <code>true</code> if the browser engine is MSHTML
      */
-    hasMshtml : function()
-    {
+    hasMshtml() {
       return qx.core.Environment.get("engine.name") == "mshtml";
     },
 
-
     /**
      * Checks if the application is running in a browser using the Opera engine
      *
      * @return {Boolean} <code>true</code> if the browser engine is Opera
      */
-    hasOpera : function()
-    {
+    hasOpera() {
       return qx.core.Environment.get("engine.name") == "opera";
     },
 
-
     /**
      * Checks if the application is running in a browser using the Webkit engine
      *
      * @return {Boolean} <code>true</code> if the browser engine is Webkit
      */
-    hasWebkit : function()
-    {
+    hasWebkit() {
       return qx.core.Environment.get("engine.name") == "webkit";
     },
 
-
     /**
      * Checks if the application is NOT running on OS X
      *
      * @return {Boolean} <code>true</code> if the operating system is NOT OX X
      */
-    hasNoOsx : function()
-    {
-      return (qx.core.Environment.get("os.name") === "osx"?false:true);
+    hasNoOsx() {
+      return qx.core.Environment.get("os.name") === "osx" ? false : true;
     },
 
-
     /**
      * Checks if the application is running on Windows 7
      *
      * @return {Boolean} <code>false</code> if operating system is Windows 7
      */
-    hasNoWin7 : function()
-    {
-      var isWin7 = (qx.core.Environment.get("os.name") === "win" && qx.core.Environment.get("os.version") === "7");
-      return (isWin7 ? false : true);
+    hasNoWin7() {
+      var isWin7 =
+        qx.core.Environment.get("os.name") === "win" &&
+        qx.core.Environment.get("os.version") === "7";
+      return isWin7 ? false : true;
     },
 
-
     /**
      * Checks if the application is running on Windows 10
      *
      * @return {Boolean} <code>false</code> if operating system is Windows 10
      */
-    hasNoWin10 : function()
-    {
-      var isWin10 = (qx.core.Environment.get("os.name") === "win" && qx.core.Environment.get("os.version") === "10");
-      return (isWin10 ? false : true);
+    hasNoWin10() {
+      var isWin10 =
+        qx.core.Environment.get("os.name") === "win" &&
+        qx.core.Environment.get("os.version") === "10";
+      return isWin10 ? false : true;
     },
 
-
     /**
      * Checks if the application is not running in a Google Chrome browser on Linux
      *
      * @return {Boolean} <code>true</code> if the browser is not Google Chrome on Linux
      */
-    hasNoChromeOnLinux : function()
-    {
-      return (qx.core.Environment.get("browser.name") === "chrome" && qx.core.Environment.get("os.name") === "linux"?false:true);
+    hasNoChromeOnLinux() {
+      return qx.core.Environment.get("browser.name") === "chrome" &&
+        qx.core.Environment.get("os.name") === "linux"
+        ? false
+        : true;
     },
 
-
     /**
-    * Checks if the application is running on a client supporting async functions
-    *
-    * @return {Boolean} <code>true</code> if the client supports async functions
-    */
-    hasAsyncFunctions : function()
-    {
+     * Checks if the application is running on a client supporting async functions
+     *
+     * @return {Boolean} <code>true</code> if the client supports async functions
+     */
+    hasAsyncFunctions() {
       return qx.core.Environment.get("ecmascript.function.async");
     }
   }
-
 });

package/source/class/qx/dev/unit/MRequirementsBasic.js

@@ -21,16 +21,12 @@
  * classes.
  */
 qx.Mixin.define("qx.dev.unit.MRequirementsBasic", {
-
-
   /*
   *****************************************************************************
      MEMBERS
   *****************************************************************************
   */
-  members :
-  {
-
+  members: {
     /**
      * Verifies a list of infrastructure requirements by checking for
      * corresponding "has" methods. If no such method was found,
@@ -44,21 +40,19 @@ qx.Mixin.define("qx.dev.unit.MRequirementsBasic", {
      * @param featureList {String[]} List of infrastructure requirements
      * @lint environmentNonLiteralKey(feature)
      */
-    require : function(featureList) {
-
+    require(featureList) {
       if (qx.core.Environment.get("qx.debug")) {
         qx.core.Assert.assertArray(featureList);
       }
 
-      for (var i=0,l=featureList.length; i<l; i++) {
+      for (var i = 0, l = featureList.length; i < l; i++) {
         var feature = featureList[i];
         var hasMethodName = "has" + qx.lang.String.capitalize(feature);
 
         if (this[hasMethodName]) {
           if (this[hasMethodName]() === true) {
             continue;
-          }
-          else {
+          } else {
             throw new qx.dev.unit.RequirementError(feature);
           }
         }
@@ -70,22 +64,33 @@ qx.Mixin.define("qx.dev.unit.MRequirementsBasic", {
           }
           if (envValue === false) {
             throw new qx.dev.unit.RequirementError(feature);
-          }
-          else {
-            throw new Error("The Environment key " + feature + " cannot be used"
-             + " as a Test Requirement since its value is not boolean!");
+          } else {
+            throw new Error(
+              "The Environment key " +
+                feature +
+                " cannot be used" +
+                " as a Test Requirement since its value is not boolean!"
+            );
           }
         }
 
         if (qx.core.Environment.getAsyncChecks()[feature]) {
-          throw new Error('Unable to verify requirement ' + feature + ': '
-          + 'Asynchronous environment checks are not supported!');
+          throw new Error(
+            "Unable to verify requirement " +
+              feature +
+              ": " +
+              "Asynchronous environment checks are not supported!"
+          );
         }
 
-        throw new Error('Unable to verify requirement: No method "'
-          + hasMethodName + '" or valid Environment key "' + feature + '" found');
+        throw new Error(
+          'Unable to verify requirement: No method "' +
+            hasMethodName +
+            '" or valid Environment key "' +
+            feature +
+            '" found'
+        );
       }
     }
   }
-
 });

package/source/class/qx/dev/unit/MTestLoader.js

@@ -23,40 +23,35 @@
  * provide the necessary information to a more advanced runner application
  */
 qx.Mixin.define("qx.dev.unit.MTestLoader", {
-
   /*
   *****************************************************************************
      PROPERTIES
   *****************************************************************************
   */
 
-  properties :
-  {
+  properties: {
     /** The test suite */
-    suite : {
-      check    : "qx.dev.unit.TestSuite",
-      nullable : true,
-      init : null
+    suite: {
+      check: "qx.dev.unit.TestSuite",
+      nullable: true,
+      init: null
     }
   },
 
-
   /*
   *****************************************************************************
      PROPERTIES
   *****************************************************************************
   */
 
-  members :
-  {
+  members: {
     /**
      * Parses the url parameters and tries to find the classes to test.
      * The pattern is like <code>index.html?testclass=qx.test</code>
      *
      * @return {String} the class/namespace to test
      */
-    _getClassNameFromUrl : function()
-    {
+    _getClassNameFromUrl() {
       var params = window.location.search;
       var className = params.match(/[\?&]testclass=([A-Za-z0-9_\.]+)/);
 
@@ -69,79 +64,87 @@ qx.Mixin.define("qx.dev.unit.MTestLoader", {
       return className;
     },
 
-
     /**
      * Sets the top level namespace of the test cases to test. All classes
      * below this namespace extending {@link TestCase} will be tested.
      *
      * @param namespace {Object} Namespace to add
      */
-    setTestNamespace : function(namespace)
-    {
+    setTestNamespace(namespace) {
       var suite = new qx.dev.unit.TestSuite();
       suite.add(namespace);
       this.setSuite(suite);
     },
 
-
     /**
      * Run all tests and export the results to JSUnit
      */
-    runJsUnit : function()
-    {
+    runJsUnit() {
       var testResult = new qx.dev.unit.JsUnitTestResult();
       this.getSuite().run(testResult);
       testResult.exportToJsUnit();
     },
 
-
     /**
      * Run tests as standalone application
      */
-    runStandAlone : function()
-    {
+    runStandAlone() {
       var testResult = new qx.dev.unit.TestResult();
 
-      testResult.addListener("failure", function(e)
-      {
-        var ex = e.getData()[0].exception;
-        var test = e.getData()[0].test;
-        this.error("Test '" + test.getFullName() + "' failed: " + ex.message + " - " + ex.getComment());
-        if (ex.getStackTrace) {
-          this.error("Stack trace: " + ex.getStackTrace().join("\n"));
-        }
-      }, this);
-
-      testResult.addListener("error", function(e)
-      {
-        var ex = e.getData()[0].exception;
-        var test = e.getData()[0].test;
-        this.error("The test '" + test.getFullName() + "' had an error: " + ex, ex);
-      }, this);
+      testResult.addListener(
+        "failure",
+        function (e) {
+          var ex = e.getData()[0].exception;
+          var test = e.getData()[0].test;
+          this.error(
+            "Test '" +
+              test.getFullName() +
+              "' failed: " +
+              ex.message +
+              " - " +
+              ex.getComment()
+          );
+
+          if (ex.getStackTrace) {
+            this.error("Stack trace: " + ex.getStackTrace().join("\n"));
+          }
+        },
+        this
+      );
+
+      testResult.addListener(
+        "error",
+        function (e) {
+          var ex = e.getData()[0].exception;
+          var test = e.getData()[0].test;
+          this.error(
+            "The test '" + test.getFullName() + "' had an error: " + ex,
+            ex
+          );
+        },
+        this
+      );
 
       this.getSuite().run(testResult);
     },
 
-
     /**
      * Get a list of test descriptions
      *
      * @return {String} A description of all tests.
      */
-    getTestDescriptions : function()
-    {
+    getTestDescriptions() {
       var desc = [];
       var classes = this.getSuite().getTestClasses();
 
-      for (var i=0; i<classes.length; i++)
-      {
+      for (var i = 0; i < classes.length; i++) {
         var cls = classes[i];
         var clsDesc = {};
         clsDesc.classname = cls.getName();
         clsDesc.tests = [];
         var methods = cls.getTestMethods();
 
-        for (var j=0; j<methods.length; j++) {
+        for (var j = 0; j < methods.length; j++) {
           clsDesc.tests.push(methods[j].getName());
         }
 
@@ -151,7 +154,6 @@ qx.Mixin.define("qx.dev.unit.MTestLoader", {
       return qx.lang.Json.stringify(desc);
     },
 
-
     /**
      * Runs exactly one test from the test suite
      *
@@ -159,18 +161,14 @@ qx.Mixin.define("qx.dev.unit.MTestLoader", {
      * @param className {String} Name of the test class
      * @param methodName {String} Name of the test method
      */
-    runTests : function(testResult, className, methodName)
-    {
+    runTests(testResult, className, methodName) {
       var classes = this.getSuite().getTestClasses();
 
-      for (var i=0; i<classes.length; i++)
-      {
-        if (className == classes[i].getName())
-        {
+      for (var i = 0; i < classes.length; i++) {
+        if (className == classes[i].getName()) {
           var methods = classes[i].getTestMethods();
 
-          for (var j=0; j<methods.length; j++)
-          {
+          for (var j = 0; j < methods.length; j++) {
             if (methodName && methods[j].getName() != methodName) {
               continue;
             }
@@ -183,19 +181,16 @@ qx.Mixin.define("qx.dev.unit.MTestLoader", {
       }
     },
 
-
     /**
      * Runs all tests inside of the given namespace
      *
      * @param testResult {qx.dev.unit.TestResult} the result logger
      * @param namespaceName {String} Namespace of the tests to run
      */
-    runTestsFromNamespace : function(testResult, namespaceName)
-    {
+    runTestsFromNamespace(testResult, namespaceName) {
       var classes = this.getSuite().getTestClasses();
 
-      for (var i=0; i<classes.length; i++)
-      {
+      for (var i = 0; i < classes.length; i++) {
         if (classes[i].getName().indexOf(namespaceName) == 0) {
           classes[i].run(testResult);
         }