Skip to content
Snippets Groups Projects
Commit befebe60 authored by Benjamin Ulrich's avatar Benjamin Ulrich :speech_balloon:
Browse files

Merge branch 'Util_lib_unit_tests' into '2021.0.2' 

Util lib unit tests

See merge request xrm/basic!800
parents 94de5288 d8d69d24
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
process/UnitTest_lib/process.js
+ 38
− 2
View file @ befebe60
...@@ -261,7 +261,7 @@ Tester.prototype.equals = function(pExpect, pCustomDescription) ...@@ -261,7 +261,7 @@ Tester.prototype.equals = function(pExpect, pCustomDescription)
if(Utils.isObject(this.actualValue) || Utils.isObject(this.expectedValue)) 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._testResult = Utils.isEqual(this.actualValue, this.expectedValue);
this._generateAssertDescription({custom: pCustomDescription, operator: "===", name: "Object value"}); this._generateAssertDescription({custom: pCustomDescription, operator: "===", name: "Object value"});
} }
...@@ -272,6 +272,24 @@ Tester.prototype.equals = function(pExpect, pCustomDescription) ...@@ -272,6 +272,24 @@ Tester.prototype.equals = function(pExpect, pCustomDescription)
} }
return this; 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) ...@@ -1202,7 +1220,7 @@ Tester.prototype._generateTestTitle = function(pTest, pDataProviderIndex)
var titleValues = []; var titleValues = [];
this.dataProvider[pDataProviderIndex].forEach(function(pElement) { 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(" | ") + ")")); 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) ...@@ -1210,6 +1228,24 @@ Tester.prototype._generateTestTitle = function(pTest, pDataProviderIndex)
{ {
this._log("info", "\t\u2699 Test: " + pTest.name); 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
+ 49
− 22
View file @ befebe60
...@@ -100,7 +100,7 @@ Utils.isNotNullOrEmptyString = function (pValue) ...@@ -100,7 +100,7 @@ Utils.isNotNullOrEmptyString = function (pValue)
*/ */
Utils.clone = function (pObject) Utils.clone = function (pObject)
{ {
var referenceMap = new Map(); var referenceMap = new WeakMap();
return _clone(pObject); return _clone(pObject);
function _clone (pObject) function _clone (pObject)
...@@ -173,35 +173,62 @@ Utils.clone = function (pObject) ...@@ -173,35 +173,62 @@ Utils.clone = function (pObject)
*/ */
Utils.isEqual = function (pFirstObject, pSecondObject) Utils.isEqual = function (pFirstObject, pSecondObject)
{ {
var firstType = typeof pFirstObject; var comparedObjects = new WeakMap();
var secondType = typeof pSecondObject; return _isEqual(pFirstObject, pSecondObject);
if (firstType !== secondType)
return false; function _isEqual (pFirstObject, pSecondObject)
if (firstType === "object" && pFirstObject !== null && pSecondObject !== null) //check for null because typeof null is also "object"
{ {
var isFirstArray = Array.isArray(pFirstObject); var firstType = typeof pFirstObject;
var isSecondArray = Array.isArray(pSecondObject); var secondType = typeof pSecondObject;
if (isFirstArray !== isSecondArray) //return false if only one object is an array if (firstType !== secondType)
return false; {
if (isFirstArray && pFirstObject.length !== pSecondObject.length)
return false; 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; 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 true;
return false;
} }
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 0 → 100644
+ 11
− 0
View file @ befebe60
<?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 0 → 100644
+ 542
− 0
View file @ befebe60
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());
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment