| 1 | var assert = require('assert');
|
| 2 | var Colr = require('./index');
|
| 3 |
|
| 4 | describe('Colr', function () {
|
| 5 |
|
| 6 | var colr;
|
| 7 |
|
| 8 | var equal = function (arr) {
|
| 9 | return colr.r === arr[0] && colr.g === arr[1] && colr.b === arr[2];
|
| 10 | };
|
| 11 |
|
| 12 | it('should parse hex strings', function () {
|
| 13 | var tests = {
|
| 14 | '#012345': [1, 35, 69],
|
| 15 | '#abcdef': [171, 205, 239],
|
| 16 | 'abcdef': [171, 205, 239],
|
| 17 | '22ccDD': [34, 204, 221],
|
| 18 | '2CD': [34, 204, 221],
|
| 19 | '#2CD': [34, 204, 221],
|
| 20 | '2CDaa': [34, 204, 221],
|
| 21 | };
|
| 22 |
|
| 23 | for (var key in tests) {
|
| 24 | colr = new Colr();
|
| 25 | colr.fromHex(key);
|
| 26 | assert(equal(tests[key]));
|
| 27 | }
|
| 28 | });
|
| 29 |
|
| 30 | it('should throw an error on an invalid hex', function () {
|
| 31 | var tests = [ '#01', '01', 'ab', 'abcdex' ];
|
| 32 |
|
| 33 | tests.forEach(function (value) {
|
| 34 | assert.throws(function () {
|
| 35 | colr = new Colr();
|
| 36 | colr.fromHex(value);
|
| 37 | });
|
| 38 | });
|
| 39 | });
|
| 40 |
|
| 41 | it('should import r, g, b as arguments, arrays and objects', function () {
|
| 42 | var tests = [
|
| 43 | [[10, 20, 30], [10, 20, 30]],
|
| 44 | [[0, 128, 255], [0, 128, 255]],
|
| 45 | [[-1, 128, 256], [0, 128, 255]],
|
| 46 | [[-0.5, 128, 255.5], [0, 128, 255]],
|
| 47 | ];
|
| 48 |
|
| 49 | tests.forEach(function (test) {
|
| 50 | var input = test[0];
|
| 51 | var expected = test[1];
|
| 52 |
|
| 53 | colr = new Colr();
|
| 54 | colr.fromRgb.apply(colr, input);
|
| 55 | assert(equal(expected));
|
| 56 |
|
| 57 | colr = new Colr();
|
| 58 | colr.fromRgbArray(input);
|
| 59 | assert(equal(expected));
|
| 60 |
|
| 61 | colr = new Colr();
|
| 62 | colr.fromRgbObject({ r: input[0], g: input[1], b: input[2] });
|
| 63 | assert(equal(expected));
|
| 64 | });
|
| 65 | });
|
| 66 |
|
| 67 | it('should throw an error on invalid rgb arguments', function () {
|
| 68 | var tests = [
|
| 69 | [],
|
| 70 | [1, 2],
|
| 71 | ['1', '2', '3'],
|
| 72 | [[], {}, true]
|
| 73 | ];
|
| 74 |
|
| 75 | tests.forEach(function (test) {
|
| 76 | assert.throws(function () {
|
| 77 | colr = new Colr();
|
| 78 | colr.fromRgb.apply(colr, test);
|
| 79 | });
|
| 80 | });
|
| 81 | });
|
| 82 |
|
| 83 | it('should output as a hex string', function () {
|
| 84 | var tests = {
|
| 85 | '#bada55': '#BADA55',
|
| 86 | 'abc': '#AABBCC',
|
| 87 | '#010203': '#010203',
|
| 88 | '000': '#000000',
|
| 89 | 'fff': '#FFFFFF',
|
| 90 | };
|
| 91 |
|
| 92 | for (var key in tests) {
|
| 93 | colr = new Colr();
|
| 94 | colr.fromHex(key);
|
| 95 | assert.equal(colr.toHex(), tests[key]);
|
| 96 | }
|
| 97 | });
|
| 98 |
|
| 99 | it('should output as an rgb array', function () {
|
| 100 | var tests = [
|
| 101 | [[-1, 128, 256], [0, 128, 255]],
|
| 102 | [[20, 30, 40], [20, 30, 40]],
|
| 103 | ];
|
| 104 |
|
| 105 | tests.forEach(function (test) {
|
| 106 | var input = test[0];
|
| 107 | var expected = test[1];
|
| 108 |
|
| 109 | colr = new Colr();
|
| 110 | colr.fromRgbArray(input);
|
| 111 | assert(equal(expected));
|
| 112 | });
|
| 113 | });
|
| 114 |
|
| 115 | it('should output as an rgb object', function () {
|
| 116 | var tests = [
|
| 117 | [[-1, 128, 256], {r: 0, g: 128, b: 255}],
|
| 118 | [[20, 30, 40], {r: 20, g: 30, b: 40}],
|
| 119 | ];
|
| 120 |
|
| 121 | tests.forEach(function (test) {
|
| 122 | var input = test[0];
|
| 123 | var expected = test[1];
|
| 124 |
|
| 125 | colr = new Colr();
|
| 126 | colr.fromRgbArray(input);
|
| 127 | assert.deepEqual(colr.toRgbObject(), expected);
|
| 128 | });
|
| 129 | });
|
| 130 |
|
| 131 | });
|