Merge pull request #7 from it-shark-pro/issue-incorrect-test-error-message

Fixed issue #5 (Incorrect test error message when test failed.)

Author: EduardTrutsyk

test/01-strings-tests.js

@@ -21,107 +21,109 @@ it.optional = require('../extensions/it-optional');
 
 describe('01-strings-tasks', () => {
   it.optional('concatenateStrings should return concatenation of two strings', () => {
-    assert.equal('aabb', concatenateStrings('aa', 'bb'));
-    assert.equal('aa', concatenateStrings('aa', ''));
-    assert.equal('bb', concatenateStrings('', 'bb'));
+    assert.equal(concatenateStrings('aa', 'bb'), 'aabb');
+    assert.equal(concatenateStrings('aa', ''), 'aa');
+    assert.equal(concatenateStrings('', 'bb'), 'bb');
   });
 
   it.optional('getStringLength should return the length of string', () => {
-    assert.equal(5, getStringLength('aaaaa'), "'aaaaa' length should be 5");
-    assert.equal(0, getStringLength(''), "'' length should be 0");
+    assert.equal(getStringLength('aaaaa'), 5, "'aaaaa' length should be 5");
+    assert.equal(getStringLength(''), 0, "'' length should be 0");
   });
 
   it.optional('getStringFromTemplate should create a string from template using given parameters', () => {
-    assert.equal('Hello, John Doe!', getStringFromTemplate('John', 'Doe'));
-    assert.equal('Hello, Chuck Norris!', getStringFromTemplate('Chuck', 'Norris'));
+    assert.equal(getStringFromTemplate('John', 'Doe'), 'Hello, John Doe!');
+    assert.equal(getStringFromTemplate('Chuck', 'Norris'), 'Hello, Chuck Norris!');
   });
 
   it.optional('getFirstChar should return the first char from given string', () => {
-    assert.equal('J', getFirstChar('John Doe'));
-    assert.equal('c', getFirstChar('cat'));
+    assert.equal(getFirstChar('John Doe'), 'J');
+    assert.equal(getFirstChar('cat'), 'c');
   });
 
   it.optional('extractNameFromTemplate should parse the name from given string', () => {
-    assert.equal('John Doe', extractNameFromTemplate('Hello, John Doe!'));
-    assert.equal('Chuck Norris', extractNameFromTemplate('Hello, Chuck Norris!'));
+    assert.equal(extractNameFromTemplate('Hello, John Doe!'), 'John Doe');
+    assert.equal(extractNameFromTemplate('Hello, Chuck Norris!'), 'Chuck Norris');
   });
 
   it.optional('removeLeadingAndTrailingWhitespaces should remove leading and trailing whitespaces from the string', () => {
-    assert.equal('Abracadabra', removeLeadingAndTrailingWhitespaces('  Abracadabra'));
-    assert.equal('cat', removeLeadingAndTrailingWhitespaces('cat'));
-    assert.equal('Hello, World!', removeLeadingAndTrailingWhitespaces('\tHello, World! '));
+    assert.equal(removeLeadingAndTrailingWhitespaces('  Abracadabra'), 'Abracadabra');
+    assert.equal(removeLeadingAndTrailingWhitespaces('cat'), 'cat');
+    assert.equal(removeLeadingAndTrailingWhitespaces('\tHello, World! '), 'Hello, World!');
   });
 
   it.optional('repeatString should repeat string specified number of times', () => {
-    assert.equal('AAAAA', repeatString('A', 5));
-    assert.equal('catcatcat', repeatString('cat', 3));
+    assert.equal(repeatString('A', 5), 'AAAAA');
+    assert.equal(repeatString('cat', 3), 'catcatcat');
   });
 
   it.optional('removeFirstOccurrences should remove all specified values from a string', () => {
-    assert.equal('To be or to be', removeFirstOccurrences('To be or not to be', ' not'));
-    assert.equal('I like legs', removeFirstOccurrences('I like legends', 'end'));
-    assert.equal('ABAB', removeFirstOccurrences('ABABAB', 'BA'));
+    assert.equal(removeFirstOccurrences('To be or not to be', ' not'), 'To be or to be');
+    assert.equal(removeFirstOccurrences('I like legends', 'end'), 'I like legs');
+    assert.equal(removeFirstOccurrences('ABABAB', 'BA'), 'ABAB');
   });
 
   it.optional('unbracketTag should remove first and last angle brackets from tag string', () => {
-    assert.equal('div', unbracketTag('<div>'));
-    assert.equal('span', unbracketTag('<span>'));
-    assert.equal('a', unbracketTag('<a>'));
+    assert.equal(unbracketTag('<div>'), 'div');
+    assert.equal(unbracketTag('<span>'), 'span');
+    assert.equal(unbracketTag('<a>'), 'a');
   });
 
   it.optional('convertToUpperCase should convert all chars from specified string into upper case', () => {
-    assert.equal('THUNDERSTRUCK', convertToUpperCase('Thunderstruck'));
-    assert.equal('ABCDEFGHIJKLMNOPQRSTUVWXYZ', convertToUpperCase('abcdefghijklmnopqrstuvwxyz'));
+    assert.equal(convertToUpperCase('Thunderstruck'), 'THUNDERSTRUCK');
+    assert.equal(convertToUpperCase('abcdefghijklmnopqrstuvwxyz'), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
   });
 
   it.optional('extractEmails should extract emails from string list delimeted by semicolons', () => {
     assert.deepEqual(
-      ['angus.young@gmail.com', 'brian.johnson@hotmail.com', 'bon.scott@yahoo.com'],
-      extractEmails('angus.young@gmail.com;brian.johnson@hotmail.com;bon.scott@yahoo.com')
+      extractEmails('angus.young@gmail.com;brian.johnson@hotmail.com;bon.scott@yahoo.com'),
+      ['angus.young@gmail.com', 'brian.johnson@hotmail.com', 'bon.scott@yahoo.com']
     );
     assert.deepEqual(
-      ['info@gmail.com'],
-      extractEmails('info@gmail.com')
+      extractEmails('info@gmail.com'),
+      ['info@gmail.com']
     );
   });
 
   it.optional('getRectangleString should return the string reprentation of rectangle with specified size', () => {
     assert.equal(
+      getRectangleString(6, 4),
       '┌────┐\n' +
       '│    │\n' +
       '│    │\n' +
-      '└────┘\n',
-      getRectangleString(6, 4)
+      '└────┘\n'
     );
     assert.deepEqual(
+      getRectangleString(2, 2),
       '┌┐\n' +
-      '└┘\n',
-      getRectangleString(2, 2)
+      '└┘\n'
     );
     assert.deepEqual(
+      getRectangleString(12, 3),
       '┌──────────┐\n' +
       '│          │\n' +
-      '└──────────┘\n',
-      getRectangleString(12, 3)
+      '└──────────┘\n'
     );
   });
 
   it.optional('encodeToRot13 should encode-decode string using ROT13 algorithm', () => {
-    assert.equal('uryyb', encodeToRot13('hello'));
-    assert.equal('Jul qvq gur puvpxra pebff gur ebnq?', encodeToRot13('Why did the chicken cross the road?'));
-    assert.equal('To get to the other side!', encodeToRot13('Gb trg gb gur bgure fvqr!'));
+    assert.equal(encodeToRot13('hello'), 'uryyb');
     assert.equal(
-      'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm',
-      encodeToRot13('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')
+      encodeToRot13('Why did the chicken cross the road?'),
+      'Jul qvq gur puvpxra pebff gur ebnq?');
+    assert.equal(encodeToRot13('Gb trg gb gur bgure fvqr!'), 'To get to the other side!');
+    assert.equal(
+      encodeToRot13('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'),
+      'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'
     );
   });
 
   it.optional('isString should return true if argument ia a string', () => {
-    assert.equal(false, isString(), 'undefined');
-    assert.equal(false, isString(null), 'null');
-    assert.equal(false, isString([]), '[]');
-    assert.equal(true, isString('test'), 'test');
-    assert.equal(true, isString(new String('test')), "new String('test')");
+    assert.equal(isString(), false, 'undefined');
+    assert.equal(isString(null), false, 'null');
+    assert.equal(isString([]), false,  '[]');
+    assert.equal(isString('test'), true, 'test');
+    assert.equal(isString(new String('test')), true,  "new String('test')");
   });
 
   it.optional('getCardId should return the index of card in the initial deck', () => {
@@ -132,8 +134,8 @@ describe('01-strings-tasks', () => {
       'A♠', '2♠', '3♠', '4♠', '5♠', '6♠', '7♠', '8♠', '9♠', '10♠', 'J♠', 'Q♠', 'K♠'
     ].forEach((val, index) => {
       assert.equal(
-        index,
         getCardId(val),
+        index,
         `Invalid id for card '${val}':`
       );
     });

test/02-numbers-tests.js

@@ -18,97 +18,100 @@ it.optional = require('../extensions/it-optional');
 
 describe('02-numbers-tasks', () => {
   it.optional('getRectangleArea should return a square of rectangle', () => {
-    assert.equal(50, getRectangleArea(5, 10));
-    assert.equal(25, getRectangleArea(5, 5));
+    assert.equal(getRectangleArea(5, 10), 50);
+    assert.equal(getRectangleArea(5, 5), 25);
   });
 
   it.optional('getCicleCircumference should return a circumference of cicle', () => {
-    assert.equal(31.41592653589793, getCicleCircumference(5));
-    assert.equal(19.729201864543903, getCicleCircumference(3.14));
-    assert.equal(0, getCicleCircumference(0));
+    assert.equal(getCicleCircumference(5), 31.41592653589793);
+    assert.equal(getCicleCircumference(3.14), 19.729201864543903);
+    assert.equal(getCicleCircumference(0), 0);
   });
 
   it.optional('getAverage should return an average of two numbers', () => {
-    assert.equal(5, getAverage(5, 5));
-    assert.equal(5, getAverage(10, 0));
-    assert.equal(0, getAverage(-3, 3));
-    assert.equal(Number.MAX_VALUE - 1, getAverage(Number.MAX_VALUE - 2, Number.MAX_VALUE));
-    assert.equal(Number.MAX_VALUE / 4, getAverage(Number.MAX_VALUE, -Number.MAX_VALUE / 2));
+    assert.equal(getAverage(5, 5), 5);
+    assert.equal(getAverage(10, 0), 5);
+    assert.equal(getAverage(-3, 3), 0);
+    assert.equal(getAverage(Number.MAX_VALUE - 2, Number.MAX_VALUE), Number.MAX_VALUE - 1);
+    assert.equal(getAverage(Number.MAX_VALUE, -Number.MAX_VALUE / 2), Number.MAX_VALUE / 4);
   });
 
   it.optional('getDistanceBetweenPoints should return a distance between points', () => {
-    assert.equal(1, getDistanceBetweenPoints(0, 0, 0, 1));
-    assert.equal(1, getDistanceBetweenPoints(0, 0, 1, 0));
-    assert.equal(18.027756377319946, getDistanceBetweenPoints(-5, 0, 10, -10));
+    assert.equal(getDistanceBetweenPoints(0, 0, 0, 1), 1);
+    assert.equal(getDistanceBetweenPoints(0, 0, 1, 0), 1);
+    assert.equal(getDistanceBetweenPoints(-5, 0, 10, -10), 18.027756377319946);
   });
 
   it.optional('getLinearEquationRoot should return a root of linear equation', () => {
-    assert.equal(2, getLinearEquationRoot(5, -10));
-    assert.equal(-8, getLinearEquationRoot(1, 8));
-    assert.equal(0, getLinearEquationRoot(5, 0));
+    assert.equal(getLinearEquationRoot(5, -10), 2);
+    assert.equal(getLinearEquationRoot(1, 8), -8);
+    assert.equal(getLinearEquationRoot(5, 0), 0);
   });
 
   it.optional('getAngleBetweenVectors should return a angle (in radians) between two linear vectors', () => {
-    assert.equal(Math.PI / 2, getAngleBetweenVectors(1, 0, 0, 1));
-    assert.equal(Math.PI, getAngleBetweenVectors(0, 1, 0, -1));
-    assert.equal(Math.PI / 2, getAngleBetweenVectors(0, -1, 1, 0));
-    assert.equal(0, getAngleBetweenVectors(0, 1, 0, 1));
+    assert.equal(getAngleBetweenVectors(1, 0, 0, 1), Math.PI / 2);
+    assert.equal(getAngleBetweenVectors(0, 1, 0, -1), Math.PI);
+    assert.equal(getAngleBetweenVectors(0, -1, 1, 0), Math.PI / 2);
+    assert.equal(getAngleBetweenVectors(0, 1, 0, 1), 0);
   });
 
   it.optional('getLastDigit should return a last digit of the number', () => {
-    assert.equal(0, getLastDigit(100));
-    assert.equal(7, getLastDigit(37));
-    assert.equal(5, getLastDigit(5));
-    assert.equal(0, getLastDigit(0));
+    assert.equal(getLastDigit(100), 0);
+    assert.equal(getLastDigit(37), 7);
+    assert.equal(getLastDigit(5), 5);
+    assert.equal(getLastDigit(0), 0);
   });
 
   it.optional('parseNumberFromString should return a number from the given string representation', () => {
-    assert.equal(100, parseNumberFromString('100'));
-    assert.equal(37, parseNumberFromString('37'));
-    assert.equal(-525.5, parseNumberFromString('-525.5'));
+    assert.equal(parseNumberFromString('100'), 100);
+    assert.equal(parseNumberFromString('37'), 37);
+    assert.equal(parseNumberFromString('-525.5'), -525.5);
   });
 
   it.optional('getParallelipidedDiagonal should return a diagonal length of the rectagular parallepiped', () => {
-    assert.equal(Math.sqrt(3), getParallelipidedDiagonal(1, 1, 1));
-    assert.equal(Math.sqrt(27), getParallelipidedDiagonal(3, 3, 3));
-    // assert.equal(Math.sqrt(14), getParallelipidedDiagonal(1,2,3));
+    assert.equal(getParallelipidedDiagonal(1, 1, 1), Math.sqrt(3));
+    assert.equal(getParallelipidedDiagonal(3, 3, 3), Math.sqrt(27));
+    assert.equal(
+      Math.round(getParallelipidedDiagonal(1, 2, 3), 15),
+      Math.round(Math.sqrt(14), 15)
+    );
   });
 
   it.optional('roundToPowerOfTen should return an number rounded to specified power of 10', () => {
-    assert.equal(1234, roundToPowerOfTen(1234, 0));
-    assert.equal(1230, roundToPowerOfTen(1234, 1));
-    assert.equal(1200, roundToPowerOfTen(1234, 2));
-    assert.equal(1000, roundToPowerOfTen(1234, 3));
+    assert.equal(roundToPowerOfTen(1234, 0), 1234);
+    assert.equal(roundToPowerOfTen(1234, 1), 1230);
+    assert.equal(roundToPowerOfTen(1234, 2), 1200);
+    assert.equal(roundToPowerOfTen(1234, 3), 1000);
 
-    assert.equal(9678, roundToPowerOfTen(9678, 0));
-    assert.equal(9680, roundToPowerOfTen(9678, 1));
-    assert.equal(9700, roundToPowerOfTen(9678, 2));
-    assert.equal(10000, roundToPowerOfTen(9678, 3));
+    assert.equal(roundToPowerOfTen(9678, 0), 9678);
+    assert.equal(roundToPowerOfTen(9678, 1), 9680);
+    assert.equal(roundToPowerOfTen(9678, 2), 9700);
+    assert.equal(roundToPowerOfTen(9678, 3), 10000);
   });
 
   it.optional('isPrime should return true if specified number is prime', () => {
-    assert.equal(true, isPrime(2), '2');
-    assert.equal(true, isPrime(3), '3');
-    assert.equal(false, isPrime(4), '4');
-    assert.equal(true, isPrime(5), '5');
-    assert.equal(false, isPrime(6), '6');
-    assert.equal(true, isPrime(7), '7');
-    assert.equal(false, isPrime(8), '8');
-    assert.equal(false, isPrime(9), '9');
-    assert.equal(false, isPrime(10), '10');
-    assert.equal(true, isPrime(11), '11');
-    assert.equal(false, isPrime(12), '12');
-    assert.equal(true, isPrime(13), '13');
-    assert.equal(true, isPrime(113), '113');
-    assert.equal(false, isPrime(119), '119');
+    assert.equal(isPrime(2), true, '2');
+    assert.equal(isPrime(3), true, '3');
+    assert.equal(isPrime(4), false, '4');
+    assert.equal(isPrime(5), true, '5');
+    assert.equal(isPrime(6), false, '6');
+    assert.equal(isPrime(7), true, '7');
+    assert.equal(isPrime(8), false, '8');
+    assert.equal(isPrime(9), false, '9');
+    assert.equal(isPrime(10), false, '10');
+    assert.equal(isPrime(11), true, '11');
+    assert.equal(isPrime(12), false, '12');
+    assert.equal(isPrime(13), true, '13');
+    assert.equal(isPrime(113), true, '113');
+    assert.equal(isPrime(119), false, '119');
   });
 
   it.optional('toNumber should convert any value to number or return the default', () => {
-    assert.equal(0, toNumber(null, 0));
-    assert.equal(0, toNumber('test', 0));
-    assert.equal(1, toNumber('1', 0));
-    assert.equal(42, toNumber(42, 0));
-    assert.equal(42, toNumber(new Number(42), 0));
-    assert.equal(-1, toNumber(undefined, -1));
+    assert.equal(toNumber(null, 0), 0);
+    assert.equal(toNumber('test', 0), 0);
+    assert.equal(toNumber('1', 0), 1);
+    assert.equal(toNumber(42, 0), 42);
+    assert.equal(toNumber(new Number(42), 0), 42);
+    assert.equal(toNumber(undefined, -1), -1);
   });
 });

test/03-date-tests.js

@@ -12,31 +12,31 @@ it.optional = require('../extensions/it-optional');
 describe('03-date-tasks', () => {
   it.optional('parseDataFromRfc2822 should parse rfc2822 string into a date value', () => {
     assert.equal(
-      new Date(1995, 11, 17, 3, 24, 0).valueOf(),
-      parseDataFromRfc2822('December 17, 1995 03:24:00').valueOf()
+      parseDataFromRfc2822('December 17, 1995 03:24:00').valueOf(),
+      new Date(1995, 11, 17, 3, 24, 0).valueOf()
     );
 
     assert.equal(
-      1453816082000,
-      parseDataFromRfc2822('Tue, 26 Jan 2016 13:48:02 GMT').valueOf()
+      parseDataFromRfc2822('Tue, 26 Jan 2016 13:48:02 GMT').valueOf(),
+      1453816082000
     );
 
     assert.equal(
-      895370400000,
-      parseDataFromRfc2822('Sun, 17 May 1998 03:00:00 GMT+0100').valueOf()
+      parseDataFromRfc2822('Sun, 17 May 1998 03:00:00 GMT+0100').valueOf(),
+      895370400000
     );
   });
 
 
   it.optional('parseDataFromIso8601 should parse ISO 8601 string into a date value', () => {
     assert.equal(
-      1453219657000,
-      parseDataFromIso8601('2016-01-19T16:07:37+00:00').valueOf()
+      parseDataFromIso8601('2016-01-19T16:07:37+00:00').valueOf(),
+      1453219657000
     );
 
     assert.equal(
-      1453190857000,
-      parseDataFromIso8601('2016-01-19T08:07:37Z').valueOf()
+      parseDataFromIso8601('2016-01-19T08:07:37Z').valueOf(),
+      1453190857000
     );
   });
 
@@ -89,8 +89,8 @@ describe('03-date-tasks', () => {
       }
     ].forEach(data => {
       assert.equal(
-        data.expected,
-        timeSpanToString(data.startDate, data.endDate)
+        timeSpanToString(data.startDate, data.endDate),
+        data.expected
       );
     });
   });