merged origin/2021.0.2 into 2021.0

entity/Appointment_entity/Appointment_entity.aod

@@ -270,6 +270,7 @@
       <jDitoRecordAlias>Data_alias</jDitoRecordAlias>
       <contentProcess>%aditoprj%/entity/Appointment_entity/recordcontainers/jdito/contentProcess.js</contentProcess>
       <rowCountProcess>%aditoprj%/entity/Appointment_entity/recordcontainers/jdito/rowCountProcess.js</rowCountProcess>
+      <hasDependentRecords v="true" />
       <onInsert>%aditoprj%/entity/Appointment_entity/recordcontainers/jdito/onInsert.js</onInsert>
       <onUpdate>%aditoprj%/entity/Appointment_entity/recordcontainers/jdito/onUpdate.js</onUpdate>
       <onDelete>%aditoprj%/entity/Appointment_entity/recordcontainers/jdito/onDelete.js</onDelete>

entity/Appointment_entity/afterUiInit.js

@@ -2,7 +2,7 @@ import("system.util");
 import("system.neon");
 import("system.vars");
 
-if(vars.exists("$param.Entry_param") && vars.get("$param.Entry_param"))
+if(vars.get("$param.Entry_param"))
 {
     var entry = JSON.parse(vars.getString("$param.Entry_param"));
    

entity/Appointment_entity/recordcontainers/jdito/contentProcess.js

@@ -18,12 +18,12 @@ var appointmentUids;
 /**
  * Will be used, if the user is operating the calendar.
  */
-if(vars.exists("$param.Entry_param") && vars.get("$param.Entry_param"))
+if(vars.get("$param.Entry_param") && JSON.parse(vars.get("$param.Entry_param"))[calendars.ID] != undefined)
 {
     var entry = JSON.parse(vars.getString("$param.Entry_param"));
 
     var masterEntry = null;
-    if (vars.exists("$param.MasterEntry_param") && vars.get("$param.MasterEntry_param") != "") {
+    if (vars.get("$param.MasterEntry_param") != "") {
         masterEntry = JSON.parse(vars.getString("$param.MasterEntry_param"));
     }
 

entity/Appointment_entity/recordcontainers/jdito/onInsert.js

@@ -8,6 +8,7 @@ import("system.neon");
 import("system.vars");
 import("system.text");
 import("system.db");
+import("system.entities");
 
 var event = JSON.parse(vars.getString("$param.Entry_param"));
 
@@ -22,36 +23,23 @@ event[calendars.LOCATION] = fields["LOCATION.value"];
 event[calendars.DESCRIPTION] = fields["DESCRIPTION.value"];
 event[calendars.DTSTART] = fields["BEGIN.value"];
 event[calendars.DTEND] = fields["END.value"];
-event["X-ADITO-ISALLDAYEVENT"] = fields["ALLDAY.value"];
 event[calendars.CLASSIFICATION] = fields["CLASSIFICATION.value"];
 event[calendars.TRANSPARENCY] = fields["TRANSPARENCY.value"];
 event[calendars.CATEGORIES] = fields["CATEGORIES.value"];
 event[calendars.ORGANIZER] = fields["ORGANIZER.value"];
+event["X-ADITO-ISALLDAYEVENT"] = fields["ALLDAY.value"];
 
 if(fields["RRULE.value"])
+{
     event[calendars.RRULE] = [fields["RRULE.value"]];
+}
 if (fields["REMINDER.value"])
 {
     event[calendars.HASREMINDER] = "true";
     event[calendars.REMINDER_DURATION] = fields["REMINDER.value"];
 }
 
-
-var idstringarray = calendars.insert([event]);
-
-if(event["LINKS"])
-{
-    event["LINKS"].forEach(function(pLink){
-        neon.addRecord("AppointmentLinks",
-        {
-            "OBJECTID" : pLink["OBJECT_ID"],
-            "OBJECTTYPE" : pLink["OBJECT_TYPE"],
-            "APPOINTMENT_ID" : idstringarray[0]
-        });
-    })
-}
-
-event[calendars.ID] = idstringarray[0];
+event[calendars.ID] = calendars.insert([event])[0];
 neon.setFieldValue("$field.UID", event[calendars.ID]);
 
 vars.set("$context.editmode", calendars.MODE_UPDATE);

entity/DocumentTemplate_entity/entityfields/openhtmleditor/stateProcess.js

@@ -7,5 +7,12 @@ import("system.neon");
 var template = DocumentTemplateUtils.getTemplate(vars.get("$field.DOCUMENTTEMPLATEID"), false);
 var kind = vars.get("$field.KIND");
 
-if(template.type == DocumentTemplate.types.HTML && kind == $KeywordRegistry.documentTemplateType$textModular() || kind == $KeywordRegistry.documentTemplateType$mail())
-    result.string(neon.COMPONENTSTATE_EDITABLE);
+if (template)
+{
+    if(template.type == DocumentTemplate.types.HTML && 
+        kind == $KeywordRegistry.documentTemplateType$textModular() || 
+        kind == $KeywordRegistry.documentTemplateType$mail())
+    {
+        result.string(neon.COMPONENTSTATE_EDITABLE);
+    }
+}

entity/Email_entity/entityfields/sendmail/onActionProcess.js

@@ -30,7 +30,7 @@ if (vars.exists("$param.AdditionalPlaceholders_param") && vars.get("$param.Addit
     });
 }
 
-var eml = EmailWritingUtils.openMailTemplate(
+EmailWritingUtils.openMailTemplate(
     vars.get("$field.RECIPIENT"), 
     EmployeeUtils.getCurrentContactId(), 
     vars.get("$field.DOCUMENT_TEMPLATE"), 

entity/Letter_entity/entityfields/downloadletterandcreateactivity/onActionProcess.js

@@ -33,6 +33,4 @@ if (template)
     }
 
     ActivityUtils.createNewActivity(null, links, null, null, translate.text("Letter"), text.parseDocument(content), $KeywordRegistry.activityDirection$outgoing(), [[template.filename, content, false]]);
-}
-else
-    throw new Error("Error while using a document template: The provided template does not contain data.");
\ No newline at end of file
+}
\ No newline at end of file

entity/Offer_entity/entityfields/contact_id/stateProcess.js

@@ -3,4 +3,11 @@ import("system.result");
 import("system.neon");
 import("system.vars");
 
-result.string(OfferUtils.isEditable(vars.get("$field.STATUS")) ? neon.COMPONENTSTATE_AUTO : neon.COMPONENTSTATE_DISABLED);
+if(vars.get("$sys.recordstate") == neon.OPERATINGSTATE_EDIT)
+{
+    result.string(neon.COMPONENTSTATE_READONLY);
+}
+else
+{
+    result.string(OfferUtils.isEditable(vars.get("$field.STATUS")) ? neon.COMPONENTSTATE_AUTO : neon.COMPONENTSTATE_DISABLED);
+}

entity/Organisation_entity/Organisation_entity.aod

@@ -1436,6 +1436,7 @@
       <title>New appointment</title>
       <onActionProcess>%aditoprj%/entity/Organisation_entity/entityfields/newappointment/onActionProcess.js</onActionProcess>
       <iconId>VAADIN:CALENDAR</iconId>
+      <state>EDITABLE</state>
       <stateProcess>%aditoprj%/entity/Organisation_entity/entityfields/newappointment/stateProcess.js</stateProcess>
       <tooltip>New Appointment</tooltip>
     </entityActionField>

entity/Person_entity/Person_entity.aod

@@ -1453,6 +1453,7 @@
       <title>New appointment</title>
       <onActionProcess>%aditoprj%/entity/Person_entity/entityfields/newappointment/onActionProcess.js</onActionProcess>
       <iconId>VAADIN:CALENDAR</iconId>
+      <state>EDITABLE</state>
       <stateProcess>%aditoprj%/entity/Person_entity/entityfields/newappointment/stateProcess.js</stateProcess>
       <tooltip>New Appointment</tooltip>
     </entityActionField>

entity/VisitPlanEntry_entity/entityfields/entityactiongroup/children/newappointment/onActionProcess.js

@@ -25,12 +25,10 @@ var summary = translate.text("Site visit") + " || " + fullName;
 var description = fullName;
 var standardMail = CommUtil.getStandardMail(selectionRowData[0].CONTACT_ID); 
 
-var startTime = selectionRowData[0].BEGIN_TIME;
-var endTime = selectionRowData[0].END_TIME;
-var duration = eMath.subInt(endTime, startTime);
-var entryDate = datetime.toLocaleDate(selectionRowData[0].ENTRYDATE, "dd-MM-yyyy");
-startTime = entryDate + " " + datetime.toLocaleDate(selectionRowData[0].BEGIN_TIME, "HH:mm:ss.S");
-startTime = datetime.toLong(startTime, "dd-MM-yyyy HH:mm:ss.S", "UTC"); // #1076044 set tz to prevent time gaps.
+//creates an js date object with the current utc time and adds the appointment begin/end time.
+//necessary for CalendarUtil.createEntry() 
+var start = new Date(datetime.today(vars.get("$sys.timezone"))+Number(selectionRowData[0].BEGIN_TIME));
+var end = new Date(datetime.today(vars.get("$sys.timezone"))+Number(selectionRowData[0].END_TIME));
 
 var links = [
     {
@@ -44,8 +42,8 @@ var links = [
 ];
 
 var params = {
-    "Entry_param": JSON.stringify(CalendarUtil.createEntry(summary, description, links, undefined, undefined, Date(Date.toExponential(startTime)),
-                                                                Date(Date.toExponential(endTime)), undefined, undefined, undefined, [standardMail], 
+    "Entry_param": JSON.stringify(CalendarUtil.createEntry(summary, description, links, undefined, undefined, start,
+                                                                end, undefined, undefined, undefined, [standardMail], 
                                                                 undefined, undefined, undefined))
 };
 

entity/VisitPlanEntry_entity/entityfields/entityactiongroup/children/newappointment/stateProcess.js

@@ -2,9 +2,14 @@ import("system.logging");
 import("system.result");
 import("system.vars");
 import("system.neon");
+import("Util_lib");
 
-if (vars.get("$field.ISGROUP") == "false" && vars.get("$sys.selectionRows") != "" 
+if (Utils.toBoolean(vars.get("$field.ISGROUP")) 
         && (vars.get("$field.STATUS") == "VISITSTATUSAPPPLANED"
-        || vars.get("$field.STATUS_APPOINTMENT") == "VISITSTATUSAPPOINTMENTCONFIRMED     "))
-    result.string(neon.COMPONENTSTATE_DISABLED);
+        || vars.get("$field.STATUS_APPOINTMENT") == "VISITSTATUSAPPOINTMENTCONFIRMED     ")
+        || Utils.isNullOrEmpty(vars.get("$sys.selectionRows"))
+        || Utils.isNullOrEmpty(vars.get("$field.PARENT_ID")))
+{
+    result.string(neon.COMPONENTSTATE_DISABLED);    
+}
 

process/CalendarUtil_test/CalendarUtil_test.aod

+<?xml version="1.0" encoding="UTF-8"?>
+<process xmlns="http://www.adito.de/2018/ao/Model" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" VERSION="1.2.2" xsi:schemaLocation="http://www.adito.de/2018/ao/Model adito://models/xsd/process/1.2.2">
+  <name>CalendarUtil_test</name>
+  <title>[TEST] Calendar_lib</title>
+  <majorModelMode>DISTRIBUTED</majorModelMode>
+  <icon>VAADIN:CHECK_CIRCLE</icon>
+  <process>%aditoprj%/process/CalendarUtil_test/process.js</process>
+  <alias>Data_alias</alias>
+  <variants>
+    <element>EXECUTABLE</element>
+  </variants>
+</process>

process/CalendarUtil_test/process.js

+import("system.calendars");
+import("system.result");
+import("system.db");
+import("UnitTest_lib");
+import("Calendar_lib");
+import("Sql_lib");
+
+
+var testUids = [];
+var tester = new Tester("Test Calendar_lib");
+var newSilentEvent = new TestSuite("CalendarUtil.newSilentEvent", [
+    new Test("Should create an appointment without graphical user interaction.", function(pTester, pDataProvider){
+        var uid = CalendarUtil.newSilentEvent(pDataProvider[0], pDataProvider[1], pDataProvider[2], pDataProvider[3], pDataProvider[4], 
+            pDataProvider[5], pDataProvider[6], pDataProvider[7], pDataProvider[8], pDataProvider[9], pDataProvider[10], pDataProvider[11], 
+            pDataProvider[12], pDataProvider[13]);
+            
+            var doesLinksExists;
+            var doesExists = Number(newSelect("count(*)", SqlUtils.getSystemAlias())
+                                    .from("asys_calendarbackend")
+                                    .where("asys_calendarbackend.elementuid", uid)
+                                    .cell());
+            
+            pTester.expectThat(doesExists).isGreaterEqual(1).assert();          
+            
+            if(pDataProvider[2] && doesExists) 
+            {
+                doesLinksExists = newSelect("ab_appointmentlink_id")
+                                        .from("ab_appointmentlink")
+                                        .where("ab_appointmentlink.appointment_id", uid)
+                                        .arrayColumn();
+
+                pTester.expectThat(doesLinksExists).hasMinLength(1).assert();
+            }
+            
+            doesLinksExists.length > 0 ? testUids.push([uid, doesLinksExists]) : testUids.push([uid]);
+    }, function(){
+        return [
+          ["Testtermin 1","Testbeschreibung",[{"OBJECT_ID":"c7ddf982-0e58-4152-b82b-8f5673b0b729", "OBJECT_TYPE":"Person"}], "Admin", ["Admin"], 
+            new Date("2021", "02", "29", "08", "30"), new Date("2021", "02", "29", "08", "45"), ["Meeting"], undefined, undefined, undefined, 
+                "Microsoft Teams", false, calendars.CLASSIFICATION_PUBLIC],      
+          ["Testtermin 2","Testbeschreibung",
+              [{"OBJECT_ID":"c7ddf982-0e58-4152-b82b-8f5673b0b729", "OBJECT_TYPE":"Person"},
+              {"OBJECT_ID":"18ed06df-30b2-4d59-a4b4-a6e646f6f05a", "OBJECT_TYPE":"Activity"}, 
+              {"OBJECT_ID":"449080f6-b714-4189-a261-37439d0d4010", "OBJECT_TYPE":"Organisation"}, 
+              {"OBJECT_ID":"e9cb198d-c420-4192-9c29-b23682457d8e", "OBJECT_TYPE":"Task"}], 
+              "Admin", ["Admin"], new Date("2021", "03", "08", "14", "30"), new Date("2021", "03", "08", "15", "45"), ["Meeting", "OutOfOffice"], 
+              calendars.STATUS_ACCEPTED, new Date("2021", "03", "08", "14", "15"), 
+              ["herbert.obermaier@hotmail.de", "lisa.lustig@yahoo.com"], "Microsoft Teams", false, calendars.CLASSIFICATION_PUBLIC],
+          ["Testtermin 3","Testbeschreibung",null, "Admin", ["Admin"], 
+            new Date("2021", "03", "29", "10", "00"), new Date("2021", "03", "29", "11", "00"), ["Vacation"], undefined, undefined, undefined, 
+                "Microsoft Teams", false, calendars.CLASSIFICATION_PUBLIC],
+          ["Testtermin 4","Testbeschreibung",[{"OBJECTID": "d8f35764-2c56-45be-93c7-f1e0695e2417", "OBJECT_TYPE":"Task"}], "Admin", ["Admin"], 
+            new Date("2021", "03", "29", "10", "00"), new Date("2021", "03", "29", "11", "00"), ["Vacation"], undefined, undefined, undefined, 
+                "Microsoft Teams", false, calendars.CLASSIFICATION_PUBLIC],
+        ];
+    })
+], null, null, function(){
+    for (i = 0; i < testUids.length; i++) 
+    {
+        if(testUids[i].length > 1)
+        {
+            newWhere("asys_calendarbackend.elementuid", testUids[i][0], null, null, SqlUtils.getSystemAlias())
+                .deleteData();  
+            testUids[i][1].forEach(function(pLinkUid){
+                newWhere("ab_appointmentlink.ab_appointmentlink_id", pLinkUid, null, null, db.getCurrentAlias())
+                    .deleteData();
+            });
+        }
+        else 
+        {
+            newWhere("asys_calendarbackend.elementuid", testUids[i][0], null, null, SqlUtils.getSystemAlias())
+                .deleteData();
+        }
+    }
+});
+
+tester.initCoverage(CalendarUtil);
+tester.test(newSilentEvent);
+
+tester.summary();
+
+result.object(tester.getResults());
\ No newline at end of file

process/Email_lib/process.js

@@ -34,7 +34,8 @@ function EmailWritingUtils () {}
  * @param {Placeholder[]} [pAdditionalPlaceholders] additional placeholders
  * @return {Array} the eml document as array with [filename, base64]
  */
-EmailWritingUtils.openMailTemplate = function (pToRecipients, pSenderContactId, pTemplateId, pRecipientContactId, pBindata, pAttachments, pSubject, pEmailFilename, pAdditionalPlaceholders)
+EmailWritingUtils.openMailTemplate = function (pToRecipients, pSenderContactId, pTemplateId, pRecipientContactId, pBindata, pAttachments, pSubject,
+                                                    pEmailFilename, pAdditionalPlaceholders)
 {
     if (pToRecipients && typeof(pToRecipients) == "string")
         pToRecipients = [pToRecipients];
@@ -66,9 +67,13 @@ EmailWritingUtils.openMailTemplate = function (pToRecipients, pSenderContactId,
     }
     
     if (pSubject)
+    {
         email.subject = pSubject;
+    }
+    
+    var isBinaryExistent = db.getBinaryCount("DOCUMENTTEMPLATE", "DOCUMENT", pTemplateId, SqlUtils.getBinariesAlias(), null);
     
-    return email.downloadEML(pEmailFilename);
+    return isBinaryExistent > 0 ? email.downloadEML(pEmailFilename) : [];
 }
 
 

process/UnitTest_lib/process.js

@@ -261,7 +261,7 @@ Tester.prototype.equals = function(pExpect, pCustomDescription)
 
     if(Utils.isObject(this.actualValue) || Utils.isObject(this.expectedValue))
     {
-        this.expectedDisplayValue = JSON.stringify(this.actualValue);
+        this.expectedDisplayValue = JSON.stringify(this.actualValue, _getCircularReplacer());
         this._testResult = Utils.isEqual(this.actualValue, this.expectedValue);
         this._generateAssertDescription({custom: pCustomDescription, operator: "===", name: "Object value"});
     }
@@ -272,6 +272,24 @@ Tester.prototype.equals = function(pExpect, pCustomDescription)
     }
 
     return this;
+    
+    //custom replacer that supports cyclic references
+    function _getCircularReplacer () 
+    {
+        var seen = new WeakSet();
+        return function (key, value) 
+        {
+            if (typeof value === "object" && value !== null) 
+            {
+                if (seen.has(value)) 
+                {
+                    return "{...}";
+                }
+                seen.add(value);
+            }
+            return value;
+        }
+    }
 }
 
 /**
@@ -1202,7 +1220,7 @@ Tester.prototype._generateTestTitle = function(pTest, pDataProviderIndex)
         var titleValues = [];
 
         this.dataProvider[pDataProviderIndex].forEach(function(pElement) {
-            titleValues.push(pElement === undefined ? "undefined" : JSON.stringify(pElement));
+            titleValues.push(pElement === undefined ? "undefined" : JSON.stringify(pElement, _getCircularReplacer()));
         });
         this._log("", this.t.info("\t\u2699 Test: " + pTest.name) + this.t.debug(" (#" + (pDataProviderIndex + 1) + ": " + titleValues.join(" | ") + ")"));
     }
@@ -1210,6 +1228,24 @@ Tester.prototype._generateTestTitle = function(pTest, pDataProviderIndex)
     {
         this._log("info", "\t\u2699 Test: " + pTest.name);
     }
+    
+    //custom replacer that supports cyclic references
+    function _getCircularReplacer () 
+    {
+        var seen = new WeakSet();
+        return function (key, value) 
+        {
+            if (typeof value === "object" && value !== null) 
+            {
+                if (seen.has(value)) 
+                {
+                    return "{...}";
+                }
+                seen.add(value);
+            }
+            return value;
+        }
+    }
 }
 
 /**

process/Util_lib/process.js

@@ -100,7 +100,7 @@ Utils.isNotNullOrEmptyString = function (pValue)
  */
 Utils.clone = function (pObject)
 {
-    var referenceMap = new Map();
+    var referenceMap = new WeakMap();
     return _clone(pObject);
     
     function _clone (pObject)
@@ -173,35 +173,62 @@ Utils.clone = function (pObject)
  */
 Utils.isEqual = function (pFirstObject, pSecondObject)
 {
-    var firstType = typeof pFirstObject;
-    var secondType = typeof pSecondObject;
-    if (firstType !== secondType)
-        return false;
-    if (firstType === "object" && pFirstObject !== null && pSecondObject !== null) //check for null because typeof null is also "object"
+    var comparedObjects = new WeakMap();
+    return _isEqual(pFirstObject, pSecondObject);
+    
+    function _isEqual (pFirstObject, pSecondObject)
     {
-        var isFirstArray = Array.isArray(pFirstObject);
-        var isSecondArray = Array.isArray(pSecondObject);
-        if (isFirstArray !== isSecondArray) //return false if only one object is an array
-            return false;
-        if (isFirstArray && pFirstObject.length !== pSecondObject.length)
+        var firstType = typeof pFirstObject;
+        var secondType = typeof pSecondObject;
+        if (firstType !== secondType)
+        {
             return false;
-        
-        for (let key in pSecondObject)
+        }
+        if (firstType === "object" && pFirstObject !== null && pSecondObject !== null) //check for null because typeof null is also "object"
         {
-            if (!(key in pFirstObject))
+            //All object comparisons are saved in comparedObjects, this makes it possible to detect recursions.
+            //If two objects have been checked for equality already, it can be safely assumed they are equal,
+            //because if they weren't, this function would have returned false already
+            if (comparedObjects.get(pFirstObject) === pSecondObject)
+            {
+                return true;
+            }
+            comparedObjects.set(pFirstObject, pSecondObject);
+            
+            var isFirstArray = Array.isArray(pFirstObject);
+            var isSecondArray = Array.isArray(pSecondObject);
+            if (isFirstArray !== isSecondArray) //return false if only one object is an array
+            {
+                return false;
+            }
+            if (isFirstArray && pFirstObject.length !== pSecondObject.length)
+            {
                 return false;
+            }
+            
+            for (let key in pSecondObject)
+            {
+                if (!(key in pFirstObject))
+                {
+                    return false;
+                }
+            }
+            for (let key in pFirstObject)
+            {
+                if (!(key in pSecondObject) || !_isEqual(pFirstObject[key], pSecondObject[key]))
+                {
+                    return false;
+                }
+            }
+            return true;
         }
-        for (let key in pFirstObject)
+        if (firstType === "number" && Number.isNaN(pFirstObject) && Number.isNaN(pSecondObject)) //NaN should be equal to NaN
         {
-            if (!(key in pSecondObject) || !Utils.isEqual(pFirstObject[key], pSecondObject[key]))
-                return false;
+            return true;
         }
-        return true;
+
+        return pFirstObject === pSecondObject;
     }
-    if (firstType === "number" && Number.isNaN(pFirstObject) && Number.isNaN(pSecondObject)) //NaN should be equal to NaN
-        return true;
-    
-    return pFirstObject === pSecondObject;
 }
 
 /**

process/Utils_test/Utils_test.aod

+<?xml version="1.0" encoding="UTF-8"?>
+<process xmlns="http://www.adito.de/2018/ao/Model" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" VERSION="1.2.2" xsi:schemaLocation="http://www.adito.de/2018/ao/Model adito://models/xsd/process/1.2.2">
+  <name>Utils_test</name>
+  <title>[TEST] Util_lib</title>
+  <majorModelMode>DISTRIBUTED</majorModelMode>
+  <icon>VAADIN:CHECK_CIRCLE</icon>
+  <process>%aditoprj%/process/Utils_test/process.js</process>
+  <variants>
+    <element>EXECUTABLE</element>
+  </variants>
+</process>

process/Utils_test/process.js

+import("Util_lib");
+import("system.result");
+import("system.vars");
+import("UnitTest_lib");
+
+var isEmpty = new TestSuite("Utils.isEmpty", [
+    new Test("should test if an object, string or array is empty",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isEmpty(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [true, ""],
+                [true, []],
+                [true, {}],
+                [true, new Set()],
+                [true, new Map()],
+                [true, function () {}],
+                [false, "never gonna"],
+                [false, ["give"]],
+                [false, {you: "up"}],
+                [false, new Set(["never gonna"])],
+                [false, new Map([["let", "you down"]])]
+            ];
+        }
+    )
+]);
+
+var isNullOrEmpty = new TestSuite("Utils.isNullOrEmpty", [
+    new Test("should test if value is null, undefined or empty",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isNullOrEmpty(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [true, null],
+                [true, undefined],
+                [true, ""],
+                [true, []],
+                [true, {}],
+                [true, new Set()],
+                [true, new Map()],
+                [true, function () {}],
+                [false, "never gonna"],
+                [false, ["give"]],
+                [false, {you: "up"}],
+                [false, new Set(["never gonna"])],
+                [false, new Map([["let", "you down"]])]
+            ];
+        }
+    )
+]);
+
+var isNullOrEmptyString = new TestSuite("Utils.isNullOrEmptyString", [
+    new Test("should test if value is null, undefined or empty string",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isNullOrEmptyString(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [true, null],
+                [true, undefined],
+                [true, ""],
+                [false, 0],
+                [false, 42],
+                [false, false],
+                [false, true],
+                [false, []],
+                [false, {}],
+                [false, new Set()],
+                [false, new Map()],
+                [false, function () {}],
+                [false, "never gonna"],
+                [false, ["give"]],
+                [false, {you: "up"}],
+                [false, new Set(["never gonna"])],
+                [false, new Map([["let", "you down"]])]
+            ];
+        }
+    )
+]);
+
+var isNotNullOrEmptyString = new TestSuite("Utils.isNotNullOrEmptyString", [
+    new Test("should test if value isn't null, undefined or empty string",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isNotNullOrEmptyString(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, ""],
+                [true, 0],
+                [true, 42],
+                [true, false],
+                [true, true],
+                [true, []],
+                [true, {}],
+                [true, new Set()],
+                [true, new Map()],
+                [true, function () {}],
+                [true, "never gonna"],
+                [true, ["give"]],
+                [true, {you: "up"}],
+                [true, new Set(["never gonna"])],
+                [true, new Map([["let", "you down"]])]
+            ];
+        }
+    )
+]);
+
+var clone = new TestSuite("Utils.clone", [
+    new Test("should test if value is copied correctly",
+        function (pTester, pDataProvider) 
+        {
+            var original = pDataProvider[0];
+            var copy = Utils.clone(original);
+
+            pTester.expectThat(original).equals(copy).assert();
+        },
+        function dataProvider() 
+        {
+            var recursiveObj = {test: "Test"};
+            recursiveObj.recursion = recursiveObj;
+            return [
+                [null],
+                [undefined],
+                [0],
+                [42],
+                [""],
+                ["yeee"],
+                [[]],
+                [{}],
+                [["one", "two", 3, 4]],
+                [{one: "two", three: 4}],
+                [["one", "two", [3, 4, {five: "6"}]]],
+                [{one: "two", three: [4, {five: "6"}]}],
+                [new Set(["one", "two", 3, 4])],
+                [new Map([["one", "two"], [3, 4]])],
+                [recursiveObj]
+            ];
+        }
+    )
+]);
+
+var isEqual = new TestSuite("Utils.isEqual", [
+    new Test("should test if object equality is checked correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isEqual(pDataProvider[1], pDataProvider[2]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            var num = 0;
+            var str = "0";
+            var objStr = new String("0");
+            var obj_1 = {a: 1, b: 2, c: 3};
+            var obj_2 = {x: null, y: "test", z: true};
+            var recursiveObj1 = {test: "Test"};
+            recursiveObj1.recursion = recursiveObj1;
+            var recursiveObj2 = {test: "Test"};
+            recursiveObj2.recursion = recursiveObj2;
+            
+            return [
+                [true,  num,     num],
+                [true,  str,     str],
+                [true,  true,    true],
+                [true,  objStr,  objStr],
+                [true,  obj_1,   obj_1],
+                [true,  obj_2,   obj_2],
+                [false, true,    false],
+                [false, obj_1,   obj_2],
+                [false, num,     objStr],
+                [false, num,     str],
+                [false, objStr,  str],
+                [false, null,    undefined],
+                [false, objStr,  null],
+                [false, objStr,  undefined],
+                [false, null,    "null"],
+                [true, recursiveObj1, recursiveObj2]
+            ];
+        }
+    )
+]);
+
+var isFunction = new TestSuite("Utils.isFunction", [
+    new Test("should test if functions are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isFunction(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [true, function () {}],
+                [true, (function () {}).bind({})],
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [false, 0],
+                [false, "str"],
+                [false, {}],
+                [false, []],
+                [false, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var isString = new TestSuite("Utils.isString", [
+    new Test("should test if strings are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isString(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [false, 0],
+                [true, ""],
+                [true, "str"],
+                [false, new String("")],
+                [false, {}],
+                [false, []],
+                [false, function () {}],
+                [false, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var isNumber = new TestSuite("Utils.isNumber", [
+    new Test("should test if numbers are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isNumber(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [true, 0],
+                [true, NaN],
+                [true, Infinity],
+                [false, "0"],
+                [false, {}],
+                [false, []],
+                [false, function () {}],
+                [false, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var isNumeric = new TestSuite("Utils.isNumeric", [
+    new Test("should test if numbers are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isNumeric(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [true, 0],
+                [true, "0"],
+                [false, "notnumber"],
+                [false, {}],
+                [false, []],
+                [false, function () {}],
+                [false, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var isInteger = new TestSuite("Utils.isInteger", [
+    new Test("should test if integers are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isInteger(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [true, 0],
+                [true, "0"],
+                [true, 1.0],
+                [true, "1.0"],
+                [false, 1.2],
+                [false, "1.2"],
+                [false, NaN],
+                [false, Infinity],
+                [false, "notnumber"],
+                [false, {}],
+                [false, []],
+                [false, function () {}],
+                [false, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var isFloat = new TestSuite("Utils.isFloat", [
+    new Test("should test if floats are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isFloat(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [false, 0],
+                [false, "0"],
+                [false, 1.0],
+                [false, "1.0"],
+                [true, 1.2],
+                [true, "1.2"],
+                [false, NaN],
+                [false, Infinity],
+                [false, "notnumber"],
+                [false, {}],
+                [false, []],
+                [false, function () {}],
+                [false, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var isObject = new TestSuite("Utils.isObject", [
+    new Test("should test if objects are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isObject(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [false, 0],
+                [false, "0"],
+                [false, NaN],
+                [false, Infinity],
+                [true, {}],
+                [true, []],
+                [false, function () {}],
+                [true, new Map()],
+                [true, new Set()]
+            ];
+        }
+    )
+]);
+
+var isMap = new TestSuite("Utils.isMap", [
+    new Test("should test if maps are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isMap(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [false, true],
+                [false, false],
+                [false, 0],
+                [false, "0"],
+                [false, NaN],
+                [false, Infinity],
+                [false, {}],
+                [false, []],
+                [false, function () {}],
+                [true, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var isBoolean = new TestSuite("Utils.isBoolean", [
+    new Test("should test if booleans are identified correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.isBoolean(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [false, null],
+                [false, undefined],
+                [true, true],
+                [true, false],
+                [false, 0],
+                [false, "0"],
+                [false, NaN],
+                [false, Infinity],
+                [false, {}],
+                [false, []],
+                [false, function () {}],
+                [false, new Map()],
+                [false, new Set()]
+            ];
+        }
+    )
+]);
+
+var toBoolean = new TestSuite("Utils.toBoolean", [
+    new Test("should test if boolean-ish values are parsed correctly",
+        function (pTester, pDataProvider) 
+        {
+            var expectValue = pDataProvider[0];
+            var actualValue = Utils.toBoolean(pDataProvider[1]);
+
+            pTester.expectThat(actualValue).equals(expectValue).assert();
+        },
+        function dataProvider() 
+        {
+            return [
+                [true, true],
+                [true, 1],
+                [true, "1"],
+                [true, "true"],
+                [true, {}],
+                [true, []],
+                [true, function () {}],
+                [true, new Map()],
+                [true, new Set()],
+                [false, false],
+                [false, 0],
+                [false, "0"],
+                [false, ""],
+                [false, "false"],
+                [false, null],
+                [false, "null"],
+                [false, undefined],
+                [false, "undefined"]
+            ];
+        }
+    )
+]);
+
+var tester = new Tester("Test Util_lib");
+tester.initCoverage(Utils);
+tester.test(isEmpty);
+tester.test(isNullOrEmpty);
+tester.test(isNullOrEmptyString);
+tester.test(clone);
+tester.test(isEqual);
+tester.test(isFunction);
+tester.test(isString);
+tester.test(isNumber);
+tester.test(isNumeric);
+tester.test(isInteger);
+tester.test(isFloat);
+tester.test(isObject);
+tester.test(isMap);
+tester.test(isBoolean);
+tester.test(toBoolean);
+
+tester.summary();
+    
+result.object(tester.getResults());