Skip to content
This repository was archived by the owner on Feb 9, 2018. It is now read-only.

Commit c1f7ee0

Browse files
samthorsamthor
authored
Merge pull request #153 from samthor/test-cleanup
Test cleanup
2 parents 7e45ed1 + e3c4ea9 commit c1f7ee0

14 files changed

+116
-105
lines changed

‎test/js/computed-style-property-map.js

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -22,11 +22,12 @@ suite('Computed StylePropertyMap', function() {
2222
document.body.removeChild(this.element);
2323
});
2424

25+
var lemonNotSupportedErr = /^lemon is not a supported CSS property$/;
26+
2527
test('get method throws a TypeError if the property is not supported', function() {
2628
var computedStyleMap = getComputedStyleMap(this.element);
2729

28-
assert.throw(function() {computedStyleMap.get('lemon')}, TypeError,
29-
'lemon is not a supported CSS property');
30+
assert.throws(function() {computedStyleMap.get('lemon')}, TypeError, lemonNotSupportedErr);
3031
});
3132

3233

@@ -87,8 +88,7 @@ suite('Computed StylePropertyMap', function() {
8788
test('getAll method throws a TypeError if the property is not supported', function() {
8889
var computedStyleMap = getComputedStyleMap(this.element);
8990

90-
assert.throw(function() {computedStyleMap.getAll('lemon')}, TypeError,
91-
'lemon is not a supported CSS property');
91+
assert.throws(function() {computedStyleMap.getAll('lemon')}, TypeError, lemonNotSupportedErr);
9292
});
9393

9494
test('getting an unsupported but valid property returns a base CSSStyleValue', function() {

‎test/js/css-angle-value.js

Lines changed: 27 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -31,60 +31,63 @@ test('CSSAngleValue constructor works for valid arguments', function() {
3131
];
3232
for (var i = 0; i < values.length; i++) {
3333
assert.instanceOf(values[i], CSSAngleValue);
34-
assert.approximately(values[i].degrees, expectations[i].degrees, EPSILON);
34+
assert.closeTo(values[i].degrees, expectations[i].degrees, EPSILON);
3535
assert.strictEqual(values[i]._value, expectations[i].value);
3636
assert.strictEqual(values[i]._unit, expectations[i].unit);
3737
assert.strictEqual(values[i].cssText, expectations[i].cssText);
3838
}
3939
});
4040

4141
test('Wrong number of arguments throws', function() {
42-
assert.throw(function() { new CSSAngleValue(); }, TypeError, 'Must specify an angle and a unit');
43-
assert.throw(function() { new CSSAngleValue(5); }, TypeError, 'Must specify an angle and a unit');
44-
assert.throw(function() { new CSSAngleValue(5, 5, 5); }, TypeError, 'Must specify an angle and a unit');
42+
var specifyErr = /^Must specify an angle and a unit$/;
43+
assert.throws(function() { new CSSAngleValue(); }, TypeError, specifyErr);
44+
assert.throws(function() { new CSSAngleValue(5); }, TypeError, specifyErr);
45+
assert.throws(function() { new CSSAngleValue(5, 5, 5); }, TypeError, specifyErr);
4546
});
4647

4748
test('Value not a number throws', function() {
48-
assert.throw(function() { new CSSAngleValue('foo', 'deg'); }, TypeError, 'Value must be a number');
49-
assert.throw(function() { new CSSAngleValue({}, 'deg'); }, TypeError, 'Value must be a number');
50-
assert.throw(function() { new CSSAngleValue(undefined, 'deg'); }, TypeError, 'Value must be a number');
49+
var numberErr = /^Value must be a number$/;
50+
assert.throws(function() { new CSSAngleValue('foo', 'deg'); }, TypeError, numberErr);
51+
assert.throws(function() { new CSSAngleValue({}, 'deg'); }, TypeError, numberErr);
52+
assert.throws(function() { new CSSAngleValue(undefined, 'deg'); }, TypeError, numberErr);
5153
});
5254

5355
test('Invalid unit throws', function() {
54-
assert.throw(function() { new CSSAngleValue(5, 'asdfa'); }, TypeError, 'Invalid unit type');
55-
assert.throw(function() { new CSSAngleValue(5, {}); }, TypeError, 'Invalid unit type');
56-
assert.throw(function() { new CSSAngleValue(5, 5); }, TypeError, 'Invalid unit type');
56+
var unitErr = /^Invalid unit type$/;
57+
assert.throws(function() { new CSSAngleValue(5, 'asdfa'); }, TypeError, unitErr);
58+
assert.throws(function() { new CSSAngleValue(5, {}); }, TypeError, unitErr);
59+
assert.throws(function() { new CSSAngleValue(5, 5); }, TypeError, unitErr);
5760
});
5861

5962
test('Conversions when specified as degrees', function() {
6063
var angleValue = new CSSAngleValue(40, 'deg');
6164
assert.strictEqual(angleValue.degrees, 40);
62-
assert.approximately(angleValue.radians, 0.698132, EPSILON);
63-
assert.approximately(angleValue.gradians, 44.444444, EPSILON);
64-
assert.approximately(angleValue.turns, 0.111111, EPSILON);
65+
assert.closeTo(angleValue.radians, 0.698132, EPSILON);
66+
assert.closeTo(angleValue.gradians, 44.444444, EPSILON);
67+
assert.closeTo(angleValue.turns, 0.111111, EPSILON);
6568
});
6669

6770
test('Conversions when specified as radians', function() {
6871
var angleValue = new CSSAngleValue(100, 'rad');
69-
assert.approximately(angleValue.degrees, 5729.577951, EPSILON);
72+
assert.closeTo(angleValue.degrees, 5729.577951, EPSILON);
7073
assert.strictEqual(angleValue.radians, 100);
71-
assert.approximately(angleValue.gradians, 6366.197724, EPSILON);
72-
assert.approximately(angleValue.turns, 15.915494, EPSILON);
74+
assert.closeTo(angleValue.gradians, 6366.197724, EPSILON);
75+
assert.closeTo(angleValue.turns, 15.915494, EPSILON);
7376
});
7477

7578
test('Conversions when specified as gradians', function() {
7679
var angleValue = new CSSAngleValue(215, 'grad');
77-
assert.approximately(angleValue.degrees, 193.5, EPSILON);
78-
assert.approximately(angleValue.radians, 3.377212, EPSILON);
80+
assert.closeTo(angleValue.degrees, 193.5, EPSILON);
81+
assert.closeTo(angleValue.radians, 3.377212, EPSILON);
7982
assert.strictEqual(angleValue.gradians, 215);
80-
assert.approximately(angleValue.turns, 0.5375, EPSILON);
83+
assert.closeTo(angleValue.turns, 0.5375, EPSILON);
8184
});
8285

8386
test('Conversions when specified as turns', function() {
8487
var angleValue = new CSSAngleValue(0.6, 'turn');
85-
assert.approximately(angleValue.degrees, 216, EPSILON);
86-
assert.approximately(angleValue.radians, 3.769911, EPSILON);
87-
assert.approximately(angleValue.gradians, 240, EPSILON);
88+
assert.closeTo(angleValue.degrees, 216, EPSILON);
89+
assert.closeTo(angleValue.radians, 3.769911, EPSILON);
90+
assert.closeTo(angleValue.gradians, 240, EPSILON);
8891
assert.strictEqual(angleValue.turns, 0.6);
8992
});
9093

@@ -99,7 +102,7 @@ test('Parsing valid strings results in expected CSSAngleValues', function() {
99102
var result = typedOM.internal.parsing.consumeAngleValue(values[i].str);
100103
assert.isNotNull(result, 'Failed parsing ' + values[i].str);
101104
assert.instanceOf(result[0], CSSAngleValue);
102-
assert.approximately(result[0].degrees, values[i].degrees, EPSILON);
105+
assert.closeTo(result[0].degrees, values[i].degrees, EPSILON);
103106
assert.strictEqual(result[0]._value, values[i].value);
104107
assert.strictEqual(result[0]._unit, values[i].unit);
105108
assert.strictEqual(result[0].cssText, values[i].cssText);
@@ -117,7 +120,7 @@ test('Parsing is case insensitive', function() {
117120
var result = typedOM.internal.parsing.consumeAngleValue(values[i].str);
118121
assert.isNotNull(result, 'Failed parsing ' + values[i].str);
119122
assert.instanceOf(result[0], CSSAngleValue);
120-
assert.approximately(result[0].degrees, values[i].degrees, EPSILON);
123+
assert.closeTo(result[0].degrees, values[i].degrees, EPSILON);
121124
assert.strictEqual(result[0]._value, values[i].value);
122125
assert.strictEqual(result[0]._unit, values[i].unit);
123126
assert.strictEqual(result[0].cssText, values[i].cssText);

‎test/js/css-color-value.js

Lines changed: 16 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -15,37 +15,33 @@
1515
suite('CSSColorValue', function() {
1616
test('Constructor should throw an error if r, g and b are not integers', function() {
1717
assert.doesNotThrow(function() {new CSSColorValue(0, 50, 255);});
18-
assert.throw(function() {new CSSColorValue(0, "lemon", 50);}, TypeError,
19-
'r, g and b must be integers.');
20-
assert.throw(function() {new CSSColorValue(0, 50, null);}, TypeError,
21-
'r, g and b must be integers.');
22-
assert.throw(function() {new CSSColorValue(50.5, 20, 50);}, TypeError,
23-
'r, g and b must be integers.');
18+
19+
var integerErr = /^r, g and b must be integers\.$/;
20+
assert.throws(function() {new CSSColorValue(0, "lemon", 50);}, TypeError, integerErr);
21+
assert.throws(function() {new CSSColorValue(0, 50, null);}, TypeError, integerErr);
22+
assert.throws(function() {new CSSColorValue(50.5, 20, 50);}, TypeError, integerErr);
2423
});
2524

2625
test('Constructor should throw an error if r, g and b are not between 0 and 255', function() {
27-
assert.throw(function() {new CSSColorValue(0, -1, 50, 0);}, TypeError,
28-
'r, g and b must be integers between 0 and 255.');
29-
assert.throw(function() {new CSSColorValue(0, 255, 256);}, TypeError,
30-
'r, g and b must be integers between 0 and 255.');
31-
assert.throw(function() {new CSSColorValue(300, 255, 256);}, TypeError,
32-
'r, g and b must be integers between 0 and 255.');
26+
var rangeErr = /^r, g and b must be integers between 0 and 255\.$/;
27+
assert.throws(function() {new CSSColorValue(0, -1, 50, 0);}, TypeError, rangeErr);
28+
assert.throws(function() {new CSSColorValue(0, 255, 256);}, TypeError, rangeErr);
29+
assert.throws(function() {new CSSColorValue(300, 255, 256);}, TypeError, rangeErr);
3330
});
3431

3532
test('Constructor should throw an error if a is not a number', function() {
36-
assert.throw(function() {new CSSColorValue(0, 50, 50, "lemon");}, TypeError,
37-
'a must be a number.');
38-
assert.throw(function() {new CSSColorValue(0, 50, 50, null);}, TypeError,
39-
'a must be a number.');
33+
var numberErr = /^a must be a number\.$/;
34+
assert.throws(function() {new CSSColorValue(0, 50, 50, "lemon");}, TypeError, numberErr);
35+
assert.throws(function() {new CSSColorValue(0, 50, 50, null);}, TypeError, numberErr);
4036
});
4137

4238
test('Constructor should throw an error if a is not between 0 and 1', function() {
4339
assert.doesNotThrow(function() {new CSSColorValue(0, 50, 255, 1);});
4440
assert.doesNotThrow(function() {new CSSColorValue(0, 50, 255, 0);});
45-
assert.throw(function() {new CSSColorValue(0, 50, 50, -0.1);}, TypeError,
46-
'a must be a number between 0 and 1.');
47-
assert.throw(function() {new CSSColorValue(0, 50, 255, 1.2);}, TypeError,
48-
'a must be a number between 0 and 1.');
41+
42+
var rangeErr = /^a must be a number between 0 and 1\.$/;
43+
assert.throws(function() {new CSSColorValue(0, 50, 50, -0.1);}, TypeError, rangeErr);
44+
assert.throws(function() {new CSSColorValue(0, 50, 255, 1.2);}, TypeError, rangeErr);
4945
});
5046

5147
test('cssText should return rgb(<number>,<number>,<number>) if alpha ' +

‎test/js/css-image-value.js

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,8 @@
1414

1515
suite('CSSImageValue', function() {
1616
test('Can only create internal CSSImageValue object', function() {
17-
assert.throw(function() { new CSSImageValue(new Image()); }, TypeError, "Can\'t instantiate CSSImageValue");
17+
var instantiateErr = /^Can't instantiate CSSImageValue$/;
18+
assert.throws(function() { new CSSImageValue(new Image()); }, TypeError, instantiateErr);
1819
assert.doesNotThrow(function() { new typedOM.internal.CSSImageValue(new Image()); });
1920
});
2021

@@ -25,11 +26,12 @@ suite('CSSImageValue', function() {
2526
});
2627

2728
test('CSSImageValue only accepts Image object', function() {
28-
assert.throw(function() { new typedOM.internal.CSSImageValue(); }, TypeError, "image must be an Image object");
29-
assert.throw(function() { new typedOM.internal.CSSImageValue(1); }, TypeError, "image must be an Image object");
30-
assert.throw(function() { new typedOM.internal.CSSImageValue("abc"); }, TypeError, "image must be an Image object");
31-
assert.throw(function() { new typedOM.internal.CSSImageValue([]); }, TypeError, "image must be an Image object");
32-
assert.throw(function() { new typedOM.internal.CSSImageValue({ x: 1, y: 2 }); }, TypeError, "image must be an Image object");
29+
var imageErr = /image must be an Image object/;
30+
assert.throws(function() { new typedOM.internal.CSSImageValue(); }, TypeError, imageErr);
31+
assert.throws(function() { new typedOM.internal.CSSImageValue(1); }, TypeError, imageErr);
32+
assert.throws(function() { new typedOM.internal.CSSImageValue("abc"); }, TypeError, imageErr);
33+
assert.throws(function() { new typedOM.internal.CSSImageValue([]); }, TypeError, imageErr);
34+
assert.throws(function() { new typedOM.internal.CSSImageValue({ x: 1, y: 2 }); }, TypeError, imageErr);
3335
});
3436

3537
test('CSSImageValue\'s state and dimensions are correct before and after loaded', function(done) {

‎test/js/css-resource-value.js

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,10 @@ suite('CSSResourceValue', function() {
1919
});
2020

2121
test('Constructor only accepts a string of CSSResourceState', function() {
22-
assert.throw(function() { new CSSResourceValue(); }, TypeError, 'State of a CSSResourceValue must be one of CSSResourceState');
23-
assert.throw(function() { new CSSResourceValue(1); }, TypeError, 'State of a CSSResourceValue must be one of CSSResourceState');
24-
assert.throw(function() { new CSSResourceValue([1, 2]); }, TypeError, 'State of a CSSResourceValue must be one of CSSResourceState');
25-
assert.throw(function() { new CSSResourceValue('undefined'); }, TypeError, 'State of a CSSResourceValue must be one of CSSResourceState');
22+
var stateErr = /^State of a CSSResourceValue must be one of CSSResourceState$/;
23+
assert.throws(function() { new CSSResourceValue(); }, TypeError, stateErr);
24+
assert.throws(function() { new CSSResourceValue(1); }, TypeError, stateErr);
25+
assert.throws(function() { new CSSResourceValue([1, 2]); }, TypeError, stateErr);
26+
assert.throws(function() { new CSSResourceValue('undefined'); }, TypeError, stateErr);
2627
});
2728
});

‎test/js/css-scale.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@ suite('CSSScale', function() {
2727
assert.throws(function() {new CSSScale(1)});
2828
assert.throws(function() {new CSSScale('1', '2')});
2929
assert.throws(function() {new CSSScale(3, 4, null)});
30-
assert.throws(function() {new CSSScale({x:1, y:2, z:4})});
30+
assert.throws(function() {new CSSScale({x: 1, y: 2, z: 4})});
3131
});
3232

3333
test('CSSScale constructor works correctly for 2 arguments', function() {

‎test/js/css-skew.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,7 @@ suite('CSSSkew', function() {
7070
{str: 'SkewX(1TuRn)', cssText: 'skewx(1turn)', xValue: 1, xUnit: 'turn', yValue: 0, yUnit: 'deg', remaining: ''},
7171
{str: 'skewx(100grad) abc', cssText: 'skewx(100grad)', xValue: 100, xUnit: 'grad', yValue: 0, yUnit: 'deg', remaining: 'abc'},
7272
// skewy
73-
{str: 'skewy(0.45turn)', cssText: 'skewy(0.45turn)', xValue: 0, xUnit: 'deg', yValue:0.45 , yUnit: 'turn', remaining: ''},
73+
{str: 'skewy(0.45turn)', cssText: 'skewy(0.45turn)', xValue: 0, xUnit: 'deg', yValue: 0.45, yUnit: 'turn', remaining: ''},
7474
{str: 'SkEwY(2.1RAD)', cssText: 'skewy(2.1rad)', xValue: 0, xUnit: 'deg', yValue: 2.1, yUnit: 'rad', remaining: ''},
7575
{str: 'skewy(20DEG))))', cssText: 'skewy(20deg)', xValue: 0, xUnit: 'deg', yValue: 20, yUnit: 'deg', remaining: ')))'},
7676
];

‎test/js/css-translation.js

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -115,8 +115,8 @@ suite('CSSTranslation', function() {
115115
assert.strictEqual(parsed[1], values[i].remaining, values[i].str + ' expected ' + values[i].remaining + ' as trailing characters');
116116
assert.instanceOf(parsed[0], CSSTranslation);
117117
assert.isTrue(parsed[0].is2D);
118-
assert.approximately(parsed[0].x.value, values[i].x, 1e-6);
119-
assert.approximately(parsed[0].y.value, values[i].y, 1e-6);
118+
assert.closeTo(parsed[0].x.value, values[i].x, 1e-6);
119+
assert.closeTo(parsed[0].y.value, values[i].y, 1e-6);
120120
assert.strictEqual(parsed[0].x.type, 'px');
121121
assert.strictEqual(parsed[0].y.type, 'px');
122122
assert.strictEqual(parsed[0].z, null);
@@ -139,9 +139,9 @@ suite('CSSTranslation', function() {
139139
assert.strictEqual(parsed[1], values[i].remaining, values[i].str + ' expected ' + values[i].remaining + ' as trailing characters');
140140
assert.instanceOf(parsed[0], CSSTranslation);
141141
assert.isFalse(parsed[0].is2D);
142-
assert.approximately(parsed[0].x.value, values[i].x, 1e-6);
143-
assert.approximately(parsed[0].y.value, values[i].y, 1e-6);
144-
assert.approximately(parsed[0].z.value, values[i].z, 1e-6);
142+
assert.closeTo(parsed[0].x.value, values[i].x, 1e-6);
143+
assert.closeTo(parsed[0].y.value, values[i].y, 1e-6);
144+
assert.closeTo(parsed[0].z.value, values[i].z, 1e-6);
145145
assert.strictEqual(parsed[0].x.type, 'px');
146146
assert.strictEqual(parsed[0].y.type, 'px');
147147
assert.strictEqual(parsed[0].z.type, 'px');
@@ -163,8 +163,8 @@ suite('CSSTranslation', function() {
163163
assert.strictEqual(parsed[1], values[i].remaining, values[i].str + ' expected ' + values[i].remaining + ' as trailing characters');
164164
assert.instanceOf(parsed[0], CSSTranslation);
165165
assert.isTrue(parsed[0].is2D);
166-
assert.approximately(parsed[0].x.value, values[i].x, 1e-6);
167-
assert.approximately(parsed[0].y.value, values[i].y, 1e-6);
166+
assert.closeTo(parsed[0].x.value, values[i].x, 1e-6);
167+
assert.closeTo(parsed[0].y.value, values[i].y, 1e-6);
168168
assert.strictEqual(parsed[0].x.type, 'px');
169169
assert.strictEqual(parsed[0].y.type, 'px');
170170
assert.strictEqual(parsed[0].z, null);

‎test/js/css-unparsed-value.js

Lines changed: 7 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -19,19 +19,16 @@ suite('CSSUnparsedValue', function() {
1919
});
2020

2121
test('Values not an array throws', function() {
22-
assert.throw(function() { new CSSUnparsedValue(1); }, TypeError,
23-
'CSSUnparsedValue should be an array of string or CSSVariableReferenceValue');
24-
assert.throw(function() { new CSSUnparsedValue("123"); }, TypeError,
25-
'CSSUnparsedValue should be an array of string or CSSVariableReferenceValue');
26-
assert.throw(function() { new CSSUnparsedValue({ h:10, w:5, d:4, t:"5" });}, TypeError,
27-
'CSSUnparsedValue should be an array of string or CSSVariableReferenceValue');
22+
var valueErr = /^CSSUnparsedValue should be an array of string or CSSVariableReferenceValue$/;
23+
assert.throws(function() { new CSSUnparsedValue(1); }, TypeError, valueErr);
24+
assert.throws(function() { new CSSUnparsedValue("123"); }, TypeError, valueErr);
25+
assert.throws(function() { new CSSUnparsedValue({h: 10, w: 5, d: 4, t: "5"});}, TypeError, valueErr);
2826
});
2927

3028
test('Values not an array of string or CSSVariableReferenceValue throws', function() {
31-
assert.throw(function() { new CSSUnparsedValue([1]); }, TypeError,
32-
"CSSUnparsedValue\'s elements should be string or CSSVariableReferenceValue");
33-
assert.throw(function() { new CSSUnparsedValue(["1234", "2342", 1]); }, TypeError,
34-
"CSSUnparsedValue\'s elements should be string or CSSVariableReferenceValue");
29+
var valueErr = /^CSSUnparsedValue's elements should be string or CSSVariableReferenceValue$/;
30+
assert.throws(function() { new CSSUnparsedValue([1]); }, TypeError, valueErr);
31+
assert.throws(function() { new CSSUnparsedValue(["1234", "2342", 1]); }, TypeError, valueErr);
3532
});
3633

3734
test('Using spread operator on CSSUnparsedValue results in the correct values', function() {

‎test/js/css-url-image-value.js

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -21,9 +21,10 @@ suite('CSSURLImageValue', function() {
2121
});
2222

2323
test('CSSURLImageValue only accepts string', function() {
24-
assert.throw(function() { new CSSURLImageValue(); }, TypeError, "URL must be a string");
25-
assert.throw(function() { new CSSURLImageValue([]); }, TypeError, "URL must be a string");
26-
assert.throw(function() { new CSSURLImageValue(1); }, TypeError, "URL must be a string");
24+
var stringErr = /^URL must be a string$/;
25+
assert.throws(function() { new CSSURLImageValue(); }, TypeError, stringErr);
26+
assert.throws(function() { new CSSURLImageValue([]); }, TypeError, stringErr);
27+
assert.throws(function() { new CSSURLImageValue(1); }, TypeError, stringErr);
2728
assert.doesNotThrow(function() { new CSSURLImageValue(''); });
2829
});
2930

0 commit comments

Comments
 (0)