more tests

Author: GlenTiki

test/tests/core/Vec/constructorTests.js

@@ -17,7 +17,6 @@ module.exports = function ({ cv, utils }) {
     it('should throw for trying to insantiate invalid vec5', () => {
       assertError(() => new cv.Vec(5, 10, 20, 30, 40), 'Vec::New - expected arguments (u, v), (w), x, y, (z)');
     });
-  });
 
     describe('Vec2', () => {
       it('should have int positions', () => {

test/tests/core/Vec/operatorTests.js

@@ -289,5 +289,93 @@ module.exports = function ({ cv, utils }) {
         });
       });
     });
+
+    describe('Vec6', () => {
+      const vec0 = new cv.Vec(50, 100, 200, 300, 400, 500);
+      const vec1 = new cv.Vec(10, 25, 50, 75, 100, 125);
+      const vec2 = new cv.Vec(2, 5, 4, 3, 2, 1);
+      const operatorRequiresArg = OperatorRequiresArg(vec0);
+      describe('add', () => {
+        operatorRequiresArg('add');
+
+        it('add vectors', () => {
+          assertPropsWithValue(vec0.add(vec1))({ u: 60, v: 125, w: 250, x: 375, y: 500, z: 625 });
+        });
+      });
+
+      describe('sub', () => {
+        operatorRequiresArg('sub');
+
+        it('subtract vectors', () => {
+          assertPropsWithValue(vec0.sub(vec1))({ u: 40, v: 75, w: 150, x: 225, y: 300, z: 375 });
+        });
+      });
+
+      describe('mul', () => {
+        operatorRequiresArg('mul', true);
+
+        it('multiply vector by scalar', () => {
+          assertPropsWithValue(vec0.mul(2))({ u: 100, v: 200, w: 400, x: 600, y: 800, z: 1000 });
+        });
+      });
+
+      describe('div', () => {
+        operatorRequiresArg('div', true);
+
+        it('divide vector by scalar', () => {
+          assertPropsWithValue(vec0.div(2))({ u: 25, v: 50, w: 100, x: 150, y: 200, z: 250 });
+        });
+      });
+
+      describe('hMul', () => {
+        operatorRequiresArg('hMul');
+
+        it('elementwise multiply vectors', () => {
+          assertPropsWithValue(vec0.hMul(vec2))({ u: 100, v: 500, w: 800, x: 900, y: 800, z: 500 });
+        });
+      });
+
+      describe('hDiv', () => {
+        operatorRequiresArg('hDiv');
+
+        it('elementwise divide vectors', () => {
+          assertPropsWithValue(vec0.hDiv(vec2))({ u: 25, v: 20, w: 50, x: 100, y: 200, z: 500 });
+        });
+      });
+
+      describe('dot', () => {
+        operatorRequiresArg('dot');
+
+        it('compute dot product of vectors', () => {
+          expect(vec0.dot(vec2)).to.equal(3600);
+        });
+      });
+
+      describe('absdiff', () => {
+        operatorRequiresArg('absdiff');
+
+        it('apply absdiff to matrices', () => {
+          assertPropsWithValue(new cv.Vec(0, 100, 50, 25, 150, 10).absdiff(new cv.Vec(50, 25, 75, 25, 50, 20)))({ u: 50, v: 75, w: 25, x: 0, y: 50, z: 10 });
+        });
+      });
+
+      describe('exp', () => {
+        it('apply exp to vector', () => {
+          assertPropsWithValue(new cv.Vec(Math.log(1), Math.log(4), 0, Math.log(0), Math.log(3), Math.log(2)).exp())({ u: 1, v: 4, w: 1, x: 0, y: 3, z: 2 });
+        });
+      });
+
+      describe('sqrt', () => {
+        it('apply sqrt to vector', () => {
+          assertPropsWithValue(new cv.Vec(0, 4, 16, 64, 255, 510).sqrt())({ u: 0, v: 2, w: 4, x: 8, y: 16, z: 32 });
+        });
+      });
+
+      describe('norm', () => {
+        it('should return magnitude', () => {
+          expect(new cv.Vec(Math.sqrt(4), Math.sqrt(4), Math.sqrt(4), Math.sqrt(4), Math.sqrt(4), Math.sqrt(4)).norm()).to.equal(4);
+        });
+      });
+    });
   });
 };