LayoutTests/imported/w3c/web-platform-tests/css/css-color/color-resolving-hsl-expected.txt

PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 28, 0)" but got "rgba(35, 27, 27, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 28, 0.2)" but got "rgba(35, 27, 27, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 56, 0)" but got "rgba(71, 55, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 56, 0.2)" but got "rgba(71, 55, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 84, 0)" but got "rgba(107, 83, 83, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 84, 0.2)" but got "rgba(107, 83, 83, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 112, 0)" but got "rgba(143, 111, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 112, 0.2)" but got "rgba(143, 111, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 24, 0)" but got "rgba(39, 23, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 24, 0.2)" but got "rgba(39, 23, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 25%) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 48, 0)" but got "rgba(79, 47, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 48, 0.2)" but got "rgba(79, 47, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 72, 0)" but got "rgba(119, 71, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 72, 0.2)" but got "rgba(119, 71, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 25%, 50%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgba(159, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgba(159, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 20, 0)" but got "rgba(43, 19, 19, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 20, 0.2)" but got "rgba(43, 19, 19, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 40, 0)" but got "rgba(87, 39, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 40, 0.2)" but got "rgba(87, 39, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 60, 0)" but got "rgba(131, 59, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 60, 0.2)" but got "rgba(131, 59, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 80, 0)" but got "rgba(175, 79, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 80, 0.2)" but got "rgba(175, 79, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 124, 0)" but got "rgba(195, 123, 123, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 124, 0.2)" but got "rgba(195, 123, 123, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 16, 0)" but got "rgba(47, 15, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 16, 0.2)" but got "rgba(47, 15, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 25%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgba(95, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgba(95, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 48, 0)" but got "rgba(143, 47, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 48, 0.2)" but got "rgba(143, 47, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 50%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgba(191, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgba(191, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 112, 0)" but got "rgba(207, 111, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 112, 0.2)" but got "rgba(207, 111, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 12, 0)" but got "rgba(51, 11, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 12, 0.2)" but got "rgba(51, 11, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 24, 0)" but got "rgba(103, 23, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 24, 0.2)" but got "rgba(103, 23, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 36, 0)" but got "rgba(155, 35, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 36, 0.2)" but got "rgba(155, 35, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 48, 0)" but got "rgba(207, 47, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 48, 0.2)" but got "rgba(207, 47, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 100, 0)" but got "rgba(219, 99, 99, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 100, 0.2)" but got "rgba(219, 99, 99, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 8, 0)" but got "rgba(55, 7, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 8, 0.2)" but got "rgba(55, 7, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 25%) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 16, 0)" but got "rgba(111, 15, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 16, 0.2)" but got "rgba(111, 15, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 24, 0)" but got "rgba(167, 23, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 24, 0.2)" but got "rgba(167, 23, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 50%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgba(223, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgba(223, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 88, 0)" but got "rgba(231, 87, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 88, 0.2)" but got "rgba(231, 87, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 4, 0)" but got "rgba(59, 3, 3, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 4, 0.2)" but got "rgba(59, 3, 3, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 8, 0)" but got "rgba(119, 7, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 8, 0.2)" but got "rgba(119, 7, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 12, 0)" but got "rgba(179, 11, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 12, 0.2)" but got "rgba(179, 11, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 16, 0)" but got "rgba(239, 15, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 16, 0.2)" but got "rgba(239, 15, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 76, 0)" but got "rgba(243, 75, 75, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 76, 0.2)" but got "rgba(243, 75, 75, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgba(63, 0, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgba(63, 0, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 25%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgba(127, 0, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgba(127, 0, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 37.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 37.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 37.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 37.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 50%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 50%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgba(255, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgba(255, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(0, 100%, 75%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgba(255, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgba(255, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(0, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(0, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(0, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 12.5%) assert_equals: expected "rgb(36, 32, 28)" but got "rgb(35, 31, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 32, 28, 0)" but got "rgba(35, 31, 27, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 32, 28, 0.2)" but got "rgba(35, 31, 27, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 32, 28)" but got "rgb(35, 31, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 25%) assert_equals: expected "rgb(72, 64, 56)" but got "rgb(71, 63, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 64, 56, 0)" but got "rgba(71, 63, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 64, 56, 0.2)" but got "rgba(71, 63, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 64, 56)" but got "rgb(71, 63, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 37.5%) assert_equals: expected "rgb(108, 96, 84)" but got "rgb(107, 95, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 96, 84, 0)" but got "rgba(107, 95, 83, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 96, 84, 0.2)" but got "rgba(107, 95, 83, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 96, 84)" but got "rgb(107, 95, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 50%) assert_equals: expected "rgb(143, 128, 112)" but got "rgb(143, 127, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 128, 112, 0)" but got "rgba(143, 127, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 128, 112, 0.2)" but got "rgba(143, 127, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 128, 112)" but got "rgb(143, 127, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 12.5%) assert_equals: expected "rgb(40, 32, 24)" but got "rgb(39, 31, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 32, 24, 0)" but got "rgba(39, 31, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 32, 24, 0.2)" but got "rgba(39, 31, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 32, 24)" but got "rgb(39, 31, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 25%) assert_equals: expected "rgb(80, 64, 48)" but got "rgb(79, 63, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0) assert_equals: expected "rgba(80, 64, 48, 0)" but got "rgba(79, 63, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 64, 48, 0.2)" but got "rgba(79, 63, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 25%, 1) assert_equals: expected "rgb(80, 64, 48)" but got "rgb(79, 63, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 37.5%) assert_equals: expected "rgb(120, 96, 72)" but got "rgb(119, 95, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 96, 72, 0)" but got "rgba(119, 95, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 96, 72, 0.2)" but got "rgba(119, 95, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 96, 72)" but got "rgb(119, 95, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 25%, 50%) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(159, 127, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0) assert_equals: expected "rgba(159, 128, 96, 0)" but got "rgba(159, 127, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 128, 96, 0.2)" but got "rgba(159, 127, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 25%, 50%, 1) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(159, 127, 95)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 12.5%) assert_equals: expected "rgb(44, 32, 20)" but got "rgb(43, 31, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 32, 20, 0)" but got "rgba(43, 31, 19, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 32, 20, 0.2)" but got "rgba(43, 31, 19, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 32, 20)" but got "rgb(43, 31, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 25%) assert_equals: expected "rgb(88, 64, 40)" but got "rgb(87, 63, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 64, 40, 0)" but got "rgba(87, 63, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 64, 40, 0.2)" but got "rgba(87, 63, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 64, 40)" but got "rgb(87, 63, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 37.5%) assert_equals: expected "rgb(131, 96, 60)" but got "rgb(131, 95, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 96, 60, 0)" but got "rgba(131, 95, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 96, 60, 0.2)" but got "rgba(131, 95, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 96, 60)" but got "rgb(131, 95, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 50%) assert_equals: expected "rgb(175, 128, 80)" but got "rgb(175, 127, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 128, 80, 0)" but got "rgba(175, 127, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 128, 80, 0.2)" but got "rgba(175, 127, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 128, 80)" but got "rgb(175, 127, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 62.5%) assert_equals: expected "rgb(195, 159, 124)" but got "rgb(195, 159, 123)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 159, 124, 0)" but got "rgba(195, 159, 123, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 159, 124, 0.2)" but got "rgba(195, 159, 123, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 159, 124)" but got "rgb(195, 159, 123)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 12.5%) assert_equals: expected "rgb(48, 32, 16)" but got "rgb(47, 31, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 32, 16, 0)" but got "rgba(47, 31, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 32, 16, 0.2)" but got "rgba(47, 31, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 32, 16)" but got "rgb(47, 31, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 25%) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(95, 63, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0) assert_equals: expected "rgba(96, 64, 32, 0)" but got "rgba(95, 63, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 64, 32, 0.2)" but got "rgba(95, 63, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 25%, 1) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(95, 63, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 37.5%) assert_equals: expected "rgb(143, 96, 48)" but got "rgb(143, 95, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 96, 48, 0)" but got "rgba(143, 95, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 96, 48, 0.2)" but got "rgba(143, 95, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 96, 48)" but got "rgb(143, 95, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 50%) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(191, 127, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0) assert_equals: expected "rgba(191, 128, 64, 0)" but got "rgba(191, 127, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 128, 64, 0.2)" but got "rgba(191, 127, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 50%, 1) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(191, 127, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 50%, 62.5%) assert_equals: expected "rgb(207, 159, 112)" but got "rgb(207, 159, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 159, 112, 0)" but got "rgba(207, 159, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 159, 112, 0.2)" but got "rgba(207, 159, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 159, 112)" but got "rgb(207, 159, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 12.5%) assert_equals: expected "rgb(52, 32, 12)" but got "rgb(51, 31, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 32, 12, 0)" but got "rgba(51, 31, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 32, 12, 0.2)" but got "rgba(51, 31, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 32, 12)" but got "rgb(51, 31, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 25%) assert_equals: expected "rgb(104, 64, 24)" but got "rgb(103, 63, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 64, 24, 0)" but got "rgba(103, 63, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 64, 24, 0.2)" but got "rgba(103, 63, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 64, 24)" but got "rgb(103, 63, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 37.5%) assert_equals: expected "rgb(155, 96, 36)" but got "rgb(155, 95, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 96, 36, 0)" but got "rgba(155, 95, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 96, 36, 0.2)" but got "rgba(155, 95, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 96, 36)" but got "rgb(155, 95, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 50%) assert_equals: expected "rgb(207, 128, 48)" but got "rgb(207, 127, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 128, 48, 0)" but got "rgba(207, 127, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 128, 48, 0.2)" but got "rgba(207, 127, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 128, 48)" but got "rgb(207, 127, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 62.5%) assert_equals: expected "rgb(219, 159, 100)" but got "rgb(219, 159, 99)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 159, 100, 0)" but got "rgba(219, 159, 99, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 159, 100, 0.2)" but got "rgba(219, 159, 99, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 159, 100)" but got "rgb(219, 159, 99)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 12.5%) assert_equals: expected "rgb(56, 32, 8)" but got "rgb(55, 31, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 32, 8, 0)" but got "rgba(55, 31, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 32, 8, 0.2)" but got "rgba(55, 31, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 32, 8)" but got "rgb(55, 31, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 25%) assert_equals: expected "rgb(112, 64, 16)" but got "rgb(111, 63, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0) assert_equals: expected "rgba(112, 64, 16, 0)" but got "rgba(111, 63, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 64, 16, 0.2)" but got "rgba(111, 63, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 25%, 1) assert_equals: expected "rgb(112, 64, 16)" but got "rgb(111, 63, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 37.5%) assert_equals: expected "rgb(167, 96, 24)" but got "rgb(167, 95, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 96, 24, 0)" but got "rgba(167, 95, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 96, 24, 0.2)" but got "rgba(167, 95, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 96, 24)" but got "rgb(167, 95, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 50%) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(223, 127, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0) assert_equals: expected "rgba(223, 128, 32, 0)" but got "rgba(223, 127, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 128, 32, 0.2)" but got "rgba(223, 127, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 50%, 1) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(223, 127, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 75%, 62.5%) assert_equals: expected "rgb(231, 159, 88)" but got "rgb(231, 159, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 159, 88, 0)" but got "rgba(231, 159, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 159, 88, 0.2)" but got "rgba(231, 159, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 159, 88)" but got "rgb(231, 159, 87)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 12.5%) assert_equals: expected "rgb(60, 32, 4)" but got "rgb(59, 31, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 32, 4, 0)" but got "rgba(59, 31, 3, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 32, 4, 0.2)" but got "rgba(59, 31, 3, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 32, 4)" but got "rgb(59, 31, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 25%) assert_equals: expected "rgb(120, 64, 8)" but got "rgb(119, 63, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 64, 8, 0)" but got "rgba(119, 63, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 64, 8, 0.2)" but got "rgba(119, 63, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 64, 8)" but got "rgb(119, 63, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 37.5%) assert_equals: expected "rgb(179, 96, 12)" but got "rgb(179, 95, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 96, 12, 0)" but got "rgba(179, 95, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 96, 12, 0.2)" but got "rgba(179, 95, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 96, 12)" but got "rgb(179, 95, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 50%) assert_equals: expected "rgb(239, 128, 16)" but got "rgb(239, 127, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 128, 16, 0)" but got "rgba(239, 127, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 128, 16, 0.2)" but got "rgba(239, 127, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 128, 16)" but got "rgb(239, 127, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 62.5%) assert_equals: expected "rgb(243, 159, 76)" but got "rgb(243, 159, 75)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 159, 76, 0)" but got "rgba(243, 159, 75, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 159, 76, 0.2)" but got "rgba(243, 159, 75, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 159, 76)" but got "rgb(243, 159, 75)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 12.5%) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(63, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 32, 0, 0)" but got "rgba(63, 31, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 32, 0, 0.2)" but got "rgba(63, 31, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(63, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 25%) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(127, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0) assert_equals: expected "rgba(128, 64, 0, 0)" but got "rgba(127, 63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 64, 0, 0.2)" but got "rgba(127, 63, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 25%, 1) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(127, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 37.5%) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(191, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0) assert_equals: expected "rgba(191, 96, 0, 0)" but got "rgba(191, 95, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 0.2) assert_equals: expected "rgba(191, 96, 0, 0.2)" but got "rgba(191, 95, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 37.5%, 1) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(191, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 50%) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(255, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0) assert_equals: expected "rgba(255, 128, 0, 0)" but got "rgba(255, 127, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 0.2) assert_equals: expected "rgba(255, 128, 0, 0.2)" but got "rgba(255, 127, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 50%, 1) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(255, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 62.5%) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(255, 159, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 159, 64, 0)" but got "rgba(255, 159, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 159, 64, 0.2)" but got "rgba(255, 159, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(255, 159, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(30, 100%, 75%) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(255, 191, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0) assert_equals: expected "rgba(255, 191, 128, 0)" but got "rgba(255, 191, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 191, 128, 0.2)" but got "rgba(255, 191, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(30, 100%, 75%, 1) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(255, 191, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(30, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(30, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 12.5%) assert_equals: expected "rgb(36, 36, 28)" but got "rgb(35, 35, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 36, 28, 0)" but got "rgba(35, 35, 27, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 36, 28, 0.2)" but got "rgba(35, 35, 27, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 36, 28)" but got "rgb(35, 35, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 25%) assert_equals: expected "rgb(72, 72, 56)" but got "rgb(71, 71, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 72, 56, 0)" but got "rgba(71, 71, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 72, 56, 0.2)" but got "rgba(71, 71, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 72, 56)" but got "rgb(71, 71, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 37.5%) assert_equals: expected "rgb(108, 108, 84)" but got "rgb(107, 107, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 108, 84, 0)" but got "rgba(107, 107, 83, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 108, 84, 0.2)" but got "rgba(107, 107, 83, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 108, 84)" but got "rgb(107, 107, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 50%) assert_equals: expected "rgb(143, 143, 112)" but got "rgb(143, 143, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 143, 112, 0)" but got "rgba(143, 143, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 143, 112, 0.2)" but got "rgba(143, 143, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 143, 112)" but got "rgb(143, 143, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 12.5%) assert_equals: expected "rgb(40, 40, 24)" but got "rgb(39, 39, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 40, 24, 0)" but got "rgba(39, 39, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 40, 24, 0.2)" but got "rgba(39, 39, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 40, 24)" but got "rgb(39, 39, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 25%) assert_equals: expected "rgb(80, 80, 48)" but got "rgb(79, 79, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0) assert_equals: expected "rgba(80, 80, 48, 0)" but got "rgba(79, 79, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 80, 48, 0.2)" but got "rgba(79, 79, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 25%, 1) assert_equals: expected "rgb(80, 80, 48)" but got "rgb(79, 79, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 37.5%) assert_equals: expected "rgb(120, 120, 72)" but got "rgb(119, 119, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 120, 72, 0)" but got "rgba(119, 119, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 120, 72, 0.2)" but got "rgba(119, 119, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 120, 72)" but got "rgb(119, 119, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 25%, 50%) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(159, 159, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0) assert_equals: expected "rgba(159, 159, 96, 0)" but got "rgba(159, 159, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 159, 96, 0.2)" but got "rgba(159, 159, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 25%, 50%, 1) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(159, 159, 95)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 12.5%) assert_equals: expected "rgb(44, 44, 20)" but got "rgb(43, 43, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 44, 20, 0)" but got "rgba(43, 43, 19, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 44, 20, 0.2)" but got "rgba(43, 43, 19, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 44, 20)" but got "rgb(43, 43, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 25%) assert_equals: expected "rgb(88, 88, 40)" but got "rgb(87, 87, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 88, 40, 0)" but got "rgba(87, 87, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 88, 40, 0.2)" but got "rgba(87, 87, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 88, 40)" but got "rgb(87, 87, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 37.5%) assert_equals: expected "rgb(131, 131, 60)" but got "rgb(131, 131, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 131, 60, 0)" but got "rgba(131, 131, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 131, 60, 0.2)" but got "rgba(131, 131, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 131, 60)" but got "rgb(131, 131, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 50%) assert_equals: expected "rgb(175, 175, 80)" but got "rgb(175, 175, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 175, 80, 0)" but got "rgba(175, 175, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 175, 80, 0.2)" but got "rgba(175, 175, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 175, 80)" but got "rgb(175, 175, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 62.5%) assert_equals: expected "rgb(195, 195, 124)" but got "rgb(195, 195, 123)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 195, 124, 0)" but got "rgba(195, 195, 123, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 195, 124, 0.2)" but got "rgba(195, 195, 123, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 195, 124)" but got "rgb(195, 195, 123)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 12.5%) assert_equals: expected "rgb(48, 48, 16)" but got "rgb(47, 47, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 48, 16, 0)" but got "rgba(47, 47, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 48, 16, 0.2)" but got "rgba(47, 47, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 48, 16)" but got "rgb(47, 47, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 25%) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(95, 95, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0) assert_equals: expected "rgba(96, 96, 32, 0)" but got "rgba(95, 95, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 96, 32, 0.2)" but got "rgba(95, 95, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 25%, 1) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(95, 95, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 37.5%) assert_equals: expected "rgb(143, 143, 48)" but got "rgb(143, 143, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 143, 48, 0)" but got "rgba(143, 143, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 143, 48, 0.2)" but got "rgba(143, 143, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 143, 48)" but got "rgb(143, 143, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 50%) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(191, 191, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0) assert_equals: expected "rgba(191, 191, 64, 0)" but got "rgba(191, 191, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 191, 64, 0.2)" but got "rgba(191, 191, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 50%, 1) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(191, 191, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 50%, 62.5%) assert_equals: expected "rgb(207, 207, 112)" but got "rgb(207, 207, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 207, 112, 0)" but got "rgba(207, 207, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 207, 112, 0.2)" but got "rgba(207, 207, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 207, 112)" but got "rgb(207, 207, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 12.5%) assert_equals: expected "rgb(52, 52, 12)" but got "rgb(51, 51, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 52, 12, 0)" but got "rgba(51, 51, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 52, 12, 0.2)" but got "rgba(51, 51, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 52, 12)" but got "rgb(51, 51, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 25%) assert_equals: expected "rgb(104, 104, 24)" but got "rgb(103, 103, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 104, 24, 0)" but got "rgba(103, 103, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 104, 24, 0.2)" but got "rgba(103, 103, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 104, 24)" but got "rgb(103, 103, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 37.5%) assert_equals: expected "rgb(155, 155, 36)" but got "rgb(155, 155, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 155, 36, 0)" but got "rgba(155, 155, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 155, 36, 0.2)" but got "rgba(155, 155, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 155, 36)" but got "rgb(155, 155, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 50%) assert_equals: expected "rgb(207, 207, 48)" but got "rgb(207, 207, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 207, 48, 0)" but got "rgba(207, 207, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 207, 48, 0.2)" but got "rgba(207, 207, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 207, 48)" but got "rgb(207, 207, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 62.5%) assert_equals: expected "rgb(219, 219, 100)" but got "rgb(219, 219, 99)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 219, 100, 0)" but got "rgba(219, 219, 99, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 219, 100, 0.2)" but got "rgba(219, 219, 99, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 219, 100)" but got "rgb(219, 219, 99)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 12.5%) assert_equals: expected "rgb(56, 56, 8)" but got "rgb(55, 55, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 56, 8, 0)" but got "rgba(55, 55, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 56, 8, 0.2)" but got "rgba(55, 55, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 56, 8)" but got "rgb(55, 55, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 25%) assert_equals: expected "rgb(112, 112, 16)" but got "rgb(111, 111, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0) assert_equals: expected "rgba(112, 112, 16, 0)" but got "rgba(111, 111, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 112, 16, 0.2)" but got "rgba(111, 111, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 25%, 1) assert_equals: expected "rgb(112, 112, 16)" but got "rgb(111, 111, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 37.5%) assert_equals: expected "rgb(167, 167, 24)" but got "rgb(167, 167, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 167, 24, 0)" but got "rgba(167, 167, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 167, 24, 0.2)" but got "rgba(167, 167, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 167, 24)" but got "rgb(167, 167, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 50%) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(223, 223, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0) assert_equals: expected "rgba(223, 223, 32, 0)" but got "rgba(223, 223, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 223, 32, 0.2)" but got "rgba(223, 223, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 50%, 1) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(223, 223, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 75%, 62.5%) assert_equals: expected "rgb(231, 231, 88)" but got "rgb(231, 231, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 231, 88, 0)" but got "rgba(231, 231, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 231, 88, 0.2)" but got "rgba(231, 231, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 231, 88)" but got "rgb(231, 231, 87)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 12.5%) assert_equals: expected "rgb(60, 60, 4)" but got "rgb(59, 59, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 60, 4, 0)" but got "rgba(59, 59, 3, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 60, 4, 0.2)" but got "rgba(59, 59, 3, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 60, 4)" but got "rgb(59, 59, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 25%) assert_equals: expected "rgb(120, 120, 8)" but got "rgb(119, 119, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 120, 8, 0)" but got "rgba(119, 119, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 120, 8, 0.2)" but got "rgba(119, 119, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 120, 8)" but got "rgb(119, 119, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 37.5%) assert_equals: expected "rgb(179, 179, 12)" but got "rgb(179, 179, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 179, 12, 0)" but got "rgba(179, 179, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 179, 12, 0.2)" but got "rgba(179, 179, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 179, 12)" but got "rgb(179, 179, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 50%) assert_equals: expected "rgb(239, 239, 16)" but got "rgb(239, 239, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 239, 16, 0)" but got "rgba(239, 239, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 239, 16, 0.2)" but got "rgba(239, 239, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 239, 16)" but got "rgb(239, 239, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 62.5%) assert_equals: expected "rgb(243, 243, 76)" but got "rgb(243, 243, 75)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 243, 76, 0)" but got "rgba(243, 243, 75, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 243, 76, 0.2)" but got "rgba(243, 243, 75, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 243, 76)" but got "rgb(243, 243, 75)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 12.5%) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 64, 0, 0)" but got "rgba(63, 63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 64, 0, 0.2)" but got "rgba(63, 63, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 25%) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0) assert_equals: expected "rgba(128, 128, 0, 0)" but got "rgba(127, 127, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 128, 0, 0.2)" but got "rgba(127, 127, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 25%, 1) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(127, 127, 0)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 37.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 37.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 37.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 37.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 50%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 50%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 62.5%) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(255, 255, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 255, 64, 0)" but got "rgba(255, 255, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 255, 64, 0.2)" but got "rgba(255, 255, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(255, 255, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(60, 100%, 75%) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(255, 255, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0) assert_equals: expected "rgba(255, 255, 128, 0)" but got "rgba(255, 255, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 255, 128, 0.2)" but got "rgba(255, 255, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(60, 100%, 75%, 1) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(255, 255, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(60, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(60, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 12.5%) assert_equals: expected "rgb(32, 36, 28)" but got "rgb(31, 35, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0) assert_equals: expected "rgba(32, 36, 28, 0)" but got "rgba(31, 35, 27, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 36, 28, 0.2)" but got "rgba(31, 35, 27, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 12.5%, 1) assert_equals: expected "rgb(32, 36, 28)" but got "rgb(31, 35, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 25%) assert_equals: expected "rgb(64, 72, 56)" but got "rgb(63, 71, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0) assert_equals: expected "rgba(64, 72, 56, 0)" but got "rgba(63, 71, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 0.2) assert_equals: expected "rgba(64, 72, 56, 0.2)" but got "rgba(63, 71, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 25%, 1) assert_equals: expected "rgb(64, 72, 56)" but got "rgb(63, 71, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 37.5%) assert_equals: expected "rgb(96, 108, 84)" but got "rgb(95, 107, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0) assert_equals: expected "rgba(96, 108, 84, 0)" but got "rgba(95, 107, 83, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 108, 84, 0.2)" but got "rgba(95, 107, 83, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 37.5%, 1) assert_equals: expected "rgb(96, 108, 84)" but got "rgb(95, 107, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 50%) assert_equals: expected "rgb(128, 143, 112)" but got "rgb(127, 143, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0) assert_equals: expected "rgba(128, 143, 112, 0)" but got "rgba(127, 143, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 0.2) assert_equals: expected "rgba(128, 143, 112, 0.2)" but got "rgba(127, 143, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 50%, 1) assert_equals: expected "rgb(128, 143, 112)" but got "rgb(127, 143, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 12.5%) assert_equals: expected "rgb(32, 40, 24)" but got "rgb(31, 39, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0) assert_equals: expected "rgba(32, 40, 24, 0)" but got "rgba(31, 39, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 0.2) assert_equals: expected "rgba(32, 40, 24, 0.2)" but got "rgba(31, 39, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 12.5%, 1) assert_equals: expected "rgb(32, 40, 24)" but got "rgb(31, 39, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 25%) assert_equals: expected "rgb(64, 80, 48)" but got "rgb(63, 79, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0) assert_equals: expected "rgba(64, 80, 48, 0)" but got "rgba(63, 79, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 0.2) assert_equals: expected "rgba(64, 80, 48, 0.2)" but got "rgba(63, 79, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 25%, 1) assert_equals: expected "rgb(64, 80, 48)" but got "rgb(63, 79, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 37.5%) assert_equals: expected "rgb(96, 120, 72)" but got "rgb(95, 119, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0) assert_equals: expected "rgba(96, 120, 72, 0)" but got "rgba(95, 119, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 0.2) assert_equals: expected "rgba(96, 120, 72, 0.2)" but got "rgba(95, 119, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 37.5%, 1) assert_equals: expected "rgb(96, 120, 72)" but got "rgb(95, 119, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 25%, 50%) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(127, 159, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0) assert_equals: expected "rgba(128, 159, 96, 0)" but got "rgba(127, 159, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 0.2) assert_equals: expected "rgba(128, 159, 96, 0.2)" but got "rgba(127, 159, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 25%, 50%, 1) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(127, 159, 95)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 12.5%) assert_equals: expected "rgb(32, 44, 20)" but got "rgb(31, 43, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0) assert_equals: expected "rgba(32, 44, 20, 0)" but got "rgba(31, 43, 19, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 44, 20, 0.2)" but got "rgba(31, 43, 19, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 12.5%, 1) assert_equals: expected "rgb(32, 44, 20)" but got "rgb(31, 43, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 25%) assert_equals: expected "rgb(64, 88, 40)" but got "rgb(63, 87, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0) assert_equals: expected "rgba(64, 88, 40, 0)" but got "rgba(63, 87, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 0.2) assert_equals: expected "rgba(64, 88, 40, 0.2)" but got "rgba(63, 87, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 25%, 1) assert_equals: expected "rgb(64, 88, 40)" but got "rgb(63, 87, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 37.5%) assert_equals: expected "rgb(96, 131, 60)" but got "rgb(95, 131, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0) assert_equals: expected "rgba(96, 131, 60, 0)" but got "rgba(95, 131, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 131, 60, 0.2)" but got "rgba(95, 131, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 37.5%, 1) assert_equals: expected "rgb(96, 131, 60)" but got "rgb(95, 131, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 50%) assert_equals: expected "rgb(128, 175, 80)" but got "rgb(127, 175, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0) assert_equals: expected "rgba(128, 175, 80, 0)" but got "rgba(127, 175, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 0.2) assert_equals: expected "rgba(128, 175, 80, 0.2)" but got "rgba(127, 175, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 50%, 1) assert_equals: expected "rgb(128, 175, 80)" but got "rgb(127, 175, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 62.5%) assert_equals: expected "rgb(159, 195, 124)" but got "rgb(159, 195, 123)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0) assert_equals: expected "rgba(159, 195, 124, 0)" but got "rgba(159, 195, 123, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 195, 124, 0.2)" but got "rgba(159, 195, 123, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 62.5%, 1) assert_equals: expected "rgb(159, 195, 124)" but got "rgb(159, 195, 123)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 12.5%) assert_equals: expected "rgb(32, 48, 16)" but got "rgb(31, 47, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0) assert_equals: expected "rgba(32, 48, 16, 0)" but got "rgba(31, 47, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 0.2) assert_equals: expected "rgba(32, 48, 16, 0.2)" but got "rgba(31, 47, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 12.5%, 1) assert_equals: expected "rgb(32, 48, 16)" but got "rgb(31, 47, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 25%) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(63, 95, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0) assert_equals: expected "rgba(64, 96, 32, 0)" but got "rgba(63, 95, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 0.2) assert_equals: expected "rgba(64, 96, 32, 0.2)" but got "rgba(63, 95, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 25%, 1) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(63, 95, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 37.5%) assert_equals: expected "rgb(96, 143, 48)" but got "rgb(95, 143, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0) assert_equals: expected "rgba(96, 143, 48, 0)" but got "rgba(95, 143, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 0.2) assert_equals: expected "rgba(96, 143, 48, 0.2)" but got "rgba(95, 143, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 37.5%, 1) assert_equals: expected "rgb(96, 143, 48)" but got "rgb(95, 143, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 50%) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(127, 191, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0) assert_equals: expected "rgba(128, 191, 64, 0)" but got "rgba(127, 191, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 0.2) assert_equals: expected "rgba(128, 191, 64, 0.2)" but got "rgba(127, 191, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 50%, 1) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(127, 191, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 50%, 62.5%) assert_equals: expected "rgb(159, 207, 112)" but got "rgb(159, 207, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0) assert_equals: expected "rgba(159, 207, 112, 0)" but got "rgba(159, 207, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 0.2) assert_equals: expected "rgba(159, 207, 112, 0.2)" but got "rgba(159, 207, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 50%, 62.5%, 1) assert_equals: expected "rgb(159, 207, 112)" but got "rgb(159, 207, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 12.5%) assert_equals: expected "rgb(32, 52, 12)" but got "rgb(31, 51, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0) assert_equals: expected "rgba(32, 52, 12, 0)" but got "rgba(31, 51, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 52, 12, 0.2)" but got "rgba(31, 51, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 12.5%, 1) assert_equals: expected "rgb(32, 52, 12)" but got "rgb(31, 51, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 25%) assert_equals: expected "rgb(64, 104, 24)" but got "rgb(63, 103, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0) assert_equals: expected "rgba(64, 104, 24, 0)" but got "rgba(63, 103, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 0.2) assert_equals: expected "rgba(64, 104, 24, 0.2)" but got "rgba(63, 103, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 25%, 1) assert_equals: expected "rgb(64, 104, 24)" but got "rgb(63, 103, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 37.5%) assert_equals: expected "rgb(96, 155, 36)" but got "rgb(95, 155, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0) assert_equals: expected "rgba(96, 155, 36, 0)" but got "rgba(95, 155, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 155, 36, 0.2)" but got "rgba(95, 155, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 37.5%, 1) assert_equals: expected "rgb(96, 155, 36)" but got "rgb(95, 155, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 50%) assert_equals: expected "rgb(128, 207, 48)" but got "rgb(127, 207, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0) assert_equals: expected "rgba(128, 207, 48, 0)" but got "rgba(127, 207, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 0.2) assert_equals: expected "rgba(128, 207, 48, 0.2)" but got "rgba(127, 207, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 50%, 1) assert_equals: expected "rgb(128, 207, 48)" but got "rgb(127, 207, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 62.5%) assert_equals: expected "rgb(159, 219, 100)" but got "rgb(159, 219, 99)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0) assert_equals: expected "rgba(159, 219, 100, 0)" but got "rgba(159, 219, 99, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 219, 100, 0.2)" but got "rgba(159, 219, 99, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 62.5%, 1) assert_equals: expected "rgb(159, 219, 100)" but got "rgb(159, 219, 99)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 12.5%) assert_equals: expected "rgb(32, 56, 8)" but got "rgb(31, 55, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0) assert_equals: expected "rgba(32, 56, 8, 0)" but got "rgba(31, 55, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 0.2) assert_equals: expected "rgba(32, 56, 8, 0.2)" but got "rgba(31, 55, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 12.5%, 1) assert_equals: expected "rgb(32, 56, 8)" but got "rgb(31, 55, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 25%) assert_equals: expected "rgb(64, 112, 16)" but got "rgb(63, 111, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0) assert_equals: expected "rgba(64, 112, 16, 0)" but got "rgba(63, 111, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 0.2) assert_equals: expected "rgba(64, 112, 16, 0.2)" but got "rgba(63, 111, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 25%, 1) assert_equals: expected "rgb(64, 112, 16)" but got "rgb(63, 111, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 37.5%) assert_equals: expected "rgb(96, 167, 24)" but got "rgb(95, 167, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0) assert_equals: expected "rgba(96, 167, 24, 0)" but got "rgba(95, 167, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 0.2) assert_equals: expected "rgba(96, 167, 24, 0.2)" but got "rgba(95, 167, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 37.5%, 1) assert_equals: expected "rgb(96, 167, 24)" but got "rgb(95, 167, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 50%) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(127, 223, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0) assert_equals: expected "rgba(128, 223, 32, 0)" but got "rgba(127, 223, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 0.2) assert_equals: expected "rgba(128, 223, 32, 0.2)" but got "rgba(127, 223, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 50%, 1) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(127, 223, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 75%, 62.5%) assert_equals: expected "rgb(159, 231, 88)" but got "rgb(159, 231, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0) assert_equals: expected "rgba(159, 231, 88, 0)" but got "rgba(159, 231, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 0.2) assert_equals: expected "rgba(159, 231, 88, 0.2)" but got "rgba(159, 231, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 75%, 62.5%, 1) assert_equals: expected "rgb(159, 231, 88)" but got "rgb(159, 231, 87)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 12.5%) assert_equals: expected "rgb(32, 60, 4)" but got "rgb(31, 59, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0) assert_equals: expected "rgba(32, 60, 4, 0)" but got "rgba(31, 59, 3, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 60, 4, 0.2)" but got "rgba(31, 59, 3, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 12.5%, 1) assert_equals: expected "rgb(32, 60, 4)" but got "rgb(31, 59, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 25%) assert_equals: expected "rgb(64, 120, 8)" but got "rgb(63, 119, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0) assert_equals: expected "rgba(64, 120, 8, 0)" but got "rgba(63, 119, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 0.2) assert_equals: expected "rgba(64, 120, 8, 0.2)" but got "rgba(63, 119, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 25%, 1) assert_equals: expected "rgb(64, 120, 8)" but got "rgb(63, 119, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 37.5%) assert_equals: expected "rgb(96, 179, 12)" but got "rgb(95, 179, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0) assert_equals: expected "rgba(96, 179, 12, 0)" but got "rgba(95, 179, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 179, 12, 0.2)" but got "rgba(95, 179, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 37.5%, 1) assert_equals: expected "rgb(96, 179, 12)" but got "rgb(95, 179, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 50%) assert_equals: expected "rgb(128, 239, 16)" but got "rgb(127, 239, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0) assert_equals: expected "rgba(128, 239, 16, 0)" but got "rgba(127, 239, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 0.2) assert_equals: expected "rgba(128, 239, 16, 0.2)" but got "rgba(127, 239, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 50%, 1) assert_equals: expected "rgb(128, 239, 16)" but got "rgb(127, 239, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 62.5%) assert_equals: expected "rgb(159, 243, 76)" but got "rgb(159, 243, 75)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0) assert_equals: expected "rgba(159, 243, 76, 0)" but got "rgba(159, 243, 75, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 243, 76, 0.2)" but got "rgba(159, 243, 75, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 62.5%, 1) assert_equals: expected "rgb(159, 243, 76)" but got "rgb(159, 243, 75)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 12.5%) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(31, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0) assert_equals: expected "rgba(32, 64, 0, 0)" but got "rgba(31, 63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 0.2) assert_equals: expected "rgba(32, 64, 0, 0.2)" but got "rgba(31, 63, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 12.5%, 1) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(31, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 25%) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(63, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0) assert_equals: expected "rgba(64, 128, 0, 0)" but got "rgba(63, 127, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 0.2) assert_equals: expected "rgba(64, 128, 0, 0.2)" but got "rgba(63, 127, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 25%, 1) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(63, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 37.5%) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(95, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0) assert_equals: expected "rgba(96, 191, 0, 0)" but got "rgba(95, 191, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 0.2) assert_equals: expected "rgba(96, 191, 0, 0.2)" but got "rgba(95, 191, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 37.5%, 1) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(95, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 50%) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(127, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0) assert_equals: expected "rgba(128, 255, 0, 0)" but got "rgba(127, 255, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 0.2) assert_equals: expected "rgba(128, 255, 0, 0.2)" but got "rgba(127, 255, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 50%, 1) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(127, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 62.5%) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(159, 255, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0) assert_equals: expected "rgba(159, 255, 64, 0)" but got "rgba(159, 255, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 0.2) assert_equals: expected "rgba(159, 255, 64, 0.2)" but got "rgba(159, 255, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 62.5%, 1) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(159, 255, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(90, 100%, 75%) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(191, 255, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0) assert_equals: expected "rgba(191, 255, 128, 0)" but got "rgba(191, 255, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 0.2) assert_equals: expected "rgba(191, 255, 128, 0.2)" but got "rgba(191, 255, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(90, 100%, 75%, 1) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(191, 255, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(90, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(90, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 12.5%) assert_equals: expected "rgb(28, 36, 28)" but got "rgb(27, 35, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 36, 28, 0)" but got "rgba(27, 35, 27, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 36, 28, 0.2)" but got "rgba(27, 35, 27, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 36, 28)" but got "rgb(27, 35, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 25%) assert_equals: expected "rgb(56, 72, 56)" but got "rgb(55, 71, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 72, 56, 0)" but got "rgba(55, 71, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 72, 56, 0.2)" but got "rgba(55, 71, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 72, 56)" but got "rgb(55, 71, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 37.5%) assert_equals: expected "rgb(84, 108, 84)" but got "rgb(83, 107, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 108, 84, 0)" but got "rgba(83, 107, 83, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 108, 84, 0.2)" but got "rgba(83, 107, 83, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 108, 84)" but got "rgb(83, 107, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 50%) assert_equals: expected "rgb(112, 143, 112)" but got "rgb(111, 143, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 143, 112, 0)" but got "rgba(111, 143, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 143, 112, 0.2)" but got "rgba(111, 143, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 143, 112)" but got "rgb(111, 143, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 12.5%) assert_equals: expected "rgb(24, 40, 24)" but got "rgb(23, 39, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 40, 24, 0)" but got "rgba(23, 39, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 40, 24, 0.2)" but got "rgba(23, 39, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 40, 24)" but got "rgb(23, 39, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 25%) assert_equals: expected "rgb(48, 80, 48)" but got "rgb(47, 79, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0) assert_equals: expected "rgba(48, 80, 48, 0)" but got "rgba(47, 79, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 80, 48, 0.2)" but got "rgba(47, 79, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 25%, 1) assert_equals: expected "rgb(48, 80, 48)" but got "rgb(47, 79, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 37.5%) assert_equals: expected "rgb(72, 120, 72)" but got "rgb(71, 119, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 120, 72, 0)" but got "rgba(71, 119, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 120, 72, 0.2)" but got "rgba(71, 119, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 120, 72)" but got "rgb(71, 119, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 25%, 50%) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(95, 159, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0) assert_equals: expected "rgba(96, 159, 96, 0)" but got "rgba(95, 159, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 159, 96, 0.2)" but got "rgba(95, 159, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 25%, 50%, 1) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(95, 159, 95)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 12.5%) assert_equals: expected "rgb(20, 44, 20)" but got "rgb(19, 43, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 44, 20, 0)" but got "rgba(19, 43, 19, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 44, 20, 0.2)" but got "rgba(19, 43, 19, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 44, 20)" but got "rgb(19, 43, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 25%) assert_equals: expected "rgb(40, 88, 40)" but got "rgb(39, 87, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 88, 40, 0)" but got "rgba(39, 87, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 88, 40, 0.2)" but got "rgba(39, 87, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 88, 40)" but got "rgb(39, 87, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 37.5%) assert_equals: expected "rgb(60, 131, 60)" but got "rgb(59, 131, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 131, 60, 0)" but got "rgba(59, 131, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 131, 60, 0.2)" but got "rgba(59, 131, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 131, 60)" but got "rgb(59, 131, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 50%) assert_equals: expected "rgb(80, 175, 80)" but got "rgb(79, 175, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 175, 80, 0)" but got "rgba(79, 175, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 175, 80, 0.2)" but got "rgba(79, 175, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 175, 80)" but got "rgb(79, 175, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 62.5%) assert_equals: expected "rgb(124, 195, 124)" but got "rgb(123, 195, 123)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 195, 124, 0)" but got "rgba(123, 195, 123, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 195, 124, 0.2)" but got "rgba(123, 195, 123, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 195, 124)" but got "rgb(123, 195, 123)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 12.5%) assert_equals: expected "rgb(16, 48, 16)" but got "rgb(15, 47, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 48, 16, 0)" but got "rgba(15, 47, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 48, 16, 0.2)" but got "rgba(15, 47, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 48, 16)" but got "rgb(15, 47, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 25%) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(31, 95, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0) assert_equals: expected "rgba(32, 96, 32, 0)" but got "rgba(31, 95, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 96, 32, 0.2)" but got "rgba(31, 95, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 25%, 1) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(31, 95, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 37.5%) assert_equals: expected "rgb(48, 143, 48)" but got "rgb(47, 143, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 143, 48, 0)" but got "rgba(47, 143, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 143, 48, 0.2)" but got "rgba(47, 143, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 143, 48)" but got "rgb(47, 143, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 50%) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(63, 191, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0) assert_equals: expected "rgba(64, 191, 64, 0)" but got "rgba(63, 191, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 191, 64, 0.2)" but got "rgba(63, 191, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 50%, 1) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(63, 191, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 50%, 62.5%) assert_equals: expected "rgb(112, 207, 112)" but got "rgb(111, 207, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 207, 112, 0)" but got "rgba(111, 207, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 207, 112, 0.2)" but got "rgba(111, 207, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 207, 112)" but got "rgb(111, 207, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 12.5%) assert_equals: expected "rgb(12, 52, 12)" but got "rgb(11, 51, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 52, 12, 0)" but got "rgba(11, 51, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 52, 12, 0.2)" but got "rgba(11, 51, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 52, 12)" but got "rgb(11, 51, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 25%) assert_equals: expected "rgb(24, 104, 24)" but got "rgb(23, 103, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 104, 24, 0)" but got "rgba(23, 103, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 104, 24, 0.2)" but got "rgba(23, 103, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 104, 24)" but got "rgb(23, 103, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 37.5%) assert_equals: expected "rgb(36, 155, 36)" but got "rgb(35, 155, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 155, 36, 0)" but got "rgba(35, 155, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 155, 36, 0.2)" but got "rgba(35, 155, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 155, 36)" but got "rgb(35, 155, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 50%) assert_equals: expected "rgb(48, 207, 48)" but got "rgb(47, 207, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 207, 48, 0)" but got "rgba(47, 207, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 207, 48, 0.2)" but got "rgba(47, 207, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 207, 48)" but got "rgb(47, 207, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 62.5%) assert_equals: expected "rgb(100, 219, 100)" but got "rgb(99, 219, 99)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 219, 100, 0)" but got "rgba(99, 219, 99, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 219, 100, 0.2)" but got "rgba(99, 219, 99, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 219, 100)" but got "rgb(99, 219, 99)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 12.5%) assert_equals: expected "rgb(8, 56, 8)" but got "rgb(7, 55, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 56, 8, 0)" but got "rgba(7, 55, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 56, 8, 0.2)" but got "rgba(7, 55, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 56, 8)" but got "rgb(7, 55, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 25%) assert_equals: expected "rgb(16, 112, 16)" but got "rgb(15, 111, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0) assert_equals: expected "rgba(16, 112, 16, 0)" but got "rgba(15, 111, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 112, 16, 0.2)" but got "rgba(15, 111, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 25%, 1) assert_equals: expected "rgb(16, 112, 16)" but got "rgb(15, 111, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 37.5%) assert_equals: expected "rgb(24, 167, 24)" but got "rgb(23, 167, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 167, 24, 0)" but got "rgba(23, 167, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 167, 24, 0.2)" but got "rgba(23, 167, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 167, 24)" but got "rgb(23, 167, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 50%) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(31, 223, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0) assert_equals: expected "rgba(32, 223, 32, 0)" but got "rgba(31, 223, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 223, 32, 0.2)" but got "rgba(31, 223, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 50%, 1) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(31, 223, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 75%, 62.5%) assert_equals: expected "rgb(88, 231, 88)" but got "rgb(87, 231, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 231, 88, 0)" but got "rgba(87, 231, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 231, 88, 0.2)" but got "rgba(87, 231, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 231, 88)" but got "rgb(87, 231, 87)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 12.5%) assert_equals: expected "rgb(4, 60, 4)" but got "rgb(3, 59, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 60, 4, 0)" but got "rgba(3, 59, 3, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 60, 4, 0.2)" but got "rgba(3, 59, 3, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 60, 4)" but got "rgb(3, 59, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 25%) assert_equals: expected "rgb(8, 120, 8)" but got "rgb(7, 119, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 120, 8, 0)" but got "rgba(7, 119, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 120, 8, 0.2)" but got "rgba(7, 119, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 120, 8)" but got "rgb(7, 119, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 37.5%) assert_equals: expected "rgb(12, 179, 12)" but got "rgb(11, 179, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 179, 12, 0)" but got "rgba(11, 179, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 179, 12, 0.2)" but got "rgba(11, 179, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 179, 12)" but got "rgb(11, 179, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 50%) assert_equals: expected "rgb(16, 239, 16)" but got "rgb(15, 239, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 239, 16, 0)" but got "rgba(15, 239, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 239, 16, 0.2)" but got "rgba(15, 239, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 239, 16)" but got "rgb(15, 239, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 62.5%) assert_equals: expected "rgb(76, 243, 76)" but got "rgb(75, 243, 75)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 243, 76, 0)" but got "rgba(75, 243, 75, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 243, 76, 0.2)" but got "rgba(75, 243, 75, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 243, 76)" but got "rgb(75, 243, 75)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 12.5%) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(0, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 64, 0, 0)" but got "rgba(0, 63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 64, 0, 0.2)" but got "rgba(0, 63, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(0, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 25%) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(0, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0) assert_equals: expected "rgba(0, 128, 0, 0)" but got "rgba(0, 127, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 128, 0, 0.2)" but got "rgba(0, 127, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 25%, 1) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(0, 127, 0)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 37.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 37.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 37.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 37.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 50%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 50%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 62.5%) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(63, 255, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 255, 64, 0)" but got "rgba(63, 255, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 255, 64, 0.2)" but got "rgba(63, 255, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(63, 255, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(120, 100%, 75%) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(127, 255, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0) assert_equals: expected "rgba(128, 255, 128, 0)" but got "rgba(127, 255, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 255, 128, 0.2)" but got "rgba(127, 255, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(120, 100%, 75%, 1) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(127, 255, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(120, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(120, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 12.5%) assert_equals: expected "rgb(28, 36, 36)" but got "rgb(27, 35, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 36, 36, 0)" but got "rgba(27, 35, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 36, 36, 0.2)" but got "rgba(27, 35, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 36, 36)" but got "rgb(27, 35, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 25%) assert_equals: expected "rgb(56, 72, 72)" but got "rgb(55, 71, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 72, 72, 0)" but got "rgba(55, 71, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 72, 72, 0.2)" but got "rgba(55, 71, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 72, 72)" but got "rgb(55, 71, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 37.5%) assert_equals: expected "rgb(84, 108, 108)" but got "rgb(83, 107, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 108, 108, 0)" but got "rgba(83, 107, 107, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 108, 108, 0.2)" but got "rgba(83, 107, 107, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 108, 108)" but got "rgb(83, 107, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 50%) assert_equals: expected "rgb(112, 143, 143)" but got "rgb(111, 143, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 143, 143, 0)" but got "rgba(111, 143, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 143, 143, 0.2)" but got "rgba(111, 143, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 143, 143)" but got "rgb(111, 143, 143)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 12.5%) assert_equals: expected "rgb(24, 40, 40)" but got "rgb(23, 39, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 40, 40, 0)" but got "rgba(23, 39, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 40, 40, 0.2)" but got "rgba(23, 39, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 40, 40)" but got "rgb(23, 39, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 25%) assert_equals: expected "rgb(48, 80, 80)" but got "rgb(47, 79, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0) assert_equals: expected "rgba(48, 80, 80, 0)" but got "rgba(47, 79, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 80, 80, 0.2)" but got "rgba(47, 79, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 25%, 1) assert_equals: expected "rgb(48, 80, 80)" but got "rgb(47, 79, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 37.5%) assert_equals: expected "rgb(72, 120, 120)" but got "rgb(71, 119, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 120, 120, 0)" but got "rgba(71, 119, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 120, 120, 0.2)" but got "rgba(71, 119, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 120, 120)" but got "rgb(71, 119, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 25%, 50%) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(95, 159, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0) assert_equals: expected "rgba(96, 159, 159, 0)" but got "rgba(95, 159, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 159, 159, 0.2)" but got "rgba(95, 159, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 25%, 50%, 1) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(95, 159, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 12.5%) assert_equals: expected "rgb(20, 44, 44)" but got "rgb(19, 43, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 44, 44, 0)" but got "rgba(19, 43, 43, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 44, 44, 0.2)" but got "rgba(19, 43, 43, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 44, 44)" but got "rgb(19, 43, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 25%) assert_equals: expected "rgb(40, 88, 88)" but got "rgb(39, 87, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 88, 88, 0)" but got "rgba(39, 87, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 88, 88, 0.2)" but got "rgba(39, 87, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 88, 88)" but got "rgb(39, 87, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 37.5%) assert_equals: expected "rgb(60, 131, 131)" but got "rgb(59, 131, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 131, 131, 0)" but got "rgba(59, 131, 131, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 131, 131, 0.2)" but got "rgba(59, 131, 131, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 131, 131)" but got "rgb(59, 131, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 50%) assert_equals: expected "rgb(80, 175, 175)" but got "rgb(79, 175, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 175, 175, 0)" but got "rgba(79, 175, 175, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 175, 175, 0.2)" but got "rgba(79, 175, 175, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 175, 175)" but got "rgb(79, 175, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 62.5%) assert_equals: expected "rgb(124, 195, 195)" but got "rgb(123, 195, 195)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 195, 195, 0)" but got "rgba(123, 195, 195, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 195, 195, 0.2)" but got "rgba(123, 195, 195, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 195, 195)" but got "rgb(123, 195, 195)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 12.5%) assert_equals: expected "rgb(16, 48, 48)" but got "rgb(15, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 48, 48, 0)" but got "rgba(15, 47, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 48, 48, 0.2)" but got "rgba(15, 47, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 48, 48)" but got "rgb(15, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 25%) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(31, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0) assert_equals: expected "rgba(32, 96, 96, 0)" but got "rgba(31, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 96, 96, 0.2)" but got "rgba(31, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 25%, 1) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(31, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 37.5%) assert_equals: expected "rgb(48, 143, 143)" but got "rgb(47, 143, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 143, 143, 0)" but got "rgba(47, 143, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 143, 143, 0.2)" but got "rgba(47, 143, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 143, 143)" but got "rgb(47, 143, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 50%) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(63, 191, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0) assert_equals: expected "rgba(64, 191, 191, 0)" but got "rgba(63, 191, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 191, 191, 0.2)" but got "rgba(63, 191, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 50%, 1) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(63, 191, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 50%, 62.5%) assert_equals: expected "rgb(112, 207, 207)" but got "rgb(111, 207, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 207, 207, 0)" but got "rgba(111, 207, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 207, 207, 0.2)" but got "rgba(111, 207, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 207, 207)" but got "rgb(111, 207, 207)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 12.5%) assert_equals: expected "rgb(12, 52, 52)" but got "rgb(11, 51, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 52, 52, 0)" but got "rgba(11, 51, 51, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 52, 52, 0.2)" but got "rgba(11, 51, 51, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 52, 52)" but got "rgb(11, 51, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 25%) assert_equals: expected "rgb(24, 104, 104)" but got "rgb(23, 103, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 104, 104, 0)" but got "rgba(23, 103, 103, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 104, 104, 0.2)" but got "rgba(23, 103, 103, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 104, 104)" but got "rgb(23, 103, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 37.5%) assert_equals: expected "rgb(36, 155, 155)" but got "rgb(35, 155, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 155, 155, 0)" but got "rgba(35, 155, 155, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 155, 155, 0.2)" but got "rgba(35, 155, 155, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 155, 155)" but got "rgb(35, 155, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 50%) assert_equals: expected "rgb(48, 207, 207)" but got "rgb(47, 207, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 207, 207, 0)" but got "rgba(47, 207, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 207, 207, 0.2)" but got "rgba(47, 207, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 207, 207)" but got "rgb(47, 207, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 62.5%) assert_equals: expected "rgb(100, 219, 219)" but got "rgb(99, 219, 219)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 219, 219, 0)" but got "rgba(99, 219, 219, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 219, 219, 0.2)" but got "rgba(99, 219, 219, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 219, 219)" but got "rgb(99, 219, 219)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 12.5%) assert_equals: expected "rgb(8, 56, 56)" but got "rgb(7, 55, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 56, 56, 0)" but got "rgba(7, 55, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 56, 56, 0.2)" but got "rgba(7, 55, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 56, 56)" but got "rgb(7, 55, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 25%) assert_equals: expected "rgb(16, 112, 112)" but got "rgb(15, 111, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0) assert_equals: expected "rgba(16, 112, 112, 0)" but got "rgba(15, 111, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 112, 112, 0.2)" but got "rgba(15, 111, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 25%, 1) assert_equals: expected "rgb(16, 112, 112)" but got "rgb(15, 111, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 37.5%) assert_equals: expected "rgb(24, 167, 167)" but got "rgb(23, 167, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 167, 167, 0)" but got "rgba(23, 167, 167, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 167, 167, 0.2)" but got "rgba(23, 167, 167, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 167, 167)" but got "rgb(23, 167, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 50%) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(31, 223, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0) assert_equals: expected "rgba(32, 223, 223, 0)" but got "rgba(31, 223, 223, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 223, 223, 0.2)" but got "rgba(31, 223, 223, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 50%, 1) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(31, 223, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 75%, 62.5%) assert_equals: expected "rgb(88, 231, 231)" but got "rgb(87, 231, 231)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 231, 231, 0)" but got "rgba(87, 231, 231, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 231, 231, 0.2)" but got "rgba(87, 231, 231, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 231, 231)" but got "rgb(87, 231, 231)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 12.5%) assert_equals: expected "rgb(4, 60, 60)" but got "rgb(3, 59, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 60, 60, 0)" but got "rgba(3, 59, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 60, 60, 0.2)" but got "rgba(3, 59, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 60, 60)" but got "rgb(3, 59, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 25%) assert_equals: expected "rgb(8, 120, 120)" but got "rgb(7, 119, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 120, 120, 0)" but got "rgba(7, 119, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 120, 120, 0.2)" but got "rgba(7, 119, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 120, 120)" but got "rgb(7, 119, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 37.5%) assert_equals: expected "rgb(12, 179, 179)" but got "rgb(11, 179, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 179, 179, 0)" but got "rgba(11, 179, 179, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 179, 179, 0.2)" but got "rgba(11, 179, 179, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 179, 179)" but got "rgb(11, 179, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 50%) assert_equals: expected "rgb(16, 239, 239)" but got "rgb(15, 239, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 239, 239, 0)" but got "rgba(15, 239, 239, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 239, 239, 0.2)" but got "rgba(15, 239, 239, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 239, 239)" but got "rgb(15, 239, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 62.5%) assert_equals: expected "rgb(76, 243, 243)" but got "rgb(75, 243, 243)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 243, 243, 0)" but got "rgba(75, 243, 243, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 243, 243, 0.2)" but got "rgba(75, 243, 243, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 243, 243)" but got "rgb(75, 243, 243)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 12.5%) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(0, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 64, 64, 0)" but got "rgba(0, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 64, 64, 0.2)" but got "rgba(0, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(0, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 25%) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(0, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0) assert_equals: expected "rgba(0, 128, 128, 0)" but got "rgba(0, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 128, 128, 0.2)" but got "rgba(0, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 25%, 1) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(0, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 37.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 37.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 37.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 37.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 50%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 50%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 62.5%) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(63, 255, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 255, 255, 0)" but got "rgba(63, 255, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 255, 255, 0.2)" but got "rgba(63, 255, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(63, 255, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsl(180, 100%, 75%) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(127, 255, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0) assert_equals: expected "rgba(128, 255, 255, 0)" but got "rgba(127, 255, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 255, 255, 0.2)" but got "rgba(127, 255, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(180, 100%, 75%, 1) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(127, 255, 255)"
PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(180, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(180, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 12.5%) assert_equals: expected "rgb(28, 32, 36)" but got "rgb(27, 31, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 32, 36, 0)" but got "rgba(27, 31, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 32, 36, 0.2)" but got "rgba(27, 31, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 32, 36)" but got "rgb(27, 31, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 25%) assert_equals: expected "rgb(56, 64, 72)" but got "rgb(55, 63, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 64, 72, 0)" but got "rgba(55, 63, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 64, 72, 0.2)" but got "rgba(55, 63, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 64, 72)" but got "rgb(55, 63, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 37.5%) assert_equals: expected "rgb(84, 96, 108)" but got "rgb(83, 95, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 96, 108, 0)" but got "rgba(83, 95, 107, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 96, 108, 0.2)" but got "rgba(83, 95, 107, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 96, 108)" but got "rgb(83, 95, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 50%) assert_equals: expected "rgb(112, 128, 143)" but got "rgb(111, 127, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 128, 143, 0)" but got "rgba(111, 127, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 128, 143, 0.2)" but got "rgba(111, 127, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 128, 143)" but got "rgb(111, 127, 143)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 12.5%) assert_equals: expected "rgb(24, 32, 40)" but got "rgb(23, 31, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 32, 40, 0)" but got "rgba(23, 31, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 32, 40, 0.2)" but got "rgba(23, 31, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 32, 40)" but got "rgb(23, 31, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 25%) assert_equals: expected "rgb(48, 64, 80)" but got "rgb(47, 63, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0) assert_equals: expected "rgba(48, 64, 80, 0)" but got "rgba(47, 63, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 64, 80, 0.2)" but got "rgba(47, 63, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 25%, 1) assert_equals: expected "rgb(48, 64, 80)" but got "rgb(47, 63, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 37.5%) assert_equals: expected "rgb(72, 96, 120)" but got "rgb(71, 95, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 96, 120, 0)" but got "rgba(71, 95, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 96, 120, 0.2)" but got "rgba(71, 95, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 96, 120)" but got "rgb(71, 95, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 25%, 50%) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(95, 127, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0) assert_equals: expected "rgba(96, 128, 159, 0)" but got "rgba(95, 127, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 128, 159, 0.2)" but got "rgba(95, 127, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 25%, 50%, 1) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(95, 127, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 12.5%) assert_equals: expected "rgb(20, 32, 44)" but got "rgb(19, 31, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 32, 44, 0)" but got "rgba(19, 31, 43, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 32, 44, 0.2)" but got "rgba(19, 31, 43, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 32, 44)" but got "rgb(19, 31, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 25%) assert_equals: expected "rgb(40, 64, 88)" but got "rgb(39, 63, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 64, 88, 0)" but got "rgba(39, 63, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 64, 88, 0.2)" but got "rgba(39, 63, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 64, 88)" but got "rgb(39, 63, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 37.5%) assert_equals: expected "rgb(60, 96, 131)" but got "rgb(59, 95, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 96, 131, 0)" but got "rgba(59, 95, 131, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 96, 131, 0.2)" but got "rgba(59, 95, 131, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 96, 131)" but got "rgb(59, 95, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 50%) assert_equals: expected "rgb(80, 128, 175)" but got "rgb(79, 127, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 128, 175, 0)" but got "rgba(79, 127, 175, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 128, 175, 0.2)" but got "rgba(79, 127, 175, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 128, 175)" but got "rgb(79, 127, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 62.5%) assert_equals: expected "rgb(124, 159, 195)" but got "rgb(123, 159, 195)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 159, 195, 0)" but got "rgba(123, 159, 195, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 159, 195, 0.2)" but got "rgba(123, 159, 195, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 159, 195)" but got "rgb(123, 159, 195)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 12.5%) assert_equals: expected "rgb(16, 32, 48)" but got "rgb(15, 31, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 32, 48, 0)" but got "rgba(15, 31, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 32, 48, 0.2)" but got "rgba(15, 31, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 32, 48)" but got "rgb(15, 31, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 25%) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(31, 63, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0) assert_equals: expected "rgba(32, 64, 96, 0)" but got "rgba(31, 63, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 64, 96, 0.2)" but got "rgba(31, 63, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 25%, 1) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(31, 63, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 37.5%) assert_equals: expected "rgb(48, 96, 143)" but got "rgb(47, 95, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 96, 143, 0)" but got "rgba(47, 95, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 96, 143, 0.2)" but got "rgba(47, 95, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 96, 143)" but got "rgb(47, 95, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 50%) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(63, 127, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0) assert_equals: expected "rgba(64, 128, 191, 0)" but got "rgba(63, 127, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 128, 191, 0.2)" but got "rgba(63, 127, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 50%, 1) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(63, 127, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 50%, 62.5%) assert_equals: expected "rgb(112, 159, 207)" but got "rgb(111, 159, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 159, 207, 0)" but got "rgba(111, 159, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 159, 207, 0.2)" but got "rgba(111, 159, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 159, 207)" but got "rgb(111, 159, 207)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 12.5%) assert_equals: expected "rgb(12, 32, 52)" but got "rgb(11, 31, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 32, 52, 0)" but got "rgba(11, 31, 51, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 32, 52, 0.2)" but got "rgba(11, 31, 51, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 32, 52)" but got "rgb(11, 31, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 25%) assert_equals: expected "rgb(24, 64, 104)" but got "rgb(23, 63, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 64, 104, 0)" but got "rgba(23, 63, 103, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 64, 104, 0.2)" but got "rgba(23, 63, 103, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 64, 104)" but got "rgb(23, 63, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 37.5%) assert_equals: expected "rgb(36, 96, 155)" but got "rgb(35, 95, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 96, 155, 0)" but got "rgba(35, 95, 155, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 96, 155, 0.2)" but got "rgba(35, 95, 155, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 96, 155)" but got "rgb(35, 95, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 50%) assert_equals: expected "rgb(48, 128, 207)" but got "rgb(47, 127, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 128, 207, 0)" but got "rgba(47, 127, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 128, 207, 0.2)" but got "rgba(47, 127, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 128, 207)" but got "rgb(47, 127, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 62.5%) assert_equals: expected "rgb(100, 159, 219)" but got "rgb(99, 159, 219)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 159, 219, 0)" but got "rgba(99, 159, 219, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 159, 219, 0.2)" but got "rgba(99, 159, 219, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 159, 219)" but got "rgb(99, 159, 219)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 12.5%) assert_equals: expected "rgb(8, 32, 56)" but got "rgb(7, 31, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 32, 56, 0)" but got "rgba(7, 31, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 32, 56, 0.2)" but got "rgba(7, 31, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 32, 56)" but got "rgb(7, 31, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 25%) assert_equals: expected "rgb(16, 64, 112)" but got "rgb(15, 63, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0) assert_equals: expected "rgba(16, 64, 112, 0)" but got "rgba(15, 63, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 64, 112, 0.2)" but got "rgba(15, 63, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 25%, 1) assert_equals: expected "rgb(16, 64, 112)" but got "rgb(15, 63, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 37.5%) assert_equals: expected "rgb(24, 96, 167)" but got "rgb(23, 95, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 96, 167, 0)" but got "rgba(23, 95, 167, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 96, 167, 0.2)" but got "rgba(23, 95, 167, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 96, 167)" but got "rgb(23, 95, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 50%) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(31, 127, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0) assert_equals: expected "rgba(32, 128, 223, 0)" but got "rgba(31, 127, 223, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 128, 223, 0.2)" but got "rgba(31, 127, 223, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 50%, 1) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(31, 127, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 75%, 62.5%) assert_equals: expected "rgb(88, 159, 231)" but got "rgb(87, 159, 231)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 159, 231, 0)" but got "rgba(87, 159, 231, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 159, 231, 0.2)" but got "rgba(87, 159, 231, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 159, 231)" but got "rgb(87, 159, 231)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 12.5%) assert_equals: expected "rgb(4, 32, 60)" but got "rgb(3, 31, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 32, 60, 0)" but got "rgba(3, 31, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 32, 60, 0.2)" but got "rgba(3, 31, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 32, 60)" but got "rgb(3, 31, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 25%) assert_equals: expected "rgb(8, 64, 120)" but got "rgb(7, 63, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 64, 120, 0)" but got "rgba(7, 63, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 64, 120, 0.2)" but got "rgba(7, 63, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 64, 120)" but got "rgb(7, 63, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 37.5%) assert_equals: expected "rgb(12, 96, 179)" but got "rgb(11, 95, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 96, 179, 0)" but got "rgba(11, 95, 179, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 96, 179, 0.2)" but got "rgba(11, 95, 179, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 96, 179)" but got "rgb(11, 95, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 50%) assert_equals: expected "rgb(16, 128, 239)" but got "rgb(15, 127, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 128, 239, 0)" but got "rgba(15, 127, 239, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 128, 239, 0.2)" but got "rgba(15, 127, 239, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 128, 239)" but got "rgb(15, 127, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 62.5%) assert_equals: expected "rgb(76, 159, 243)" but got "rgb(75, 159, 243)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 159, 243, 0)" but got "rgba(75, 159, 243, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 159, 243, 0.2)" but got "rgba(75, 159, 243, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 159, 243)" but got "rgb(75, 159, 243)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 12.5%) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(0, 31, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 32, 64, 0)" but got "rgba(0, 31, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 32, 64, 0.2)" but got "rgba(0, 31, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(0, 31, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 25%) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(0, 63, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0) assert_equals: expected "rgba(0, 64, 128, 0)" but got "rgba(0, 63, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 64, 128, 0.2)" but got "rgba(0, 63, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 25%, 1) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(0, 63, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 37.5%) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(0, 95, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0) assert_equals: expected "rgba(0, 96, 191, 0)" but got "rgba(0, 95, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 0.2) assert_equals: expected "rgba(0, 96, 191, 0.2)" but got "rgba(0, 95, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 37.5%, 1) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(0, 95, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 50%) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(0, 127, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0) assert_equals: expected "rgba(0, 128, 255, 0)" but got "rgba(0, 127, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 0.2) assert_equals: expected "rgba(0, 128, 255, 0.2)" but got "rgba(0, 127, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 50%, 1) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(0, 127, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 62.5%) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(63, 159, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 159, 255, 0)" but got "rgba(63, 159, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 159, 255, 0.2)" but got "rgba(63, 159, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(63, 159, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsl(210, 100%, 75%) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(127, 191, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0) assert_equals: expected "rgba(128, 191, 255, 0)" but got "rgba(127, 191, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 191, 255, 0.2)" but got "rgba(127, 191, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(210, 100%, 75%, 1) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(127, 191, 255)"
PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(210, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(210, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 12.5%) assert_equals: expected "rgb(28, 28, 36)" but got "rgb(27, 27, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0) assert_equals: expected "rgba(28, 28, 36, 0)" but got "rgba(27, 27, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(28, 28, 36, 0.2)" but got "rgba(27, 27, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 12.5%, 1) assert_equals: expected "rgb(28, 28, 36)" but got "rgb(27, 27, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 25%) assert_equals: expected "rgb(56, 56, 72)" but got "rgb(55, 55, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0) assert_equals: expected "rgba(56, 56, 72, 0)" but got "rgba(55, 55, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 0.2) assert_equals: expected "rgba(56, 56, 72, 0.2)" but got "rgba(55, 55, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 25%, 1) assert_equals: expected "rgb(56, 56, 72)" but got "rgb(55, 55, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 37.5%) assert_equals: expected "rgb(84, 84, 108)" but got "rgb(83, 83, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0) assert_equals: expected "rgba(84, 84, 108, 0)" but got "rgba(83, 83, 107, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(84, 84, 108, 0.2)" but got "rgba(83, 83, 107, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 37.5%, 1) assert_equals: expected "rgb(84, 84, 108)" but got "rgb(83, 83, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 50%) assert_equals: expected "rgb(112, 112, 143)" but got "rgb(111, 111, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0) assert_equals: expected "rgba(112, 112, 143, 0)" but got "rgba(111, 111, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 0.2) assert_equals: expected "rgba(112, 112, 143, 0.2)" but got "rgba(111, 111, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 50%, 1) assert_equals: expected "rgb(112, 112, 143)" but got "rgb(111, 111, 143)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 12.5%) assert_equals: expected "rgb(24, 24, 40)" but got "rgb(23, 23, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0) assert_equals: expected "rgba(24, 24, 40, 0)" but got "rgba(23, 23, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 0.2) assert_equals: expected "rgba(24, 24, 40, 0.2)" but got "rgba(23, 23, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 12.5%, 1) assert_equals: expected "rgb(24, 24, 40)" but got "rgb(23, 23, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 25%) assert_equals: expected "rgb(48, 48, 80)" but got "rgb(47, 47, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0) assert_equals: expected "rgba(48, 48, 80, 0)" but got "rgba(47, 47, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 0.2) assert_equals: expected "rgba(48, 48, 80, 0.2)" but got "rgba(47, 47, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 25%, 1) assert_equals: expected "rgb(48, 48, 80)" but got "rgb(47, 47, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 37.5%) assert_equals: expected "rgb(72, 72, 120)" but got "rgb(71, 71, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0) assert_equals: expected "rgba(72, 72, 120, 0)" but got "rgba(71, 71, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 0.2) assert_equals: expected "rgba(72, 72, 120, 0.2)" but got "rgba(71, 71, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 37.5%, 1) assert_equals: expected "rgb(72, 72, 120)" but got "rgb(71, 71, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 25%, 50%) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(95, 95, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0) assert_equals: expected "rgba(96, 96, 159, 0)" but got "rgba(95, 95, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 0.2) assert_equals: expected "rgba(96, 96, 159, 0.2)" but got "rgba(95, 95, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 25%, 50%, 1) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(95, 95, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 12.5%) assert_equals: expected "rgb(20, 20, 44)" but got "rgb(19, 19, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0) assert_equals: expected "rgba(20, 20, 44, 0)" but got "rgba(19, 19, 43, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(20, 20, 44, 0.2)" but got "rgba(19, 19, 43, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 12.5%, 1) assert_equals: expected "rgb(20, 20, 44)" but got "rgb(19, 19, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 25%) assert_equals: expected "rgb(40, 40, 88)" but got "rgb(39, 39, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0) assert_equals: expected "rgba(40, 40, 88, 0)" but got "rgba(39, 39, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 0.2) assert_equals: expected "rgba(40, 40, 88, 0.2)" but got "rgba(39, 39, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 25%, 1) assert_equals: expected "rgb(40, 40, 88)" but got "rgb(39, 39, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 37.5%) assert_equals: expected "rgb(60, 60, 131)" but got "rgb(59, 59, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0) assert_equals: expected "rgba(60, 60, 131, 0)" but got "rgba(59, 59, 131, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(60, 60, 131, 0.2)" but got "rgba(59, 59, 131, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 37.5%, 1) assert_equals: expected "rgb(60, 60, 131)" but got "rgb(59, 59, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 50%) assert_equals: expected "rgb(80, 80, 175)" but got "rgb(79, 79, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0) assert_equals: expected "rgba(80, 80, 175, 0)" but got "rgba(79, 79, 175, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 0.2) assert_equals: expected "rgba(80, 80, 175, 0.2)" but got "rgba(79, 79, 175, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 50%, 1) assert_equals: expected "rgb(80, 80, 175)" but got "rgb(79, 79, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 62.5%) assert_equals: expected "rgb(124, 124, 195)" but got "rgb(123, 123, 195)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0) assert_equals: expected "rgba(124, 124, 195, 0)" but got "rgba(123, 123, 195, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(124, 124, 195, 0.2)" but got "rgba(123, 123, 195, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 62.5%, 1) assert_equals: expected "rgb(124, 124, 195)" but got "rgb(123, 123, 195)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 12.5%) assert_equals: expected "rgb(16, 16, 48)" but got "rgb(15, 15, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0) assert_equals: expected "rgba(16, 16, 48, 0)" but got "rgba(15, 15, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 0.2) assert_equals: expected "rgba(16, 16, 48, 0.2)" but got "rgba(15, 15, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 12.5%, 1) assert_equals: expected "rgb(16, 16, 48)" but got "rgb(15, 15, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 25%) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(31, 31, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0) assert_equals: expected "rgba(32, 32, 96, 0)" but got "rgba(31, 31, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 0.2) assert_equals: expected "rgba(32, 32, 96, 0.2)" but got "rgba(31, 31, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 25%, 1) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(31, 31, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 37.5%) assert_equals: expected "rgb(48, 48, 143)" but got "rgb(47, 47, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0) assert_equals: expected "rgba(48, 48, 143, 0)" but got "rgba(47, 47, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 0.2) assert_equals: expected "rgba(48, 48, 143, 0.2)" but got "rgba(47, 47, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 37.5%, 1) assert_equals: expected "rgb(48, 48, 143)" but got "rgb(47, 47, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 50%) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(63, 63, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0) assert_equals: expected "rgba(64, 64, 191, 0)" but got "rgba(63, 63, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 0.2) assert_equals: expected "rgba(64, 64, 191, 0.2)" but got "rgba(63, 63, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 50%, 1) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(63, 63, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 50%, 62.5%) assert_equals: expected "rgb(112, 112, 207)" but got "rgb(111, 111, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0) assert_equals: expected "rgba(112, 112, 207, 0)" but got "rgba(111, 111, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 0.2) assert_equals: expected "rgba(112, 112, 207, 0.2)" but got "rgba(111, 111, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 50%, 62.5%, 1) assert_equals: expected "rgb(112, 112, 207)" but got "rgb(111, 111, 207)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 12.5%) assert_equals: expected "rgb(12, 12, 52)" but got "rgb(11, 11, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0) assert_equals: expected "rgba(12, 12, 52, 0)" but got "rgba(11, 11, 51, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(12, 12, 52, 0.2)" but got "rgba(11, 11, 51, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 12.5%, 1) assert_equals: expected "rgb(12, 12, 52)" but got "rgb(11, 11, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 25%) assert_equals: expected "rgb(24, 24, 104)" but got "rgb(23, 23, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0) assert_equals: expected "rgba(24, 24, 104, 0)" but got "rgba(23, 23, 103, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 0.2) assert_equals: expected "rgba(24, 24, 104, 0.2)" but got "rgba(23, 23, 103, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 25%, 1) assert_equals: expected "rgb(24, 24, 104)" but got "rgb(23, 23, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 37.5%) assert_equals: expected "rgb(36, 36, 155)" but got "rgb(35, 35, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0) assert_equals: expected "rgba(36, 36, 155, 0)" but got "rgba(35, 35, 155, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(36, 36, 155, 0.2)" but got "rgba(35, 35, 155, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 37.5%, 1) assert_equals: expected "rgb(36, 36, 155)" but got "rgb(35, 35, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 50%) assert_equals: expected "rgb(48, 48, 207)" but got "rgb(47, 47, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0) assert_equals: expected "rgba(48, 48, 207, 0)" but got "rgba(47, 47, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 0.2) assert_equals: expected "rgba(48, 48, 207, 0.2)" but got "rgba(47, 47, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 50%, 1) assert_equals: expected "rgb(48, 48, 207)" but got "rgb(47, 47, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 62.5%) assert_equals: expected "rgb(100, 100, 219)" but got "rgb(99, 99, 219)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0) assert_equals: expected "rgba(100, 100, 219, 0)" but got "rgba(99, 99, 219, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(100, 100, 219, 0.2)" but got "rgba(99, 99, 219, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 62.5%, 1) assert_equals: expected "rgb(100, 100, 219)" but got "rgb(99, 99, 219)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 12.5%) assert_equals: expected "rgb(8, 8, 56)" but got "rgb(7, 7, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0) assert_equals: expected "rgba(8, 8, 56, 0)" but got "rgba(7, 7, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 0.2) assert_equals: expected "rgba(8, 8, 56, 0.2)" but got "rgba(7, 7, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 12.5%, 1) assert_equals: expected "rgb(8, 8, 56)" but got "rgb(7, 7, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 25%) assert_equals: expected "rgb(16, 16, 112)" but got "rgb(15, 15, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0) assert_equals: expected "rgba(16, 16, 112, 0)" but got "rgba(15, 15, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 0.2) assert_equals: expected "rgba(16, 16, 112, 0.2)" but got "rgba(15, 15, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 25%, 1) assert_equals: expected "rgb(16, 16, 112)" but got "rgb(15, 15, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 37.5%) assert_equals: expected "rgb(24, 24, 167)" but got "rgb(23, 23, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0) assert_equals: expected "rgba(24, 24, 167, 0)" but got "rgba(23, 23, 167, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 0.2) assert_equals: expected "rgba(24, 24, 167, 0.2)" but got "rgba(23, 23, 167, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 37.5%, 1) assert_equals: expected "rgb(24, 24, 167)" but got "rgb(23, 23, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 50%) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(31, 31, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0) assert_equals: expected "rgba(32, 32, 223, 0)" but got "rgba(31, 31, 223, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 0.2) assert_equals: expected "rgba(32, 32, 223, 0.2)" but got "rgba(31, 31, 223, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 50%, 1) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(31, 31, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 75%, 62.5%) assert_equals: expected "rgb(88, 88, 231)" but got "rgb(87, 87, 231)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0) assert_equals: expected "rgba(88, 88, 231, 0)" but got "rgba(87, 87, 231, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 0.2) assert_equals: expected "rgba(88, 88, 231, 0.2)" but got "rgba(87, 87, 231, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 75%, 62.5%, 1) assert_equals: expected "rgb(88, 88, 231)" but got "rgb(87, 87, 231)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 12.5%) assert_equals: expected "rgb(4, 4, 60)" but got "rgb(3, 3, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0) assert_equals: expected "rgba(4, 4, 60, 0)" but got "rgba(3, 3, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(4, 4, 60, 0.2)" but got "rgba(3, 3, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 12.5%, 1) assert_equals: expected "rgb(4, 4, 60)" but got "rgb(3, 3, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 25%) assert_equals: expected "rgb(8, 8, 120)" but got "rgb(7, 7, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0) assert_equals: expected "rgba(8, 8, 120, 0)" but got "rgba(7, 7, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 0.2) assert_equals: expected "rgba(8, 8, 120, 0.2)" but got "rgba(7, 7, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 25%, 1) assert_equals: expected "rgb(8, 8, 120)" but got "rgb(7, 7, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 37.5%) assert_equals: expected "rgb(12, 12, 179)" but got "rgb(11, 11, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0) assert_equals: expected "rgba(12, 12, 179, 0)" but got "rgba(11, 11, 179, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(12, 12, 179, 0.2)" but got "rgba(11, 11, 179, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 37.5%, 1) assert_equals: expected "rgb(12, 12, 179)" but got "rgb(11, 11, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 50%) assert_equals: expected "rgb(16, 16, 239)" but got "rgb(15, 15, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0) assert_equals: expected "rgba(16, 16, 239, 0)" but got "rgba(15, 15, 239, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 0.2) assert_equals: expected "rgba(16, 16, 239, 0.2)" but got "rgba(15, 15, 239, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 50%, 1) assert_equals: expected "rgb(16, 16, 239)" but got "rgb(15, 15, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 62.5%) assert_equals: expected "rgb(76, 76, 243)" but got "rgb(75, 75, 243)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0) assert_equals: expected "rgba(76, 76, 243, 0)" but got "rgba(75, 75, 243, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(76, 76, 243, 0.2)" but got "rgba(75, 75, 243, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 62.5%, 1) assert_equals: expected "rgb(76, 76, 243)" but got "rgb(75, 75, 243)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 12.5%) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(0, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0) assert_equals: expected "rgba(0, 0, 64, 0)" but got "rgba(0, 0, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 0.2) assert_equals: expected "rgba(0, 0, 64, 0.2)" but got "rgba(0, 0, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 12.5%, 1) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(0, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 25%) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(0, 0, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0) assert_equals: expected "rgba(0, 0, 128, 0)" but got "rgba(0, 0, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 0.2) assert_equals: expected "rgba(0, 0, 128, 0.2)" but got "rgba(0, 0, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 25%, 1) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(0, 0, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 37.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 37.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 37.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 37.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 50%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 50%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 62.5%) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(63, 63, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0) assert_equals: expected "rgba(64, 64, 255, 0)" but got "rgba(63, 63, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 0.2) assert_equals: expected "rgba(64, 64, 255, 0.2)" but got "rgba(63, 63, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 62.5%, 1) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(63, 63, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsl(240, 100%, 75%) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(127, 127, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0) assert_equals: expected "rgba(128, 128, 255, 0)" but got "rgba(127, 127, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 0.2) assert_equals: expected "rgba(128, 128, 255, 0.2)" but got "rgba(127, 127, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(240, 100%, 75%, 1) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(127, 127, 255)"
PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(240, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(240, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 12.5%) assert_equals: expected "rgb(32, 28, 36)" but got "rgb(31, 27, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0) assert_equals: expected "rgba(32, 28, 36, 0)" but got "rgba(31, 27, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 28, 36, 0.2)" but got "rgba(31, 27, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 12.5%, 1) assert_equals: expected "rgb(32, 28, 36)" but got "rgb(31, 27, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 25%) assert_equals: expected "rgb(64, 56, 72)" but got "rgb(63, 55, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0) assert_equals: expected "rgba(64, 56, 72, 0)" but got "rgba(63, 55, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 0.2) assert_equals: expected "rgba(64, 56, 72, 0.2)" but got "rgba(63, 55, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 25%, 1) assert_equals: expected "rgb(64, 56, 72)" but got "rgb(63, 55, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 37.5%) assert_equals: expected "rgb(96, 84, 108)" but got "rgb(95, 83, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0) assert_equals: expected "rgba(96, 84, 108, 0)" but got "rgba(95, 83, 107, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 84, 108, 0.2)" but got "rgba(95, 83, 107, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 37.5%, 1) assert_equals: expected "rgb(96, 84, 108)" but got "rgb(95, 83, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 50%) assert_equals: expected "rgb(128, 112, 143)" but got "rgb(127, 111, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0) assert_equals: expected "rgba(128, 112, 143, 0)" but got "rgba(127, 111, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 0.2) assert_equals: expected "rgba(128, 112, 143, 0.2)" but got "rgba(127, 111, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 50%, 1) assert_equals: expected "rgb(128, 112, 143)" but got "rgb(127, 111, 143)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 12.5%) assert_equals: expected "rgb(32, 24, 40)" but got "rgb(31, 23, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0) assert_equals: expected "rgba(32, 24, 40, 0)" but got "rgba(31, 23, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 0.2) assert_equals: expected "rgba(32, 24, 40, 0.2)" but got "rgba(31, 23, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 12.5%, 1) assert_equals: expected "rgb(32, 24, 40)" but got "rgb(31, 23, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 25%) assert_equals: expected "rgb(64, 48, 80)" but got "rgb(63, 47, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0) assert_equals: expected "rgba(64, 48, 80, 0)" but got "rgba(63, 47, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 0.2) assert_equals: expected "rgba(64, 48, 80, 0.2)" but got "rgba(63, 47, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 25%, 1) assert_equals: expected "rgb(64, 48, 80)" but got "rgb(63, 47, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 37.5%) assert_equals: expected "rgb(96, 72, 120)" but got "rgb(95, 71, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0) assert_equals: expected "rgba(96, 72, 120, 0)" but got "rgba(95, 71, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 0.2) assert_equals: expected "rgba(96, 72, 120, 0.2)" but got "rgba(95, 71, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 37.5%, 1) assert_equals: expected "rgb(96, 72, 120)" but got "rgb(95, 71, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 25%, 50%) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(127, 95, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0) assert_equals: expected "rgba(128, 96, 159, 0)" but got "rgba(127, 95, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 0.2) assert_equals: expected "rgba(128, 96, 159, 0.2)" but got "rgba(127, 95, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 25%, 50%, 1) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(127, 95, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 12.5%) assert_equals: expected "rgb(32, 20, 44)" but got "rgb(31, 19, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0) assert_equals: expected "rgba(32, 20, 44, 0)" but got "rgba(31, 19, 43, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 20, 44, 0.2)" but got "rgba(31, 19, 43, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 12.5%, 1) assert_equals: expected "rgb(32, 20, 44)" but got "rgb(31, 19, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 25%) assert_equals: expected "rgb(64, 40, 88)" but got "rgb(63, 39, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0) assert_equals: expected "rgba(64, 40, 88, 0)" but got "rgba(63, 39, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 0.2) assert_equals: expected "rgba(64, 40, 88, 0.2)" but got "rgba(63, 39, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 25%, 1) assert_equals: expected "rgb(64, 40, 88)" but got "rgb(63, 39, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 37.5%) assert_equals: expected "rgb(96, 60, 131)" but got "rgb(95, 59, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0) assert_equals: expected "rgba(96, 60, 131, 0)" but got "rgba(95, 59, 131, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 60, 131, 0.2)" but got "rgba(95, 59, 131, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 37.5%, 1) assert_equals: expected "rgb(96, 60, 131)" but got "rgb(95, 59, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 50%) assert_equals: expected "rgb(128, 80, 175)" but got "rgb(127, 79, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0) assert_equals: expected "rgba(128, 80, 175, 0)" but got "rgba(127, 79, 175, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 0.2) assert_equals: expected "rgba(128, 80, 175, 0.2)" but got "rgba(127, 79, 175, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 50%, 1) assert_equals: expected "rgb(128, 80, 175)" but got "rgb(127, 79, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 62.5%) assert_equals: expected "rgb(159, 124, 195)" but got "rgb(159, 123, 195)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0) assert_equals: expected "rgba(159, 124, 195, 0)" but got "rgba(159, 123, 195, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 124, 195, 0.2)" but got "rgba(159, 123, 195, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 62.5%, 1) assert_equals: expected "rgb(159, 124, 195)" but got "rgb(159, 123, 195)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 12.5%) assert_equals: expected "rgb(32, 16, 48)" but got "rgb(31, 15, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0) assert_equals: expected "rgba(32, 16, 48, 0)" but got "rgba(31, 15, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 0.2) assert_equals: expected "rgba(32, 16, 48, 0.2)" but got "rgba(31, 15, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 12.5%, 1) assert_equals: expected "rgb(32, 16, 48)" but got "rgb(31, 15, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 25%) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(63, 31, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0) assert_equals: expected "rgba(64, 32, 96, 0)" but got "rgba(63, 31, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 0.2) assert_equals: expected "rgba(64, 32, 96, 0.2)" but got "rgba(63, 31, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 25%, 1) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(63, 31, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 37.5%) assert_equals: expected "rgb(96, 48, 143)" but got "rgb(95, 47, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0) assert_equals: expected "rgba(96, 48, 143, 0)" but got "rgba(95, 47, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 0.2) assert_equals: expected "rgba(96, 48, 143, 0.2)" but got "rgba(95, 47, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 37.5%, 1) assert_equals: expected "rgb(96, 48, 143)" but got "rgb(95, 47, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 50%) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(127, 63, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0) assert_equals: expected "rgba(128, 64, 191, 0)" but got "rgba(127, 63, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 0.2) assert_equals: expected "rgba(128, 64, 191, 0.2)" but got "rgba(127, 63, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 50%, 1) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(127, 63, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 50%, 62.5%) assert_equals: expected "rgb(159, 112, 207)" but got "rgb(159, 111, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0) assert_equals: expected "rgba(159, 112, 207, 0)" but got "rgba(159, 111, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 0.2) assert_equals: expected "rgba(159, 112, 207, 0.2)" but got "rgba(159, 111, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 50%, 62.5%, 1) assert_equals: expected "rgb(159, 112, 207)" but got "rgb(159, 111, 207)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 12.5%) assert_equals: expected "rgb(32, 12, 52)" but got "rgb(31, 11, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0) assert_equals: expected "rgba(32, 12, 52, 0)" but got "rgba(31, 11, 51, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 12, 52, 0.2)" but got "rgba(31, 11, 51, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 12.5%, 1) assert_equals: expected "rgb(32, 12, 52)" but got "rgb(31, 11, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 25%) assert_equals: expected "rgb(64, 24, 104)" but got "rgb(63, 23, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0) assert_equals: expected "rgba(64, 24, 104, 0)" but got "rgba(63, 23, 103, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 0.2) assert_equals: expected "rgba(64, 24, 104, 0.2)" but got "rgba(63, 23, 103, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 25%, 1) assert_equals: expected "rgb(64, 24, 104)" but got "rgb(63, 23, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 37.5%) assert_equals: expected "rgb(96, 36, 155)" but got "rgb(95, 35, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0) assert_equals: expected "rgba(96, 36, 155, 0)" but got "rgba(95, 35, 155, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 36, 155, 0.2)" but got "rgba(95, 35, 155, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 37.5%, 1) assert_equals: expected "rgb(96, 36, 155)" but got "rgb(95, 35, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 50%) assert_equals: expected "rgb(128, 48, 207)" but got "rgb(127, 47, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0) assert_equals: expected "rgba(128, 48, 207, 0)" but got "rgba(127, 47, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 0.2) assert_equals: expected "rgba(128, 48, 207, 0.2)" but got "rgba(127, 47, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 50%, 1) assert_equals: expected "rgb(128, 48, 207)" but got "rgb(127, 47, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 62.5%) assert_equals: expected "rgb(159, 100, 219)" but got "rgb(159, 99, 219)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0) assert_equals: expected "rgba(159, 100, 219, 0)" but got "rgba(159, 99, 219, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 100, 219, 0.2)" but got "rgba(159, 99, 219, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 62.5%, 1) assert_equals: expected "rgb(159, 100, 219)" but got "rgb(159, 99, 219)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 12.5%) assert_equals: expected "rgb(32, 8, 56)" but got "rgb(31, 7, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0) assert_equals: expected "rgba(32, 8, 56, 0)" but got "rgba(31, 7, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 0.2) assert_equals: expected "rgba(32, 8, 56, 0.2)" but got "rgba(31, 7, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 12.5%, 1) assert_equals: expected "rgb(32, 8, 56)" but got "rgb(31, 7, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 25%) assert_equals: expected "rgb(64, 16, 112)" but got "rgb(63, 15, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0) assert_equals: expected "rgba(64, 16, 112, 0)" but got "rgba(63, 15, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 0.2) assert_equals: expected "rgba(64, 16, 112, 0.2)" but got "rgba(63, 15, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 25%, 1) assert_equals: expected "rgb(64, 16, 112)" but got "rgb(63, 15, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 37.5%) assert_equals: expected "rgb(96, 24, 167)" but got "rgb(95, 23, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0) assert_equals: expected "rgba(96, 24, 167, 0)" but got "rgba(95, 23, 167, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 0.2) assert_equals: expected "rgba(96, 24, 167, 0.2)" but got "rgba(95, 23, 167, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 37.5%, 1) assert_equals: expected "rgb(96, 24, 167)" but got "rgb(95, 23, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 50%) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(127, 31, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0) assert_equals: expected "rgba(128, 32, 223, 0)" but got "rgba(127, 31, 223, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 0.2) assert_equals: expected "rgba(128, 32, 223, 0.2)" but got "rgba(127, 31, 223, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 50%, 1) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(127, 31, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 75%, 62.5%) assert_equals: expected "rgb(159, 88, 231)" but got "rgb(159, 87, 231)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0) assert_equals: expected "rgba(159, 88, 231, 0)" but got "rgba(159, 87, 231, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 0.2) assert_equals: expected "rgba(159, 88, 231, 0.2)" but got "rgba(159, 87, 231, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 75%, 62.5%, 1) assert_equals: expected "rgb(159, 88, 231)" but got "rgb(159, 87, 231)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 12.5%) assert_equals: expected "rgb(32, 4, 60)" but got "rgb(31, 3, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0) assert_equals: expected "rgba(32, 4, 60, 0)" but got "rgba(31, 3, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(32, 4, 60, 0.2)" but got "rgba(31, 3, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 12.5%, 1) assert_equals: expected "rgb(32, 4, 60)" but got "rgb(31, 3, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 25%) assert_equals: expected "rgb(64, 8, 120)" but got "rgb(63, 7, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0) assert_equals: expected "rgba(64, 8, 120, 0)" but got "rgba(63, 7, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 0.2) assert_equals: expected "rgba(64, 8, 120, 0.2)" but got "rgba(63, 7, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 25%, 1) assert_equals: expected "rgb(64, 8, 120)" but got "rgb(63, 7, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 37.5%) assert_equals: expected "rgb(96, 12, 179)" but got "rgb(95, 11, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0) assert_equals: expected "rgba(96, 12, 179, 0)" but got "rgba(95, 11, 179, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(96, 12, 179, 0.2)" but got "rgba(95, 11, 179, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 37.5%, 1) assert_equals: expected "rgb(96, 12, 179)" but got "rgb(95, 11, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 50%) assert_equals: expected "rgb(128, 16, 239)" but got "rgb(127, 15, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0) assert_equals: expected "rgba(128, 16, 239, 0)" but got "rgba(127, 15, 239, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 0.2) assert_equals: expected "rgba(128, 16, 239, 0.2)" but got "rgba(127, 15, 239, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 50%, 1) assert_equals: expected "rgb(128, 16, 239)" but got "rgb(127, 15, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 62.5%) assert_equals: expected "rgb(159, 76, 243)" but got "rgb(159, 75, 243)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0) assert_equals: expected "rgba(159, 76, 243, 0)" but got "rgba(159, 75, 243, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(159, 76, 243, 0.2)" but got "rgba(159, 75, 243, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 62.5%, 1) assert_equals: expected "rgb(159, 76, 243)" but got "rgb(159, 75, 243)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 12.5%) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(31, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0) assert_equals: expected "rgba(32, 0, 64, 0)" but got "rgba(31, 0, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 0.2) assert_equals: expected "rgba(32, 0, 64, 0.2)" but got "rgba(31, 0, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 12.5%, 1) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(31, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 25%) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(63, 0, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0) assert_equals: expected "rgba(64, 0, 128, 0)" but got "rgba(63, 0, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 0.2) assert_equals: expected "rgba(64, 0, 128, 0.2)" but got "rgba(63, 0, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 25%, 1) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(63, 0, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 37.5%) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(95, 0, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0) assert_equals: expected "rgba(96, 0, 191, 0)" but got "rgba(95, 0, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 0.2) assert_equals: expected "rgba(96, 0, 191, 0.2)" but got "rgba(95, 0, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 37.5%, 1) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(95, 0, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 50%) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(127, 0, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0) assert_equals: expected "rgba(128, 0, 255, 0)" but got "rgba(127, 0, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 0.2) assert_equals: expected "rgba(128, 0, 255, 0.2)" but got "rgba(127, 0, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 50%, 1) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(127, 0, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 62.5%) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(159, 63, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0) assert_equals: expected "rgba(159, 64, 255, 0)" but got "rgba(159, 63, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 0.2) assert_equals: expected "rgba(159, 64, 255, 0.2)" but got "rgba(159, 63, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 62.5%, 1) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(159, 63, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsl(270, 100%, 75%) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(191, 127, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0) assert_equals: expected "rgba(191, 128, 255, 0)" but got "rgba(191, 127, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 0.2) assert_equals: expected "rgba(191, 128, 255, 0.2)" but got "rgba(191, 127, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(270, 100%, 75%, 1) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(191, 127, 255)"
PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(270, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(270, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 36)" but got "rgb(35, 27, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 36, 0)" but got "rgba(35, 27, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 36, 0.2)" but got "rgba(35, 27, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 36)" but got "rgb(35, 27, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 72)" but got "rgb(71, 55, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 72, 0)" but got "rgba(71, 55, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 72, 0.2)" but got "rgba(71, 55, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 72)" but got "rgb(71, 55, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 108)" but got "rgb(107, 83, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 108, 0)" but got "rgba(107, 83, 107, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 108, 0.2)" but got "rgba(107, 83, 107, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 108)" but got "rgb(107, 83, 107)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 143)" but got "rgb(143, 111, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 143, 0)" but got "rgba(143, 111, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 143, 0.2)" but got "rgba(143, 111, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 143)" but got "rgb(143, 111, 143)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 40)" but got "rgb(39, 23, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 40, 0)" but got "rgba(39, 23, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 40, 0.2)" but got "rgba(39, 23, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 40)" but got "rgb(39, 23, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 25%) assert_equals: expected "rgb(80, 48, 80)" but got "rgb(79, 47, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 80, 0)" but got "rgba(79, 47, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 80, 0.2)" but got "rgba(79, 47, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 80)" but got "rgb(79, 47, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 120)" but got "rgb(119, 71, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 120, 0)" but got "rgba(119, 71, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 120, 0.2)" but got "rgba(119, 71, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 120)" but got "rgb(119, 71, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 25%, 50%) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(159, 95, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 159, 0)" but got "rgba(159, 95, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 159, 0.2)" but got "rgba(159, 95, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(159, 95, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 44)" but got "rgb(43, 19, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 44, 0)" but got "rgba(43, 19, 43, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 44, 0.2)" but got "rgba(43, 19, 43, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 44)" but got "rgb(43, 19, 43)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 88)" but got "rgb(87, 39, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 88, 0)" but got "rgba(87, 39, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 88, 0.2)" but got "rgba(87, 39, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 88)" but got "rgb(87, 39, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 131)" but got "rgb(131, 59, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 131, 0)" but got "rgba(131, 59, 131, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 131, 0.2)" but got "rgba(131, 59, 131, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 131)" but got "rgb(131, 59, 131)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 175)" but got "rgb(175, 79, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 175, 0)" but got "rgba(175, 79, 175, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 175, 0.2)" but got "rgba(175, 79, 175, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 175)" but got "rgb(175, 79, 175)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 195)" but got "rgb(195, 123, 195)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 195, 0)" but got "rgba(195, 123, 195, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 195, 0.2)" but got "rgba(195, 123, 195, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 195)" but got "rgb(195, 123, 195)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 48)" but got "rgb(47, 15, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 48, 0)" but got "rgba(47, 15, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 48, 0.2)" but got "rgba(47, 15, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 48)" but got "rgb(47, 15, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 25%) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(95, 31, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 96, 0)" but got "rgba(95, 31, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 96, 0.2)" but got "rgba(95, 31, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(95, 31, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 143)" but got "rgb(143, 47, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 143, 0)" but got "rgba(143, 47, 143, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 143, 0.2)" but got "rgba(143, 47, 143, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 143)" but got "rgb(143, 47, 143)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 50%) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(191, 63, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 191, 0)" but got "rgba(191, 63, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 191, 0.2)" but got "rgba(191, 63, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(191, 63, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 207)" but got "rgb(207, 111, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 207, 0)" but got "rgba(207, 111, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 207, 0.2)" but got "rgba(207, 111, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 207)" but got "rgb(207, 111, 207)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 52)" but got "rgb(51, 11, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 52, 0)" but got "rgba(51, 11, 51, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 52, 0.2)" but got "rgba(51, 11, 51, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 52)" but got "rgb(51, 11, 51)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 104)" but got "rgb(103, 23, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 104, 0)" but got "rgba(103, 23, 103, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 104, 0.2)" but got "rgba(103, 23, 103, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 104)" but got "rgb(103, 23, 103)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 155)" but got "rgb(155, 35, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 155, 0)" but got "rgba(155, 35, 155, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 155, 0.2)" but got "rgba(155, 35, 155, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 155)" but got "rgb(155, 35, 155)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 207)" but got "rgb(207, 47, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 207, 0)" but got "rgba(207, 47, 207, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 207, 0.2)" but got "rgba(207, 47, 207, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 207)" but got "rgb(207, 47, 207)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 219)" but got "rgb(219, 99, 219)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 219, 0)" but got "rgba(219, 99, 219, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 219, 0.2)" but got "rgba(219, 99, 219, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 219)" but got "rgb(219, 99, 219)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 56)" but got "rgb(55, 7, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 56, 0)" but got "rgba(55, 7, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 56, 0.2)" but got "rgba(55, 7, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 56)" but got "rgb(55, 7, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 25%) assert_equals: expected "rgb(112, 16, 112)" but got "rgb(111, 15, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 112, 0)" but got "rgba(111, 15, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 112, 0.2)" but got "rgba(111, 15, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 112)" but got "rgb(111, 15, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 167)" but got "rgb(167, 23, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 167, 0)" but got "rgba(167, 23, 167, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 167, 0.2)" but got "rgba(167, 23, 167, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 167)" but got "rgb(167, 23, 167)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 50%) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(223, 31, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 223, 0)" but got "rgba(223, 31, 223, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 223, 0.2)" but got "rgba(223, 31, 223, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(223, 31, 223)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 231)" but got "rgb(231, 87, 231)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 231, 0)" but got "rgba(231, 87, 231, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 231, 0.2)" but got "rgba(231, 87, 231, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 231)" but got "rgb(231, 87, 231)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 60)" but got "rgb(59, 3, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 60, 0)" but got "rgba(59, 3, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 60, 0.2)" but got "rgba(59, 3, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 60)" but got "rgb(59, 3, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 120)" but got "rgb(119, 7, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 120, 0)" but got "rgba(119, 7, 119, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 120, 0.2)" but got "rgba(119, 7, 119, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 120)" but got "rgb(119, 7, 119)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 179)" but got "rgb(179, 11, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 179, 0)" but got "rgba(179, 11, 179, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 179, 0.2)" but got "rgba(179, 11, 179, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 179)" but got "rgb(179, 11, 179)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 239)" but got "rgb(239, 15, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 239, 0)" but got "rgba(239, 15, 239, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 239, 0.2)" but got "rgba(239, 15, 239, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 239)" but got "rgb(239, 15, 239)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 243)" but got "rgb(243, 75, 243)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 243, 0)" but got "rgba(243, 75, 243, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 243, 0.2)" but got "rgba(243, 75, 243, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 243)" but got "rgb(243, 75, 243)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(63, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 64, 0)" but got "rgba(63, 0, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 64, 0.2)" but got "rgba(63, 0, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(63, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 25%) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(127, 0, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 128, 0)" but got "rgba(127, 0, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 128, 0.2)" but got "rgba(127, 0, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(127, 0, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 37.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 37.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 37.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 37.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 50%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 50%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(255, 63, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 255, 0)" but got "rgba(255, 63, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 255, 0.2)" but got "rgba(255, 63, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(255, 63, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsl(300, 100%, 75%) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(255, 127, 255)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 255, 0)" but got "rgba(255, 127, 255, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 255, 0.2)" but got "rgba(255, 127, 255, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(300, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(255, 127, 255)"
PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(300, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(300, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 32)" but got "rgb(35, 27, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 32, 0)" but got "rgba(35, 27, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 32, 0.2)" but got "rgba(35, 27, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 32)" but got "rgb(35, 27, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 64)" but got "rgb(71, 55, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 64, 0)" but got "rgba(71, 55, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 64, 0.2)" but got "rgba(71, 55, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 64)" but got "rgb(71, 55, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 96)" but got "rgb(107, 83, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 96, 0)" but got "rgba(107, 83, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 96, 0.2)" but got "rgba(107, 83, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 96)" but got "rgb(107, 83, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 128)" but got "rgb(143, 111, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 128, 0)" but got "rgba(143, 111, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 128, 0.2)" but got "rgba(143, 111, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 128)" but got "rgb(143, 111, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 32)" but got "rgb(39, 23, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 32, 0)" but got "rgba(39, 23, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 32, 0.2)" but got "rgba(39, 23, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 32)" but got "rgb(39, 23, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 25%) assert_equals: expected "rgb(80, 48, 64)" but got "rgb(79, 47, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 64, 0)" but got "rgba(79, 47, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 64, 0.2)" but got "rgba(79, 47, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 64)" but got "rgb(79, 47, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 96)" but got "rgb(119, 71, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 96, 0)" but got "rgba(119, 71, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 96, 0.2)" but got "rgba(119, 71, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 96)" but got "rgb(119, 71, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 25%, 50%) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(159, 95, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 128, 0)" but got "rgba(159, 95, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 128, 0.2)" but got "rgba(159, 95, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(159, 95, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 32)" but got "rgb(43, 19, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 32, 0)" but got "rgba(43, 19, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 32, 0.2)" but got "rgba(43, 19, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 32)" but got "rgb(43, 19, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 64)" but got "rgb(87, 39, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 64, 0)" but got "rgba(87, 39, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 64, 0.2)" but got "rgba(87, 39, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 64)" but got "rgb(87, 39, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 96)" but got "rgb(131, 59, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 96, 0)" but got "rgba(131, 59, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 96, 0.2)" but got "rgba(131, 59, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 96)" but got "rgb(131, 59, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 128)" but got "rgb(175, 79, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 128, 0)" but got "rgba(175, 79, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 128, 0.2)" but got "rgba(175, 79, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 128)" but got "rgb(175, 79, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 159)" but got "rgb(195, 123, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 159, 0)" but got "rgba(195, 123, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 159, 0.2)" but got "rgba(195, 123, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 159)" but got "rgb(195, 123, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 32)" but got "rgb(47, 15, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 32, 0)" but got "rgba(47, 15, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 32, 0.2)" but got "rgba(47, 15, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 32)" but got "rgb(47, 15, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 25%) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(95, 31, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 64, 0)" but got "rgba(95, 31, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 64, 0.2)" but got "rgba(95, 31, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(95, 31, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 96)" but got "rgb(143, 47, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 96, 0)" but got "rgba(143, 47, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 96, 0.2)" but got "rgba(143, 47, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 96)" but got "rgb(143, 47, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 50%) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(191, 63, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 128, 0)" but got "rgba(191, 63, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 128, 0.2)" but got "rgba(191, 63, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(191, 63, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 159)" but got "rgb(207, 111, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 159, 0)" but got "rgba(207, 111, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 159, 0.2)" but got "rgba(207, 111, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 159)" but got "rgb(207, 111, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 32)" but got "rgb(51, 11, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 32, 0)" but got "rgba(51, 11, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 32, 0.2)" but got "rgba(51, 11, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 32)" but got "rgb(51, 11, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 64)" but got "rgb(103, 23, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 64, 0)" but got "rgba(103, 23, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 64, 0.2)" but got "rgba(103, 23, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 64)" but got "rgb(103, 23, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 96)" but got "rgb(155, 35, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 96, 0)" but got "rgba(155, 35, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 96, 0.2)" but got "rgba(155, 35, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 96)" but got "rgb(155, 35, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 128)" but got "rgb(207, 47, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 128, 0)" but got "rgba(207, 47, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 128, 0.2)" but got "rgba(207, 47, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 128)" but got "rgb(207, 47, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 159)" but got "rgb(219, 99, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 159, 0)" but got "rgba(219, 99, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 159, 0.2)" but got "rgba(219, 99, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 159)" but got "rgb(219, 99, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 32)" but got "rgb(55, 7, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 32, 0)" but got "rgba(55, 7, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 32, 0.2)" but got "rgba(55, 7, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 32)" but got "rgb(55, 7, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 25%) assert_equals: expected "rgb(112, 16, 64)" but got "rgb(111, 15, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 64, 0)" but got "rgba(111, 15, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 64, 0.2)" but got "rgba(111, 15, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 64)" but got "rgb(111, 15, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 96)" but got "rgb(167, 23, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 96, 0)" but got "rgba(167, 23, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 96, 0.2)" but got "rgba(167, 23, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 96)" but got "rgb(167, 23, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 50%) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(223, 31, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 128, 0)" but got "rgba(223, 31, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 128, 0.2)" but got "rgba(223, 31, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(223, 31, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 159)" but got "rgb(231, 87, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 159, 0)" but got "rgba(231, 87, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 159, 0.2)" but got "rgba(231, 87, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 159)" but got "rgb(231, 87, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 32)" but got "rgb(59, 3, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 32, 0)" but got "rgba(59, 3, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 32, 0.2)" but got "rgba(59, 3, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 32)" but got "rgb(59, 3, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 64)" but got "rgb(119, 7, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 64, 0)" but got "rgba(119, 7, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 64, 0.2)" but got "rgba(119, 7, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 64)" but got "rgb(119, 7, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 96)" but got "rgb(179, 11, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 96, 0)" but got "rgba(179, 11, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 96, 0.2)" but got "rgba(179, 11, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 96)" but got "rgb(179, 11, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 128)" but got "rgb(239, 15, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 128, 0)" but got "rgba(239, 15, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 128, 0.2)" but got "rgba(239, 15, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 128)" but got "rgb(239, 15, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 159)" but got "rgb(243, 75, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 159, 0)" but got "rgba(243, 75, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 159, 0.2)" but got "rgba(243, 75, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 159)" but got "rgb(243, 75, 159)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(63, 0, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 32, 0)" but got "rgba(63, 0, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 32, 0.2)" but got "rgba(63, 0, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(63, 0, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 25%) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(127, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 64, 0)" but got "rgba(127, 0, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 64, 0.2)" but got "rgba(127, 0, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(127, 0, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 37.5%) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(191, 0, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 0) assert_equals: expected "rgba(191, 0, 96, 0)" but got "rgba(191, 0, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 0.2) assert_equals: expected "rgba(191, 0, 96, 0.2)" but got "rgba(191, 0, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 37.5%, 1) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(191, 0, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 50%) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(255, 0, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 0) assert_equals: expected "rgba(255, 0, 128, 0)" but got "rgba(255, 0, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 0.2) assert_equals: expected "rgba(255, 0, 128, 0.2)" but got "rgba(255, 0, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 50%, 1) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(255, 0, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(255, 63, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 159, 0)" but got "rgba(255, 63, 159, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 159, 0.2)" but got "rgba(255, 63, 159, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(255, 63, 159)"
FAIL HSL/HSLA value should parse and round correctly: hsl(330, 100%, 75%) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(255, 127, 191)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 191, 0)" but got "rgba(255, 127, 191, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 191, 0.2)" but got "rgba(255, 127, 191, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(330, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(255, 127, 191)"
PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(330, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(330, 100%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 12.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgba(31, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgba(31, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 12.5%, 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(31, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 25%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgba(63, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgba(63, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 25%, 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(63, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 37.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgba(95, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgba(95, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 37.5%, 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(95, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 0%, 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgba(127, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgba(127, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 0%, 50%, 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(127, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 0%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 0%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 12.5%) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 0) assert_equals: expected "rgba(36, 28, 28, 0)" but got "rgba(35, 27, 27, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 0.2) assert_equals: expected "rgba(36, 28, 28, 0.2)" but got "rgba(35, 27, 27, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 12.5%, 1) assert_equals: expected "rgb(36, 28, 28)" but got "rgb(35, 27, 27)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 25%) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 0) assert_equals: expected "rgba(72, 56, 56, 0)" but got "rgba(71, 55, 55, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 0.2) assert_equals: expected "rgba(72, 56, 56, 0.2)" but got "rgba(71, 55, 55, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 25%, 1) assert_equals: expected "rgb(72, 56, 56)" but got "rgb(71, 55, 55)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 37.5%) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 0) assert_equals: expected "rgba(108, 84, 84, 0)" but got "rgba(107, 83, 83, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 0.2) assert_equals: expected "rgba(108, 84, 84, 0.2)" but got "rgba(107, 83, 83, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 37.5%, 1) assert_equals: expected "rgb(108, 84, 84)" but got "rgb(107, 83, 83)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 50%) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 0) assert_equals: expected "rgba(143, 112, 112, 0)" but got "rgba(143, 111, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 0.2) assert_equals: expected "rgba(143, 112, 112, 0.2)" but got "rgba(143, 111, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 50%, 1) assert_equals: expected "rgb(143, 112, 112)" but got "rgb(143, 111, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 12.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 12.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 12.5%) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 0) assert_equals: expected "rgba(40, 24, 24, 0)" but got "rgba(39, 23, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 0.2) assert_equals: expected "rgba(40, 24, 24, 0.2)" but got "rgba(39, 23, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 12.5%, 1) assert_equals: expected "rgb(40, 24, 24)" but got "rgb(39, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 25%) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 0) assert_equals: expected "rgba(80, 48, 48, 0)" but got "rgba(79, 47, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 0.2) assert_equals: expected "rgba(80, 48, 48, 0.2)" but got "rgba(79, 47, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 25%, 1) assert_equals: expected "rgb(80, 48, 48)" but got "rgb(79, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 37.5%) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 0) assert_equals: expected "rgba(120, 72, 72, 0)" but got "rgba(119, 71, 71, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 0.2) assert_equals: expected "rgba(120, 72, 72, 0.2)" but got "rgba(119, 71, 71, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 37.5%, 1) assert_equals: expected "rgb(120, 72, 72)" but got "rgb(119, 71, 71)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 25%, 50%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgba(159, 95, 95, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgba(159, 95, 95, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 25%, 50%, 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(159, 95, 95)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 62.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 62.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 62.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 62.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 25%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 25%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 12.5%) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 0) assert_equals: expected "rgba(44, 20, 20, 0)" but got "rgba(43, 19, 19, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 0.2) assert_equals: expected "rgba(44, 20, 20, 0.2)" but got "rgba(43, 19, 19, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 12.5%, 1) assert_equals: expected "rgb(44, 20, 20)" but got "rgb(43, 19, 19)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 25%) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 0) assert_equals: expected "rgba(88, 40, 40, 0)" but got "rgba(87, 39, 39, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 0.2) assert_equals: expected "rgba(88, 40, 40, 0.2)" but got "rgba(87, 39, 39, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 25%, 1) assert_equals: expected "rgb(88, 40, 40)" but got "rgb(87, 39, 39)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 37.5%) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 0) assert_equals: expected "rgba(131, 60, 60, 0)" but got "rgba(131, 59, 59, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 0.2) assert_equals: expected "rgba(131, 60, 60, 0.2)" but got "rgba(131, 59, 59, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 37.5%, 1) assert_equals: expected "rgb(131, 60, 60)" but got "rgb(131, 59, 59)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 50%) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 0) assert_equals: expected "rgba(175, 80, 80, 0)" but got "rgba(175, 79, 79, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 0.2) assert_equals: expected "rgba(175, 80, 80, 0.2)" but got "rgba(175, 79, 79, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 50%, 1) assert_equals: expected "rgb(175, 80, 80)" but got "rgb(175, 79, 79)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 62.5%) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 0) assert_equals: expected "rgba(195, 124, 124, 0)" but got "rgba(195, 123, 123, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 0.2) assert_equals: expected "rgba(195, 124, 124, 0.2)" but got "rgba(195, 123, 123, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 62.5%, 1) assert_equals: expected "rgb(195, 124, 124)" but got "rgb(195, 123, 123)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 37.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 37.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 12.5%) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 0) assert_equals: expected "rgba(48, 16, 16, 0)" but got "rgba(47, 15, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 0.2) assert_equals: expected "rgba(48, 16, 16, 0.2)" but got "rgba(47, 15, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 12.5%, 1) assert_equals: expected "rgb(48, 16, 16)" but got "rgb(47, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 25%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgba(95, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgba(95, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 25%, 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(95, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 37.5%) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 0) assert_equals: expected "rgba(143, 48, 48, 0)" but got "rgba(143, 47, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 0.2) assert_equals: expected "rgba(143, 48, 48, 0.2)" but got "rgba(143, 47, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 37.5%, 1) assert_equals: expected "rgb(143, 48, 48)" but got "rgb(143, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 50%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgba(191, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgba(191, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 50%, 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(191, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 50%, 62.5%) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 0) assert_equals: expected "rgba(207, 112, 112, 0)" but got "rgba(207, 111, 111, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 0.2) assert_equals: expected "rgba(207, 112, 112, 0.2)" but got "rgba(207, 111, 111, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 50%, 62.5%, 1) assert_equals: expected "rgb(207, 112, 112)" but got "rgb(207, 111, 111)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 50%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 50%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 12.5%) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 0) assert_equals: expected "rgba(52, 12, 12, 0)" but got "rgba(51, 11, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 0.2) assert_equals: expected "rgba(52, 12, 12, 0.2)" but got "rgba(51, 11, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 12.5%, 1) assert_equals: expected "rgb(52, 12, 12)" but got "rgb(51, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 25%) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 0) assert_equals: expected "rgba(104, 24, 24, 0)" but got "rgba(103, 23, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 0.2) assert_equals: expected "rgba(104, 24, 24, 0.2)" but got "rgba(103, 23, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 25%, 1) assert_equals: expected "rgb(104, 24, 24)" but got "rgb(103, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 37.5%) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 0) assert_equals: expected "rgba(155, 36, 36, 0)" but got "rgba(155, 35, 35, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 0.2) assert_equals: expected "rgba(155, 36, 36, 0.2)" but got "rgba(155, 35, 35, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 37.5%, 1) assert_equals: expected "rgb(155, 36, 36)" but got "rgb(155, 35, 35)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 50%) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 0) assert_equals: expected "rgba(207, 48, 48, 0)" but got "rgba(207, 47, 47, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 0.2) assert_equals: expected "rgba(207, 48, 48, 0.2)" but got "rgba(207, 47, 47, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 50%, 1) assert_equals: expected "rgb(207, 48, 48)" but got "rgb(207, 47, 47)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 62.5%) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 0) assert_equals: expected "rgba(219, 100, 100, 0)" but got "rgba(219, 99, 99, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 0.2) assert_equals: expected "rgba(219, 100, 100, 0.2)" but got "rgba(219, 99, 99, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 62.5%, 1) assert_equals: expected "rgb(219, 100, 100)" but got "rgb(219, 99, 99)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 62.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 62.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 12.5%) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 0) assert_equals: expected "rgba(56, 8, 8, 0)" but got "rgba(55, 7, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 0.2) assert_equals: expected "rgba(56, 8, 8, 0.2)" but got "rgba(55, 7, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 12.5%, 1) assert_equals: expected "rgb(56, 8, 8)" but got "rgb(55, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 25%) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 0) assert_equals: expected "rgba(112, 16, 16, 0)" but got "rgba(111, 15, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 0.2) assert_equals: expected "rgba(112, 16, 16, 0.2)" but got "rgba(111, 15, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 25%, 1) assert_equals: expected "rgb(112, 16, 16)" but got "rgb(111, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 37.5%) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 0) assert_equals: expected "rgba(167, 24, 24, 0)" but got "rgba(167, 23, 23, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 0.2) assert_equals: expected "rgba(167, 24, 24, 0.2)" but got "rgba(167, 23, 23, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 37.5%, 1) assert_equals: expected "rgb(167, 24, 24)" but got "rgb(167, 23, 23)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 50%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgba(223, 31, 31, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgba(223, 31, 31, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 50%, 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(223, 31, 31)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 75%, 62.5%) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 0) assert_equals: expected "rgba(231, 88, 88, 0)" but got "rgba(231, 87, 87, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 0.2) assert_equals: expected "rgba(231, 88, 88, 0.2)" but got "rgba(231, 87, 87, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 75%, 62.5%, 1) assert_equals: expected "rgb(231, 88, 88)" but got "rgb(231, 87, 87)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 75%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 75%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 12.5%) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 0) assert_equals: expected "rgba(60, 4, 4, 0)" but got "rgba(59, 3, 3, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 0.2) assert_equals: expected "rgba(60, 4, 4, 0.2)" but got "rgba(59, 3, 3, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 12.5%, 1) assert_equals: expected "rgb(60, 4, 4)" but got "rgb(59, 3, 3)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 25%) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 0) assert_equals: expected "rgba(120, 8, 8, 0)" but got "rgba(119, 7, 7, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 0.2) assert_equals: expected "rgba(120, 8, 8, 0.2)" but got "rgba(119, 7, 7, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 25%, 1) assert_equals: expected "rgb(120, 8, 8)" but got "rgb(119, 7, 7)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 37.5%) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 0) assert_equals: expected "rgba(179, 12, 12, 0)" but got "rgba(179, 11, 11, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 0.2) assert_equals: expected "rgba(179, 12, 12, 0.2)" but got "rgba(179, 11, 11, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 37.5%, 1) assert_equals: expected "rgb(179, 12, 12)" but got "rgb(179, 11, 11)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 50%) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 0) assert_equals: expected "rgba(239, 16, 16, 0)" but got "rgba(239, 15, 15, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 0.2) assert_equals: expected "rgba(239, 16, 16, 0.2)" but got "rgba(239, 15, 15, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 50%, 1) assert_equals: expected "rgb(239, 16, 16)" but got "rgb(239, 15, 15)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 62.5%) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 0) assert_equals: expected "rgba(243, 76, 76, 0)" but got "rgba(243, 75, 75, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 0.2) assert_equals: expected "rgba(243, 76, 76, 0.2)" but got "rgba(243, 75, 75, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 62.5%, 1) assert_equals: expected "rgb(243, 76, 76)" but got "rgb(243, 75, 75)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 75%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 75%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 75%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 75%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 87.5%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 87.5%, 100%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 0%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 0%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 0%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 0%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 12.5%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgba(63, 0, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgba(63, 0, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 12.5%, 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(63, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 25%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgba(127, 0, 0, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgba(127, 0, 0, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 25%, 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(127, 0, 0)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 37.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 37.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 37.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 37.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 50%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 50%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 50%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 50%, 1) 
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 62.5%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgba(255, 63, 63, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgba(255, 63, 63, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 62.5%, 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(255, 63, 63)"
FAIL HSL/HSLA value should parse and round correctly: hsl(360, 100%, 75%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgba(255, 127, 127, 0)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgba(255, 127, 127, 0.2)"
FAIL HSL/HSLA value should parse and round correctly: hsla(360, 100%, 75%, 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(255, 127, 127)"
PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 87.5%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 87.5%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 87.5%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 87.5%, 1) 
PASS HSL/HSLA value should parse and round correctly: hsl(360, 100%, 100%) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 100%, 0) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 100%, 0.2) 
PASS HSL/HSLA value should parse and round correctly: hsla(360, 100%, 100%, 1)