ruby_css_lint 0.0.1

data/csslint/tests/rules/duplicate-background-images.js

@@ -0,0 +1,25 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Duplicate Background-URL Rule Errors",
+
+        "duplicate background-image should result in a warning": function(){
+            var result = CSSLint.verify(".foo { background-image: url('mega-sprite.png'); } .foofoo { background-image: url('fancy-sprite.png'); } .bar { background-image: url(\"mega-sprite.png\"); } .foobar { background: white url(mega-sprite.png); }", {"duplicate-background-images": 1 });
+            Assert.areEqual(2, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Background image 'mega-sprite.png' was used multiple times, first declared at line 1, col 8.", result.messages[0].message);
+        },
+
+        "duplicate background with url should result in a warning": function(){
+            var result = CSSLint.verify(".foo { background: url(mega-sprite.png) repeat-x; } .foofoo { background-image: url('fancy-sprite.png'); } .bar { background: white url(\"mega-sprite.png\") no-repeat left top; } .foobar { background: white url('mega-sprite.png'); }", {"duplicate-background-images": 1 });
+            Assert.areEqual(2, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Background image 'mega-sprite.png' was used multiple times, first declared at line 1, col 8.", result.messages[0].message);
+        }
+    }));
+
+})();

data/csslint/tests/rules/duplicate-properties.js

@@ -0,0 +1,54 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Duplicate Property Rule Errors",
+
+        "Duplicate properties back-to-back should not result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left; float: right }", { "duplicate-properties": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Duplicate properties in @font-face back-to-back should not result in a warning": function(){
+            var result = CSSLint.verify("@font-face { src: url(foo.svg); src: url(foo1.svg) }", { "duplicate-properties": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Duplicate properties in @page back-to-back should not result in a warning": function(){
+            var result = CSSLint.verify("@page :left { margin: 5px; margin: 4px; }", { "duplicate-properties": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Duplicate properties not back-to-back should result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left; margin: 0; float: right }", { "duplicate-properties": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Duplicate property 'float' found.", result.messages[0].message);
+        },
+        
+        "Duplicate properties not back-to-back with same values should result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left; margin: 0; float: left }", { "duplicate-properties": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Duplicate property 'float' found.", result.messages[0].message);
+        },
+        
+        "Duplicate properties back-to-back with same values should result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left; float: left }", { "duplicate-properties": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Duplicate property 'float' found.", result.messages[0].message);
+        },
+        
+        "Duplicate properties in @keyframe rules should not result in a warning": function(){
+            var result = CSSLint.verify("@-webkit-keyframes slide_up {  from {  bottom:-91px; } to {  bottom:0; } }", { "duplicate-properties": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+        
+
+    }));
+
+})();

data/csslint/tests/rules/empty-rules.js

@@ -0,0 +1,18 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Empty Rule Errors",
+
+        "Empty rule should result in a warning": function(){
+            var result = CSSLint.verify("li { }", { "empty-rules": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Rule is empty.", result.messages[0].message);
+        }
+    }));
+
+})();

data/csslint/tests/rules/errors.js

@@ -0,0 +1,17 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Parsing Errors",
+
+        "Parsing error should result in one parsing error message": function(){
+            var result = CSSLint.verify("li { float left;}", { errors: 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("error", result.messages[0].type);
+        }
+    }));
+
+})();

data/csslint/tests/rules/fallback-colors.js

@@ -0,0 +1,162 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Fallback Colors Rule Errors",
+
+        "Using only a named color should not result in a warning": function(){
+            var result = CSSLint.verify(".hex { color: red; }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using only a hex color should not result in a warning": function(){
+            var result = CSSLint.verify(".hex { color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using only rgb() should not result in a warning": function(){
+            var result = CSSLint.verify(".rgb { color: rgb(0, 0, 0); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using only rgba() should result in a warning": function(){
+            var result = CSSLint.verify(".rgba { color: rgba(0, 0, 0, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback color (hex or RGB) should precede RGBA color.", result.messages[0].message);
+        },
+        
+        "Using only hsl() should result in a warning": function(){
+            var result = CSSLint.verify(".hsl { color: hsl(0, 0%, 0%); }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback color (hex or RGB) should precede HSL color.", result.messages[0].message);
+        },
+
+        "Using only hsla() should result in a warning": function(){
+            var result = CSSLint.verify(".hsla { color: hsla(0, 0%, 0%, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback color (hex or RGB) should precede HSLA color.", result.messages[0].message);
+        },
+
+        "Using rgba() with a fallback should not result in a warning": function(){
+            var result = CSSLint.verify(".rgba { color: #fff; color: rgba(0, 0, 0, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using hsl() with a fallback should not result in a warning": function(){
+            var result = CSSLint.verify(".hsl { color: #fff; color: hsl(0, 0%, 0%); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using hsla() with a fallback should not result in a warning": function(){
+            var result = CSSLint.verify(".hsla { color: #fff; color: hsla(0, 0%, 0%, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using rgba() with fallback color afterwards should result in a warning": function(){
+            var result = CSSLint.verify(".rgba { color: rgba(0, 0, 0, 0.5); color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback color (hex or RGB) should precede RGBA color.", result.messages[0].message);
+        },
+        
+        "Using hsl() with fallback color afterwards should result in a warning": function(){
+            var result = CSSLint.verify(".hsl { color: hsl(0, 0%, 0%); color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback color (hex or RGB) should precede HSL color.", result.messages[0].message);
+        },
+
+        "Using hsla() with fallback color afterwards  should result in a warning": function(){
+            var result = CSSLint.verify(".hsla { color: hsla(0, 0%, 0%, 0.5); color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback color (hex or RGB) should precede HSLA color.", result.messages[0].message);
+        },
+        
+
+        "Using only a named background-color should not result in a warning": function(){
+            var result = CSSLint.verify(".hex { background-color: red; }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using only a hex background-color should not result in a warning": function(){
+            var result = CSSLint.verify(".hex { background-color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using only rgb() background-color should not result in a warning": function(){
+            var result = CSSLint.verify(".rgb { background-color: rgb(0, 0, 0); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using only rgba() background-color should result in a warning": function(){
+            var result = CSSLint.verify(".rgba { background-color: rgba(0, 0, 0, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback background-color (hex or RGB) should precede RGBA background-color.", result.messages[0].message);
+        },
+        
+        "Using only hsl() background-color should result in a warning": function(){
+            var result = CSSLint.verify(".hsl { background-color: hsl(0, 0%, 0%); }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback background-color (hex or RGB) should precede HSL background-color.", result.messages[0].message);
+        },
+
+        "Using only hsla() background-color should result in a warning": function(){
+            var result = CSSLint.verify(".hsla { background-color: hsla(0, 0%, 0%, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback background-color (hex or RGB) should precede HSLA background-color.", result.messages[0].message);
+        },
+
+        "Using rgba() with a fallback background-color should not result in a warning": function(){
+            var result = CSSLint.verify(".rgba { background-color: #fff; background-color: rgba(0, 0, 0, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using hsl() with a fallback background-color should not result in a warning": function(){
+            var result = CSSLint.verify(".hsl { background-color: #fff; background-color: hsl(0, 0%, 0%); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using hsla() with a fallback background-color should not result in a warning": function(){
+            var result = CSSLint.verify(".hsla { background-color: #fff; background-color: hsla(0, 0%, 0%, 0.5); }", { "fallback-colors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using rgba() with fallback background-color afterwards should result in a warning": function(){
+            var result = CSSLint.verify(".rgba { background-color: rgba(0, 0, 0, 0.5); background-color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback background-color (hex or RGB) should precede RGBA background-color.", result.messages[0].message);
+        },
+        
+        "Using hsl() with fallback background-color afterwards should result in a warning": function(){
+            var result = CSSLint.verify(".hsl { background-color: hsl(0, 0%, 0%); background-color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback background-color (hex or RGB) should precede HSL background-color.", result.messages[0].message);
+        },
+
+        "Using hsla() with fallback background-color afterwards  should result in a warning": function(){
+            var result = CSSLint.verify(".hsla { background-color: hsla(0, 0%, 0%, 0.5); background-color: #fff; }", { "fallback-colors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Fallback background-color (hex or RGB) should precede HSLA background-color.", result.messages[0].message);
+        }
+
+
+        
+
+
+
+    }));
+
+})();

data/csslint/tests/rules/floats.js

@@ -0,0 +1,35 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Floats Rule Errors",
+
+        "10 floats should result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; }", { "floats": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Too many floats (10), you're probably using them for layout. Consider using a grid system instead.", result.messages[0].message);
+        },
+
+        "9 floats should not result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; }", { "floats": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "11 floats should result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; }", { "floats": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Too many floats (11), you're probably using them for layout. Consider using a grid system instead.", result.messages[0].message);
+        },
+
+        "float: none should not count and therefore should not result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: none; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; } .foo { float: left; }", { "floats": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+    }));
+
+})();

data/csslint/tests/rules/font-faces.js

@@ -0,0 +1,28 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "font-faces Rule Errors",
+
+        "5 font-faces should result in a warning": function(){
+            var result = CSSLint.verify("@font-face{ } @font-face{ } @font-face{ } @font-face{ } @font-face{ }", { "font-faces": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "4 font-faces should not result in a warning": function(){
+            var result = CSSLint.verify("@font-face{} @font-face{} @font-face{} @font-face{}", { "font-faces": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "6 font-faces should result in a warning": function(){
+            var result = CSSLint.verify("@font-face{} @font-face{} @font-face{} @font-face{} @font-face{} @font-face{}", { "font-faces": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Too many @font-face declarations (6).", result.messages[0].message);
+        }
+    }));
+
+})();

data/csslint/tests/rules/font-sizes.js

@@ -0,0 +1,30 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+    
+        name: "font-size Rule Errors",
+
+        "10 font-sizes should result in a warning": function(){
+            var result = CSSLint.verify(".foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } ", {"font-sizes": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Too many font-size declarations (10), abstraction needed.", result.messages[0].message);
+        },
+
+        "9 font-sizes should not result in a warning": function(){
+            var result = CSSLint.verify(" .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } ", {"font-sizes": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "11 font-sizes should result in a warning": function(){
+            var result = CSSLint.verify(".foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } .foo { font-size: 10px; } ", {"font-sizes": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Too many font-size declarations (11), abstraction needed.", result.messages[0].message);
+        }
+    }));
+
+})();

data/csslint/tests/rules/gradients.js

@@ -0,0 +1,60 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+    
+/*
+background: -moz-linear-gradient(top, #1e5799 , #2989d8 , #207cca , #7db9e8 ); 
+background: -webkit-gradient(linear, left top, left bottom, color-stop(,#1e5799), color-stop(,#2989d8), color-stop(,#207cca), color-stop(10,#7db9e8)); 
+background: -webkit-linear-gradient(top, #1e5799 ,#2989d8 ,#207cca ,#7db9e8 );
+background: -o-linear-gradient(top, #1e5799 ,#2989d8 ,#207cca ,#7db9e8 );
+background: -ms-linear-gradient(top, #1e5799 ,#2989d8 ,#207cca ,#7db9e8 ); 
+
+*/
+
+        name: "Gradients Rule Errors",
+
+        "Only using Mozilla gradients should result in a warning": function(){
+            var result = CSSLint.verify(".foo { background: -moz-linear-gradient(top, #1e5799 , #2989d8 , #207cca , #7db9e8 ); }", {"gradients": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Missing vendor-prefixed CSS gradients for Webkit (Safari 5+, Chrome), Old Webkit (Safari 4+, Chrome), Internet Explorer 10+, Opera 11.1+.", result.messages[0].message);
+        },
+
+        "Only using Opera gradients should result in a warning": function(){
+            var result = CSSLint.verify(".foo { background: -o-linear-gradient(top, #1e5799 , #2989d8 , #207cca , #7db9e8 ); }", {"gradients": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Missing vendor-prefixed CSS gradients for Firefox 3.6+, Webkit (Safari 5+, Chrome), Old Webkit (Safari 4+, Chrome), Internet Explorer 10+.", result.messages[0].message);
+        },
+
+        "Only using IE gradients should result in a warning": function(){
+            var result = CSSLint.verify(".foo { background: -ms-linear-gradient(top, #1e5799 , #2989d8 , #207cca , #7db9e8 ); }", {"gradients": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Missing vendor-prefixed CSS gradients for Firefox 3.6+, Webkit (Safari 5+, Chrome), Old Webkit (Safari 4+, Chrome), Opera 11.1+.", result.messages[0].message);
+        },
+
+        "Only using WebKit gradients should result in a warning": function(){
+            var result = CSSLint.verify(".foo { background: -webkit-linear-gradient(top, #1e5799 , #2989d8 , #207cca , #7db9e8 ); }", {"gradients": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Missing vendor-prefixed CSS gradients for Firefox 3.6+, Old Webkit (Safari 4+, Chrome), Internet Explorer 10+, Opera 11.1+.", result.messages[0].message);
+        },
+
+        "Only using old WebKit gradients should result in a warning": function(){
+            var result = CSSLint.verify(".foo { background: -webkit-gradient(linear, left top, left bottom, color-stop(10%,#1e5799), color-stop(20%,#2989d8), color-stop(30%,#207cca), color-stop(100%,#7db9e8)); }", {"gradients": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Missing vendor-prefixed CSS gradients for Firefox 3.6+, Webkit (Safari 5+, Chrome), Internet Explorer 10+, Opera 11.1+.", result.messages[0].message);
+        },
+
+        "Using all vendor-prefixed gradients should not result in a warning": function(){
+            var result = CSSLint.verify("div.box {\n    background: -moz-linear-gradient(top,  #1e5799 0%, #7db9e8 100%);\n    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#1e5799), color-   stop(100%,#7db9e8));\n    background: -webkit-linear-gradient(top,  #1e5799 0%,#7db9e8 100%);\n    background: -o-linear-gradient(top,  #1e5799 0%,#7db9e8 100%);\n    background: -ms-linear-gradient(top,  #1e5799 0%,#7db9e8 100%); \n}", { "gradients": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+    }));
+
+})();

data/csslint/tests/rules/ids.js

@@ -0,0 +1,25 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "IDs Rule Errors",
+
+        "Using an ID should result in one warning": function(){
+            var result = CSSLint.verify("#foo { float: left;}", { ids: 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Don't use IDs in selectors.", result.messages[0].message);
+        },
+
+        "Using multiple IDs should result in one warning": function(){
+            var result = CSSLint.verify("#foo #bar { float: left;}", { ids: 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("2 IDs in the selector, really?", result.messages[0].message);
+        }
+    }));
+
+})();