Update charted to 0.4.8 and roll

packages/csslib/test/mixin_test.dart

 // Copyright (c) 2013, 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.
 
 library mixin_test;
 
+import 'package:csslib/src/messages.dart';
 import 'package:test/test.dart';
 
 import 'testing.dart';
 
 compileAndValidate(String input, String generated) {
-  var errors = [];
+  var errors = <Message>[];
   var stylesheet = compileCss(input, errors: errors, opts: options);
   expect(stylesheet != null, true);
   expect(errors.isEmpty, true, reason: errors.toString());
   expect(prettyPrint(stylesheet), generated);
 }
 
 compilePolyfillAndValidate(String input, String generated) {
-  var errors = [];
+  var errors = <Message>[];
   var stylesheet = polyFillCompileCss(input, errors: errors, opts: options);
   expect(stylesheet != null, true);
   expect(errors.isEmpty, true, reason: errors.toString());
   expect(prettyPrint(stylesheet), generated);
 }
 
 void topLevelMixin() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin silly-links {
   a {
     color: blue;
     background-color: red;
   }
 }
 
 @include silly-links;
-''', r'''a {
+''',
+      r'''
+a {
   color: #00f;
   background-color: #f00;
 }''');
 }
 
 void topLevelMixinTwoIncludes() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin a {
   a {
     color: blue;
     background-color: red;
   }
 }
 @mixin b {
   span {
     color: black;
     background-color: orange;
   }
 }
 @include a;
 @include b;
-''', r'''a {
+''',
+      r'''
+a {
   color: #00f;
   background-color: #f00;
 }
 span {
   color: #000;
   background-color: #ffa500;
 }''');
 }
 
 /** Tests top-level mixins that includes another mixin. */
 void topLevelMixinMultiRulesets() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin a {
   a {
     color: blue;
     background-color: red;
   }
 }
 @mixin b {
   #foo-id {
     border-top: 1px solid red;
     border-bottom: 2px solid green;
   }
 }
 @mixin c {
   span {
     color: black;
     background-color: orange;
   }
   @include b;
 }
 @include a;
 @include c;
-''', r'''a {
+''',
+      r'''
+a {
   color: #00f;
   background-color: #f00;
 }
 span {
   color: #000;
   background-color: #ffa500;
 }
 #foo-id {
   border-top: 1px solid #f00;
   border-bottom: 2px solid #008000;
 }''');
 }
 
 void topLevelMixinDeeplyNestedRulesets() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin a {
   a {
     color: blue;
     background-color: red;
   }
 }
 @mixin b {
   #foo-id {
     border-top: 1px solid red;
     border-bottom: 2px solid green;
@@ skipping 19 matching lines @@
 @mixin c {
   @include a;
   span {
     color: black;
     background-color: orange;
   }
   @include b;
   @include d;
 }
 @include c;
-''', r'''a {
+''',
+      r'''
+a {
   color: #00f;
   background-color: #f00;
 }
 span {
   color: #000;
   background-color: #ffa500;
 }
 #foo-id {
   border-top: 1px solid #f00;
   border-bottom: 2px solid #008000;
 }
 a:hover {
   cursor: arrow;
 }
 #split-bar:visited {
   color: #808080;
 }
 #split-bar div {
   border: 1px solid #d3d3d3;
 }''');
 }
 
 /** Tests selector groups and other combinators. */
 void topLevelMixinSelectors() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin a {
   a, b {
     color: blue;
     background-color: red;
   }
   div > span {
     color: black;
     background-color: orange;
   }
 }
 
 @include a;
-''', r'''a, b {
+''',
+      r'''
+a, b {
   color: #00f;
   background-color: #f00;
 }
 div > span {
   color: #000;
   background-color: #ffa500;
 }''');
 }
 
 void declSimpleMixin() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin div-border {
   border: 2px dashed red;
 }
 div {
   @include div-border;
 }
-''', r'''div {
+''',
+      r'''
+div {
   border: 2px dashed #f00;
 }''');
 }
 
 void declMixinTwoIncludes() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin div-border {
   border: 2px dashed red;
 }
 @mixin div-color {
   color: blue;
 }
 div {
   @include div-border;
   @include div-color;
 }
