@e22m4u/js-repository 0.6.0 → 0.6.2

package/src/filter/operator-clause-tool.spec.js

@@ -7,54 +7,131 @@ const S = new OperatorClauseTool();
 
 describe('OperatorClauseTool', function () {
   describe('compare', function () {
-    it('returns a negative number if a second value is greatest', function () {
-      expect(S.compare(0, 5)).to.be.eq(-5);
-      expect(S.compare(0, '5')).to.be.eq(-5);
-      expect(S.compare(0, true)).to.be.eq(-1);
-      expect(S.compare('0', 5)).to.be.eq(-5);
-      expect(S.compare('a', 'b')).to.be.eq(-1);
-    });
-
-    it('returns a positive number if a second value is lowest', function () {
-      expect(S.compare(5, 0)).to.be.eq(5);
-      expect(S.compare(5, '0')).to.be.eq(5);
-      expect(S.compare(5, false)).to.be.eq(5);
-      expect(S.compare(5, true)).to.be.eq(4);
-      expect(S.compare('5', 0)).to.be.eq(5);
-      expect(S.compare('b', 'a')).to.be.eq(1);
-    });
-
-    it('returns zero if given values are equal', function () {
+    it('returns zero for equal values of the same type', function () {
       const obj = {};
+      const arr = [];
       expect(S.compare(0, 0)).to.be.eq(0);
-      expect(S.compare(0, '0')).to.be.eq(0);
-      expect(S.compare('0', 0)).to.be.eq(0);
       expect(S.compare('a', 'a')).to.be.eq(0);
+      expect(S.compare(true, true)).to.be.eq(0);
       expect(S.compare(obj, obj)).to.be.eq(0);
+      expect(S.compare(arr, arr)).to.be.eq(0);
       expect(S.compare(null, null)).to.be.eq(0);
       expect(S.compare(undefined, undefined)).to.be.eq(0);
     });
 
-    it('returns NaN if we do not know how to compare', function () {
-      expect(isNaN(S.compare(null, 'string'))).to.be.true;
-      expect(isNaN(S.compare(null, 10))).to.be.true;
-      expect(isNaN(S.compare([], 0))).to.be.true;
-      expect(isNaN(S.compare([], []))).to.be.true;
-      expect(isNaN(S.compare({}, {}))).to.be.true;
-      expect(isNaN(S.compare(10, {}))).to.be.true;
-      expect(isNaN(S.compare('string', Symbol()))).to.be.true;
+    it('returns a non-zero number for different numbers', function () {
+      expect(S.compare(5, 0)).to.be.eq(5);
+      expect(S.compare(0, 5)).to.be.eq(-5);
+    });
+
+    it('returns a non-zero number for different booleans', function () {
+      expect(S.compare(true, false)).to.be.eq(1);
+      expect(S.compare(false, true)).to.be.eq(-1);
+    });
+
+    it('returns a non-zero number for different strings', function () {
+      expect(S.compare('c', 'a')).to.be.eq(1);
+      expect(S.compare('b', 'a')).to.be.eq(1);
+      expect(S.compare('a', 'b')).to.be.eq(-1);
+      expect(S.compare('a', 'c')).to.be.eq(-1);
+    });
+
+    it('compares numbers and numeric strings as numbers', function () {
+      expect(S.compare(10, '10')).to.be.eq(0);
+      expect(S.compare('10', 10)).to.be.eq(0);
+      expect(S.compare(15, '10')).to.be.eq(5);
+      expect(S.compare('15', 10)).to.be.eq(5);
+      expect(S.compare(5, '10')).to.be.eq(-5);
+      expect(S.compare('5', 10)).to.be.eq(-5);
+    });
+
+    it('returns NaN when comparing null/undefined with other types', function () {
+      expect(S.compare(null, 'string')).to.be.NaN;
+      expect(S.compare(null, 10)).to.be.NaN;
+      expect(S.compare(null, 0)).to.be.NaN;
+      expect(S.compare(null, false)).to.be.NaN;
+      expect(S.compare(undefined, 'string')).to.be.NaN;
+      expect(S.compare(undefined, 10)).to.be.NaN;
+      expect(S.compare(undefined, 0)).to.be.NaN;
+      expect(S.compare(undefined, false)).to.be.NaN;
+    });
+
+    it('returns 0 for deeply equal objects', function () {
+      expect(S.compare({a: 1, b: {c: 2}}, {a: 1, b: {c: 2}})).to.be.eq(0);
+    });
+
+    it('returns NaN for different objects', function () {
+      expect(S.compare({a: 1}, {a: 2})).to.be.NaN;
+      expect(S.compare({a: 1}, {b: 1})).to.be.NaN;
+    });
+
+    it('returns 0 for deeply equal arrays', function () {
+      expect(S.compare([1, {a: 2}], [1, {a: 2}])).to.be.eq(0);
+    });
+
+    it('returns NaN for different arrays', function () {
+      expect(S.compare([1, 2], [1, 3])).to.be.NaN;
+      expect(S.compare([1, 2], [1, 2, 3])).to.be.NaN;
+    });
+
+    it('returns NaN for incomparable types', function () {
+      // строка (не число) и число
+      expect(S.compare('abc', 10)).to.be.NaN;
+      expect(S.compare(10, 'abc')).to.be.NaN;
+      // строка и булево
+      expect(S.compare('true', true)).to.be.NaN;
+      expect(S.compare(true, 'true')).to.be.NaN;
+      // число и объект
+      expect(S.compare(10, {})).to.be.NaN;
+      expect(S.compare({}, 10)).to.be.NaN;
+      // строка и символ
+      expect(S.compare('string', Symbol())).to.be.NaN;
+      // объект и массив
+      expect(S.compare({}, [])).to.be.NaN;
+    });
+
+    describe('with type conversion disabled (noTypeConversion = true)', function () {
+      it('returns 0 only for strictly equal primitives', function () {
+        expect(S.compare(10, 10, true)).to.be.eq(0);
+        expect(S.compare('a', 'a', true)).to.be.eq(0);
+        expect(S.compare(true, true, true)).to.be.eq(0);
+      });
+
+      it('returns NaN for different types, even if their values are equivalent', function () {
+        expect(S.compare(10, '10', true)).to.be.NaN;
+        expect(S.compare('10', 10, true)).to.be.NaN;
+        expect(S.compare(1, true, true)).to.be.NaN;
+        expect(S.compare(true, 1, true)).to.be.NaN;
+        expect(S.compare(0, false, true)).to.be.NaN;
+      });
+
+      it('returns a non-zero number for different values of the same type', function () {
+        expect(S.compare(10, 5, true)).to.be.greaterThan(0);
+        expect(S.compare('b', 'a', true)).to.be.greaterThan(0);
+        expect(S.compare(true, false, true)).to.be.greaterThan(0);
+      });
+
+      it('returns 0 for deeply equal objects and NaN for different ones', function () {
+        expect(S.compare({a: 1}, {a: 1}, true)).to.be.eq(0);
+        expect(S.compare({a: 1}, {a: 2}, true)).to.be.NaN;
+      });
+
+      it('returns 0 for deeply equal arrays and NaN for different ones', function () {
+        expect(S.compare([1, 2], [1, 2], true)).to.be.eq(0);
+        expect(S.compare([1, 2], [1, 3], true)).to.be.NaN;
+      });
     });
   });
 
   describe('testAll', function () {
-    it('tests "eq" and "neq" operators', function () {
+    it('should test "eq" and "neq" operators', function () {
       expect(S.testAll({eq: 10}, 10)).to.be.true;
       expect(S.testAll({eq: 10}, 9)).to.be.false;
       expect(S.testAll({neq: 10}, 9)).to.be.true;
       expect(S.testAll({neq: 10}, 10)).to.be.false;
     });
 
-    it('tests "gt", "gte", "lt" and "lte" operators', function () {
+    it('should test "gt", "gte", "lt" and "lte" operators', function () {
       expect(S.testAll({gt: 5}, 6)).to.be.true;
       expect(S.testAll({gte: 5}, 5)).to.be.true;
       expect(S.testAll({lt: 5}, 4)).to.be.true;
@@ -65,54 +142,68 @@ describe('OperatorClauseTool', function () {
       expect(S.testAll({lte: 5}, 6)).to.be.false;
     });
 
-    it('tests a "inq" operator', function () {
+    it('should test the "inq" operator', function () {
       expect(S.testAll({inq: [1, 2, 3]}, 2)).to.be.true;
       expect(S.testAll({inq: [1, 2, 3]}, 'a')).to.be.false;
     });
 
-    it('tests a "nin" operator', function () {
+    it('should test the "nin" operator', function () {
       expect(S.testAll({nin: [1, 2, 3]}, 'a')).to.be.true;
       expect(S.testAll({nin: [1, 2, 3]}, 2)).to.be.false;
     });
 
-    it('tests a "between" operator', function () {
+    it('should test the "between" operator', function () {
       expect(S.testAll({between: [-2, 2]}, 0)).to.be.true;
       expect(S.testAll({between: [-2, 2]}, 10)).to.be.false;
     });
 
-    it('tests an "exists" operator', function () {
+    it('should test the "exists" operator', function () {
       expect(S.testAll({exists: true}, 10)).to.be.true;
       expect(S.testAll({exists: false}, undefined)).to.be.true;
       expect(S.testAll({exists: true}, undefined)).to.be.false;
       expect(S.testAll({exists: false}, 10)).to.be.false;
     });
 
-    it('tests a "like" operator', function () {
-      expect(S.testAll({like: 'World'}, 'Hello World!')).to.be.true;
-      expect(S.testAll({like: 'world'}, 'Hello World!')).to.be.false;
+    it('should test the "like" operator', function () {
+      expect(S.testAll({like: '%World%'}, 'Hello World!')).to.be.true;
+      expect(S.testAll({like: '%world%'}, 'Hello World!')).to.be.false;
     });
 
-    it('tests a "nlike" operator', function () {
-      expect(S.testAll({nlike: 'John'}, 'Hello World!')).to.be.true;
-      expect(S.testAll({nlike: 'World'}, 'Hello World!')).to.be.false;
+    it('should test the "nlike" operator', function () {
+      expect(S.testAll({nlike: '%John%'}, 'Hello World!')).to.be.true;
+      expect(S.testAll({nlike: '%World%'}, 'Hello World!')).to.be.false;
     });
 
-    it('tests a "ilike" operator', function () {
-      expect(S.testAll({ilike: 'WORLD'}, 'Hello World!')).to.be.true;
-      expect(S.testAll({ilike: 'John'}, 'Hello World!')).to.be.false;
+    it('should test the "ilike" operator', function () {
+      expect(S.testAll({ilike: '%WORLD%'}, 'Hello World!')).to.be.true;
+      expect(S.testAll({ilike: '%John%'}, 'Hello World!')).to.be.false;
     });
 
-    it('tests a "nilike" operator', function () {
-      expect(S.testAll({nilike: 'John'}, 'Hello World!')).to.be.true;
-      expect(S.testAll({nilike: 'world'}, 'Hello World!')).to.be.false;
+    it('should test the "nilike" operator', function () {
+      expect(S.testAll({nilike: '%John%'}, 'Hello World!')).to.be.true;
+      expect(S.testAll({nilike: '%world%'}, 'Hello World!')).to.be.false;
     });
 
-    it('tests a "regexp" operator', function () {
+    it('should test the "regexp" operator', function () {
       expect(S.testAll({regexp: 'Wo.+'}, 'Hello World!')).to.be.true;
       expect(S.testAll({regexp: 'Fo.+'}, 'Hello World!')).to.be.false;
+      expect(S.testAll({regexp: 'wo.+', flags: 'i'}, 'World')).to.be.true;
+      expect(S.testAll({regexp: 'fo.+', flags: 'i'}, 'World')).to.be.false;
     });
 
-    it('throws an error if a first argument is not an object', function () {
+    it('should allow to combine operators', function () {
+      const clause = {gt: 20, lt: 30};
+      expect(S.testAll(clause, 10)).to.be.false;
+      expect(S.testAll(clause, 25)).to.be.true;
+      expect(S.testAll(clause, 40)).to.be.false;
+    });
+
+    it('should return undefined for an empty clause or non-operator key', function () {
+      expect(S.testAll({}, 'value')).to.be.undefined;
+      expect(S.testAll({foo: 'bar'}, 'value')).to.be.undefined;
+    });
+
+    it('should throws an error if a first argument is not an object', function () {
       const throwable = () => S.testAll(10);
       expect(throwable).to.throw(
         'The first argument of OperatorUtils.testAll ' +
@@ -138,9 +229,7 @@ describe('OperatorClauseTool', function () {
     describe('eq', function () {
       it('returns true if a given value is equal to reference', function () {
         expect(S.testEqNeq({eq: 0}, 0)).to.be.true;
-        expect(S.testEqNeq({eq: 0}, '0')).to.be.true;
-        expect(S.testEqNeq({eq: 0}, false)).to.be.true;
-        expect(S.testEqNeq({eq: 1}, true)).to.be.true;
+        expect(S.testEqNeq({eq: 1}, 1)).to.be.true;
         expect(S.testEqNeq({eq: 'a'}, 'a')).to.be.true;
         expect(S.testEqNeq({eq: true}, true)).to.be.true;
         expect(S.testEqNeq({eq: false}, false)).to.be.true;
@@ -150,6 +239,8 @@ describe('OperatorClauseTool', function () {
       });
 
       it('returns false if a given value is not-equal to reference', function () {
+        expect(S.testEqNeq({eq: 0}, '0')).to.be.false;
+        expect(S.testEqNeq({eq: 0}, false)).to.be.false;
         expect(S.testEqNeq({eq: 0}, 1)).to.be.false;
         expect(S.testEqNeq({eq: 0}, '1')).to.be.false;
         expect(S.testEqNeq({eq: 0}, true)).to.be.false;
@@ -161,6 +252,18 @@ describe('OperatorClauseTool', function () {
         expect(S.testEqNeq({eq: '0'}, Infinity)).to.be.false;
         expect(S.testEqNeq({eq: '0'}, null)).to.be.false;
         expect(S.testEqNeq({eq: '0'}, undefined)).to.be.false;
+        expect(S.testEqNeq({eq: 1}, '0')).to.be.false;
+        expect(S.testEqNeq({eq: 1}, false)).to.be.false;
+        expect(S.testEqNeq({eq: 1}, '1')).to.be.false;
+        expect(S.testEqNeq({eq: 1}, true)).to.be.false;
+        expect(S.testEqNeq({eq: 1}, Infinity)).to.be.false;
+        expect(S.testEqNeq({eq: 1}, null)).to.be.false;
+        expect(S.testEqNeq({eq: 1}, undefined)).to.be.false;
+        expect(S.testEqNeq({eq: '1'}, '0')).to.be.false;
+        expect(S.testEqNeq({eq: '1'}, true)).to.be.false;
+        expect(S.testEqNeq({eq: '1'}, Infinity)).to.be.false;
+        expect(S.testEqNeq({eq: '1'}, null)).to.be.false;
+        expect(S.testEqNeq({eq: '1'}, undefined)).to.be.false;
         expect(S.testEqNeq({eq: true}, false)).to.be.false;
         expect(S.testEqNeq({eq: true}, null)).to.be.false;
         expect(S.testEqNeq({eq: true}, undefined)).to.be.false;
@@ -168,14 +271,25 @@ describe('OperatorClauseTool', function () {
         expect(S.testEqNeq({eq: false}, null)).to.be.false;
         expect(S.testEqNeq({eq: false}, undefined)).to.be.false;
       });
+
+      it('returns true for deeply equal objects and arrays', function () {
+        expect(S.testEqNeq({eq: {a: 1, b: {c: 2}}}, {a: 1, b: {c: 2}})).to.be
+          .true;
+        expect(S.testEqNeq({eq: [1, {a: 2}]}, [1, {a: 2}])).to.be.true;
+      });
+
+      it('returns false for different objects and arrays', function () {
+        expect(S.testEqNeq({eq: {a: 1}}, {a: 2})).to.be.false;
+        expect(S.testEqNeq({eq: {a: 1}}, {b: 1})).to.be.false;
+        expect(S.testEqNeq({eq: [1, 2]}, [1, 3])).to.be.false;
+        expect(S.testEqNeq({eq: [1, 2]}, [1, 2, 3])).to.be.false;
+      });
     });
 
     describe('neq', function () {
-      it('returns false if a given value is strictly equal to reference', function () {
+      it('returns false if a given value is equal to reference', function () {
         expect(S.testEqNeq({neq: 0}, 0)).to.be.false;
-        expect(S.testEqNeq({neq: 0}, '0')).to.be.false;
-        expect(S.testEqNeq({neq: 0}, false)).to.be.false;
-        expect(S.testEqNeq({neq: 1}, true)).to.be.false;
+        expect(S.testEqNeq({neq: 1}, 1)).to.be.false;
         expect(S.testEqNeq({neq: 'a'}, 'a')).to.be.false;
         expect(S.testEqNeq({neq: true}, true)).to.be.false;
         expect(S.testEqNeq({neq: false}, false)).to.be.false;
@@ -184,7 +298,9 @@ describe('OperatorClauseTool', function () {
         expect(S.testEqNeq({neq: undefined}, undefined)).to.be.false;
       });
 
-      it('returns true if a given value is strictly not-equal to reference', function () {
+      it('returns true if a given value is not-equal to reference', function () {
+        expect(S.testEqNeq({neq: 0}, '0')).to.be.true;
+        expect(S.testEqNeq({neq: 0}, false)).to.be.true;
         expect(S.testEqNeq({neq: 0}, 1)).to.be.true;
         expect(S.testEqNeq({neq: 0}, '1')).to.be.true;
         expect(S.testEqNeq({neq: 0}, true)).to.be.true;
@@ -196,6 +312,18 @@ describe('OperatorClauseTool', function () {
         expect(S.testEqNeq({neq: '0'}, Infinity)).to.be.true;
         expect(S.testEqNeq({neq: '0'}, null)).to.be.true;
         expect(S.testEqNeq({neq: '0'}, undefined)).to.be.true;
+        expect(S.testEqNeq({neq: 1}, '0')).to.be.true;
+        expect(S.testEqNeq({neq: 1}, false)).to.be.true;
+        expect(S.testEqNeq({neq: 1}, '1')).to.be.true;
+        expect(S.testEqNeq({neq: 1}, true)).to.be.true;
+        expect(S.testEqNeq({neq: 1}, Infinity)).to.be.true;
+        expect(S.testEqNeq({neq: 1}, null)).to.be.true;
+        expect(S.testEqNeq({neq: 1}, undefined)).to.be.true;
+        expect(S.testEqNeq({neq: '1'}, '0')).to.be.true;
+        expect(S.testEqNeq({neq: '1'}, true)).to.be.true;
+        expect(S.testEqNeq({neq: '1'}, Infinity)).to.be.true;
+        expect(S.testEqNeq({neq: '1'}, null)).to.be.true;
+        expect(S.testEqNeq({neq: '1'}, undefined)).to.be.true;
         expect(S.testEqNeq({neq: true}, false)).to.be.true;
         expect(S.testEqNeq({neq: true}, null)).to.be.true;
         expect(S.testEqNeq({neq: true}, undefined)).to.be.true;
@@ -203,6 +331,19 @@ describe('OperatorClauseTool', function () {
         expect(S.testEqNeq({neq: false}, null)).to.be.true;
         expect(S.testEqNeq({neq: false}, undefined)).to.be.true;
       });
+
+      it('returns false for deeply equal objects and arrays', function () {
+        expect(S.testEqNeq({neq: {a: 1, b: {c: 2}}}, {a: 1, b: {c: 2}})).to.be
+          .false;
+        expect(S.testEqNeq({neq: [1, {a: 2}]}, [1, {a: 2}])).to.be.false;
+      });
+
+      it('returns true for different objects and arrays', function () {
+        expect(S.testEqNeq({neq: {a: 1}}, {a: 2})).to.be.true;
+        expect(S.testEqNeq({neq: {a: 1}}, {b: 1})).to.be.true;
+        expect(S.testEqNeq({neq: [1, 2]}, [1, 3])).to.be.true;
+        expect(S.testEqNeq({neq: [1, 2]}, [1, 2, 3])).to.be.true;
+      });
     });
   });
 
@@ -373,18 +514,40 @@ describe('OperatorClauseTool', function () {
 
     it('returns true if a given value has in array', function () {
       expect(S.testInq({inq: [1, 2]}, 2)).to.be.true;
-      expect(S.testInq({inq: [1, 2]}, '2')).to.be.true;
       expect(S.testInq({inq: ['a', 'b']}, 'b')).to.be.true;
-      expect(S.testInq({inq: [1, 2]}, true)).to.be.true;
-      expect(S.testInq({inq: [-1, 0]}, false)).to.be.true;
     });
 
     it('returns false if a given value is not in array', function () {
       expect(S.testInq({inq: [1, 2]}, 3)).to.be.false;
+      expect(S.testInq({inq: [1, 2]}, '2')).to.be.false;
       expect(S.testInq({inq: [1, 2]}, '3')).to.be.false;
       expect(S.testInq({inq: ['a', 'b']}, 'c')).to.be.false;
-      expect(S.testInq({inq: [-1, 0]}, true)).to.be.false;
+      expect(S.testInq({inq: [1, 2]}, true)).to.be.false;
       expect(S.testInq({inq: [1, 2]}, false)).to.be.false;
+      expect(S.testInq({inq: [-1, 0]}, true)).to.be.false;
+      expect(S.testInq({inq: [-1, 0]}, false)).to.be.false;
+    });
+
+    it('returns true if a given object is deeply equal to an element in the array', function () {
+      const clause = {inq: [{a: 1}, {b: 2}]};
+      expect(S.testInq(clause, {a: 1})).to.be.true;
+    });
+
+    it('returns false if a given object is not deeply equal to any element in the array', function () {
+      const clause = {inq: [{a: 1}, {b: 2}]};
+      expect(S.testInq(clause, {c: 3})).to.be.false;
+    });
+
+    it('returns true if a given array is deeply equal to an element in the array', function () {
+      // prettier-ignore
+      const clause = {inq: [[1, 2], [3, 4]]};
+      expect(S.testInq(clause, [1, 2])).to.be.true;
+    });
+
+    it('returns false if a given array is not deeply equal to any element in the array', function () {
+      // prettier-ignore
+      const clause = {inq: [[1, 2], [3, 4]]};
+      expect(S.testInq(clause, [5, 6])).to.be.false;
     });
 
     it('throws an error if a first argument is not an object', function () {
@@ -428,20 +591,43 @@ describe('OperatorClauseTool', function () {
 
     it('returns false if a given value has in array', function () {
       expect(S.testNin({nin: [1, 2]}, 2)).to.be.false;
-      expect(S.testNin({nin: [1, 2]}, '2')).to.be.false;
+
       expect(S.testNin({nin: ['a', 'b']}, 'b')).to.be.false;
-      expect(S.testNin({nin: [1, 2]}, true)).to.be.false;
-      expect(S.testNin({nin: [-1, 0]}, false)).to.be.false;
     });
 
     it('returns true if a given value is not in array', function () {
       expect(S.testNin({nin: [1, 2]}, 3)).to.be.true;
+      expect(S.testNin({nin: [1, 2]}, '2')).to.be.true;
       expect(S.testNin({nin: [1, 2]}, '3')).to.be.true;
       expect(S.testNin({nin: ['a', 'b']}, 'c')).to.be.true;
       expect(S.testNin({nin: [-1, 0]}, true)).to.be.true;
+      expect(S.testNin({nin: [-1, 0]}, false)).to.be.true;
+      expect(S.testNin({nin: [1, 2]}, true)).to.be.true;
       expect(S.testNin({nin: [1, 2]}, false)).to.be.true;
     });
 
+    it('returns false if a given object is deeply equal to an element in the array', function () {
+      const clause = {nin: [{a: 1}, {b: 2}]};
+      expect(S.testNin(clause, {a: 1})).to.be.false;
+    });
+
+    it('returns true if a given object is not deeply equal to any element in the array', function () {
+      const clause = {nin: [{a: 1}, {b: 2}]};
+      expect(S.testNin(clause, {c: 3})).to.be.true;
+    });
+
+    it('returns false if a given array is deeply equal to an element in the array', function () {
+      // prettier-ignore
+      const clause = {nin: [[1, 2], [3, 4]]};
+      expect(S.testNin(clause, [1, 2])).to.be.false;
+    });
+
+    it('returns true if a given array is not deeply equal to any element in the array', function () {
+      // prettier-ignore
+      const clause = {nin: [[1, 2], [3, 4]]};
+      expect(S.testNin(clause, [5, 6])).to.be.true;
+    });
+
     it('throws an error if a first argument is not an object', function () {
       const throwable = () => S.testNin(10);
       expect(throwable).to.throw(
@@ -640,318 +826,377 @@ describe('OperatorClauseTool', function () {
   });
 
   describe('testLike', function () {
-    it('returns undefined if no operator given', function () {
+    it('should return undefined if no operator given', function () {
       const result = S.testLike({}, 'value');
       expect(result).to.be.undefined;
     });
 
-    it('returns true if a given value matches a substring', function () {
-      expect(S.testLike({like: 'val'}, 'value')).to.be.true;
-      expect(S.testLike({like: 'lue'}, 'value')).to.be.true;
-      expect(S.testLike({like: 'value'}, 'value')).to.be.true;
+    it('should return false when matching by substring', function () {
+      expect(S.testLike({like: 'val'}, 'value')).to.be.false;
+      expect(S.testLike({like: 'lue'}, 'value')).to.be.false;
+      expect(S.testLike({like: 'alu'}, 'value')).to.be.false;
     });
 
-    it('returns false if a given value not matches a substring', function () {
+    it('should return false when the value is a substring', function () {
       expect(S.testLike({like: 'value'}, 'val')).to.be.false;
       expect(S.testLike({like: 'value'}, 'lue')).to.be.false;
-      expect(S.testLike({like: 'value'}, 'foo')).to.be.false;
-    });
-
-    it('uses case-sensitive matching for a substring', function () {
-      expect(S.testLike({like: 'Val'}, 'value')).to.be.false;
-      expect(S.testLike({like: 'Val'}, 'Value')).to.be.true;
-      expect(S.testLike({like: 'val'}, 'Value')).to.be.false;
-    });
-
-    it('returns true if a given value matches a string expression', function () {
-      expect(S.testLike({like: 'val.+'}, 'value')).to.be.true;
-    });
-
-    it('returns false if a given value not matches a string expression', function () {
-      expect(S.testLike({like: 'foo.+'}, 'value')).to.be.false;
-    });
-
-    it('uses case-sensitive matching for a string expression', function () {
-      expect(S.testLike({like: 'Val.+'}, 'value')).to.be.false;
-      expect(S.testLike({like: 'Val.+'}, 'Value')).to.be.true;
-      expect(S.testLike({like: 'val.+'}, 'Value')).to.be.false;
-    });
-
-    it('returns true if a given value matches a RegExp', function () {
-      expect(S.testLike({like: new RegExp(/val.+/)}, 'value')).to.be.true;
+      expect(S.testLike({like: 'value'}, 'alu')).to.be.false;
     });
 
-    it('returns false if a given value matches a RegExp', function () {
-      expect(S.testLike({like: new RegExp(/foo.+/)}, 'value')).to.be.false;
-    });
-
-    it('uses case-sensitive matching for a RegExp', function () {
-      expect(S.testLike({like: new RegExp(/Val.+/)}, 'value')).to.be.false;
-      expect(S.testLike({like: new RegExp(/Val.+/)}, 'Value')).to.be.true;
-      expect(S.testLike({like: new RegExp(/val.+/)}, 'Value')).to.be.false;
-    });
-
-    it('throws an error if a first argument is not an object', function () {
-      const throwable = () => S.testLike(10);
-      expect(throwable).to.throw(
-        'The first argument of OperatorUtils.testLike ' +
-          'should be an Object, but 10 was given.',
-      );
-    });
-
-    it('throws an error if an operator value is a number', function () {
-      const like = 10;
-      const throwable = () => S.testLike({like}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
-    });
-
-    it('throws an error if an operator value is an object', function () {
-      const like = {};
-      const throwable = () => S.testLike({like}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should return true for exact match', function () {
+      expect(S.testLike({like: 'value'}, 'value')).to.be.true;
     });
 
-    it('throws an error if an operator value is a null', function () {
-      const like = null;
-      const throwable = () => S.testLike({like}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should use case-sensitive matching', function () {
+      expect(S.testLike({like: 'VALUE'}, 'VALUE')).to.be.true;
+      expect(S.testLike({like: 'VALUE'}, 'value')).to.be.false;
+      expect(S.testLike({like: 'value'}, 'VALUE')).to.be.false;
+    });
+
+    it('should handle "%" wildcard as zero or more characters', function () {
+      expect(S.testLike({like: 'hello wo%'}, 'hello world today')).to.be.true;
+      expect(S.testLike({like: '%ld today'}, 'hello world today')).to.be.true;
+      expect(S.testLike({like: '%world%'}, 'hello world today')).to.be.true;
+      expect(S.testLike({like: '%hello wo%'}, 'hello world today')).to.be.true;
+      expect(S.testLike({like: '%ld today%'}, 'hello world today')).to.be.true;
+      expect(S.testLike({like: '%wurld%'}, 'hello world today')).to.be.false;
+    });
+
+    it('should handle "_" wildcard as any characters', function () {
+      expect(S.testLike({like: 'h_ll_'}, 'hello')).to.be.true;
+      expect(S.testLike({like: 'hello_world'}, 'hello world')).to.be.true;
+      expect(S.testLike({like: 'hello_'}, 'hello')).to.be.false;
+      expect(S.testLike({like: '_hello'}, 'hello')).to.be.false;
+    });
+
+    it('should throw an error for non-object clause', function () {
+      const throwable = v => () => {
+        S.testLike(v);
+      };
+      const error = s =>
+        format(
+          'The first argument of OperatorUtils.testLike ' +
+            'should be an Object, but %s was given.',
+          s,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      throwable({})();
+    });
+
+    it('should throw an error for non-string operator value', function () {
+      const throwable = v => () => {
+        S.testLike({like: v});
+      };
+      const error = s =>
+        format(
+          'Condition of {like: ...} should have a String, but %s was given.',
+          s,
+        );
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable({foo: 'bar'})).to.throw(error('Object'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      expect(throwable(new RegExp())).to.throw(error('RegExp (instance)'));
+      throwable('str')();
+      throwable(null);
+      throwable(undefined);
     });
   });
 
   describe('testNlike', function () {
-    it('returns undefined if no operator given', function () {
+    it('should return undefined if no operator given', function () {
       const result = S.testNlike({}, 'value');
       expect(result).to.be.undefined;
     });
 
-    it('returns false if a given value matches a substring', function () {
-      expect(S.testNlike({nlike: 'val'}, 'value')).to.be.false;
-      expect(S.testNlike({nlike: 'lue'}, 'value')).to.be.false;
-      expect(S.testNlike({nlike: 'value'}, 'value')).to.be.false;
+    it('should return true when matching by substring', function () {
+      expect(S.testNlike({nlike: 'val'}, 'value')).to.be.true;
+      expect(S.testNlike({nlike: 'lue'}, 'value')).to.be.true;
+      expect(S.testNlike({nlike: 'alu'}, 'value')).to.be.true;
     });
 
-    it('returns true if a given value not matches a substring', function () {
+    it('should return true when the value is a substring', function () {
       expect(S.testNlike({nlike: 'value'}, 'val')).to.be.true;
       expect(S.testNlike({nlike: 'value'}, 'lue')).to.be.true;
-      expect(S.testNlike({nlike: 'value'}, 'foo')).to.be.true;
-    });
-
-    it('uses case-sensitive matching for a substring', function () {
-      expect(S.testNlike({nlike: 'Val'}, 'value')).to.be.true;
-      expect(S.testNlike({nlike: 'Val'}, 'Value')).to.be.false;
-      expect(S.testNlike({nlike: 'val'}, 'Value')).to.be.true;
-    });
-
-    it('returns false if a given value matches a string expression', function () {
-      expect(S.testNlike({nlike: 'val.+'}, 'value')).to.be.false;
-    });
-
-    it('returns true if a given value not matches a string expression', function () {
-      expect(S.testNlike({nlike: 'foo.+'}, 'value')).to.be.true;
-    });
-
-    it('uses case-sensitive matching for a string expression', function () {
-      expect(S.testNlike({nlike: 'Val.+'}, 'value')).to.be.true;
-      expect(S.testNlike({nlike: 'Val.+'}, 'Value')).to.be.false;
-      expect(S.testNlike({nlike: 'val.+'}, 'Value')).to.be.true;
-    });
-
-    it('returns false if a given value matches a RegExp', function () {
-      expect(S.testNlike({nlike: new RegExp(/val.+/)}, 'value')).to.be.false;
+      expect(S.testNlike({nlike: 'value'}, 'alu')).to.be.true;
     });
 
-    it('returns true if a given value matches a RegExp', function () {
-      expect(S.testNlike({nlike: new RegExp(/foo.+/)}, 'value')).to.be.true;
-    });
-
-    it('uses case-sensitive matching for a RegExp', function () {
-      expect(S.testNlike({nlike: new RegExp(/Val.+/)}, 'value')).to.be.true;
-      expect(S.testNlike({nlike: new RegExp(/Val.+/)}, 'Value')).to.be.false;
-      expect(S.testNlike({nlike: new RegExp(/val.+/)}, 'Value')).to.be.true;
-    });
-
-    it('throws an error if a first argument is not an object', function () {
-      const throwable = () => S.testNlike(10);
-      expect(throwable).to.throw(
-        'The first argument of OperatorUtils.testNlike ' +
-          'should be an Object, but 10 was given.',
-      );
-    });
-
-    it('throws an error if an operator value is a number', function () {
-      const nlike = 10;
-      const throwable = () => S.testNlike({nlike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
-    });
-
-    it('throws an error if an operator value is an object', function () {
-      const nlike = {};
-      const throwable = () => S.testNlike({nlike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should return true for exact match', function () {
+      expect(S.testNlike({nlike: 'value'}, 'value')).to.be.false;
     });
 
-    it('throws an error if an operator value is a null', function () {
-      const nlike = null;
-      const throwable = () => S.testNlike({nlike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should use case-sensitive matching', function () {
+      expect(S.testNlike({nlike: 'VALUE'}, 'VALUE')).to.be.false;
+      expect(S.testNlike({nlike: 'VALUE'}, 'value')).to.be.true;
+      expect(S.testNlike({nlike: 'value'}, 'VALUE')).to.be.true;
+    });
+
+    it('should handle "%" wildcard as zero or more characters', function () {
+      expect(S.testNlike({nlike: 'hello wo%'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNlike({nlike: '%ld today'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNlike({nlike: '%world%'}, 'hello world today')).to.be.false;
+      expect(S.testNlike({nlike: '%hello wo%'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNlike({nlike: '%ld today%'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNlike({nlike: '%wurld%'}, 'hello world today')).to.be.true;
+    });
+
+    it('should handle "_" wildcard as any characters', function () {
+      expect(S.testNlike({nlike: 'h_ll_'}, 'hello')).to.be.false;
+      expect(S.testNlike({nlike: 'hello_world'}, 'hello world')).to.be.false;
+      expect(S.testNlike({nlike: 'hello_'}, 'hello')).to.be.true;
+      expect(S.testNlike({nlike: '_hello'}, 'hello')).to.be.true;
+    });
+
+    it('should throw an error for non-object clause', function () {
+      const throwable = v => () => {
+        S.testNlike(v);
+      };
+      const error = s =>
+        format(
+          'The first argument of OperatorUtils.testNlike ' +
+            'should be an Object, but %s was given.',
+          s,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      throwable({})();
+    });
+
+    it('should throw an error for non-string operator value', function () {
+      const throwable = v => () => {
+        S.testNlike({nlike: v});
+      };
+      const error = s =>
+        format(
+          'Condition of {nlike: ...} should have a String, but %s was given.',
+          s,
+        );
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable({foo: 'bar'})).to.throw(error('Object'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      expect(throwable(new RegExp())).to.throw(error('RegExp (instance)'));
+      throwable('str')();
+      throwable(null);
+      throwable(undefined);
     });
   });
 
   describe('testIlike', function () {
-    it('returns undefined if no operator given', function () {
+    it('should return undefined if no operator given', function () {
       const result = S.testIlike({}, 'value');
       expect(result).to.be.undefined;
     });
 
-    it('returns true if a given value matches a substring', function () {
-      expect(S.testIlike({ilike: 'val'}, 'value')).to.be.true;
-      expect(S.testIlike({ilike: 'lue'}, 'value')).to.be.true;
-      expect(S.testIlike({ilike: 'value'}, 'value')).to.be.true;
+    it('should return false when matching by substring', function () {
+      expect(S.testIlike({ilike: 'val'}, 'value')).to.be.false;
+      expect(S.testIlike({ilike: 'lue'}, 'value')).to.be.false;
+      expect(S.testIlike({ilike: 'alu'}, 'value')).to.be.false;
     });
 
-    it('returns false if a given value not matches a substring', function () {
+    it('should return false when the value is a substring', function () {
       expect(S.testIlike({ilike: 'value'}, 'val')).to.be.false;
       expect(S.testIlike({ilike: 'value'}, 'lue')).to.be.false;
-      expect(S.testIlike({ilike: 'value'}, 'foo')).to.be.false;
-    });
-
-    it('uses case-insensitive matching for a substring', function () {
-      expect(S.testIlike({ilike: 'Val'}, 'value')).to.be.true;
-      expect(S.testIlike({ilike: 'Val'}, 'Value')).to.be.true;
-      expect(S.testIlike({ilike: 'val'}, 'Value')).to.be.true;
-    });
-
-    it('returns true if a given value matches a string expression', function () {
-      expect(S.testIlike({ilike: 'val.+'}, 'value')).to.be.true;
-    });
-
-    it('returns false if a given value not matches a string expression', function () {
-      expect(S.testIlike({ilike: 'foo.+'}, 'value')).to.be.false;
-    });
-
-    it('uses case-insensitive matching for a string expression', function () {
-      expect(S.testIlike({ilike: 'Val.+'}, 'value')).to.be.true;
-      expect(S.testIlike({ilike: 'Val.+'}, 'Value')).to.be.true;
-      expect(S.testIlike({ilike: 'val.+'}, 'Value')).to.be.true;
-    });
-
-    it('returns true if a given value matches a RegExp', function () {
-      expect(S.testIlike({ilike: new RegExp(/val.+/)}, 'value')).to.be.true;
-    });
-
-    it('returns false if a given value matches a RegExp', function () {
-      expect(S.testIlike({ilike: new RegExp(/foo.+/)}, 'value')).to.be.false;
-    });
-
-    it('uses case-insensitive matching for a RegExp', function () {
-      expect(S.testIlike({ilike: new RegExp(/Val.+/)}, 'value')).to.be.true;
-      expect(S.testIlike({ilike: new RegExp(/Val.+/)}, 'Value')).to.be.true;
-      expect(S.testIlike({ilike: new RegExp(/val.+/)}, 'Value')).to.be.true;
+      expect(S.testIlike({ilike: 'value'}, 'alu')).to.be.false;
     });
 
-    it('throws an error if a first argument is not an object', function () {
-      const throwable = () => S.testIlike(10);
-      expect(throwable).to.throw(
-        'The first argument of OperatorUtils.testIlike ' +
-          'should be an Object, but 10 was given.',
-      );
-    });
-
-    it('throws an error if an operator value is a number', function () {
-      const ilike = 10;
-      const throwable = () => S.testIlike({ilike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
-    });
-
-    it('throws an error if an operator value is an object', function () {
-      const ilike = {};
-      const throwable = () => S.testIlike({ilike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should return true for exact match', function () {
+      expect(S.testIlike({ilike: 'value'}, 'value')).to.be.true;
     });
 
-    it('throws an error if an operator value is a null', function () {
-      const ilike = null;
-      const throwable = () => S.testIlike({ilike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should use case-insensitive matching', function () {
+      expect(S.testIlike({ilike: 'VALUE'}, 'VALUE')).to.be.true;
+      expect(S.testIlike({ilike: 'VALUE'}, 'value')).to.be.true;
+      expect(S.testIlike({ilike: 'value'}, 'VALUE')).to.be.true;
+    });
+
+    it('should handle "%" wildcard as zero or more characters', function () {
+      expect(S.testIlike({ilike: 'hello wo%'}, 'hello world today')).to.be.true;
+      expect(S.testIlike({ilike: '%ld today'}, 'hello world today')).to.be.true;
+      expect(S.testIlike({ilike: '%world%'}, 'hello world today')).to.be.true;
+      expect(S.testIlike({ilike: '%hello wo%'}, 'hello world today')).to.be
+        .true;
+      expect(S.testIlike({ilike: '%ld today%'}, 'hello world today')).to.be
+        .true;
+      expect(S.testIlike({ilike: '%wurld%'}, 'hello world today')).to.be.false;
+    });
+
+    it('should handle "_" wildcard as any characters', function () {
+      expect(S.testIlike({ilike: 'h_ll_'}, 'hello')).to.be.true;
+      expect(S.testIlike({ilike: 'hello_world'}, 'hello world')).to.be.true;
+      expect(S.testIlike({ilike: 'hello_'}, 'hello')).to.be.false;
+      expect(S.testIlike({ilike: '_hello'}, 'hello')).to.be.false;
+    });
+
+    it('should throw an error for non-object clause', function () {
+      const throwable = v => () => {
+        S.testIlike(v);
+      };
+      const error = s =>
+        format(
+          'The first argument of OperatorUtils.testIlike ' +
+            'should be an Object, but %s was given.',
+          s,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      throwable({})();
+    });
+
+    it('should throw an error for non-string operator value', function () {
+      const throwable = v => () => {
+        S.testIlike({ilike: v});
+      };
+      const error = s =>
+        format(
+          'Condition of {ilike: ...} should have a String, but %s was given.',
+          s,
+        );
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable({foo: 'bar'})).to.throw(error('Object'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      expect(throwable(new RegExp())).to.throw(error('RegExp (instance)'));
+      throwable('str')();
+      throwable(null);
+      throwable(undefined);
     });
   });
 
   describe('testNilike', function () {
-    it('returns undefined if no operator given', function () {
+    it('should return undefined if no operator given', function () {
       const result = S.testNilike({}, 'value');
       expect(result).to.be.undefined;
     });
 
-    it('returns false if a given value matches a substring', function () {
-      expect(S.testNilike({nilike: 'val'}, 'value')).to.be.false;
-      expect(S.testNilike({nilike: 'lue'}, 'value')).to.be.false;
-      expect(S.testNilike({nilike: 'value'}, 'value')).to.be.false;
+    it('should return true when matching by substring', function () {
+      expect(S.testNilike({nilike: 'val'}, 'value')).to.be.true;
+      expect(S.testNilike({nilike: 'lue'}, 'value')).to.be.true;
+      expect(S.testNilike({nilike: 'alu'}, 'value')).to.be.true;
     });
 
-    it('returns true if a given value not matches a substring', function () {
+    it('should return true when the value is a substring', function () {
       expect(S.testNilike({nilike: 'value'}, 'val')).to.be.true;
       expect(S.testNilike({nilike: 'value'}, 'lue')).to.be.true;
-      expect(S.testNilike({nilike: 'value'}, 'foo')).to.be.true;
-    });
-
-    it('uses case-insensitive matching for a substring', function () {
-      expect(S.testNilike({nilike: 'Val'}, 'value')).to.be.false;
-      expect(S.testNilike({nilike: 'Val'}, 'Value')).to.be.false;
-      expect(S.testNilike({nilike: 'val'}, 'Value')).to.be.false;
-    });
-
-    it('returns false if a given value matches a string expression', function () {
-      expect(S.testNilike({nilike: 'val.+'}, 'value')).to.be.false;
-    });
-
-    it('returns true if a given value not matches a string expression', function () {
-      expect(S.testNilike({nilike: 'foo.+'}, 'value')).to.be.true;
-    });
-
-    it('uses case-insensitive matching for a string expression', function () {
-      expect(S.testNilike({nilike: 'Val.+'}, 'value')).to.be.false;
-      expect(S.testNilike({nilike: 'Val.+'}, 'Value')).to.be.false;
-      expect(S.testNilike({nilike: 'val.+'}, 'Value')).to.be.false;
-    });
-
-    it('returns false if a given value matches a RegExp', function () {
-      expect(S.testNilike({nilike: new RegExp(/val.+/)}, 'value')).to.be.false;
-    });
-
-    it('returns true if a given value matches a RegExp', function () {
-      expect(S.testNilike({nilike: new RegExp(/foo.+/)}, 'value')).to.be.true;
-    });
-
-    it('uses case-insensitive matching for a RegExp', function () {
-      expect(S.testNilike({nilike: new RegExp(/Val.+/)}, 'value')).to.be.false;
-      expect(S.testNilike({nilike: new RegExp(/Val.+/)}, 'Value')).to.be.false;
-      expect(S.testNilike({nilike: new RegExp(/val.+/)}, 'Value')).to.be.false;
-    });
-
-    it('throws an error if a first argument is not an object', function () {
-      const throwable = () => S.testNilike(10);
-      expect(throwable).to.throw(
-        'The first argument of OperatorUtils.testNilike ' +
-          'should be an Object, but 10 was given.',
-      );
+      expect(S.testNilike({nilike: 'value'}, 'alu')).to.be.true;
     });
 
-    it('throws an error if an operator value is a number', function () {
-      const nilike = 10;
-      const throwable = () => S.testNilike({nilike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
-    });
-
-    it('throws an error if an operator value is an object', function () {
-      const nilike = {};
-      const throwable = () => S.testNilike({nilike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should return false for exact match', function () {
+      expect(S.testNilike({nilike: 'value'}, 'value')).to.be.false;
     });
 
-    it('throws an error if an operator value is a null', function () {
-      const nilike = null;
-      const throwable = () => S.testNilike({nilike}, 10);
-      expect(throwable).to.throw(InvalidOperatorValueError);
+    it('should use case-insensitive matching', function () {
+      expect(S.testNilike({nilike: 'VALUE'}, 'VALUE')).to.be.false;
+      expect(S.testNilike({nilike: 'VALUE'}, 'value')).to.be.false;
+      expect(S.testNilike({nilike: 'value'}, 'VALUE')).to.be.false;
+    });
+
+    it('should handle "%" wildcard as zero or more characters', function () {
+      expect(S.testNilike({nilike: 'hello wo%'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNilike({nilike: '%ld today'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNilike({nilike: '%world%'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNilike({nilike: '%hello wo%'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNilike({nilike: '%ld today%'}, 'hello world today')).to.be
+        .false;
+      expect(S.testNilike({nilike: '%wurld%'}, 'hello world today')).to.be.true;
+    });
+
+    it('should handle "_" wildcard as any characters', function () {
+      expect(S.testNilike({nilike: 'h_ll_'}, 'hello')).to.be.false;
+      expect(S.testNilike({nilike: 'hello_world'}, 'hello world')).to.be.false;
+      expect(S.testNilike({nilike: 'hello_'}, 'hello')).to.be.true;
+      expect(S.testNilike({nilike: '_hello'}, 'hello')).to.be.true;
+    });
+
+    it('should throw an error for non-object clause', function () {
+      const throwable = v => () => {
+        S.testNilike(v);
+      };
+      const error = s =>
+        format(
+          'The first argument of OperatorUtils.testNilike ' +
+            'should be an Object, but %s was given.',
+          s,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      throwable({})();
+    });
+
+    it('should throw an error for non-string operator value', function () {
+      const throwable = v => () => {
+        S.testNilike({nilike: v});
+      };
+      const error = s =>
+        format(
+          'Condition of {nilike: ...} should have a String, but %s was given.',
+          s,
+        );
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable({foo: 'bar'})).to.throw(error('Object'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable([1, 2, 3])).to.throw(error('Array'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      expect(throwable(new RegExp())).to.throw(error('RegExp (instance)'));
+      throwable('str')();
+      throwable(null);
+      throwable(undefined);
     });
   });