Enabled CSS tests, added CSS tests to buildbot, fixed tooling with nodejs, and added more tests.

utils/tests/css/src/ExpressionTest.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#import("../../../css/css.dart");
 #import('../../../../frog/lang.dart', prefix:'lang');
-#import("../../../css/css.dart");
 
-class SelectorLiteralTest {
+class ExpressionTest {
 
   static testMain() {
     initCssWorld();
 
     testClass();
     testId();
     testElement();
     testNamespace();
     testSelectorGroups();
     testCombinator();
     testWildcard();
     testPseudo();
     testAttribute();
     testNegation();
   }
 
   static void testClass() {
     Parser parser = new Parser(new lang.SourceFile(
-        lang.SourceFile.IN_MEMORY_FILE, ".foobar"));
-
-    List<SelectorGroup> exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      Expect.equals(selectorGroup.selectors.length, 1);
-      for (selector in selectorGroup.selectors) {
-        Expect.isTrue(selector is ClassSelector);
+        lang.SourceFile.IN_MEMORY_FILE, ".foobar {}"));
+
+    Stylesheet stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    RuleSet ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    List<SimpleSelectorSequence> simpleSeqs =
+        ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+    Expect.equals(simpleSeqs.length, 1);
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      Expect.isTrue(simpSelector is ClassSelector);
+      Expect.isTrue(selector.isCombinatorNone());
+      Expect.equals(simpSelector.name, "foobar");
+    }
+
+    parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
+        ".foobar .bar .no-story {}"));
+
+    stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    simpleSeqs = ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+  
+    var idx = 0;
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      if (idx == 0) {
+        Expect.isTrue(simpSelector is ClassSelector);
         Expect.isTrue(selector.isCombinatorNone());
-        Expect.equals(selector.name, "foobar");
+        Expect.equals(simpSelector.name, "foobar");
+      } else if (idx == 1) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.name, "bar");
+      } else if (idx == 2) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.name, "no-story");
+      } else {
+        Expect.fail("unexpected expression");
       }
+
+      idx++;
+    }
+
+    Expect.equals(simpleSeqs.length, idx);
+  }
+
+  static void testId() {
+    Parser parser = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "#elemId {}"));
+
+    Stylesheet stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    RuleSet ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    List<SimpleSelectorSequence> simpleSeqs =
+        ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+  
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      Expect.isTrue(simpSelector is IdSelector);
+      Expect.isTrue(selector.isCombinatorNone());
+      Expect.equals(simpSelector.name, "elemId");
+    }
+  }
+
+  static void testElement() {
+    Parser parser = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "div {}"));
+    Stylesheet stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    RuleSet ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    List<SimpleSelectorSequence> simpleSeqs =
+        ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      Expect.isTrue(simpSelector is ElementSelector);
+      Expect.isTrue(selector.isCombinatorNone());
+      Expect.equals(simpSelector.name, "div");
     }
 
     parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
-        ".foobar .bar .no-story"));
-
-    exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      var idx = 0;
-      for (selector in selectorGroup.selectors) {
-        if (idx == 0) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.equals(selector.name, "foobar");
-        } else if (idx == 1) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.name, "bar");
-        } else if (idx == 2) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.name, "no-story");
-        } else {
-          Expect.fail("unexpected expression");
-        }
-
-        idx++;
+        "div div span {}"));
+    stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    simpleSeqs = ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+
+    var idx = 0;
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      if (idx == 0) {
+        Expect.isTrue(simpSelector is ElementSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals(simpSelector.name, "div");
+      } else if (idx == 1) {
+        Expect.isTrue(simpSelector is ElementSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.name, "div");
+      } else if (idx == 2) {
+        Expect.isTrue(simpSelector is ElementSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.name, "span");
+      } else {
+        Expect.fail("unexpected expression");
       }
-    }
-  }
-
-  static void testId() {
-    Parser parser = new Parser(new lang.SourceFile(
-        lang.SourceFile.IN_MEMORY_FILE, "#elemId"));
-
-    List<SelectorGroup> exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    Expect.isNotNull(exprTree);
-    for (selectorGroup in exprTree) {
-      Expect.equals(selectorGroup.selectors.length, 1);
-      for (selector in selectorGroup.selectors) {
-        Expect.isTrue(selector is IdSelector);
+  
+      idx++;
+    }
+    Expect.equals(simpleSeqs.length, idx);
+  }
+
+  static void testNamespace() {
+    Parser parser = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "ns1|div {}"));
+    Stylesheet stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    RuleSet ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    List<SimpleSelectorSequence> simpleSeqs =
+        ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      Expect.isTrue(simpSelector is NamespaceSelector);
+      Expect.isTrue(selector.isCombinatorNone());
+      Expect.isFalse(simpSelector.isNamespaceWildcard());
+      Expect.equals(simpSelector.namespace, "ns1");
+      ElementSelector elementSelector = simpSelector.nameAsSimpleSelector;
+      Expect.isTrue(elementSelector is ElementSelector);
+      Expect.isFalse(elementSelector.isWildcard());
+      Expect.equals(elementSelector.name, "div");
+    }
+
+    parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
+        "ns1|div div ns2|span .foobar {}"));
+    stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    simpleSeqs = ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+
+    var idx = 0;
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      if (idx == 0) {
+        Expect.isTrue(simpSelector is NamespaceSelector);
         Expect.isTrue(selector.isCombinatorNone());
-        Expect.equals(selector.name, "elemId");
-      }
-    }
-  }
-
-  static void testElement() {
-    Parser parser = new Parser(new lang.SourceFile(
-        lang.SourceFile.IN_MEMORY_FILE, "div"));
-    List<SelectorGroup> exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      Expect.equals(selectorGroup.selectors.length, 1);
-      for (selector in selectorGroup.selectors) {
-        Expect.isTrue(selector is ElementSelector);
-        Expect.isTrue(selector.isCombinatorNone());
-        Expect.equals(selector.name, "div");
-      }
-    }
-
-    parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
-        "div div span"));
-    exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      var idx = 0;
-      for (selector in selectorGroup.selectors) {
-        if (idx == 0) {
-          Expect.isTrue(selector is ElementSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.equals(selector.name, "div");
-        } else if (idx == 1) {
-          Expect.isTrue(selector is ElementSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.name, "div");
-        } else if (idx == 2) {
-          Expect.isTrue(selector is ElementSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.name, "span");
-        } else {
-          Expect.fail("unexpected expression");
-        }
-  
-        idx++;
-      }
-    }
-  }
-
-  static void testNamespace() {
-    Parser parser = new Parser(new lang.SourceFile(
-        lang.SourceFile.IN_MEMORY_FILE, "ns1|div"));
-    List<SelectorGroup> exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      Expect.equals(selectorGroup.selectors.length, 1);
-      for (selector in selectorGroup.selectors) {
-        Expect.isTrue(selector is NamespaceSelector);
-        Expect.isTrue(selector.isCombinatorNone());
-        Expect.isFalse(selector.isNamespaceWildcard());
-        Expect.equals(selector.namespace, "ns1");
-        ElementSelector elementSelector = selector.nameAsSimpleSelector;
+        Expect.equals(simpSelector.namespace, "ns1");
+        ElementSelector elementSelector = simpSelector.nameAsSimpleSelector;
         Expect.isTrue(elementSelector is ElementSelector);
         Expect.isFalse(elementSelector.isWildcard());
         Expect.equals(elementSelector.name, "div");
+      } else if (idx == 1) {
+        Expect.isTrue(simpSelector is ElementSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.name, "div");
+      } else if (idx == 2) {
+        Expect.isTrue(simpSelector is NamespaceSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.namespace, "ns2");
+        ElementSelector elementSelector = simpSelector.nameAsSimpleSelector;
+        Expect.isTrue(elementSelector is ElementSelector);
+        Expect.isFalse(elementSelector.isWildcard());
+        Expect.equals(elementSelector.name, "span");
+      } else if (idx == 3) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.name, "foobar");
+      } else {
+        Expect.fail("unexpected expression");
       }
-    }
-
-    parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
-        "ns1|div div ns2|span .foobar"));
-    exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
+  
+      idx++;
+    }
+
+    Expect.equals(simpleSeqs.length, idx);
+  }
+
+  static void testSelectorGroups() {
+    Parser parser = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE,
+        "div, .foobar ,#elemId, .xyzzy .test, ns1|div div #elemId .foobar {}"));
+    Stylesheet stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    RuleSet ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 5);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    var groupIdx = 0;
+    for (final selectorGroup in ruleset.selectorGroup.selectors) {
       var idx = 0;
-      for (selector in selectorGroup.selectors) {
-        if (idx == 0) {
-          Expect.isTrue(selector is NamespaceSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.equals(selector.namespace, "ns1");
-          ElementSelector elementSelector = selector.nameAsSimpleSelector;
-          Expect.isTrue(elementSelector is ElementSelector);
-          Expect.isFalse(elementSelector.isWildcard());
-          Expect.equals(elementSelector.name, "div");
-        } else if (idx == 1) {
-          Expect.isTrue(selector is ElementSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.name, "div");
-        } else if (idx == 2) {
-          Expect.isTrue(selector is NamespaceSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.namespace, "ns2");
-          ElementSelector elementSelector = selector.nameAsSimpleSelector;
-          Expect.isTrue(elementSelector is ElementSelector);
-          Expect.isFalse(elementSelector.isWildcard());
-          Expect.equals(elementSelector.name, "span");
-        } else if (idx == 3) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.name, "foobar");
-        } else {
-          Expect.fail("unexpected expression");
-        }
-  
-        idx++;
-      }
-    }
-  }
-
-  static void testSelectorGroups() {
-    Parser parser = new Parser(new lang.SourceFile(
-        lang.SourceFile.IN_MEMORY_FILE,
-        "div, .foobar ,#elemId, .xyzzy .test, ns1|div div #elemId .foobar"));
-    List<SelectorGroup> exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 5);
-    var groupIdx = 0;
-    for (selectorGroup in exprTree) {
-      var idx = 0;
-      for (selector in selectorGroup.selectors) {
+      for (final selector in selectorGroup.simpleSelectorSequences) {
+        final simpSelector = selector.simpleSelector;
         switch (groupIdx) {
           case 0:                       // First selector group.
-            Expect.equals(selectorGroup.selectors.length, 1);
-            Expect.isTrue(selector is ElementSelector);
+            Expect.isTrue(simpSelector is ElementSelector);
             Expect.isTrue(selector.isCombinatorNone());
-            Expect.equals(selector.name, "div");
+            Expect.equals(simpSelector.name, "div");
             break;
           case 1:                       // Second selector group.
-            Expect.equals(selectorGroup.selectors.length, 1);
-            Expect.isTrue(selector is ClassSelector);
+            Expect.isTrue(simpSelector is ClassSelector);
             Expect.isTrue(selector.isCombinatorNone());
-            Expect.equals(selector.name, "foobar");
+            Expect.equals(simpSelector.name, "foobar");
             break;
           case 2:                       // Third selector group.
-            Expect.equals(selectorGroup.selectors.length, 1);
-            Expect.isTrue(selector is IdSelector);
+            Expect.isTrue(simpSelector is IdSelector);
             Expect.isTrue(selector.isCombinatorNone());
-            Expect.equals(selector.name, "elemId");
+            Expect.equals(simpSelector.name, "elemId");
             break;
           case 3:                       // Fourth selector group.
-            Expect.equals(selectorGroup.selectors.length, 2);
+            Expect.equals(selectorGroup.simpleSelectorSequences.length, 2);
             if (idx == 0) {
-              Expect.isTrue(selector is ClassSelector);
+              Expect.isTrue(simpSelector is ClassSelector);
               Expect.isTrue(selector.isCombinatorNone());
-              Expect.equals(selector.name, "xyzzy");
+              Expect.equals(simpSelector.name, "xyzzy");
             } else if (idx == 1) {
-              Expect.isTrue(selector is ClassSelector);
-              Expect.isTrue(selector.isCombinatorDescendant());
-              Expect.equals(selector.name, "test");
+              Expect.isTrue(simpSelector is ClassSelector);
+              Expect.isTrue(selector.isCombinatorDescendant());
+              Expect.equals(simpSelector.name, "test");
             } else {
               Expect.fail("unexpected expression");
             }
             break;
           case 4:                       // Fifth selector group.
-            Expect.equals(selectorGroup.selectors.length, 4);
+            Expect.equals(selectorGroup.simpleSelectorSequences.length, 4);
             if (idx == 0) {
-              Expect.isTrue(selector is NamespaceSelector);
+              Expect.isTrue(simpSelector is NamespaceSelector);
               Expect.isTrue(selector.isCombinatorNone());
-              Expect.equals(selector.namespace, "ns1");
-              ElementSelector elementSelector = selector.nameAsSimpleSelector;
+              Expect.equals(simpSelector.namespace, "ns1");
+              ElementSelector elementSelector = simpSelector.nameAsSimpleSelector;
               Expect.isTrue(elementSelector is ElementSelector);
               Expect.isFalse(elementSelector.isWildcard());
               Expect.equals(elementSelector.name, "div");
             } else if (idx == 1) {
-              Expect.isTrue(selector is ElementSelector);
-              Expect.isTrue(selector.isCombinatorDescendant());
-              Expect.equals(selector.name, "div");
+              Expect.isTrue(simpSelector is ElementSelector);
+              Expect.isTrue(selector.isCombinatorDescendant());
+              Expect.equals(simpSelector.name, "div");
             } else if (idx == 2) {
-              Expect.isTrue(selector is IdSelector);
-              Expect.isTrue(selector.isCombinatorDescendant());
-              Expect.equals(selector.name, "elemId");
+              Expect.isTrue(simpSelector is IdSelector);
+              Expect.isTrue(selector.isCombinatorDescendant());
+              Expect.equals(simpSelector.name, "elemId");
             } else if (idx == 3) {
-              Expect.isTrue(selector is ClassSelector);
-              Expect.isTrue(selector.isCombinatorDescendant());
-              Expect.equals(selector.name, "foobar");
+              Expect.isTrue(simpSelector is ClassSelector);
+              Expect.isTrue(selector.isCombinatorDescendant());
+              Expect.equals(simpSelector.name, "foobar");
             } else {
               Expect.fail("unexpected expression");
             }
             break;
         }
         idx++;
       }
       groupIdx++;
     }
   }
 
   static void testCombinator() {
     Parser parser = new Parser(new lang.SourceFile(
         lang.SourceFile.IN_MEMORY_FILE,
-        ".foobar > .bar + .no-story ~ myNs|div #elemId"));
+        ".foobar > .bar + .no-story ~ myNs|div #elemId {}"));
 
-    List<SelectorGroup> exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      var idx = 0;
-      Expect.equals(selectorGroup.selectors.length, 5);
-      for (selector in selectorGroup.selectors) {
-        if (idx == 0) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.equals(selector.name, "foobar");
-        } else if (idx == 1) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorGreater());
-          Expect.equals(selector.name, "bar");
-        } else if (idx == 2) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorPlus());
-          Expect.equals(selector.name, "no-story");
-        } else if (idx == 3) {
-          Expect.isTrue(selector is NamespaceSelector);
-          Expect.isTrue(selector.isCombinatorTilde());
-          Expect.equals(selector.namespace, "myNs");
-          ElementSelector elementSelector = selector.nameAsSimpleSelector;
-          Expect.isTrue(elementSelector is ElementSelector);
-          Expect.isFalse(elementSelector.isWildcard());
-          Expect.equals(elementSelector.name, "div");
-        } else if (idx == 4) {
-          Expect.isTrue(selector is IdSelector);
-          Expect.isTrue(selector.isCombinatorDescendant());
-          Expect.equals(selector.name, "elemId");
-        } else {
-          Expect.fail("unexpected expression");
-        }
+    Stylesheet stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
 
-        idx++;
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    RuleSet ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    List<SimpleSelectorSequence> simpleSeqs =
+      ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+
+    Expect.equals(simpleSeqs.length, 5);
+    var idx = 0;
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      if (idx == 0) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals(simpSelector.name, "foobar");
+      } else if (idx == 1) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorGreater());
+        Expect.equals(simpSelector.name, "bar");
+      } else if (idx == 2) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorPlus());
+        Expect.equals(simpSelector.name, "no-story");
+      } else if (idx == 3) {
+        Expect.isTrue(simpSelector is NamespaceSelector);
+        Expect.isTrue(selector.isCombinatorTilde());
+        Expect.equals(simpSelector.namespace, "myNs");
+        ElementSelector elementSelector = simpSelector.nameAsSimpleSelector;
+        Expect.isTrue(elementSelector is ElementSelector);
+        Expect.isFalse(elementSelector.isWildcard());
+        Expect.equals(elementSelector.name, "div");
+      } else if (idx == 4) {
+        Expect.isTrue(simpSelector is IdSelector);
+        Expect.isTrue(selector.isCombinatorDescendant());
+        Expect.equals(simpSelector.name, "elemId");
+      } else {
+        Expect.fail("unexpected expression");
       }