-''', r'''div {
+''',
+      r'''
+div {
   border: 2px dashed #f00;
   color: #00f;
 }''');
 }
 
 void declMixinNestedIncludes() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin div-border {
   border: 2px dashed red;
 }
 @mixin div-padding {
   padding: .5em;
 }
 @mixin div-margin {
   margin: 5px;
 }
 @mixin div-color {
   @include div-padding;
   color: blue;
   @include div-margin;
 }
 div {
   @include div-border;
   @include div-color;
 }
-''', r'''div {
+''',
+      r'''
+div {
   border: 2px dashed #f00;
   padding: .5em;
   color: #00f;
   margin: 5px;
 }''');
 }
 
 void declMixinDeeperNestedIncludes() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin div-border {
   border: 2px dashed red;
 }
 @mixin div-padding {
   padding: .5em;
 }
 @mixin div-margin {
   margin: 5px;
 }
 @mixin div-color {
   @include div-padding;
   @include div-margin;
 }
 div {
   @include div-border;
   @include div-color;
 }
-''', r'''div {
+''',
+      r'''
+div {
   border: 2px dashed #f00;
   padding: .5em;
   margin: 5px;
 }''');
 }
 
 void mixinArg() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin div-border-1 {
   border: 2px dashed red;
 }
 @mixin div-border-2() {
   border: 22px solid blue;
 }
 @mixin div-left(@dist) {
   margin-left: @dist;
 }
 @mixin div-right(var-margin) {
   margin-right: var(margin);
 }
 div-1 {
   @include div-left(10px);
   @include div-right(100px);
   @include div-border-1;
 }
 div-2 {
   @include div-left(20em);
   @include div-right(5in);
   @include div-border-2();
 }
 div-3 {
   @include div-border-1();
 }
 div-4 {
   @include div-border-2;
 }
-''', r'''div-1 {
+''',
+      r'''
+div-1 {
   margin-left: 10px;
   margin-right: 100px;
   border: 2px dashed #f00;
 }
 div-2 {
   margin-left: 20em;
   margin-right: 5in;
   border: 22px solid #00f;
 }
 div-3 {
   border: 2px dashed #f00;
 }
 div-4 {
   border: 22px solid #00f;
 }''');
 }
 
 void mixinArgs() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin box-shadow(@shadows...) {
   -moz-box-shadow: @shadows;
   -webkit-box-shadow: @shadows;
   box-shadow: var(shadows);
 }
 
 .shadows {
   @include box-shadow(0px 4px 5px #666, 2px 6px 10px #999);
-}''', r'''
+}''',
+      r'''
 .shadowed {
   -moz-box-shadow: 0px 4px 5px #666, 2px 6px 10px #999;
   -webkit-box-shadow: 0px 4px 5px #666, 2px 6px 10px #999;
   box-shadow: 0px 4px 5px #666, 2px 6px 10px #999;
 }
 ''');
 }
 
 void mixinManyArgs() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin border(@border-values) {
   border: @border-values
 }
 
 .primary {
   @include border(3px solid green);
 }
-''', r'''
+''',
+      r'''
 .primary {
   border: 3px solid #008000;
 }''');
 
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin setup(@border-color, @border-style, @border-size, @color) {
   border: @border-size @border-style @border-color;
   color: @color;
 }
 
 .primary {
   @include setup(red, solid, 5px, blue);
 }
-''', r'''
+''',
+      r'''
 .primary {
   border: 5px solid #f00;
   color: #00f;
 }''');
 
   // Test passing a declaration that is multiple parameters.
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin colors(@text, @background, @border) {
   color: @text;
   background-color: @background;
   border-color: @border;
 }
 
 @values: #ff0000, #00ff00, #0000ff;
 .primary {
   @include colors(@values);
 }
-''', r'''var-values: #f00, #0f0, #00f;
+''',
+      r'''
+var-values: #f00, #0f0, #00f;
 
 .primary {
   color: #f00;
   background-color: #0f0;
   border-color: #00f;
 }''');
 
