1 package csscolorparser
2
3 import (
4 "image/color"
5 "strings"
6 "testing"
7 )
8
9 type rgba struct {
10 r, g, b, a uint32
11 }
12
13 func isColorEqual(c1, c2 color.Color) bool {
14 r1, g1, b1, a1 := c1.RGBA()
15 r2, g2, b2, a2 := c2.RGBA()
16 a := rgba{r1, g1, b1, a1}
17 b := rgba{r2, g2, b2, a2}
18 if a == b {
19 return true
20 }
21 return false
22 }
23
24 func equalStr(t *testing.T, a, b string) {
25 if a != b {
26 t.Errorf("%s != %s", a, b)
27 }
28 }
29
30 func TestColor(t *testing.T) {
31 a := Color{0, 0, 1, 1}
32 equalStr(t, a.HexString(), "#0000ff")
33 equalStr(t, a.RGBString(), "rgb(0,0,255)")
34
35 b := Color{0, 0, 1, 0.5}
36 equalStr(t, b.HexString(), "#0000ff80")
37 equalStr(t, b.RGBString(), "rgba(0,0,255,0.5)")
38 }
39
40 func TestParseColor(t *testing.T) {
41 type colorPair struct {
42 in string
43 out [4]uint8
44 }
45 testData := []colorPair{
46 {"transparent", [4]uint8{0, 0, 0, 0}},
47 {"rebeccapurple", [4]uint8{102, 51, 153, 255}},
48 {"#ff00ff64", [4]uint8{255, 0, 255, 100}},
49 {"ff00ff64", [4]uint8{255, 0, 255, 100}},
50 {"rgb(247,179,99)", [4]uint8{247, 179, 99, 255}},
51 {"rgb(50% 50% 50%)", [4]uint8{128, 128, 128, 255}},
52 {"rgb(247,179,99,0.37)", [4]uint8{247, 179, 99, 94}},
53 {"hsl(270 0% 50%)", [4]uint8{128, 128, 128, 255}},
54 {"hwb(0 50% 50%)", [4]uint8{128, 128, 128, 255}},
55 {"hsv(0 0% 50%)", [4]uint8{128, 128, 128, 255}},
56 {"hsv(0 0% 100%)", [4]uint8{255, 255, 255, 255}},
57 {"hsv(0 0% 19%)", [4]uint8{48, 48, 48, 255}},
58 }
59 for _, d := range testData {
60 c, err := Parse(d.in)
61 if err != nil {
62 t.Errorf("Parse error: %s", d.in)
63 continue
64 }
65 r, g, b, a := c.RGBA255()
66 rgba := [4]uint8{r, g, b, a}
67 if rgba != d.out {
68 t.Errorf("%s -> %v != %v", d.in, d.out, rgba)
69 }
70 }
71 }
72
73 func TestNamedColors(t *testing.T) {
74 for name, rgb := range namedColors {
75 c, _ := Parse(name)
76 r, g, b, _ := c.RGBA255()
77 rgb_ := [3]uint8{r, g, b}
78 if rgb_ != rgb {
79 t.Errorf("%s != %s", rgb_, rgb)
80 }
81 if name == "aqua" || name == "cyan" || name == "fuchsia" || name == "magenta" {
82 continue
83 }
84 if strings.Contains(name, "gray") || strings.Contains(name, "grey") {
85 continue
86 }
87 name_, _ := c.Name()
88 if name_ != name {
89 t.Errorf("%s != %s", name_, name)
90 }
91 }
92
93 data := [][2]string{
94 {"aliceblue", "#f0f8ff"},
95 {"bisque", "#ffe4c4"},
96 {"chartreuse", "#7fff00"},
97 {"coral", "#ff7f50"},
98 {"crimson", "#dc143c"},
99 {"dodgerblue", "#1e90ff"},
100 {"firebrick", "#b22222"},
101 {"gold", "#ffd700"},
102 {"hotpink", "#ff69b4"},
103 {"indigo", "#4b0082"},
104 {"lavender", "#e6e6fa"},
105 {"plum", "#dda0dd"},
106 {"salmon", "#fa8072"},
107 {"skyblue", "#87ceeb"},
108 {"tomato", "#ff6347"},
109 {"violet", "#ee82ee"},
110 {"yellowgreen", "#9acd32"},
111 }
112 for _, d := range data {
113 c, _ := Parse(d[0])
114 hex := c.HexString()
115 if hex != d[1] {
116 t.Errorf("%s != %s", hex, d[1])
117 }
118 }
119 }
120
121 func TestEqualColorsBlack(t *testing.T) {
122 data := []string{
123 "black",
124 "#000",
125 "#000f",
126 "#000000",
127 "#000000ff",
128 "rgb(0,0,0)",
129 "rgb(0% 0% 0%)",
130 "rgb(0 0 0 100%)",
131 "hsl(270,100%,0%)",
132 "hwb(90 0% 100%)",
133 "hwb(120deg 0% 100% 100%)",
134 "hsv(120 100% 0%)",
135 }
136 black := color.NRGBA{0, 0, 0, 255}
137 for _, d := range data {
138 c, _ := Parse(d)
139 if !isColorEqual(black, c) {
140 t.Errorf("Not black, %s -> %v", d, c)
141 break
142 }
143 }
144 }
145
146 func TestEqualColorsRed(t *testing.T) {
147 data := []string{
148 "red",
149 "#f00",
150 "#f00f",
151 "#ff0000",
152 "#ff0000ff",
153 "rgb(255,0,0)",
154 "rgb(255 0 0)",
155 "rgb(700, -99, 0)",
156 "rgb(100% 0% 0%)",
157 "rgb(200% -10% -100%)",
158 "rgb(255 0 0 100%)",
159 "RGB( 255 , 0 , 0 )",
160 "RGB( 255 0 0 )",
161 "hsl(0,100%,50%)",
162 "hsl(360 100% 50%)",
163 "hwb(0 0% 0%)",
164 "hwb(360deg 0% 0% 100%)",
165 "hsv(0 100% 100%)",
166 }
167 red := color.NRGBA{255, 0, 0, 255}
168 for _, d := range data {
169 c, _ := Parse(d)
170 if !isColorEqual(red, c) {
171 t.Errorf("Not red, %s -> %v", d, c)
172 break
173 }
174 }
175 }
176
177 func TestEqualColorsLime(t *testing.T) {
178 data := []string{
179 "lime",
180 "#0f0",
181 "#0f0f",
182 "#00ff00",
183 "#00ff00ff",
184 "rgb(0,255,0)",
185 "rgb(0% 100% 0%)",
186 "rgb(0 255 0 / 100%)",
187 "rgba(0,255,0,1)",
188 "hsl(120,100%,50%)",
189 "hsl(120deg 100% 50%)",
190 "hsl(-240 100% 50%)",
191 "hsl(-240deg 100% 50%)",
192 "hsl(0.3333turn 100% 50%)",
193 "hsl(133.333grad 100% 50%)",
194 "hsl(2.0944rad 100% 50%)",
195 "hsla(120,100%,50%,100%)",
196 "hwb(120 0% 0%)",
197 "hwb(480deg 0% 0% / 100%)",
198 "hsv(120 100% 100%)",
199 }
200 lime := [4]uint8{0, 255, 0, 255}
201 for _, d := range data {
202 c, _ := Parse(d)
203 r, g, b, a := c.RGBA255()
204 rgba := [4]uint8{r, g, b, a}
205 if rgba != lime {
206 t.Errorf("Not lime, %s -> %v", d, rgba)
207 break
208 }
209 }
210 }
211
212 func TestEqualColorsLimeAlpha(t *testing.T) {
213 data := []string{
214 "#00ff0080",
215 "rgb(0,255,0,50%)",
216 "rgb(0% 100% 0% / 0.5)",
217 "rgba(0%,100%,0%,50%)",
218 "hsl(120,100%,50%,0.5)",
219 "hsl(120deg 100% 50% / 50%)",
220 "hsla(120,100%,50%,0.5)",
221 "hwb(120 0% 0% / 50%)",
222 "hsv(120 100% 100% / 50%)",
223 }
224 limeAlpha := [4]uint8{0, 255, 0, 128}
225 for _, d := range data {
226 c, _ := Parse(d)
227 r, g, b, a := c.RGBA255()
228 rgba := [4]uint8{r, g, b, a}
229 if rgba != limeAlpha {
230 t.Errorf("Not lime 0.5 alpha, %s -> %v", d, rgba)
231 break
232 }
233 }
234 }
235
236 func TestInvalidData(t *testing.T) {
237 testData := []string{
238 "",
239 "bloodred",
240 "#78afzd",
241 "#fffff",
242 "rgb(0,255,8s)",
243 "rgb(100%,z9%,75%)",
244 "cmyk(1 0 0)",
245 "rgba(0 0)",
246 "hsl(90',100%,50%)",
247 "hsl(deg 100% 50%)",
248 "hsl(Xturn 100% 50%)",
249 "hsl(Zgrad 100% 50%)",
250 "hsl(180 1 x%)",
251 "hsla(360)",
252 "hwb(Xrad,50%,50%)",
253 "hwb(270 0% 0% 0% 0%)",
254 "hsv(120 100% 100% 1 50%)",
255 "hsv(120 XXX 100%)",
256 }
257 for _, d := range testData {
258 c, err := Parse(d)
259 if err == nil {
260 t.Errorf("It should fail, %s -> %v", d, c)
261 }
262 t.Log(err)
263 }
264 }
265
266 func TestParseAngle(t *testing.T) {
267 type pair struct {
268 in string
269 out float64
270 }
271 testData := []pair{
272 {"360", 360},
273 {"127.356", 127.356},
274 {"+120deg", 120},
275 {"90deg", 90},
276 {"-127deg", -127},
277 {"100grad", 90},
278 {"1.5707963267948966rad", 90},
279 {"0.25turn", 90},
280 {"-0.25turn", -90},
281 }
282 for _, s := range testData {
283 d, ok := parseAngle(s.in)
284 if !ok {
285 t.Errorf("Parse error, %s", s.in)
286 }
287 if d != s.out {
288 t.Errorf("%s -> %v != %v", s.in, d, s.out)
289 }
290 }
291 }
292
293 func TestNormalizeAngle(t *testing.T) {
294 testData := [][2]float64{
295 {0, 0},
296 {360, 0},
297 {400, 40},
298 {1155, 75},
299 {-360, 0},
300 {-90, 270},
301 {-765, 315},
302 }
303 for _, s := range testData {
304 d := normalizeAngle(s[0])
305 if d != s[1] {
306 t.Errorf("%v -> %v != %v", s[0], d, s[1])
307 }
308 }
309 }
310
View as plain text