+
+      idx++;
     }
   }
 
   static void testWildcard() {
     Parser parser = new Parser(new lang.SourceFile(
-        lang.SourceFile.IN_MEMORY_FILE, "*"));
+        lang.SourceFile.IN_MEMORY_FILE, "* {}"));
 
-    List<SelectorGroup> exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      Expect.equals(selectorGroup.selectors.length, 1);
-      for (selector in selectorGroup.selectors) {
-        Expect.isTrue(selector is ElementSelector);
-        Expect.isTrue(selector.isCombinatorNone());
-        Expect.isTrue(selector.isWildcard());
-        Expect.equals(selector.name, "*");
-      }
+    Stylesheet stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
+
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    RuleSet ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    List<SimpleSelectorSequence> simpleSeqs =
+        ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      Expect.isTrue(simpSelector is ElementSelector);
+      Expect.isTrue(selector.isCombinatorNone());
+      Expect.isTrue(simpSelector.isWildcard());
+      Expect.equals(simpSelector.name, "*");
     }
 
     parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
-        "*.foobar"));
+        "*.foobar {}"));
 
-    exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      var idx = 0;
-      for (selector in selectorGroup.selectors) {
-        Expect.equals(selectorGroup.selectors.length, 2);
-        if (idx == 0) {
-          Expect.isTrue(selector is ElementSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.isTrue(selector.isWildcard());
-          Expect.equals(selector.name, "*");
-        } else if (idx == 1) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.equals(selector.name, "foobar");
-        } else {
-          Expect.fail("unexpected expression");
-        }
+    stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
 
-        idx++;
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    simpleSeqs = ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+    
+    Expect.equals(simpleSeqs.length, 2);
+    var idx = 0;
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      if (idx == 0) {
+        Expect.isTrue(simpSelector is ElementSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.isTrue(simpSelector.isWildcard());
+        Expect.equals(simpSelector.name, "*");
+      } else if (idx == 1) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals(simpSelector.name, "foobar");
+      } else {
+        Expect.fail("unexpected expression");
       }
+
+      idx++;
     }
 
     parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
-        "myNs|*.foobar"));
+        "myNs|*.foobar {}"));
 
-    exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      var idx = 0;
-      for (selector in selectorGroup.selectors) {
-        Expect.equals(selectorGroup.selectors.length, 2);
-        if (idx == 0) {
-          Expect.isTrue(selector is NamespaceSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.isFalse(selector.isNamespaceWildcard());
-          ElementSelector elementSelector = selector.nameAsSimpleSelector;
-          Expect.equals("myNs", selector.namespace);
-          Expect.isTrue(elementSelector.isWildcard());
-          Expect.equals("*", elementSelector.name);
-        } else if (idx == 1) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.equals("foobar", selector.name);
-        } else {
-          Expect.fail("unexpected expression");
-        }
+    stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
+    Expect.equals(stylesheet.topLevels.length, 1);
 
-        idx++;
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    simpleSeqs = ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+
+    Expect.equals(simpleSeqs.length, 2);
+    idx = 0;
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      if (idx == 0) {
+        Expect.isTrue(simpSelector is NamespaceSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.isFalse(simpSelector.isNamespaceWildcard());
+        ElementSelector elementSelector = simpSelector.nameAsSimpleSelector;
+        Expect.equals("myNs", simpSelector.namespace);
+        Expect.isTrue(elementSelector.isWildcard());
+        Expect.equals("*", elementSelector.name);
+      } else if (idx == 1) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals("foobar", simpSelector.name);
+      } else {
+        Expect.fail("unexpected expression");
       }
+
+      idx++;
     }
 
     parser = new Parser(new lang.SourceFile(lang.SourceFile.IN_MEMORY_FILE,
-        "*|*.foobar"));
+        "*|*.foobar {}"));
 
-    exprTree = parser.parse();
-    Expect.isNotNull(exprTree);
-    Expect.equals(exprTree.length, 1);
-    for (selectorGroup in exprTree) {
-      var idx = 0;
-      for (selector in selectorGroup.selectors) {
-        Expect.equals(selectorGroup.selectors.length, 2);
-        if (idx == 0) {
-          Expect.isTrue(selector is NamespaceSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.isTrue(selector.isNamespaceWildcard());
-          Expect.equals("*", selector.namespace);
-          ElementSelector elementSelector = selector.nameAsSimpleSelector;
-          Expect.isTrue(elementSelector.isWildcard());
-          Expect.equals("*", elementSelector.name);
-        } else if (idx == 1) {
-          Expect.isTrue(selector is ClassSelector);
-          Expect.isTrue(selector.isCombinatorNone());
-          Expect.equals("foobar", selector.name);
-        } else {
-          Expect.fail("unexpected expression");
-        }
+    stylesheet = parser.parse();
+    Expect.isNotNull(stylesheet);
 
-        idx++;
+    Expect.isTrue(stylesheet.topLevels[0] is RuleSet);
+    ruleset = stylesheet.topLevels[0];
+    Expect.equals(ruleset.selectorGroup.selectors.length, 1);
+    Expect.equals(ruleset.declarationGroup.declarations.length, 0);
+
+    simpleSeqs = ruleset.selectorGroup.selectors[0].simpleSelectorSequences;
+    
+    Expect.equals(simpleSeqs.length, 2);
+    idx = 0;
+    for (final selector in simpleSeqs) {
+      final simpSelector = selector.simpleSelector;
+      if (idx == 0) {
+        Expect.isTrue(simpSelector is NamespaceSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.isTrue(simpSelector.isNamespaceWildcard());
+        Expect.equals("*", simpSelector.namespace);
+        ElementSelector elementSelector = simpSelector.nameAsSimpleSelector;
+        Expect.isTrue(elementSelector.isWildcard());
+        Expect.equals("*", elementSelector.name);
+      } else if (idx == 1) {
+        Expect.isTrue(simpSelector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals("foobar", simpSelector.name);
+      } else {
+        Expect.fail("unexpected expression");
       }
+
+      idx++;
     }
 
   }
 
   static void testPseudo() {
     // TODO(terry): Implement
   }
 
   static void testAttribute() {
     // TODO(terry): Implement
   }
 
   static void testNegation() {
     // TODO(terry): Implement
   }
 
 }
 
 
 main() {
-  SelectorLiteralTest.testMain();
+  ExpressionTest.testMain();
 }