-  compilePolyfillAndValidate(r'''
+  compilePolyfillAndValidate(
+      r'''
 @mixin colors(@text, @background, @border) {
   color: @text;
   background-color: @background;
   border-color: @border;
 }
 
 @values: #ff0000, #00ff00, #0000ff;
 .primary {
   @include colors(@values);
 }
-''', r'''.primary {
+''',
+      r'''
+.primary {
   color: #f00;
   background-color: #0f0;
   border-color: #00f;
 }''');
 }
 
 void badDeclarationInclude() {
-  final errors = [];
+  final errors = <Message>[];
   final input = r'''
 @mixin a {
   #foo-id {
     color: red;
   }
 }
 @mixin b {
   span {
     border: 2px dashed red;
     @include a;
   }
 }
 @include b;
 ''';
 
   var stylesheet = compileCss(input, errors: errors, opts: options);
 
   expect(stylesheet != null, true);
   expect(errors.isNotEmpty, true);
   expect(errors.length, 1, reason: errors.toString());
   var error = errors[0];
   expect(error.message, 'Using top-level mixin a as a declaration');
   expect(error.span.start.line, 8);
   expect(error.span.end.offset, 105);
 }
 
 void badTopInclude() {
-  final errors = [];
+  final errors = <Message>[];
   final input = r'''
 @mixin b {
   color: red;
 }
 
 @mixin a {
   span {
     border: 2px dashed red;
   }
   @include b;
 }
 
 @include a;
   ''';
 
   var stylesheet = compileCss(input, errors: errors, opts: options);
   expect(stylesheet != null, true);
   expect(errors.length, 1, reason: errors.toString());
   var error = errors[0];
   expect(error.message, 'Using declaration mixin b as top-level mixin');
   expect(error.span.start.line, 8);
   expect(error.span.end.offset, 90);
 }
 
 void emptyMixin() {
-  final errors = [];
+  final errors = <Message>[];
   final input = r'''
 @mixin a {
 }
 @mixin b {
   border: 2px dashed red;
   @include a;
 }
 div {
   @include b;
 }
   ''';
 
-  var generated = r'''div {
+  var generated = r'''
+div {
   border: 2px dashed #f00;
 }''';
 
   var stylesheet = compileCss(input, errors: errors, opts: options);
 
   expect(stylesheet != null, true);
   expect(errors.isEmpty, true, reason: errors.toString());
   expect(prettyPrint(stylesheet), generated);
 }
 
 void undefinedTopLevel() {
-  final errors = [];
+  final errors = <Message>[];
   final input = r'''
 @mixin a {
   @include b;
 }
 @mixin b {
   span {
     border: 2px dashed red;
   }
   @include a;
 }
 
 @include b;
 
   ''';
 
   var stylesheet = compileCss(input, errors: errors, opts: options);
 
   expect(stylesheet != null, true);
   expect(errors.isNotEmpty, true);
   expect(errors.length, 1, reason: errors.toString());
   var error = errors[0];
   expect(error.message, 'Undefined mixin b');
   expect(error.span.start.line, 1);
   expect(error.span.start.offset, 14);
 }
 
 void undefinedDeclaration() {
-  final errors = [];
+  final errors = <Message>[];
   final input = r'''
 @mixin a {
   @include b;
 }
 @mixin b {
   border: 2px dashed red;
   @include a;
 }
 div {
   @include b;
 }
   ''';
 
   var stylesheet = compileCss(input, errors: errors, opts: options);
 
   expect(stylesheet != null, true);
   expect(errors.isNotEmpty, true);
   expect(errors.length, 1, reason: errors.toString());
   var error = errors[0];
   expect(error.message, 'Undefined mixin b');
   expect(error.span.start.line, 1);
   expect(error.span.start.offset, 14);
 }
 
 void includeGrammar() {
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin a {
   foo { color: red }
 }
 
 @mixin b {
   @include a;
   @include a;
 }
 
 @include b;
-''', r'''foo {
+''',
+      r'''
+foo {
   color: #f00;
 }
 foo {
   color: #f00;
 }''');
 
-  compileAndValidate(r'''
+  compileAndValidate(
+      r'''
 @mixin a {
   color: red
 }
 
 foo {
   @include a;
   @include a
 }
-''', r'''foo {
+''',
+      r'''
+foo {
   color: #f00;
   color: #f00;
 }''');
 
-  var errors = [];
+  var errors = <Message>[];
   var input = r'''
 @mixin a {
   foo { color: red }
 }
 
 @mixin b {
   @include a
   @include a
 }
 
@@ skipping 58 matching lines @@
     test('multiple args and var decls as args', mixinManyArgs);
   });
 
   group('Mixin warnings', () {
     test('undefined top-level', undefinedTopLevel);
     test('undefined declaration', undefinedDeclaration);
     test('detect bad top-level as declaration', badDeclarationInclude);
     test('detect bad declaration as top-level', badTopInclude);
   });
 }