Debian Codegraph @

closure-library/closure/goog/color/alpha_test.js

raw
1 // Copyright 2006 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 goog.provide('goog.color.alphaTest');
15 goog.setTestOnly('goog.color.alphaTest');
16
17 goog.require('goog.array');
18 goog.require('goog.color');
19 goog.require('goog.color.alpha');
20 goog.require('goog.testing.jsunit');
21
22 function testIsValidAlphaHexColor() {
23 var goodAlphaHexColors = [
24 '#ffffffff', '#ff781259', '#01234567', '#Ff003DaB', '#3CAF', '#abcdefab',
25 '#3CAB'
26 ];
27 var badAlphaHexColors =
28 ['#xxxxxxxx', '88990077', 'not_color', '#123456789', 'fffffgfg'];
29 for (var i = 0; i < goodAlphaHexColors.length; i++) {
30 assertTrue(
31 goodAlphaHexColors[i],
32 goog.color.alpha.isValidAlphaHexColor_(goodAlphaHexColors[i]));
33 }
34 for (var i = 0; i < badAlphaHexColors.length; i++) {
35 assertFalse(
36 badAlphaHexColors[i],
37 goog.color.alpha.isValidAlphaHexColor_(badAlphaHexColors[i]));
38 }
39 }
40
41 function testIsValidRgbaColor() {
42 var goodRgbaColors = [
43 'rgba(255, 0, 0, 1)', 'rgba(255,127,0,1)', 'rgba(0,0,255,0.5)',
44 '(255, 26, 75, 0.2)', 'RGBA(0, 55, 0, 0.6)', 'rgba(0, 200, 0, 0.123456789)'
45 ];
46 var badRgbaColors = [
47 '(255, 0, 0)', '(2555,0,0, 0)', '(1,2,3,4,5)', 'rgba(1,20,)',
48 'RGBA(20,20,20,)', 'RGBA', 'rgba(255, 0, 0, 1.1)'
49 ];
50 for (var i = 0; i < goodRgbaColors.length; i++) {
51 assertEquals(
52 goodRgbaColors[i], 4,
53 goog.color.alpha.isValidRgbaColor_(goodRgbaColors[i]).length);
54 }
55 for (var i = 0; i < badRgbaColors.length; i++) {
56 assertEquals(
57 badRgbaColors[i], 0,
58 goog.color.alpha.isValidRgbaColor_(badRgbaColors[i]).length);
59 }
60 }
61
62 function testIsValidHslaColor() {
63 var goodHslaColors = [
64 'hsla(120, 0%, 0%, 1)', 'hsla(360,20%,0%,1)', 'hsla(0,0%,50%,0.5)',
65 'HSLA(0, 55%, 0%, 0.6)', 'hsla(0, 85%, 0%, 0.123456789)'
66 ];
67 var badHslaColors = [
68 '(255, 0, 0, 0)', 'hsla(2555,0,0, 0)', 'hsla(1,2,3,4,5)', 'hsla(1,20,)',
69 'HSLA(20,20,20,)', 'hsla(255, 0, 0, 1.1)', 'HSLA'
70 ];
71 for (var i = 0; i < goodHslaColors.length; i++) {
72 assertEquals(
73 goodHslaColors[i], 4,
74 goog.color.alpha.isValidHslaColor_(goodHslaColors[i]).length);
75 }
76 for (var i = 0; i < badHslaColors.length; i++) {
77 assertEquals(
78 badHslaColors[i], 0,
79 goog.color.alpha.isValidHslaColor_(badHslaColors[i]).length);
80 }
81 }
82
83 function testParse() {
84 var colors = [
85 'rgba(15, 250, 77, 0.5)', '(127, 127, 127, 0.8)', '#ffeeddaa', '12345678',
86 'hsla(160, 50%, 90%, 0.2)'
87 ];
88 var parsed = goog.array.map(colors, goog.color.alpha.parse);
89 assertEquals('rgba', parsed[0].type);
90 assertEquals(goog.color.alpha.rgbaToHex(15, 250, 77, 0.5), parsed[0].hex);
91 assertEquals('rgba', parsed[1].type);
92 assertEquals(goog.color.alpha.rgbaToHex(127, 127, 127, 0.8), parsed[1].hex);
93 assertEquals('hex', parsed[2].type);
94 assertEquals('#ffeeddaa', parsed[2].hex);
95 assertEquals('hex', parsed[3].type);
96 assertEquals('#12345678', parsed[3].hex);
97 assertEquals('hsla', parsed[4].type);
98 assertEquals('#d9f2ea33', parsed[4].hex);
99
100 var badColors = ['rgb(01, 1, 23)', '(256, 256, 256)', '#ffeeddaa'];
101 for (var i = 0; i < badColors.length; i++) {
102 var e = assertThrows(
103 badColors[i] + ' is not a valid color string',
104 goog.partial(goog.color.parse, badColors[i]));
105 assertContains(
106 'Error processing ' + badColors[i], 'is not a valid color string',
107 e.message);
108 }
109 }
110
111 function testHexToRgba() {
112 var testColors = [
113 ['#B0FF2D66', [176, 255, 45, 0.4]], ['#b26e5fcc', [178, 110, 95, 0.8]],
114 ['#66f3', [102, 102, 255, 0.2]]
115 ];
116
117 for (var i = 0; i < testColors.length; i++) {
118 var r = goog.color.alpha.hexToRgba(testColors[i][0]);
119 var t = testColors[i][1];
120
121 assertEquals('Red channel should match.', t[0], r[0]);
122 assertEquals('Green channel should match.', t[1], r[1]);
123 assertEquals('Blue channel should match.', t[2], r[2]);
124 assertEquals('Alpha channel should match.', t[3], r[3]);
125 }
126
127 var badColors = ['', '#g00', 'some words'];
128 for (var i = 0; i < badColors.length; i++) {
129 var e =
130 assertThrows(goog.partial(goog.color.alpha.hexToRgba, badColors[i]));
131 assertEquals(
132 "'" + badColors[i] + "' is not a valid alpha hex color", e.message);
133 }
134 }
135
136 function testHexToRgbaStyle() {
137 assertEquals('rgba(255,0,0,1)', goog.color.alpha.hexToRgbaStyle('#ff0000ff'));
138 assertEquals(
139 'rgba(206,206,206,0.8)', goog.color.alpha.hexToRgbaStyle('#cecececc'));
140 assertEquals(
141 'rgba(51,204,170,0.2)', goog.color.alpha.hexToRgbaStyle('#3CA3'));
142 assertEquals(
143 'rgba(1,2,3,0.016)', goog.color.alpha.hexToRgbaStyle('#01020304'));
144 assertEquals(
145 'rgba(255,255,0,0.333)', goog.color.alpha.hexToRgbaStyle('#FFFF0055'));
146
147 var badHexColors = ['#12345', null, undefined, '#.1234567890'];
148 for (var i = 0; i < badHexColors.length; ++i) {
149 var e = assertThrows(
150 badHexColors[i] + ' is an invalid hex color',
151 goog.partial(goog.color.alpha.hexToRgbaStyle, badHexColors[i]));
152 assertEquals(
153 "'" + badHexColors[i] + "' is not a valid alpha hex color", e.message);
154 }
155 }
156
157 function testRgbaToHex() {
158 assertEquals('#af13ffff', goog.color.alpha.rgbaToHex(175, 19, 255, 1));
159 assertEquals('#357cf099', goog.color.alpha.rgbaToHex(53, 124, 240, 0.6));
160 var badRgba = [
161 [-1, -1, -1, -1], [0, 0, 0, 2], ['a', 'b', 'c', 'd'], [undefined, 5, 5, 5]
162 ];
163 for (var i = 0; i < badRgba.length; ++i) {
164 var e = assertThrows(
165 badRgba[i] + ' is not a valid rgba color',
166 goog.partial(goog.color.alpha.rgbaArrayToHex, badRgba[i]));
167 assertContains('is not a valid RGBA color', e.message);
168 }
169 }
170
171 function testRgbaToRgbaStyle() {
172 var testColors = [
173 [[175, 19, 255, 1], 'rgba(175,19,255,1)'],
174 [[53, 124, 240, .6], 'rgba(53,124,240,0.6)'],
175 [[10, 20, 30, .1234567], 'rgba(10,20,30,0.123)'],
176 [[20, 30, 40, 1 / 3], 'rgba(20,30,40,0.333)']
177 ];
178
179 for (var i = 0; i < testColors.length; ++i) {
180 var r = goog.color.alpha.rgbaToRgbaStyle(
181 testColors[i][0][0], testColors[i][0][1], testColors[i][0][2],
182 testColors[i][0][3]);
183 assertEquals(testColors[i][1], r);
184 }
185
186 var badColors = [[0, 0, 0, 2]];
187 for (var i = 0; i < badColors.length; ++i) {
188 var e = assertThrows(
189 goog.partial(
190 goog.color.alpha.rgbaToRgbaStyle, badColors[i][0], badColors[i][1],
191 badColors[i][2], badColors[i][3]));
192
193 assertContains('is not a valid RGBA color', e.message);
194 }
195
196 // Loop through all bad color values and ensure they fail in each channel.
197 var badValues = [-1, 300, 'a', undefined, null, NaN];
198 var color = [0, 0, 0, 0];
199 for (var i = 0; i < badValues.length; ++i) {
200 for (var channel = 0; channel < color.length; ++channel) {
201 color[channel] = badValues[i];
202 var e = assertThrows(
203 color + ' is not a valid rgba color',
204 goog.partial(goog.color.alpha.rgbaToRgbaStyle, color));
205 assertContains('is not a valid RGBA color', e.message);
206
207 color[channel] = 0;
208 }
209 }
210 }
211
212 function testRgbaArrayToRgbaStyle() {
213 var testColors = [
214 [[175, 19, 255, 1], 'rgba(175,19,255,1)'],
215 [[53, 124, 240, .6], 'rgba(53,124,240,0.6)']
216 ];
217
218 for (var i = 0; i < testColors.length; ++i) {
219 var r = goog.color.alpha.rgbaArrayToRgbaStyle(testColors[i][0]);
220 assertEquals(testColors[i][1], r);
221 }
222
223 var badColors = [[0, 0, 0, 2]];
224 for (var i = 0; i < badColors.length; ++i) {
225 var e = assertThrows(
226 goog.partial(goog.color.alpha.rgbaArrayToRgbaStyle, badColors[i]));
227
228 assertContains('is not a valid RGBA color', e.message);
229 }
230
231 // Loop through all bad color values and ensure they fail in each channel.
232 var badValues = [-1, 300, 'a', undefined, null, NaN];
233 var color = [0, 0, 0, 0];
234 for (var i = 0; i < badValues.length; ++i) {
235 for (var channel = 0; channel < color.length; ++channel) {
236 color[channel] = badValues[i];
237 var e = assertThrows(
238 color + ' is not a valid rgba color',
239 goog.partial(goog.color.alpha.rgbaToRgbaStyle, color));
240 assertContains('is not a valid RGBA color', e.message);
241
242 color[channel] = 0;
243 }
244 }
245 }
246
247 function testRgbaArrayToHsla() {
248 var opaqueBlueRgb = [0, 0, 255, 1];
249 var opaqueBlueHsl = goog.color.alpha.rgbaArrayToHsla(opaqueBlueRgb);
250 assertArrayEquals(
251 'Conversion from RGBA to HSLA should be as expected', [240, 1, 0.5, 1],
252 opaqueBlueHsl);
253
254 var nearlyOpaqueYellowRgb = [255, 190, 0, 0.7];
255 var nearlyOpaqueYellowHsl =
256 goog.color.alpha.rgbaArrayToHsla(nearlyOpaqueYellowRgb);
257 assertArrayEquals(
258 'Conversion from RGBA to HSLA should be as expected', [45, 1, 0.5, 0.7],
259 nearlyOpaqueYellowHsl);
260
261 var transparentPurpleRgb = [180, 0, 255, 0];
262 var transparentPurpleHsl =
263 goog.color.alpha.rgbaArrayToHsla(transparentPurpleRgb);
264 assertArrayEquals(
265 'Conversion from RGBA to HSLA should be as expected', [282, 1, 0.5, 0],
266 transparentPurpleHsl);
267 }
268
269 function testNormalizeAlphaHex() {
270 var compactColor = '#abcd';
271 var normalizedCompactColor =
272 goog.color.alpha.normalizeAlphaHex_(compactColor);
273 assertEquals(
274 'The color should have been normalized to the right length', '#aabbccdd',
275 normalizedCompactColor);
276
277 var uppercaseColor = '#ABCDEF01';
278 var normalizedUppercaseColor =
279 goog.color.alpha.normalizeAlphaHex_(uppercaseColor);
280 assertEquals(
281 'The color should have been normalized to lowercase', '#abcdef01',
282 normalizedUppercaseColor);
283 }
284
285 function testHsvaArrayToHex() {
286 var opaqueSkyBlueHsv = [190, 1, 255, 1];
287 var opaqueSkyBlueHex = goog.color.alpha.hsvaArrayToHex(opaqueSkyBlueHsv);
288 assertEquals(
289 'The HSVA array should have been properly converted to hex', '#00d4ffff',
290 opaqueSkyBlueHex);
291
292 var halfTransparentPinkHsv = [300, 1, 255, 0.5];
293 var halfTransparentPinkHex =
294 goog.color.alpha.hsvaArrayToHex(halfTransparentPinkHsv);
295 assertEquals(
296 'The HSVA array should have been properly converted to hex', '#ff00ff7f',
297 halfTransparentPinkHex);
298
299 var transparentDarkTurquoiseHsv = [175, 1, 127, 0.5];
300 var transparentDarkTurquoiseHex =
301 goog.color.alpha.hsvaArrayToHex(transparentDarkTurquoiseHsv);
302 assertEquals(
303 'The HSVA array should have been properly converted to hex', '#007f747f',
304 transparentDarkTurquoiseHex);
305 }
306
307 function testExtractHexColor() {
308 var opaqueRed = '#ff0000ff';
309 var red = goog.color.alpha.extractHexColor(opaqueRed);
310 assertEquals(
311 'The hex part of the color should have been extracted correctly',
312 '#ff0000', red);
313
314 var halfOpaqueDarkGreenCompact = '#0507';
315 var darkGreen = goog.color.alpha.extractHexColor(halfOpaqueDarkGreenCompact);
316 assertEquals(
317 'The hex part of the color should have been extracted correctly',
318 '#005500', darkGreen);
319 }
320
321 function testExtractAlpha() {
322 var colors = ['#ff0000ff', '#0507', '#ff000005'];
323 var expectedOpacities = ['ff', '77', '05'];
324
325 for (var i = 0; i < colors.length; i++) {
326 var opacity = goog.color.alpha.extractAlpha(colors[i]);
327 assertEquals(
328 'The alpha transparency should have been extracted correctly',
329 expectedOpacities[i], opacity);
330 }
331 }
332
333 function testHslaArrayToRgbaStyle() {
334 assertEquals(
335 'rgba(102,255,102,0.5)',
336 goog.color.alpha.hslaArrayToRgbaStyle([120, 100, 70, 0.5]));
337 assertEquals(
338 'rgba(28,23,23,0.9)',
339 goog.color.alpha.hslaArrayToRgbaStyle([0, 10, 10, 0.9]));
340 }
341
342 function testRgbaStyleParsableResult() {
343 var testColors = [
344 [175, 19, 255, 1], [53, 124, 240, .6], [20, 30, 40, 0.3333333],
345 [255, 255, 255, 0.7071067811865476]
346 ];
347
348 for (var i = 0, testColor; testColor = testColors[i]; i++) {
349 var rgbaStyle = goog.color.alpha.rgbaStyle_(testColor);
350 var parsedColor =
351 goog.color.alpha.hexToRgba(goog.color.alpha.parse(rgbaStyle).hex);
352 assertEquals(testColor[0], parsedColor[0]);
353 assertEquals(testColor[1], parsedColor[1]);
354 assertEquals(testColor[2], parsedColor[2]);
355 // Parsing keeps a 1/255 accuracy on the alpha channel.
356 assertRoughlyEquals(testColor[3], parsedColor[3], 0.005);
357 }
358 }