Inline JUnitTestCase 'assert' methods.

pkg/analyzer/test/generated/scanner_test.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.scanner_test;
 
-import 'package:analyzer/src/generated/java_core.dart';
-import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart' show TokenMap;
-import 'package:unittest/unittest.dart' as _ut;
+import 'package:unittest/unittest.dart';
 import 'test_support.dart';
 import '../reflective_tests.dart';
 
 
-class CharSequenceReaderTest extends JUnitTestCase {
+class CharSequenceReaderTest {
   void test_advance() {
     CharSequenceReader reader = new CharSequenceReader("x");
-    JUnitTestCase.assertEquals(0x78, reader.advance());
-    JUnitTestCase.assertEquals(-1, reader.advance());
-    JUnitTestCase.assertEquals(-1, reader.advance());
+    expect(reader.advance(), 0x78);
+    expect(reader.advance(), -1);
+    expect(reader.advance(), -1);
   }
 
   void test_creation() {
-    JUnitTestCase.assertNotNull(new CharSequenceReader("x"));
+    expect(new CharSequenceReader("x"), isNotNull);
   }
 
   void test_getOffset() {
     CharSequenceReader reader = new CharSequenceReader("x");
-    JUnitTestCase.assertEquals(-1, reader.offset);
+    expect(reader.offset, -1);
     reader.advance();
-    JUnitTestCase.assertEquals(0, reader.offset);
+    expect(reader.offset, 0);
     reader.advance();
-    JUnitTestCase.assertEquals(0, reader.offset);
+    expect(reader.offset, 0);
   }
 
   void test_getString() {
     CharSequenceReader reader = new CharSequenceReader("xyzzy");
     reader.offset = 3;
-    JUnitTestCase.assertEquals("yzz", reader.getString(1, 0));
-    JUnitTestCase.assertEquals("zzy", reader.getString(2, 1));
+    expect(reader.getString(1, 0), "yzz");
+    expect(reader.getString(2, 1), "zzy");
   }
 
   void test_peek() {
     CharSequenceReader reader = new CharSequenceReader("xy");
-    JUnitTestCase.assertEquals(0x78, reader.peek());
-    JUnitTestCase.assertEquals(0x78, reader.peek());
+    expect(reader.peek(), 0x78);
+    expect(reader.peek(), 0x78);
     reader.advance();
-    JUnitTestCase.assertEquals(0x79, reader.peek());
-    JUnitTestCase.assertEquals(0x79, reader.peek());
+    expect(reader.peek(), 0x79);
+    expect(reader.peek(), 0x79);
     reader.advance();
-    JUnitTestCase.assertEquals(-1, reader.peek());
-    JUnitTestCase.assertEquals(-1, reader.peek());
+    expect(reader.peek(), -1);
+    expect(reader.peek(), -1);
   }
 
   void test_setOffset() {
     CharSequenceReader reader = new CharSequenceReader("xyz");
     reader.offset = 2;
-    JUnitTestCase.assertEquals(2, reader.offset);
+    expect(reader.offset, 2);
   }
 }
 
 class IncrementalScannerTest extends EngineTestCase {
   /**
    * The first token from the token stream resulting from parsing the original source, or
    * `null` if [scan] has not been invoked.
    */
   Token _originalTokens;
 
   /**
    * The scanner used to perform incremental scanning, or `null` if [scan] has not been
    * invoked.
    */
   IncrementalScanner _incrementalScanner;
 
   /**
    * The first token from the token stream resulting from performing an incremental scan, or
    * `null` if [scan] has not been invoked.
    */
   Token _incrementalTokens;
 
   void test_delete_identifier_beginning() {
     // "abs + b;"
     // "s + b;")
     _scan("", "ab", "", "s + b;");
     _assertTokens(-1, 1, ["s", "+", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_identifier_end() {
     // "abs + b;"
     // "a + b;")
     _scan("a", "bs", "", " + b;");
     _assertTokens(-1, 1, ["a", "+", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_identifier_middle() {
     // "abs + b;"
     // "as + b;")
     _scan("a", "b", "", "s + b;");
     _assertTokens(-1, 1, ["as", "+", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_mergeTokens() {
     // "a + b + c;"
     // "ac;")
     _scan("a", " + b + ", "", "c;");
     _assertTokens(-1, 1, ["ac", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_afterIdentifier1() {
     // "a + b;"
     // "abs + b;"
     _scan("a", "", "bs", " + b;");
     _assertTokens(-1, 1, ["abs", "+", "b", ";"]);
     _assertReplaced(1, "+");
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_afterIdentifier2() {
     // "a + b;"
     // "a + by;"
     _scan("a + b", "", "y", ";");
     _assertTokens(1, 3, ["a", "+", "by", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_beforeIdentifier() {
     // "a + b;"
     // "a + xb;")
     _scan("a + ", "", "x", "b;");
     _assertTokens(1, 3, ["a", "+", "xb", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_beforeIdentifier_firstToken() {
     // "a + b;"
     // "xa + b;"
     _scan("", "", "x", "a + b;");
     _assertTokens(-1, 1, ["xa", "+", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_convertOneFunctionToTwo() {
     // "f() {}"
     // "f() => 0; g() {}"
     _scan("f()", "", " => 0; g()", " {}");
     _assertTokens(2, 9, ["f", "(", ")", "=>", "0", ";", "g", "(", ")", "{", "}"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_end() {
     // "class A {}"
     // "class A {} class B {}"
     _scan("class A {}", "", " class B {}", "");
     _assertTokens(3, 8, ["class", "A", "{", "}", "class", "B", "{", "}"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_insideIdentifier() {
     // "cob;"
     // "cow.b;"
     _scan("co", "", "w.", "b;");
     _assertTokens(-1, 3, ["cow", ".", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_newIdentifier1() {
     // "a;  c;"
     // "a; b c;"
     _scan("a; ", "", "b", " c;");
     _assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_newIdentifier2() {
     // "a;  c;"
     // "a;b  c;"
     _scan("a;", "", "b", "  c;");
     _assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
     _assertReplaced(1, ";");
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_period() {
     // "a + b;"
     // "a + b.;"
     _scan("a + b", "", ".", ";");
     _assertTokens(2, 4, ["a", "+", "b", ".", ";"]);
   }
 
   void test_insert_period_betweenIdentifiers1() {
     // "a b;"
     // "a. b;"
     _scan("a", "", ".", " b;");
     _assertTokens(0, 2, ["a", ".", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_period_betweenIdentifiers2() {
     // "a b;"
     // "a .b;"
     _scan("a ", "", ".", "b;");
     _assertTokens(0, 2, ["a", ".", "b", ";"]);
   }
 
   void test_insert_period_betweenIdentifiers3() {
     // "a  b;"
     // "a . b;"
     _scan("a ", "", ".", " b;");
     _assertTokens(0, 2, ["a", ".", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_period_insideExistingIdentifier() {
     // "ab;"
     // "a.b;"
     _scan("a", "", ".", "b;");
     _assertTokens(-1, 3, ["a", ".", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_periodAndIdentifier() {
     // "a + b;"
     // "a + b.x;"
     _scan("a + b", "", ".x", ";");
     _assertTokens(2, 5, ["a", "+", "b", ".", "x", ";"]);
   }
 
   void test_insert_whitespace_beginning_beforeToken() {
     // "a + b;"
     // " a + b;"
     _scan("", "", " ", "a + b;");
     _assertTokens(0, 1, ["a", "+", "b", ";"]);
-    JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
   void test_insert_whitespace_betweenTokens() {
     // "a + b;"
     // "a  + b;"
     _scan("a ", "", " ", "+ b;");
     _assertTokens(1, 2, ["a", "+", "b", ";"]);
-    JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
   void test_insert_whitespace_end_afterToken() {
     // "a + b;"
     // "a + b; "
     _scan("a + b;", "", " ", "");
     _assertTokens(3, 4, ["a", "+", "b", ";"]);
-    JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
   void test_insert_whitespace_end_afterWhitespace() {
     // "a + b; "
     // "a + b;  "
     _scan("a + b; ", "", " ", "");
     _assertTokens(3, 4, ["a", "+", "b", ";"]);
-    JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
   void test_insert_whitespace_withMultipleComments() {
     // "//comment", "//comment2", "a + b;"
     // "//comment", "//comment2", "a  + b;"
     _scan(r'''
 //comment
 //comment2
 a''', "", " ", " + b;");
     _assertTokens(1, 2, ["a", "+", "b", ";"]);
-    JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
   void test_replace_identifier_beginning() {
     // "bell + b;"
     // "fell + b;")
     _scan("", "b", "f", "ell + b;");
     _assertTokens(-1, 1, ["fell", "+", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_identifier_end() {
     // "bell + b;"
     // "belt + b;")
     _scan("bel", "l", "t", " + b;");
     _assertTokens(-1, 1, ["belt", "+", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_identifier_middle() {
     // "first + b;"
     // "frost + b;")
     _scan("f", "ir", "ro", "st + b;");
     _assertTokens(-1, 1, ["frost", "+", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_multiple_partialFirstAndLast() {
     // "aa + bb;"
     // "ab * ab;")
     _scan("a", "a + b", "b * a", "b;");
     _assertTokens(-1, 3, ["ab", "*", "ab", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_operator_oneForMany() {
     // "a + b;"
     // "a * c - b;")
     _scan("a ", "+", "* c -", " b;");
     _assertTokens(0, 4, ["a", "*", "c", "-", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_operator_oneForOne() {
     // "a + b;"
     // "a * b;")
     _scan("a ", "+", "*", " b;");
     _assertTokens(0, 2, ["a", "*", "b", ";"]);
-    JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_tokenMap() {
     // "main() {a + b;}"
     // "main() { a + b;}"
     _scan("main() {", "", " ", "a + b;}");
     TokenMap tokenMap = _incrementalScanner.tokenMap;
     Token oldToken = _originalTokens;
     while (oldToken.type != TokenType.EOF) {
       Token newToken = tokenMap.get(oldToken);
-      JUnitTestCase.assertNotSame(oldToken, newToken);
-      JUnitTestCase.assertSame(oldToken.type, newToken.type);
-      JUnitTestCase.assertEquals(oldToken.lexeme, newToken.lexeme);
+      expect(newToken, isNot(same(oldToken)));
+      expect(newToken.type, same(oldToken.type));
+      expect(newToken.lexeme, oldToken.lexeme);
       oldToken = oldToken.next;
     }
-    JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
   /**
    * Assert that the token at the given offset was replaced with a new token having the given
    * lexeme.
    *
    * @param tokenOffset the offset of the token being tested
    * @param lexeme the expected lexeme of the new token
    */
   void _assertReplaced(int tokenOffset, String lexeme) {
     Token oldToken = _originalTokens;
     for (int i = 0; i < tokenOffset; i++) {
       oldToken = oldToken.next;
     }
-    JUnitTestCase.assertEquals(lexeme, oldToken.lexeme);
+    expect(oldToken.lexeme, lexeme);
     Token newToken = _incrementalScanner.tokenMap.get(oldToken);
-    JUnitTestCase.assertNotNull(newToken);
-    JUnitTestCase.assertEquals(lexeme, newToken.lexeme);
-    JUnitTestCase.assertNotSame(oldToken, newToken);
+    expect(newToken, isNotNull);
+    expect(newToken.lexeme, lexeme);
+    expect(newToken, isNot(same(oldToken)));
   }
 
   /**
    * Assert that the result of the incremental scan matches the given list of lexemes and that the
    * left and right tokens correspond to the tokens at the given indices.
    *
    * @param leftIndex the expected index of the left token
    * @param rightIndex the expected index of the right token
    * @param lexemes the expected lexemes of the resulting tokens
    */
   void _assertTokens(int leftIndex, int rightIndex, List<String> lexemes) {
     int count = lexemes.length;
-    JUnitTestCase.assertTrueMsg("Invalid left index", leftIndex >= -1 && leftIndex < count);
-    JUnitTestCase.assertTrueMsg("Invalid right index", rightIndex >= 0 && rightIndex <= count);
+    expect(leftIndex >= -1 && leftIndex < count, isTrue, reason: "Invalid left index");
+    expect(rightIndex >= 0 && rightIndex <= count, isTrue, reason: "Invalid right index");
     Token leftToken = null;
     Token rightToken = null;
     Token token = _incrementalTokens;
     if (leftIndex < 0) {
       leftToken = token.previous;
     }
     for (int i = 0; i < count; i++) {
-      JUnitTestCase.assertEquals(lexemes[i], token.lexeme);
+      expect(token.lexeme, lexemes[i]);
       if (i == leftIndex) {
         leftToken = token;
       }
       if (i == rightIndex) {
         rightToken = token;
       }
       token = token.next;
     }
     if (rightIndex >= count) {
       rightToken = token;
     }
-    JUnitTestCase.assertSameMsg("Too many tokens", TokenType.EOF, token.type);
+    expect(token.type, same(TokenType.EOF), reason: "Too many tokens");
     if (leftIndex >= 0) {
-      JUnitTestCase.assertNotNull(leftToken);
+      expect(leftToken, isNotNull);
     }
-    JUnitTestCase.assertSameMsg("Invalid left token", leftToken, _incrementalScanner.leftToken);
+    expect(_incrementalScanner.leftToken, same(leftToken), reason: "Invalid left token");
     if (rightIndex >= 0) {
-      JUnitTestCase.assertNotNull(rightToken);
+      expect(rightToken, isNotNull);
     }
-    JUnitTestCase.assertSameMsg("Invalid right token", rightToken, _incrementalScanner.rightToken);
+    expect(_incrementalScanner.rightToken, same(rightToken), reason: "Invalid right token");
   }
 
   /**
    * Given a description of the original and modified contents, perform an incremental scan of the
    * two pieces of text. Verify that the incremental scan produced the same tokens as those that
    * would be produced by a full scan of the new contents.
    *
    * @param prefix the unchanged text before the edit region
    * @param removed the text that was removed from the original contents
    * @param added the text that was added to the modified contents
    * @param suffix the unchanged text after the edit region
    */
   void _scan(String prefix, String removed, String added, String suffix) {
     //
     // Compute the information needed to perform the test.
     //
     String originalContents = "$prefix$removed$suffix";
     String modifiedContents = "$prefix$added$suffix";
     int replaceStart = prefix.length;
     Source source = new TestSource();
     //
     // Scan the original contents.
     //
     GatheringErrorListener originalListener = new GatheringErrorListener();
     Scanner originalScanner = new Scanner(source, new CharSequenceReader(originalContents), originalListener);
     _originalTokens = originalScanner.tokenize();
-    JUnitTestCase.assertNotNull(_originalTokens);
+    expect(_originalTokens, isNotNull);
     //
     // Scan the modified contents.
     //
     GatheringErrorListener modifiedListener = new GatheringErrorListener();
     Scanner modifiedScanner = new Scanner(source, new CharSequenceReader(modifiedContents), modifiedListener);
     Token modifiedTokens = modifiedScanner.tokenize();
-    JUnitTestCase.assertNotNull(modifiedTokens);
+    expect(modifiedTokens, isNotNull);
     //
     // Incrementally scan the modified contents.
     //
     GatheringErrorListener incrementalListener = new GatheringErrorListener();
     _incrementalScanner = new IncrementalScanner(source, new CharSequenceReader(modifiedContents), incrementalListener);
     _incrementalTokens = _incrementalScanner.rescan(_originalTokens, replaceStart, removed.length, added.length);
     //
     // Validate that the results of the incremental scan are the same as the full scan of the
     // modified source.
     //
     Token incrementalToken = _incrementalTokens;
-    JUnitTestCase.assertNotNull(incrementalToken);
+    expect(incrementalToken, isNotNull);
     while (incrementalToken.type != TokenType.EOF && modifiedTokens.type != TokenType.EOF) {
-      JUnitTestCase.assertSameMsg("Wrong type for token", modifiedTokens.type, incrementalToken.type);
-      JUnitTestCase.assertEqualsMsg("Wrong offset for token", modifiedTokens.offset, incrementalToken.offset);
-      JUnitTestCase.assertEqualsMsg("Wrong length for token", modifiedTokens.length, incrementalToken.length);
-      JUnitTestCase.assertEqualsMsg("Wrong lexeme for token", modifiedTokens.lexeme, incrementalToken.lexeme);
+      expect(incrementalToken.type, same(modifiedTokens.type), reason: "Wrong type for token");
+      expect(incrementalToken.offset, modifiedTokens.offset, reason: "Wrong offset for token");
+      expect(incrementalToken.length, modifiedTokens.length, reason: "Wrong length for token");
+      expect(incrementalToken.lexeme, modifiedTokens.lexeme, reason: "Wrong lexeme for token");
       incrementalToken = incrementalToken.next;
       modifiedTokens = modifiedTokens.next;
     }
-    JUnitTestCase.assertSameMsg("Too many tokens", TokenType.EOF, incrementalToken.type);
-    JUnitTestCase.assertSameMsg("Not enough tokens", TokenType.EOF, modifiedTokens.type);
+    expect(incrementalToken.type, same(TokenType.EOF), reason: "Too many tokens");
+    expect(modifiedTokens.type, same(TokenType.EOF), reason: "Not enough tokens");
     // TODO(brianwilkerson) Verify that the errors are correct?
   }
 }
 
-class KeywordStateTest extends JUnitTestCase {
+class KeywordStateTest {
   void test_KeywordState() {
     //
     // Generate the test data to be scanned.
     //
     List<Keyword> keywords = Keyword.values;
     int keywordCount = keywords.length;
     List<String> textToTest = new List<String>(keywordCount * 3);
     for (int i = 0; i < keywordCount; i++) {
       String syntax = keywords[i].syntax;
       textToTest[i] = syntax;
       textToTest[i + keywordCount] = "${syntax}x";
       textToTest[i + keywordCount * 2] = syntax.substring(0, syntax.length - 1);
     }
     //
     // Scan each of the identifiers.
     //
     KeywordState firstState = KeywordState.KEYWORD_STATE;
     for (int i = 0; i < textToTest.length; i++) {
       String text = textToTest[i];
       int index = 0;
       int length = text.length;
       KeywordState state = firstState;
       while (index < length && state != null) {
         state = state.next(text.codeUnitAt(index));
         index++;
       }
       if (i < keywordCount) {
         // keyword
-        JUnitTestCase.assertNotNull(state);
-        JUnitTestCase.assertNotNull(state.keyword());
-        JUnitTestCase.assertEquals(keywords[i], state.keyword());
+        expect(state, isNotNull);
+        expect(state.keyword(), isNotNull);
+        expect(state.keyword(), keywords[i]);
       } else if (i < keywordCount * 2) {
         // keyword + "x"
-        JUnitTestCase.assertNull(state);
+        expect(state, isNull);
       } else {
         // keyword.substring(0, keyword.length() - 1)
-        JUnitTestCase.assertNotNull(state);
+        expect(state, isNotNull);
       }
     }
   }
 }
 
-class ScannerTest extends JUnitTestCase {
+class ScannerTest {
   void fail_incomplete_string_interpolation() {
     // https://code.google.com/p/dart/issues/detail?id=18073
     _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 9, "\"foo \${bar", [
         new StringToken(TokenType.STRING, "\"foo ", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 5),
         new StringToken(TokenType.IDENTIFIER, "bar", 7)]);
   }
 
   void test_ampersand() {
     _assertToken(TokenType.AMPERSAND, "&");
@@ skipping 64 matching lines @@
   }
 
   void test_comma() {
     _assertToken(TokenType.COMMA, ",");
   }
 
   void test_comment_disabled_multi() {
     Scanner scanner = new Scanner(null, new CharSequenceReader("/* comment */ "), AnalysisErrorListener.NULL_LISTENER);
     scanner.preserveComments = false;
     Token token = scanner.tokenize();
-    JUnitTestCase.assertNotNull(token);
-    JUnitTestCase.assertNull(token.precedingComments);
+    expect(token, isNotNull);
+    expect(token.precedingComments, isNull);
   }
 
   void test_comment_multi() {
     _assertComment(TokenType.MULTI_LINE_COMMENT, "/* comment */");
   }
 
   void test_comment_multi_unterminated() {
     _assertError(ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT, 3, "/* x");
   }
 
@@ skipping 446 matching lines @@
     _assertToken(TokenType.SEMICOLON, ";");
   }
 
   void test_setSourceStart() {
     int offsetDelta = 42;
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new SubSequenceReader("a", offsetDelta), listener);
     scanner.setSourceStart(3, 9);
     scanner.tokenize();
     List<int> lineStarts = scanner.lineStarts;
-    JUnitTestCase.assertNotNull(lineStarts);
-    JUnitTestCase.assertEquals(3, lineStarts.length);
-    JUnitTestCase.assertEquals(33, lineStarts[2]);
+    expect(lineStarts, isNotNull);
+    expect(lineStarts.length, 3);
+    expect(lineStarts[2], 33);
   }
 
   void test_slash() {
     _assertToken(TokenType.SLASH, "/");
   }
 
   void test_slash_eq() {
     _assertToken(TokenType.SLASH_EQ, "/=");
   }
 
   void test_star() {
     _assertToken(TokenType.STAR, "*");
   }
 
   void test_star_eq() {
     _assertToken(TokenType.STAR_EQ, "*=");
   }
 
   void test_startAndEnd() {
     Token token = _scan("a");
     Token previous = token.previous;
-    JUnitTestCase.assertEquals(token, previous.next);
-    JUnitTestCase.assertEquals(previous, previous.previous);
+    expect(previous.next, token);
+    expect(previous.previous, previous);
     Token next = token.next;
-    JUnitTestCase.assertEquals(next, next.next);
-    JUnitTestCase.assertEquals(token, next.previous);
+    expect(next.next, next);
+    expect(next.previous, token);
   }
 
   void test_string_multi_double() {
     _assertToken(TokenType.STRING, "\"\"\"line1\nline2\"\"\"");
   }
 
   void test_string_multi_embeddedQuotes() {
     _assertToken(TokenType.STRING, "\"\"\"line1\n\"\"\nline2\"\"\"");
   }
 
@@ skipping 202 matching lines @@
   void test_unclosedPairInInterpolation() {
     GatheringErrorListener listener = new GatheringErrorListener();
     _scanWithListener("'\${(}'", listener);
   }
 
   void _assertComment(TokenType commentType, String source) {
     //
     // Test without a trailing end-of-line marker
     //
     Token token = _scan(source);
-    JUnitTestCase.assertNotNull(token);
-    JUnitTestCase.assertEquals(TokenType.EOF, token.type);
+    expect(token, isNotNull);
+    expect(token.type, TokenType.EOF);
     Token comment = token.precedingComments;
-    JUnitTestCase.assertNotNull(comment);
-    JUnitTestCase.assertEquals(commentType, comment.type);
-    JUnitTestCase.assertEquals(0, comment.offset);
-    JUnitTestCase.assertEquals(source.length, comment.length);
-    JUnitTestCase.assertEquals(source, comment.lexeme);
+    expect(comment, isNotNull);
+    expect(comment.type, commentType);
+    expect(comment.offset, 0);
+    expect(comment.length, source.length);
+    expect(comment.lexeme, source);
     //
     // Test with a trailing end-of-line marker
     //
     token = _scan("$source\n");
-    JUnitTestCase.assertNotNull(token);
-    JUnitTestCase.assertEquals(TokenType.EOF, token.type);
+    expect(token, isNotNull);
+    expect(token.type, TokenType.EOF);
     comment = token.precedingComments;
-    JUnitTestCase.assertNotNull(comment);
-    JUnitTestCase.assertEquals(commentType, comment.type);
-    JUnitTestCase.assertEquals(0, comment.offset);
-    JUnitTestCase.assertEquals(source.length, comment.length);
-    JUnitTestCase.assertEquals(source, comment.lexeme);
+    expect(comment, isNotNull);
+    expect(comment.type, commentType);
+    expect(comment.offset, 0);
+    expect(comment.length, source.length);
+    expect(comment.lexeme, source);
   }
 
   /**
    * Assert that scanning the given source produces an error with the given code.
    *
    * @param expectedError the error that should be produced
    * @param expectedOffset the string offset that should be associated with the error
    * @param source the source to be scanned to produce the error
    */
   void _assertError(ScannerErrorCode expectedError, int expectedOffset, String source) {
@@ skipping 19 matching lines @@
   }
 
   /**
    * Assert that when scanned the given source contains a single keyword token with the same lexeme
    * as the original source.
    *
    * @param source the source to be scanned
    */
   void _assertKeywordToken(String source) {
     Token token = _scan(source);
-    JUnitTestCase.assertNotNull(token);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
-    JUnitTestCase.assertEquals(0, token.offset);
-    JUnitTestCase.assertEquals(source.length, token.length);
-    JUnitTestCase.assertEquals(source, token.lexeme);
+    expect(token, isNotNull);
+    expect(token.type, TokenType.KEYWORD);
+    expect(token.offset, 0);
+    expect(token.length, source.length);
+    expect(token.lexeme, source);
     Object value = token.value();
-    JUnitTestCase.assertTrue(value is Keyword);
-    JUnitTestCase.assertEquals(source, (value as Keyword).syntax);
+    expect(value is Keyword, isTrue);
+    expect((value as Keyword).syntax, source);
     token = _scan(" $source ");
-    JUnitTestCase.assertNotNull(token);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
-    JUnitTestCase.assertEquals(1, token.offset);
-    JUnitTestCase.assertEquals(source.length, token.length);
-    JUnitTestCase.assertEquals(source, token.lexeme);
+    expect(token, isNotNull);
+    expect(token.type, TokenType.KEYWORD);
+    expect(token.offset, 1);
+    expect(token.length, source.length);
+    expect(token.lexeme, source);
     value = token.value();
-    JUnitTestCase.assertTrue(value is Keyword);
-    JUnitTestCase.assertEquals(source, (value as Keyword).syntax);
-    JUnitTestCase.assertEquals(TokenType.EOF, token.next.type);
+    expect(value is Keyword, isTrue);
+    expect((value as Keyword).syntax, source);
+    expect(token.next.type, TokenType.EOF);
   }
 
   void _assertLineInfo(String source, List<ScannerTest_ExpectedLocation> expectedLocations) {
     GatheringErrorListener listener = new GatheringErrorListener();
     _scanWithListener(source, listener);
     listener.assertNoErrors();
     LineInfo info = listener.getLineInfo(new TestSource());
-    JUnitTestCase.assertNotNull(info);
+    expect(info, isNotNull);
     for (ScannerTest_ExpectedLocation expectedLocation in expectedLocations) {
       LineInfo_Location location = info.getLocation(expectedLocation._offset);
-      JUnitTestCase.assertEquals(expectedLocation._lineNumber, location.lineNumber);
-      JUnitTestCase.assertEquals(expectedLocation._columnNumber, location.columnNumber);
+      expect(location.lineNumber, expectedLocation._lineNumber);
+      expect(location.columnNumber, expectedLocation._columnNumber);
     }
   }
 
   /**
    * Assert that the token scanned from the given source has the expected type.
    *
    * @param expectedType the expected type of the token
    * @param source the source to be scanned to produce the actual token
    */
   Token _assertToken(TokenType expectedType, String source) {
     Token originalToken = _scan(source);
-    JUnitTestCase.assertNotNull(originalToken);
-    JUnitTestCase.assertEquals(expectedType, originalToken.type);
-    JUnitTestCase.assertEquals(0, originalToken.offset);
-    JUnitTestCase.assertEquals(source.length, originalToken.length);
-    JUnitTestCase.assertEquals(source, originalToken.lexeme);
+    expect(originalToken, isNotNull);
+    expect(originalToken.type, expectedType);
+    expect(originalToken.offset, 0);
+    expect(originalToken.length, source.length);
+    expect(originalToken.lexeme, source);
     if (expectedType == TokenType.SCRIPT_TAG) {
       // Adding space before the script tag is not allowed, and adding text at the end changes nothing.
       return originalToken;
     } else if (expectedType == TokenType.SINGLE_LINE_COMMENT) {
       // Adding space to an end-of-line comment changes the comment.
       Token tokenWithSpaces = _scan(" $source");
-      JUnitTestCase.assertNotNull(tokenWithSpaces);
-      JUnitTestCase.assertEquals(expectedType, tokenWithSpaces.type);
-      JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
-      JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
-      JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
+      expect(tokenWithSpaces, isNotNull);
+      expect(tokenWithSpaces.type, expectedType);
+      expect(tokenWithSpaces.offset, 1);
+      expect(tokenWithSpaces.length, source.length);
+      expect(tokenWithSpaces.lexeme, source);
       return originalToken;
     } else if (expectedType == TokenType.INT || expectedType == TokenType.DOUBLE) {
       Token tokenWithLowerD = _scan("${source}d");
-      JUnitTestCase.assertNotNull(tokenWithLowerD);
-      JUnitTestCase.assertEquals(expectedType, tokenWithLowerD.type);
-      JUnitTestCase.assertEquals(0, tokenWithLowerD.offset);
-      JUnitTestCase.assertEquals(source.length, tokenWithLowerD.length);
-      JUnitTestCase.assertEquals(source, tokenWithLowerD.lexeme);
+      expect(tokenWithLowerD, isNotNull);
+      expect(tokenWithLowerD.type, expectedType);
+      expect(tokenWithLowerD.offset, 0);
+      expect(tokenWithLowerD.length, source.length);
+      expect(tokenWithLowerD.lexeme, source);
       Token tokenWithUpperD = _scan("${source}D");
-      JUnitTestCase.assertNotNull(tokenWithUpperD);
-      JUnitTestCase.assertEquals(expectedType, tokenWithUpperD.type);
-      JUnitTestCase.assertEquals(0, tokenWithUpperD.offset);
-      JUnitTestCase.assertEquals(source.length, tokenWithUpperD.length);
-      JUnitTestCase.assertEquals(source, tokenWithUpperD.lexeme);
+      expect(tokenWithUpperD, isNotNull);
+      expect(tokenWithUpperD.type, expectedType);
+      expect(tokenWithUpperD.offset, 0);
+      expect(tokenWithUpperD.length, source.length);
+      expect(tokenWithUpperD.lexeme, source);
     }
     Token tokenWithSpaces = _scan(" $source ");
-    JUnitTestCase.assertNotNull(tokenWithSpaces);
-    JUnitTestCase.assertEquals(expectedType, tokenWithSpaces.type);
-    JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
-    JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
-    JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
-    JUnitTestCase.assertEquals(TokenType.EOF, originalToken.next.type);
+    expect(tokenWithSpaces, isNotNull);
+    expect(tokenWithSpaces.type, expectedType);
+    expect(tokenWithSpaces.offset, 1);
+    expect(tokenWithSpaces.length, source.length);
+    expect(tokenWithSpaces.lexeme, source);
+    expect(originalToken.next.type, TokenType.EOF);
     return originalToken;
   }
 
   /**
    * Assert that when scanned the given source contains a sequence of tokens identical to the given
    * tokens.
    *
    * @param source the source to be scanned
    * @param expectedTokens the tokens that are expected to be in the source
    */
   void _assertTokens(String source, List<Token> expectedTokens) {
     Token token = _scan(source);
     _checkTokens(token, expectedTokens);
   }
 
   void _checkTokens(Token firstToken, List<Token> expectedTokens) {
-    JUnitTestCase.assertNotNull(firstToken);
+    expect(firstToken, isNotNull);
     Token token = firstToken;
     for (int i = 0; i < expectedTokens.length; i++) {
       Token expectedToken = expectedTokens[i];
-      JUnitTestCase.assertEqualsMsg("Wrong type for token $i", expectedToken.type, token.type);
-      JUnitTestCase.assertEqualsMsg("Wrong offset for token $i", expectedToken.offset, token.offset);
-      JUnitTestCase.assertEqualsMsg("Wrong length for token $i", expectedToken.length, token.length);
-      JUnitTestCase.assertEqualsMsg("Wrong lexeme for token $i", expectedToken.lexeme, token.lexeme);
+      expect(token.type, expectedToken.type, reason: "Wrong type for token $i");
+      expect(token.offset, expectedToken.offset, reason: "Wrong offset for token $i");
+      expect(token.length, expectedToken.length, reason: "Wrong length for token $i");
+      expect(token.lexeme, expectedToken.lexeme, reason: "Wrong lexeme for token $i");
       token = token.next;
-      JUnitTestCase.assertNotNull(token);
+      expect(token, isNotNull);
     }
-    JUnitTestCase.assertEquals(TokenType.EOF, token.type);
+    expect(token.type, TokenType.EOF);
   }
 
   Token _scan(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Token token = _scanWithListener(source, listener);
     listener.assertNoErrors();
     return token;
   }
 
   Token _scanWithListener(String source, GatheringErrorListener listener) {
@@ skipping 25 matching lines @@
 class TokenStreamValidator {
   /**
    * Validate that the stream of tokens that starts with the given token is correct.
    *
    * @param token the first token in the stream of tokens to be validated
    */
   void validate(Token token) {
     StringBuffer buffer = new StringBuffer();
     _validateStream(buffer, token);
     if (buffer.length > 0) {
-      JUnitTestCase.fail(buffer.toString());
+      fail(buffer.toString());
     }
   }
 
   void _validateStream(StringBuffer buffer, Token token) {
     if (token == null) {
       return;
     }
     Token previousToken = null;
     int previousEnd = -1;
     Token currentToken = token;
@@ skipping 31 matching lines @@
     buffer.write("', ");
     buffer.write(token.offset);
     buffer.write(", ");
     buffer.write(token.length);
     buffer.write("]");
   }
 }
 
 class TokenTypeTest extends EngineTestCase {
   void test_isOperator() {
-    JUnitTestCase.assertTrue(TokenType.AMPERSAND.isOperator);
-    JUnitTestCase.assertTrue(TokenType.AMPERSAND_AMPERSAND.isOperator);
-    JUnitTestCase.assertTrue(TokenType.AMPERSAND_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.BANG.isOperator);
-    JUnitTestCase.assertTrue(TokenType.BANG_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.BAR.isOperator);
-    JUnitTestCase.assertTrue(TokenType.BAR_BAR.isOperator);
-    JUnitTestCase.assertTrue(TokenType.BAR_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.CARET.isOperator);
-    JUnitTestCase.assertTrue(TokenType.CARET_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.EQ_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.GT.isOperator);
-    JUnitTestCase.assertTrue(TokenType.GT_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.GT_GT.isOperator);
-    JUnitTestCase.assertTrue(TokenType.GT_GT_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.INDEX.isOperator);
-    JUnitTestCase.assertTrue(TokenType.INDEX_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.IS.isOperator);
-    JUnitTestCase.assertTrue(TokenType.LT.isOperator);
-    JUnitTestCase.assertTrue(TokenType.LT_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.LT_LT.isOperator);
-    JUnitTestCase.assertTrue(TokenType.LT_LT_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.MINUS.isOperator);
-    JUnitTestCase.assertTrue(TokenType.MINUS_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.MINUS_MINUS.isOperator);
-    JUnitTestCase.assertTrue(TokenType.PERCENT.isOperator);
-    JUnitTestCase.assertTrue(TokenType.PERCENT_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.PERIOD_PERIOD.isOperator);
-    JUnitTestCase.assertTrue(TokenType.PLUS.isOperator);
-    JUnitTestCase.assertTrue(TokenType.PLUS_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.PLUS_PLUS.isOperator);
-    JUnitTestCase.assertTrue(TokenType.QUESTION.isOperator);
-    JUnitTestCase.assertTrue(TokenType.SLASH.isOperator);
-    JUnitTestCase.assertTrue(TokenType.SLASH_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.STAR.isOperator);
-    JUnitTestCase.assertTrue(TokenType.STAR_EQ.isOperator);
-    JUnitTestCase.assertTrue(TokenType.TILDE.isOperator);
-    JUnitTestCase.assertTrue(TokenType.TILDE_SLASH.isOperator);
-    JUnitTestCase.assertTrue(TokenType.TILDE_SLASH_EQ.isOperator);
+    expect(TokenType.AMPERSAND.isOperator, isTrue);
+    expect(TokenType.AMPERSAND_AMPERSAND.isOperator, isTrue);
+    expect(TokenType.AMPERSAND_EQ.isOperator, isTrue);
+    expect(TokenType.BANG.isOperator, isTrue);
+    expect(TokenType.BANG_EQ.isOperator, isTrue);
+    expect(TokenType.BAR.isOperator, isTrue);
+    expect(TokenType.BAR_BAR.isOperator, isTrue);
+    expect(TokenType.BAR_EQ.isOperator, isTrue);
+    expect(TokenType.CARET.isOperator, isTrue);
+    expect(TokenType.CARET_EQ.isOperator, isTrue);
+    expect(TokenType.EQ.isOperator, isTrue);
+    expect(TokenType.EQ_EQ.isOperator, isTrue);
+    expect(TokenType.GT.isOperator, isTrue);
+    expect(TokenType.GT_EQ.isOperator, isTrue);
+    expect(TokenType.GT_GT.isOperator, isTrue);
+    expect(TokenType.GT_GT_EQ.isOperator, isTrue);
+    expect(TokenType.INDEX.isOperator, isTrue);
+    expect(TokenType.INDEX_EQ.isOperator, isTrue);
+    expect(TokenType.IS.isOperator, isTrue);
+    expect(TokenType.LT.isOperator, isTrue);
+    expect(TokenType.LT_EQ.isOperator, isTrue);
+    expect(TokenType.LT_LT.isOperator, isTrue);
+    expect(TokenType.LT_LT_EQ.isOperator, isTrue);
+    expect(TokenType.MINUS.isOperator, isTrue);
+    expect(TokenType.MINUS_EQ.isOperator, isTrue);
+    expect(TokenType.MINUS_MINUS.isOperator, isTrue);
+    expect(TokenType.PERCENT.isOperator, isTrue);
+    expect(TokenType.PERCENT_EQ.isOperator, isTrue);
+    expect(TokenType.PERIOD_PERIOD.isOperator, isTrue);
+    expect(TokenType.PLUS.isOperator, isTrue);
+    expect(TokenType.PLUS_EQ.isOperator, isTrue);
+    expect(TokenType.PLUS_PLUS.isOperator, isTrue);
+    expect(TokenType.QUESTION.isOperator, isTrue);
+    expect(TokenType.SLASH.isOperator, isTrue);
+    expect(TokenType.SLASH_EQ.isOperator, isTrue);
+    expect(TokenType.STAR.isOperator, isTrue);
+    expect(TokenType.STAR_EQ.isOperator, isTrue);
+    expect(TokenType.TILDE.isOperator, isTrue);
+    expect(TokenType.TILDE_SLASH.isOperator, isTrue);
+    expect(TokenType.TILDE_SLASH_EQ.isOperator, isTrue);
   }
 
   void test_isUserDefinableOperator() {
-    JUnitTestCase.assertTrue(TokenType.AMPERSAND.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.BAR.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.CARET.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.EQ_EQ.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.GT.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.GT_EQ.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.GT_GT.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.INDEX.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.INDEX_EQ.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.LT.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.LT_EQ.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.LT_LT.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.MINUS.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.PERCENT.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.PLUS.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.SLASH.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.STAR.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.TILDE.isUserDefinableOperator);
-    JUnitTestCase.assertTrue(TokenType.TILDE_SLASH.isUserDefinableOperator);
+    expect(TokenType.AMPERSAND.isUserDefinableOperator, isTrue);
+    expect(TokenType.BAR.isUserDefinableOperator, isTrue);
+    expect(TokenType.CARET.isUserDefinableOperator, isTrue);
+    expect(TokenType.EQ_EQ.isUserDefinableOperator, isTrue);
+    expect(TokenType.GT.isUserDefinableOperator, isTrue);
+    expect(TokenType.GT_EQ.isUserDefinableOperator, isTrue);
+    expect(TokenType.GT_GT.isUserDefinableOperator, isTrue);
+    expect(TokenType.INDEX.isUserDefinableOperator, isTrue);
+    expect(TokenType.INDEX_EQ.isUserDefinableOperator, isTrue);
+    expect(TokenType.LT.isUserDefinableOperator, isTrue);
+    expect(TokenType.LT_EQ.isUserDefinableOperator, isTrue);
+    expect(TokenType.LT_LT.isUserDefinableOperator, isTrue);
+    expect(TokenType.MINUS.isUserDefinableOperator, isTrue);
+    expect(TokenType.PERCENT.isUserDefinableOperator, isTrue);
+    expect(TokenType.PLUS.isUserDefinableOperator, isTrue);
+    expect(TokenType.SLASH.isUserDefinableOperator, isTrue);
+    expect(TokenType.STAR.isUserDefinableOperator, isTrue);
+    expect(TokenType.TILDE.isUserDefinableOperator, isTrue);
+    expect(TokenType.TILDE_SLASH.isUserDefinableOperator, isTrue);
   }
 }
 
 main() {
-  _ut.groupSep = ' | ';
+  groupSep = ' | ';
   runReflectiveTests(CharSequenceReaderTest);
   runReflectiveTests(IncrementalScannerTest);
   runReflectiveTests(KeywordStateTest);
   runReflectiveTests(ScannerTest);
   runReflectiveTests(TokenTypeTest);
 }