pkg/analyzer/test/generated/all_the_rest.dart - Issue 622743002: New analyzer snapshot.

Side by Side Diff: pkg/analyzer/test/generated/all_the_rest.dart

Issue 622743002: New analyzer snapshot. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart

Patch Set: Created 6 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
1 // // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file	1 // // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file

2 // // for details. All rights reserved. Use of this source code is governed by a	2 // // for details. All rights reserved. Use of this source code is governed by a

3 // // BSD-style license that can be found in the LICENSE file.	3 // // BSD-style license that can be found in the LICENSE file.

4 // // This code was auto-generated, is not intended to be edited, and is subject to	4 // // This code was auto-generated, is not intended to be edited, and is subject to

5 // // significant change. Please see the README file for more information.	5 // // significant change. Please see the README file for more information.

6 // abstract class AbstractScannerTest extends JUnitTestCase {	6 // abstract class AbstractScannerTest extends JUnitTestCase {

7 // void test_tokenize_attribute() {	7 // void test_tokenize_attribute() {

8 // _tokenize("<html bob=\"one two\">", <Object> [LT, "html", "bob", EQ, "\"o ne two\"", GT]);	8 // _tokenize("<html bob=\"one two\">", <Object> [LT, "html", "bob", EQ, "\"o ne two\"", GT]);

9 // }	9 // }

10 // void test_tokenize_comment() {	10 // void test_tokenize_comment() {

(...skipping 1472 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
1483 // AngularPropertyElement attr = findMainElement2("attr");	1483 // AngularPropertyElement attr = findMainElement2("attr");

1484 // JUnitTestCase.assertNotNull(selectorElement);	1484 // JUnitTestCase.assertNotNull(selectorElement);

1485 // JUnitTestCase.assertNotNull(attr);	1485 // JUnitTestCase.assertNotNull(attr);

1486 // // index	1486 // // index

1487 // indexUnit.accept(_index);	1487 // indexUnit.accept(_index);

1488 // // verify	1488 // // verify

1489 // List<RecordedRelation> relations = captureRecordedRelations();	1489 // List<RecordedRelation> relations = captureRecordedRelations();

1490 // assertRecordedRelation(relations, selectorElement, IndexConstants.ANGULAR _REFERENCE, new ExpectedLocation(indexHtmlUnit, findOffset2("myComponent attr='n ull"), "myComponent"));	1490 // assertRecordedRelation(relations, selectorElement, IndexConstants.ANGULAR _REFERENCE, new ExpectedLocation(indexHtmlUnit, findOffset2("myComponent attr='n ull"), "myComponent"));

1491 // assertRecordedRelation(relations, attr, IndexConstants.ANGULAR_REFERENCE, new ExpectedLocation(indexHtmlUnit, findOffset2("attr='null"), "attr"));	1491 // assertRecordedRelation(relations, attr, IndexConstants.ANGULAR_REFERENCE, new ExpectedLocation(indexHtmlUnit, findOffset2("attr='null"), "attr"));

1492 // }	1492 // }

	1493 // @override

	1494 // void tearDown() {

	1495 // _index = null;

	1496 // super.tearDown();

	1497 // }

1493 // List<RecordedRelation> captureRecordedRelations() => captureRelations(_stor e);	1498 // List<RecordedRelation> captureRecordedRelations() => captureRelations(_stor e);

1494 // static dartSuite() {	1499 // static dartSuite() {

1495 // _ut.group('AngularHtmlIndexContributorTest', () {	1500 // _ut.group('AngularHtmlIndexContributorTest', () {

1496 // _ut.test('test_Formatter_use', () {	1501 // _ut.test('test_Formatter_use', () {

1497 // final __test = new AngularHtmlIndexContributorTest();	1502 // final __test = new AngularHtmlIndexContributorTest();

1498 // runJUnitTest(__test, __test.test_Formatter_use);	1503 // runJUnitTest(__test, __test.test_Formatter_use);

1499 // });	1504 // });

1500 // _ut.test('test_NgComponent_templateFile', () {	1505 // _ut.test('test_NgComponent_templateFile', () {

1501 // final __test = new AngularHtmlIndexContributorTest();	1506 // final __test = new AngularHtmlIndexContributorTest();

1502 // runJUnitTest(__test, __test.test_NgComponent_templateFile);	1507 // runJUnitTest(__test, __test.test_NgComponent_templateFile);

(...skipping 1598 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
3101 // JUnitTestCase.assertTrue(result.isValid);	3106 // JUnitTestCase.assertTrue(result.isValid);

3102 // DartObject value = result.value;	3107 // DartObject value = result.value;

3103 // JUnitTestCase.assertEquals(null, value);	3108 // JUnitTestCase.assertEquals(null, value);

3104 // }	3109 // }

3105 // void fail_identifier_typeParameter() {	3110 // void fail_identifier_typeParameter() {

3106 // EvaluationResult result = _getExpressionValue("?");	3111 // EvaluationResult result = _getExpressionValue("?");

3107 // JUnitTestCase.assertTrue(result.isValid);	3112 // JUnitTestCase.assertTrue(result.isValid);

3108 // DartObject value = result.value;	3113 // DartObject value = result.value;

3109 // JUnitTestCase.assertEquals(null, value);	3114 // JUnitTestCase.assertEquals(null, value);

3110 // }	3115 // }

	3116 // void fail_plus_string_string() {

	3117 // _assertValue4("ab", "'a' + 'b'");

	3118 // }

3111 // void fail_prefixedIdentifier_invalid() {	3119 // void fail_prefixedIdentifier_invalid() {

3112 // EvaluationResult result = _getExpressionValue("?");	3120 // EvaluationResult result = _getExpressionValue("?");

3113 // JUnitTestCase.assertTrue(result.isValid);	3121 // JUnitTestCase.assertTrue(result.isValid);

3114 // DartObject value = result.value;	3122 // DartObject value = result.value;

3115 // JUnitTestCase.assertEquals(null, value);	3123 // JUnitTestCase.assertEquals(null, value);

3116 // }	3124 // }

3117 // void fail_prefixedIdentifier_valid() {	3125 // void fail_prefixedIdentifier_valid() {

3118 // EvaluationResult result = _getExpressionValue("?");	3126 // EvaluationResult result = _getExpressionValue("?");

3119 // JUnitTestCase.assertTrue(result.isValid);	3127 // JUnitTestCase.assertTrue(result.isValid);

3120 // DartObject value = result.value;	3128 // DartObject value = result.value;

(...skipping 16 matching lines...) Expand all Loading...
3137 // JUnitTestCase.assertTrue(result.isValid);	3145 // JUnitTestCase.assertTrue(result.isValid);

3138 // DartObject value = result.value;	3146 // DartObject value = result.value;

3139 // JUnitTestCase.assertEquals(null, value);	3147 // JUnitTestCase.assertEquals(null, value);

3140 // }	3148 // }

3141 // void fail_simpleIdentifier_valid() {	3149 // void fail_simpleIdentifier_valid() {

3142 // EvaluationResult result = _getExpressionValue("?");	3150 // EvaluationResult result = _getExpressionValue("?");

3143 // JUnitTestCase.assertTrue(result.isValid);	3151 // JUnitTestCase.assertTrue(result.isValid);

3144 // DartObject value = result.value;	3152 // DartObject value = result.value;

3145 // JUnitTestCase.assertEquals(null, value);	3153 // JUnitTestCase.assertEquals(null, value);

3146 // }	3154 // }

	3155 // void fail_stringLength_complex() {

	3156 // _assertValue3(6, "('qwe' + 'rty').length");

	3157 // }

	3158 // void fail_stringLength_simple() {

	3159 // _assertValue3(6, "'Dvorak'.length");

	3160 // }

3147 // void test_bitAnd_int_int() {	3161 // void test_bitAnd_int_int() {

3148 // _assertValue3(74 & 42, "74 & 42");	3162 // _assertValue3(74 & 42, "74 & 42");

3149 // }	3163 // }

3150 // void test_bitNot() {	3164 // void test_bitNot() {

3151 // _assertValue3(~42, "~42");	3165 // _assertValue3(~42, "~42");

3152 // }	3166 // }

3153 // void test_bitOr_int_int() {	3167 // void test_bitOr_int_int() {

3154 // _assertValue3(74 \| 42, "74 \| 42");	3168 // _assertValue3(74 \| 42, "74 \| 42");

3155 // }	3169 // }

3156 // void test_bitXor_int_int() {	3170 // void test_bitXor_int_int() {

(...skipping 175 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
3332 // void _assertValue3(int expectedValue, String contents) {	3346 // void _assertValue3(int expectedValue, String contents) {

3333 // EvaluationResult result = _getExpressionValue(contents);	3347 // EvaluationResult result = _getExpressionValue(contents);

3334 // JUnitTestCase.assertTrue(result.isValid);	3348 // JUnitTestCase.assertTrue(result.isValid);

3335 // DartObject value = result.value;	3349 // DartObject value = result.value;

3336 // JUnitTestCase.assertEquals("int", value.type.name);	3350 // JUnitTestCase.assertEquals("int", value.type.name);

3337 // JUnitTestCase.assertEquals(expectedValue, value.intValue.longValue());	3351 // JUnitTestCase.assertEquals(expectedValue, value.intValue.longValue());

3338 // }	3352 // }

3339 // void _assertValue4(String expectedValue, String contents) {	3353 // void _assertValue4(String expectedValue, String contents) {

3340 // EvaluationResult result = _getExpressionValue(contents);	3354 // EvaluationResult result = _getExpressionValue(contents);

3341 // DartObject value = result.value;	3355 // DartObject value = result.value;

3342 // JUnitTestCase.assertEquals("String", value.type.name);	3356 // JUnitTestCase.assertNotNull(value);

	3357 // InterfaceType type = value.type;

	3358 // JUnitTestCase.assertNotNull(type);

	3359 // JUnitTestCase.assertEquals("String", type.name);

3343 // JUnitTestCase.assertEquals(expectedValue, value.stringValue);	3360 // JUnitTestCase.assertEquals(expectedValue, value.stringValue);

3344 // }	3361 // }

3345 // EvaluationResult _getExpressionValue(String contents) {	3362 // EvaluationResult _getExpressionValue(String contents) {

3346 // Source source = addSource("var x = ${contents};");	3363 // Source source = addSource("var x = ${contents};");

3347 // LibraryElement library = resolve(source);	3364 // LibraryElement library = resolve(source);

3348 // CompilationUnit unit = analysisContext.resolveCompilationUnit(source, lib rary);	3365 // CompilationUnit unit = analysisContext.resolveCompilationUnit(source, lib rary);

3349 // JUnitTestCase.assertNotNull(unit);	3366 // JUnitTestCase.assertNotNull(unit);

3350 // NodeList<CompilationUnitMember> declarations = unit.declarations;	3367 // NodeList<CompilationUnitMember> declarations = unit.declarations;

3351 // EngineTestCase.assertSizeOfList(1, declarations);	3368 // EngineTestCase.assertSizeOfList(1, declarations);

3352 // CompilationUnitMember declaration = declarations[0];	3369 // CompilationUnitMember declaration = declarations[0];

3353 // EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclarati on, TopLevelVariableDeclaration, declaration);	3370 // EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclarati on, TopLevelVariableDeclaration, declaration);

3354 // NodeList<VariableDeclaration> variables = (declaration as TopLevelVariabl eDeclaration).variables.variables;	3371 // NodeList<VariableDeclaration> variables = (declaration as TopLevelVariabl eDeclaration).variables.variables;

3355 // EngineTestCase.assertSizeOfList(1, variables);	3372 // EngineTestCase.assertSizeOfList(1, variables);

3356 // ConstantEvaluator evaluator = new ConstantEvaluator(source, new TestTypeP rovider());	3373 // ConstantEvaluator evaluator = new ConstantEvaluator(source, (analysisCont ext as AnalysisContextImpl).typeProvider);

3357 // return evaluator.evaluate(variables[0].initializer);	3374 // return evaluator.evaluate(variables[0].initializer);

3358 // }	3375 // }

3359 // static dartSuite() {	3376 // static dartSuite() {

3360 // _ut.group('ConstantEvaluatorTest', () {	3377 // _ut.group('ConstantEvaluatorTest', () {

3361 // _ut.test('test_bitAnd_int_int', () {	3378 // _ut.test('test_bitAnd_int_int', () {

3362 // final __test = new ConstantEvaluatorTest();	3379 // final __test = new ConstantEvaluatorTest();

3363 // runJUnitTest(__test, __test.test_bitAnd_int_int);	3380 // runJUnitTest(__test, __test.test_bitAnd_int_int);

3364 // });	3381 // });

3365 // _ut.test('test_bitNot', () {	3382 // _ut.test('test_bitNot', () {

3366 // final __test = new ConstantEvaluatorTest();	3383 // final __test = new ConstantEvaluatorTest();

(...skipping 391 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
3758 // _assertProperDependencies(EngineTestCase.createSource([	3775 // _assertProperDependencies(EngineTestCase.createSource([

3759 // "class A {",	3776 // "class A {",

3760 // " const A(this.next);",	3777 // " const A(this.next);",

3761 // " final A next;",	3778 // " final A next;",

3762 // "}",	3779 // "}",

3763 // "const A x = const A(null);",	3780 // "const A x = const A(null);",

3764 // "const A y = const A(x);"]), []);	3781 // "const A y = const A(x);"]), []);

3765 // }	3782 // }

3766 // void test_dependencyOnConstructorArgument_unresolvedConstructor() {	3783 // void test_dependencyOnConstructorArgument_unresolvedConstructor() {

3767 // // "const A.a(x)" depends on x even if the constructor A.a can't be found .	3784 // // "const A.a(x)" depends on x even if the constructor A.a can't be found .

3768 // // TODO(paulberry): the error CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE i s redundant and

3769 // // probably shouldn't be issued.

3770 // _assertProperDependencies(EngineTestCase.createSource([	3785 // _assertProperDependencies(EngineTestCase.createSource([

3771 // "class A {",	3786 // "class A {",

3772 // "}",	3787 // "}",

3773 // "const int x = 1;",	3788 // "const int x = 1;",

3774 // "const A y = const A.a(x);"]), [	3789 // "const A y = const A.a(x);"]), [CompileTimeErrorCode.CONST_WITH_UNDEF INED_CONSTRUCTOR]);

3775 // CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE,

3776 // CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);

3777 // }	3790 // }

3778 // void test_dependencyOnConstructorInitializer() {	3791 // void test_dependencyOnConstructorInitializer() {

3779 // // "const A()" depends on x	3792 // // "const A()" depends on x

3780 // _assertProperDependencies(EngineTestCase.createSource([	3793 // _assertProperDependencies(EngineTestCase.createSource([

3781 // "const int x = 1;",	3794 // "const int x = 1;",

3782 // "class A {",	3795 // "class A {",

3783 // " const A() : v = x;",	3796 // " const A() : v = x;",

3784 // " final int v;",	3797 // " final int v;",

3785 // "}"]), []);	3798 // "}"]), []);

3786 // }	3799 // }

(...skipping 345 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4132 // "",	4145 // "",

4133 // "const A<int> a = const A<int>(10);"]));	4146 // "const A<int> a = const A<int>(10);"]));

4134 // EvaluationResultImpl result = _evaluateInstanceCreationExpression(compila tionUnit, "a");	4147 // EvaluationResultImpl result = _evaluateInstanceCreationExpression(compila tionUnit, "a");

4135 // HashMap<String, DartObjectImpl> fields = _assertType(result, "B<int>");	4148 // HashMap<String, DartObjectImpl> fields = _assertType(result, "B<int>");

4136 // EngineTestCase.assertSizeOfMap(1, fields);	4149 // EngineTestCase.assertSizeOfMap(1, fields);

4137 // _assertIntField(fields, "x", 10);	4150 // _assertIntField(fields, "x", 10);

4138 // }	4151 // }

4139 // void test_instanceCreationExpression_symbol() {	4152 // void test_instanceCreationExpression_symbol() {

4140 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const foo = const Symbol('a');"]));	4153 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const foo = const Symbol('a');"]));

4141 // EvaluationResultImpl evaluationResult = _evaluateInstanceCreationExpressi on(compilationUnit, "foo");	4154 // EvaluationResultImpl evaluationResult = _evaluateInstanceCreationExpressi on(compilationUnit, "foo");

4142 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, evaluationResult);	4155 // JUnitTestCase.assertNotNull(evaluationResult.value);

4143 // DartObjectImpl value = (evaluationResult as ValidResult).value;	4156 // DartObjectImpl value = evaluationResult.value;

4144 // JUnitTestCase.assertEquals(typeProvider.symbolType, value.type);	4157 // JUnitTestCase.assertEquals(typeProvider.symbolType, value.type);

4145 // JUnitTestCase.assertEquals("a", value.value);	4158 // JUnitTestCase.assertEquals("a", value.value);

4146 // }	4159 // }

4147 // void test_instanceCreationExpression_withSupertypeParams_explicit() {	4160 // void test_instanceCreationExpression_withSupertypeParams_explicit() {

4148 // _checkInstanceCreation_withSupertypeParams(true);	4161 // _checkInstanceCreation_withSupertypeParams(true);

4149 // }	4162 // }

4150 // void test_instanceCreationExpression_withSupertypeParams_implicit() {	4163 // void test_instanceCreationExpression_withSupertypeParams_implicit() {

4151 // _checkInstanceCreation_withSupertypeParams(false);	4164 // _checkInstanceCreation_withSupertypeParams(false);

4152 // }	4165 // }

4153 // void test_instanceCreationExpression_withTypeParams() {	4166 // void test_instanceCreationExpression_withTypeParams() {

4154 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce([	4167 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce([

4155 // "class C<E> {",	4168 // "class C<E> {",

4156 // " const C();",	4169 // " const C();",

4157 // "}",	4170 // "}",

4158 // "const c_int = const C<int>();",	4171 // "const c_int = const C<int>();",

4159 // "const c_num = const C<num>();"]));	4172 // "const c_num = const C<num>();"]));

4160 // EvaluationResultImpl c_int = _evaluateInstanceCreationExpression(compilat ionUnit, "c_int");	4173 // EvaluationResultImpl c_int = _evaluateInstanceCreationExpression(compilat ionUnit, "c_int");

4161 // _assertType(c_int, "C<int>");	4174 // _assertType(c_int, "C<int>");

4162 // DartObjectImpl c_int_value = (c_int as ValidResult).value;	4175 // DartObjectImpl c_int_value = c_int.value;

4163 // EvaluationResultImpl c_num = _evaluateInstanceCreationExpression(compilat ionUnit, "c_num");	4176 // EvaluationResultImpl c_num = _evaluateInstanceCreationExpression(compilat ionUnit, "c_num");

4164 // _assertType(c_num, "C<num>");	4177 // _assertType(c_num, "C<num>");

4165 // DartObjectImpl c_num_value = (c_num as ValidResult).value;	4178 // DartObjectImpl c_num_value = c_num.value;

4166 // JUnitTestCase.assertFalse(c_int_value == c_num_value);	4179 // JUnitTestCase.assertFalse(c_int_value == c_num_value);

4167 // }	4180 // }

4168 // void test_isValidSymbol() {	4181 // void test_isValidSymbol() {

4169 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol(""));	4182 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol(""));

4170 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo") );	4183 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo") );

4171 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo.b ar"));	4184 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo.b ar"));

4172 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo\$ "));	4185 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo\$ "));

4173 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo\$ bar"));	4186 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("foo\$ bar"));

4174 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("iff") );	4187 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("iff") );

4175 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("gif") );	4188 // JUnitTestCase.assertTrue(ConstantValueComputer.isValidPublicSymbol("gif") );

(...skipping 12 matching lines...) Expand all Loading...
4188 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("foo= .bar"));	4201 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("foo= .bar"));

4189 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("foo. "));	4202 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("foo. "));

4190 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("+.fo o"));	4203 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("+.fo o"));

4191 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("void .foo"));	4204 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("void .foo"));

4192 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("foo. void"));	4205 // JUnitTestCase.assertFalse(ConstantValueComputer.isValidPublicSymbol("foo. void"));

4193 // }	4206 // }

4194 // void test_symbolLiteral_void() {	4207 // void test_symbolLiteral_void() {

4195 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const voidSymbol = #void;"]));	4208 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const voidSymbol = #void;"]));

4196 // VariableDeclaration voidSymbol = findTopLevelDeclaration(compilationUnit, "voidSymbol");	4209 // VariableDeclaration voidSymbol = findTopLevelDeclaration(compilationUnit, "voidSymbol");

4197 // EvaluationResultImpl voidSymbolResult = (voidSymbol.element as VariableEl ementImpl).evaluationResult;	4210 // EvaluationResultImpl voidSymbolResult = (voidSymbol.element as VariableEl ementImpl).evaluationResult;

4198 // DartObjectImpl value = (voidSymbolResult as ValidResult).value;	4211 // DartObjectImpl value = voidSymbolResult.value;

4199 // JUnitTestCase.assertEquals(typeProvider.symbolType, value.type);	4212 // JUnitTestCase.assertEquals(typeProvider.symbolType, value.type);

4200 // JUnitTestCase.assertEquals("void", value.value);	4213 // JUnitTestCase.assertEquals("void", value.value);

4201 // }	4214 // }

4202 // HashMap<String, DartObjectImpl> _assertFieldType(HashMap<String, DartObject Impl> fields, String fieldName, String expectedType) {	4215 // HashMap<String, DartObjectImpl> _assertFieldType(HashMap<String, DartObject Impl> fields, String fieldName, String expectedType) {

4203 // DartObjectImpl field = fields[fieldName];	4216 // DartObjectImpl field = fields[fieldName];

4204 // JUnitTestCase.assertEquals(expectedType, field.type.displayName);	4217 // JUnitTestCase.assertEquals(expectedType, field.type.displayName);

4205 // return field.fields;	4218 // return field.fields;

4206 // }	4219 // }

4207 // void _assertIntField(HashMap<String, DartObjectImpl> fields, String fieldNa me, int expectedValue) {	4220 // void _assertIntField(HashMap<String, DartObjectImpl> fields, String fieldNa me, int expectedValue) {

4208 // DartObjectImpl field = fields[fieldName];	4221 // DartObjectImpl field = fields[fieldName];

4209 // JUnitTestCase.assertEquals("int", field.type.name);	4222 // JUnitTestCase.assertEquals("int", field.type.name);

4210 // JUnitTestCase.assertEquals(expectedValue, field.intValue.longValue());	4223 // JUnitTestCase.assertEquals(expectedValue, field.intValue.longValue());

4211 // }	4224 // }

4212 // void _assertNullField(HashMap<String, DartObjectImpl> fields, String fieldN ame) {	4225 // void _assertNullField(HashMap<String, DartObjectImpl> fields, String fieldN ame) {

4213 // DartObjectImpl field = fields[fieldName];	4226 // DartObjectImpl field = fields[fieldName];

4214 // JUnitTestCase.assertTrue(field.isNull);	4227 // JUnitTestCase.assertTrue(field.isNull);

4215 // }	4228 // }

4216 // void _assertProperDependencies(String sourceText, List<ErrorCode> expectedE rrorCodes) {	4229 // void _assertProperDependencies(String sourceText, List<ErrorCode> expectedE rrorCodes) {

4217 // Source source = addSource(sourceText);	4230 // Source source = addSource(sourceText);

4218 // LibraryElement element = resolve(source);	4231 // LibraryElement element = resolve(source);

4219 // CompilationUnit unit = analysisContext.resolveCompilationUnit(source, ele ment);	4232 // CompilationUnit unit = analysisContext.resolveCompilationUnit(source, ele ment);

4220 // JUnitTestCase.assertNotNull(unit);	4233 // JUnitTestCase.assertNotNull(unit);

4221 // ConstantValueComputer computer = _makeConstantValueComputer();	4234 // ConstantValueComputer computer = _makeConstantValueComputer();

4222 // computer.add(unit);	4235 // computer.add(unit);

4223 // computer.computeValues();	4236 // computer.computeValues();

4224 // assertErrors(source, expectedErrorCodes);	4237 // assertErrors(source, expectedErrorCodes);

4225 // }	4238 // }

4226 // HashMap<String, DartObjectImpl> _assertType(EvaluationResultImpl result, St ring typeName) {	4239 // HashMap<String, DartObjectImpl> _assertType(EvaluationResultImpl result, St ring typeName) {

4227 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, result);	4240 // JUnitTestCase.assertNotNull(result.value);

4228 // DartObjectImpl value = (result as ValidResult).value;	4241 // DartObjectImpl value = result.value;

4229 // JUnitTestCase.assertEquals(typeName, value.type.displayName);	4242 // JUnitTestCase.assertEquals(typeName, value.type.displayName);

4230 // return value.fields;	4243 // return value.fields;

4231 // }	4244 // }

4232 // bool _assertValidBool(EvaluationResultImpl result) {	4245 // bool _assertValidBool(EvaluationResultImpl result) {

4233 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, result);	4246 // JUnitTestCase.assertNotNull(result.value);

4234 // DartObjectImpl value = (result as ValidResult).value;	4247 // DartObjectImpl value = result.value;

4235 // JUnitTestCase.assertEquals(typeProvider.boolType, value.type);	4248 // JUnitTestCase.assertEquals(typeProvider.boolType, value.type);

4236 // bool boolValue = value.boolValue;	4249 // bool boolValue = value.boolValue;

4237 // JUnitTestCase.assertNotNull(boolValue);	4250 // JUnitTestCase.assertNotNull(boolValue);

4238 // return boolValue;	4251 // return boolValue;

4239 // }	4252 // }

4240 // int _assertValidInt(EvaluationResultImpl result) {	4253 // int _assertValidInt(EvaluationResultImpl result) {

4241 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, result);	4254 // JUnitTestCase.assertNotNull(result.value);

4242 // DartObjectImpl value = (result as ValidResult).value;	4255 // DartObjectImpl value = result.value;

4243 // JUnitTestCase.assertEquals(typeProvider.intType, value.type);	4256 // JUnitTestCase.assertEquals(typeProvider.intType, value.type);

4244 // return value.intValue;	4257 // return value.intValue;

4245 // }	4258 // }

4246 // void _assertValidNull(EvaluationResultImpl result) {	4259 // void _assertValidNull(EvaluationResultImpl result) {

4247 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, result);	4260 // JUnitTestCase.assertNotNull(result.value);

4248 // DartObjectImpl value = (result as ValidResult).value;	4261 // DartObjectImpl value = result.value;

4249 // JUnitTestCase.assertEquals(typeProvider.nullType, value.type);	4262 // JUnitTestCase.assertEquals(typeProvider.nullType, value.type);

4250 // }	4263 // }

4251 // String _assertValidString(EvaluationResultImpl result) {	4264 // String _assertValidString(EvaluationResultImpl result) {

4252 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, result);	4265 // JUnitTestCase.assertNotNull(result.value);

4253 // DartObjectImpl value = (result as ValidResult).value;	4266 // DartObjectImpl value = result.value;

4254 // JUnitTestCase.assertEquals(typeProvider.stringType, value.type);	4267 // JUnitTestCase.assertEquals(typeProvider.stringType, value.type);

4255 // return value.stringValue;	4268 // return value.stringValue;

4256 // }	4269 // }

4257 // void _assertValidUnknown(EvaluationResultImpl result) {	4270 // void _assertValidUnknown(EvaluationResultImpl result) {

4258 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, result);	4271 // JUnitTestCase.assertNotNull(result.value);

4259 // DartObjectImpl value = (result as ValidResult).value;	4272 // DartObjectImpl value = result.value;

4260 // JUnitTestCase.assertTrue(value.isUnknown);	4273 // JUnitTestCase.assertTrue(value.isUnknown);

4261 // }	4274 // }

4262 // EvaluationResultImpl _check_fromEnvironment_bool(String valueInEnvironment, String defaultExpr) {	4275 // EvaluationResultImpl _check_fromEnvironment_bool(String valueInEnvironment, String defaultExpr) {

4263 // String envVarName = "x";	4276 // String envVarName = "x";

4264 // String varName = "foo";	4277 // String varName = "foo";

4265 // if (valueInEnvironment != null) {	4278 // if (valueInEnvironment != null) {

4266 // analysisContext2.declaredVariables.define(envVarName, valueInEnvironmen t);	4279 // analysisContext2.declaredVariables.define(envVarName, valueInEnvironmen t);

4267 // }	4280 // }

4268 // String defaultArg = defaultExpr == null ? "" : ", defaultValue: ${default Expr}";	4281 // String defaultArg = defaultExpr == null ? "" : ", defaultValue: ${default Expr}";

4269 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const ${varName} = const bool.fromEnvironment('${envVarName}'${defaultArg}) ;"]));	4282 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const ${varName} = const bool.fromEnvironment('${envVarName}'${defaultArg}) ;"]));

(...skipping 61 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4331 // }	4344 // }

4332 // EvaluationResultImpl y = _evaluateInstanceCreationExpression(compilationU nit, "y");	4345 // EvaluationResultImpl y = _evaluateInstanceCreationExpression(compilationU nit, "y");

4333 // HashMap<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");	4346 // HashMap<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");

4334 // EngineTestCase.assertSizeOfMap(1, fieldsOfY);	4347 // EngineTestCase.assertSizeOfMap(1, fieldsOfY);

4335 // _assertIntField(fieldsOfY, fieldName, 10);	4348 // _assertIntField(fieldsOfY, fieldName, 10);

4336 // }	4349 // }

4337 // EvaluationResultImpl _evaluateInstanceCreationExpression(CompilationUnit co mpilationUnit, String name) {	4350 // EvaluationResultImpl _evaluateInstanceCreationExpression(CompilationUnit co mpilationUnit, String name) {

4338 // Expression expression = findTopLevelConstantExpression(compilationUnit, n ame);	4351 // Expression expression = findTopLevelConstantExpression(compilationUnit, n ame);

4339 // return (expression as InstanceCreationExpression).evaluationResult;	4352 // return (expression as InstanceCreationExpression).evaluationResult;

4340 // }	4353 // }

4341 // ConstantValueComputer _makeConstantValueComputer() => new ConstantValueComp uterTest_ValidatingConstantValueComputer(new TestTypeProvider(), analysisContext 2.declaredVariables);	4354 // ConstantValueComputer _makeConstantValueComputer() => new ConstantValueComp uterTest_ValidatingConstantValueComputer(analysisContext2.typeProvider, analysis Context2.declaredVariables);

4342 // void _validate(bool shouldBeValid, VariableDeclarationList declarationList) {	4355 // void _validate(bool shouldBeValid, VariableDeclarationList declarationList) {

4343 // for (VariableDeclaration declaration in declarationList.variables) {	4356 // for (VariableDeclaration declaration in declarationList.variables) {

4344 // VariableElementImpl element = declaration.element as VariableElementImp l;	4357 // VariableElementImpl element = declaration.element as VariableElementImp l;

4345 // JUnitTestCase.assertNotNull(element);	4358 // JUnitTestCase.assertNotNull(element);

4346 // EvaluationResultImpl result = element.evaluationResult;	4359 // EvaluationResultImpl result = element.evaluationResult;

4347 // if (shouldBeValid) {	4360 // if (shouldBeValid) {

4348 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidRes ult, result);	4361 // JUnitTestCase.assertNotNull(result.value);

4349 // Object value = (result as ValidResult).value;

4350 // JUnitTestCase.assertNotNull(value);

4351 // } else {	4362 // } else {

4352 // EngineTestCase.assertInstanceOf((obj) => obj is ErrorResult, ErrorRes ult, result);	4363 // JUnitTestCase.assertNull(result.value);

4353 // }	4364 // }

4354 // }	4365 // }

4355 // }	4366 // }

4356 // static dartSuite() {	4367 // static dartSuite() {

4357 // _ut.group('ConstantValueComputerTest', () {	4368 // _ut.group('ConstantValueComputerTest', () {

4358 // _ut.test('test_computeValues_cycle', () {	4369 // _ut.test('test_computeValues_cycle', () {

4359 // final __test = new ConstantValueComputerTest();	4370 // final __test = new ConstantValueComputerTest();

4360 // runJUnitTest(__test, __test.test_computeValues_cycle);	4371 // runJUnitTest(__test, __test.test_computeValues_cycle);

4361 // });	4372 // });

4362 // _ut.test('test_computeValues_dependentVariables', () {	4373 // _ut.test('test_computeValues_dependentVariables', () {

(...skipping 290 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4653 // // If we are getting the default parameter for a constructor in the graph , make sure we properly	4664 // // If we are getting the default parameter for a constructor in the graph , make sure we properly

4654 // // recorded the dependency on the parameter.	4665 // // recorded the dependency on the parameter.

4655 // ConstructorDeclaration constructorNode = constructorDeclarationMap[constr uctor];	4666 // ConstructorDeclaration constructorNode = constructorDeclarationMap[constr uctor];

4656 // if (constructorNode != null) {	4667 // if (constructorNode != null) {

4657 // FormalParameter parameterNode = constructorNode.parameters.parameters[p arameterIndex];	4668 // FormalParameter parameterNode = constructorNode.parameters.parameters[p arameterIndex];

4658 // JUnitTestCase.assertTrue(referenceGraph.nodes.contains(parameterNode));	4669 // JUnitTestCase.assertTrue(referenceGraph.nodes.contains(parameterNode));

4659 // JUnitTestCase.assertTrue(referenceGraph.containsPath(_nodeBeingEvaluate d, parameterNode));	4670 // JUnitTestCase.assertTrue(referenceGraph.containsPath(_nodeBeingEvaluate d, parameterNode));

4660 // }	4671 // }

4661 // }	4672 // }

4662 // @override	4673 // @override

4663 // ConstantVisitor createConstantVisitor() => new ConstantValueComputerTest_Va lidatingConstantVisitor(typeProvider, referenceGraph, _nodeBeingEvaluated);	4674 // ConstantVisitor createConstantVisitor(ErrorReporter errorReporter) => new C onstantValueComputerTest_ValidatingConstantVisitor(typeProvider, referenceGraph, _nodeBeingEvaluated, errorReporter);

4664 // }	4675 // }

4665 // class ConstantValueComputerTest_ValidatingConstantVisitor extends ConstantVis itor {	4676 // class ConstantValueComputerTest_ValidatingConstantVisitor extends ConstantVis itor {

4666 // final DirectedGraph<AstNode> _referenceGraph;	4677 // final DirectedGraph<AstNode> _referenceGraph;

4667 // final AstNode _nodeBeingEvaluated;	4678 // final AstNode _nodeBeingEvaluated;

4668 // ConstantValueComputerTest_ValidatingConstantVisitor(TypeProvider typeProvid er, this._referenceGraph, this._nodeBeingEvaluated) : super.con1(typeProvider);	4679 // ConstantValueComputerTest_ValidatingConstantVisitor(TypeProvider typeProvid er, this._referenceGraph, this._nodeBeingEvaluated, ErrorReporter errorReporter) : super.con1(typeProvider, errorReporter);

4669 // @override	4680 // @override

4670 // void beforeGetEvaluationResult(AstNode node) {	4681 // void beforeGetEvaluationResult(AstNode node) {

4671 // super.beforeGetEvaluationResult(node);	4682 // super.beforeGetEvaluationResult(node);

4672 // // If we are getting the evaluation result for a node in the graph, make sure we properly	4683 // // If we are getting the evaluation result for a node in the graph, make sure we properly

4673 // // recorded the dependency.	4684 // // recorded the dependency.

4674 // if (_referenceGraph.nodes.contains(node)) {	4685 // if (_referenceGraph.nodes.contains(node)) {

4675 // JUnitTestCase.assertTrue(_referenceGraph.containsPath(_nodeBeingEvaluat ed, node));	4686 // JUnitTestCase.assertTrue(_referenceGraph.containsPath(_nodeBeingEvaluat ed, node));

4676 // }	4687 // }

4677 // }	4688 // }

4678 // }	4689 // }

4679 // class ConstantVisitorTest extends ResolverTestCase {	4690 // class ConstantVisitorTest extends ResolverTestCase {

4680 // void test_visitConditionalExpression_false() {	4691 // void test_visitConditionalExpression_false() {

4681 // Expression thenExpression = AstFactory.integer(1);	4692 // Expression thenExpression = AstFactory.integer(1);

4682 // Expression elseExpression = AstFactory.integer(0);	4693 // Expression elseExpression = AstFactory.integer(0);

4683 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(false), thenExpression, elseExpression);	4694 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(false), thenExpression, elseExpression);

4684 // _assertValue(0, expression.accept(new ConstantVisitor.con1(new TestTypePr ovider())));	4695 // GatheringErrorListener errorListener = new GatheringErrorListener();

	4696 // ErrorReporter errorReporter = new ErrorReporter(errorListener, _dummySour ce());

	4697 // _assertValue(0, expression.accept(new ConstantVisitor.con1(new TestTypePr ovider(), errorReporter)));

	4698 // errorListener.assertNoErrors();

4685 // }	4699 // }

4686 // void test_visitConditionalExpression_instanceCreation_invalidFieldInitializ er() {	4700 // void test_visitConditionalExpression_instanceCreation_invalidFieldInitializ er() {

4687 // TestTypeProvider typeProvider = new TestTypeProvider();	4701 // TestTypeProvider typeProvider = new TestTypeProvider();

4688 // LibraryElementImpl libraryElement = ElementFactory.library(null, "lib");	4702 // LibraryElementImpl libraryElement = ElementFactory.library(null, "lib");

4689 // String className = "C";	4703 // String className = "C";

4690 // ClassElementImpl classElement = ElementFactory.classElement2(className, [ ]);	4704 // ClassElementImpl classElement = ElementFactory.classElement2(className, [ ]);

4691 // (libraryElement.definingCompilationUnit as CompilationUnitElementImpl).ty pes = <ClassElement> [classElement];	4705 // (libraryElement.definingCompilationUnit as CompilationUnitElementImpl).ty pes = <ClassElement> [classElement];

4692 // ConstructorElementImpl constructorElement = ElementFactory.constructorEle ment(classElement, null, true, [typeProvider.intType]);	4706 // ConstructorElementImpl constructorElement = ElementFactory.constructorEle ment(classElement, null, true, [typeProvider.intType]);

4693 // constructorElement.parameters[0] = new FieldFormalParameterElementImpl(As tFactory.identifier3("x"));	4707 // constructorElement.parameters[0] = new FieldFormalParameterElementImpl(As tFactory.identifier3("x"));

4694 // InstanceCreationExpression expression = AstFactory.instanceCreationExpres sion2(Keyword.CONST, AstFactory.typeName4(className, []), [AstFactory.integer(0) ]);	4708 // InstanceCreationExpression expression = AstFactory.instanceCreationExpres sion2(Keyword.CONST, AstFactory.typeName4(className, []), [AstFactory.integer(0) ]);

4695 // expression.staticElement = constructorElement;	4709 // expression.staticElement = constructorElement;

4696 // expression.accept(new ConstantVisitor.con1(typeProvider));	4710 // GatheringErrorListener errorListener = new GatheringErrorListener();

	4711 // ErrorReporter errorReporter = new ErrorReporter(errorListener, _dummySour ce());

	4712 // expression.accept(new ConstantVisitor.con1(typeProvider, errorReporter));

	4713 // errorListener.assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTAN T]);

4697 // }	4714 // }

4698 // void test_visitConditionalExpression_nonBooleanCondition() {	4715 // void test_visitConditionalExpression_nonBooleanCondition() {

4699 // Expression thenExpression = AstFactory.integer(1);	4716 // Expression thenExpression = AstFactory.integer(1);

4700 // Expression elseExpression = AstFactory.integer(0);	4717 // Expression elseExpression = AstFactory.integer(0);

4701 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.nullLiteral(), thenExpression, elseExpression);	4718 // NullLiteral conditionExpression = AstFactory.nullLiteral();

4702 // EvaluationResultImpl result = expression.accept(new ConstantVisitor.con1( new TestTypeProvider()));	4719 // ConditionalExpression expression = AstFactory.conditionalExpression(condi tionExpression, thenExpression, elseExpression);

4703 // EngineTestCase.assertInstanceOf((obj) => obj is ErrorResult, ErrorResult, result);	4720 // GatheringErrorListener errorListener = new GatheringErrorListener();

	4721 // ErrorReporter errorReporter = new ErrorReporter(errorListener, _dummySour ce());

	4722 // DartObjectImpl result = expression.accept(new ConstantVisitor.con1(new Te stTypeProvider(), errorReporter));

	4723 // JUnitTestCase.assertNull(result);

	4724 // errorListener.assertErrorsWithCodes([CompileTimeErrorCode.CONST_EVAL_TYPE _BOOL]);

4704 // }	4725 // }

4705 // void test_visitConditionalExpression_nonConstantElse() {	4726 // void test_visitConditionalExpression_nonConstantElse() {

4706 // Expression thenExpression = AstFactory.integer(1);	4727 // Expression thenExpression = AstFactory.integer(1);

4707 // Expression elseExpression = AstFactory.identifier3("x");	4728 // Expression elseExpression = AstFactory.identifier3("x");

4708 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(true), thenExpression, elseExpression);	4729 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(true), thenExpression, elseExpression);

4709 // EvaluationResultImpl result = expression.accept(new ConstantVisitor.con1( new TestTypeProvider()));	4730 // GatheringErrorListener errorListener = new GatheringErrorListener();

4710 // EngineTestCase.assertInstanceOf((obj) => obj is ErrorResult, ErrorResult, result);	4731 // ErrorReporter errorReporter = new ErrorReporter(errorListener, _dummySour ce());

	4732 // DartObjectImpl result = expression.accept(new ConstantVisitor.con1(new Te stTypeProvider(), errorReporter));

	4733 // JUnitTestCase.assertNull(result);

	4734 // errorListener.assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTAN T]);

4711 // }	4735 // }

4712 // void test_visitConditionalExpression_nonConstantThen() {	4736 // void test_visitConditionalExpression_nonConstantThen() {

4713 // Expression thenExpression = AstFactory.identifier3("x");	4737 // Expression thenExpression = AstFactory.identifier3("x");

4714 // Expression elseExpression = AstFactory.integer(0);	4738 // Expression elseExpression = AstFactory.integer(0);

4715 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(true), thenExpression, elseExpression);	4739 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(true), thenExpression, elseExpression);

4716 // EvaluationResultImpl result = expression.accept(new ConstantVisitor.con1( new TestTypeProvider()));	4740 // GatheringErrorListener errorListener = new GatheringErrorListener();

4717 // EngineTestCase.assertInstanceOf((obj) => obj is ErrorResult, ErrorResult, result);	4741 // ErrorReporter errorReporter = new ErrorReporter(errorListener, _dummySour ce());

	4742 // DartObjectImpl result = expression.accept(new ConstantVisitor.con1(new Te stTypeProvider(), errorReporter));

	4743 // JUnitTestCase.assertNull(result);

	4744 // errorListener.assertErrorsWithCodes([CompileTimeErrorCode.INVALID_CONSTAN T]);

4718 // }	4745 // }

4719 // void test_visitConditionalExpression_true() {	4746 // void test_visitConditionalExpression_true() {

4720 // Expression thenExpression = AstFactory.integer(1);	4747 // Expression thenExpression = AstFactory.integer(1);

4721 // Expression elseExpression = AstFactory.integer(0);	4748 // Expression elseExpression = AstFactory.integer(0);

4722 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(true), thenExpression, elseExpression);	4749 // ConditionalExpression expression = AstFactory.conditionalExpression(AstFa ctory.booleanLiteral(true), thenExpression, elseExpression);

4723 // _assertValue(1, expression.accept(new ConstantVisitor.con1(new TestTypePr ovider())));	4750 // GatheringErrorListener errorListener = new GatheringErrorListener();

	4751 // ErrorReporter errorReporter = new ErrorReporter(errorListener, _dummySour ce());

	4752 // _assertValue(1, expression.accept(new ConstantVisitor.con1(new TestTypePr ovider(), errorReporter)));

	4753 // errorListener.assertNoErrors();

4724 // }	4754 // }

	4755 // NonExistingSource _dummySource() => new NonExistingSource("foo.dart", UriKi nd.FILE_URI);

4725 // void test_visitSimpleIdentifier_inEnvironment() {	4756 // void test_visitSimpleIdentifier_inEnvironment() {

4726 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const a = b;", "const b = 3;"]));	4757 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const a = b;", "const b = 3;"]));

4727 // HashMap<String, DartObjectImpl> environment = new HashMap<String, DartObj ectImpl>();	4758 // HashMap<String, DartObjectImpl> environment = new HashMap<String, DartObj ectImpl>();

4728 // DartObjectImpl six = new DartObjectImpl(typeProvider.intType, new IntStat e(6));	4759 // DartObjectImpl six = new DartObjectImpl(typeProvider.intType, new IntStat e(6));

4729 // environment["b"] = six;	4760 // environment["b"] = six;

4730 // _assertValue(6, _evaluateConstant(compilationUnit, "a", environment));	4761 // _assertValue(6, _evaluateConstant(compilationUnit, "a", environment));

4731 // }	4762 // }

4732 // void test_visitSimpleIdentifier_notInEnvironment() {	4763 // void test_visitSimpleIdentifier_notInEnvironment() {

4733 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const a = b;", "const b = 3;"]));	4764 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const a = b;", "const b = 3;"]));

4734 // HashMap<String, DartObjectImpl> environment = new HashMap<String, DartObj ectImpl>();	4765 // HashMap<String, DartObjectImpl> environment = new HashMap<String, DartObj ectImpl>();

4735 // DartObjectImpl six = new DartObjectImpl(typeProvider.intType, new IntStat e(6));	4766 // DartObjectImpl six = new DartObjectImpl(typeProvider.intType, new IntStat e(6));

4736 // environment["c"] = six;	4767 // environment["c"] = six;

4737 // _assertValue(3, _evaluateConstant(compilationUnit, "a", environment));	4768 // _assertValue(3, _evaluateConstant(compilationUnit, "a", environment));

4738 // }	4769 // }

4739 // void test_visitSimpleIdentifier_withoutEnvironment() {	4770 // void test_visitSimpleIdentifier_withoutEnvironment() {

4740 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const a = b;", "const b = 3;"]));	4771 // CompilationUnit compilationUnit = resolveSource(EngineTestCase.createSour ce(["const a = b;", "const b = 3;"]));

4741 // _assertValue(3, _evaluateConstant(compilationUnit, "a", null));	4772 // _assertValue(3, _evaluateConstant(compilationUnit, "a", null));

4742 // }	4773 // }

4743 // void _assertValue(int expectedValue, EvaluationResultImpl result) {	4774 // void _assertValue(int expectedValue, DartObjectImpl result) {

4744 // EngineTestCase.assertInstanceOf((obj) => obj is ValidResult, ValidResult, result);	4775 // JUnitTestCase.assertNotNull(result);

4745 // DartObjectImpl value = (result as ValidResult).value;	4776 // JUnitTestCase.assertEquals("int", result.type.name);

4746 // JUnitTestCase.assertEquals("int", value.type.name);	4777 // JUnitTestCase.assertEquals(expectedValue, result.intValue.longValue());

4747 // JUnitTestCase.assertEquals(expectedValue, value.intValue.longValue());

4748 // }	4778 // }

4749 // EvaluationResultImpl _evaluateConstant(CompilationUnit compilationUnit, Str ing name, HashMap<String, DartObjectImpl> lexicalEnvironment) {	4779 // DartObjectImpl _evaluateConstant(CompilationUnit compilationUnit, String na me, HashMap<String, DartObjectImpl> lexicalEnvironment) {

	4780 // Source source = compilationUnit.element.source;

4750 // Expression expression = findTopLevelConstantExpression(compilationUnit, n ame);	4781 // Expression expression = findTopLevelConstantExpression(compilationUnit, n ame);

4751 // return expression.accept(new ConstantVisitor.con2(typeProvider, lexicalEn vironment));	4782 // GatheringErrorListener errorListener = new GatheringErrorListener();

	4783 // ErrorReporter errorReporter = new ErrorReporter(errorListener, source);

	4784 // DartObjectImpl result = expression.accept(new ConstantVisitor.con2(typePr ovider, lexicalEnvironment, errorReporter));

	4785 // errorListener.assertNoErrors();

	4786 // return result;

4752 // }	4787 // }

4753 // static dartSuite() {	4788 // static dartSuite() {

4754 // _ut.group('ConstantVisitorTest', () {	4789 // _ut.group('ConstantVisitorTest', () {

4755 // _ut.test('test_visitConditionalExpression_false', () {	4790 // _ut.test('test_visitConditionalExpression_false', () {

4756 // final __test = new ConstantVisitorTest();	4791 // final __test = new ConstantVisitorTest();

4757 // runJUnitTest(__test, __test.test_visitConditionalExpression_false);	4792 // runJUnitTest(__test, __test.test_visitConditionalExpression_false);

4758 // });	4793 // });

4759 // _ut.test('test_visitConditionalExpression_instanceCreation_invalidField Initializer', () {	4794 // _ut.test('test_visitConditionalExpression_instanceCreation_invalidField Initializer', () {

4760 // final __test = new ConstantVisitorTest();	4795 // final __test = new ConstantVisitorTest();

4761 // runJUnitTest(__test, __test.test_visitConditionalExpression_instanceC reation_invalidFieldInitializer);	4796 // runJUnitTest(__test, __test.test_visitConditionalExpression_instanceC reation_invalidFieldInitializer);

(...skipping 49 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
4811 // _ut.group('ContentCacheTest', () {	4846 // _ut.group('ContentCacheTest', () {

4812 // _ut.test('test_setContents', () {	4847 // _ut.test('test_setContents', () {

4813 // final __test = new ContentCacheTest();	4848 // final __test = new ContentCacheTest();

4814 // runJUnitTest(__test, __test.test_setContents);	4849 // runJUnitTest(__test, __test.test_setContents);

4815 // });	4850 // });

4816 // });	4851 // });

4817 // }	4852 // }

4818 // }	4853 // }

4819 // class DartObjectImplTest extends EngineTestCase {	4854 // class DartObjectImplTest extends EngineTestCase {

4820 // TypeProvider _typeProvider = new TestTypeProvider();	4855 // TypeProvider _typeProvider = new TestTypeProvider();

4821 // void test_add_invalid_knownInt() {	4856 // void fail_add_knownString_knownString() {

4822 // _assertAdd(null, _stringValue("1"), _intValue(2));	4857 // JUnitTestCase.fail("New constant semantics are not yet enabled");

	4858 // _assertAdd(_stringValue("ab"), _stringValue("a"), _stringValue("b"));

	4859 // }

	4860 // void fail_add_knownString_unknownString() {

	4861 // JUnitTestCase.fail("New constant semantics are not yet enabled");

	4862 // _assertAdd(_stringValue(null), _stringValue("a"), _stringValue(null));

	4863 // }

	4864 // void fail_add_unknownString_knownString() {

	4865 // JUnitTestCase.fail("New constant semantics are not yet enabled");

	4866 // _assertAdd(_stringValue(null), _stringValue(null), _stringValue("b"));

	4867 // }

	4868 // void fail_add_unknownString_unknownString() {

	4869 // JUnitTestCase.fail("New constant semantics are not yet enabled");

	4870 // _assertAdd(_stringValue(null), _stringValue(null), _stringValue(null));

4823 // }	4871 // }

4824 // void test_add_knownDouble_knownDouble() {	4872 // void test_add_knownDouble_knownDouble() {

4825 // _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _doubleValue(2.0));	4873 // _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _doubleValue(2.0));

4826 // }	4874 // }

4827 // void test_add_knownDouble_knownInt() {	4875 // void test_add_knownDouble_knownInt() {

4828 // _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _intValue(2));	4876 // _assertAdd(_doubleValue(3.0), _doubleValue(1.0), _intValue(2));

4829 // }	4877 // }

4830 // void test_add_knownDouble_unknownDouble() {	4878 // void test_add_knownDouble_unknownDouble() {

4831 // _assertAdd(_doubleValue(null), _doubleValue(1.0), _doubleValue(null));	4879 // _assertAdd(_doubleValue(null), _doubleValue(1.0), _doubleValue(null));

4832 // }	4880 // }

4833 // void test_add_knownDouble_unknownInt() {	4881 // void test_add_knownDouble_unknownInt() {

4834 // _assertAdd(_doubleValue(null), _doubleValue(1.0), _intValue(null));	4882 // _assertAdd(_doubleValue(null), _doubleValue(1.0), _intValue(null));

4835 // }	4883 // }

4836 // void test_add_knownInt_invalid() {

4837 // _assertAdd(null, _intValue(1), _stringValue("2"));

4838 // }

4839 // void test_add_knownInt_knownInt() {	4884 // void test_add_knownInt_knownInt() {

4840 // _assertAdd(_intValue(3), _intValue(1), _intValue(2));	4885 // _assertAdd(_intValue(3), _intValue(1), _intValue(2));

4841 // }	4886 // }

	4887 // void test_add_knownInt_knownString() {

	4888 // _assertAdd(null, _intValue(1), _stringValue("2"));

	4889 // }

4842 // void test_add_knownInt_unknownDouble() {	4890 // void test_add_knownInt_unknownDouble() {

4843 // _assertAdd(_doubleValue(null), _intValue(1), _doubleValue(null));	4891 // _assertAdd(_doubleValue(null), _intValue(1), _doubleValue(null));

4844 // }	4892 // }

4845 // void test_add_knownInt_unknownInt() {	4893 // void test_add_knownInt_unknownInt() {

4846 // _assertAdd(_intValue(null), _intValue(1), _intValue(null));	4894 // _assertAdd(_intValue(null), _intValue(1), _intValue(null));

4847 // }	4895 // }

	4896 // void test_add_knownString_knownInt() {

	4897 // _assertAdd(null, _stringValue("1"), _intValue(2));

	4898 // }

4848 // void test_add_unknownDouble_knownDouble() {	4899 // void test_add_unknownDouble_knownDouble() {

4849 // _assertAdd(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));	4900 // _assertAdd(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));

4850 // }	4901 // }

4851 // void test_add_unknownDouble_knownInt() {	4902 // void test_add_unknownDouble_knownInt() {

4852 // _assertAdd(_doubleValue(null), _doubleValue(null), _intValue(2));	4903 // _assertAdd(_doubleValue(null), _doubleValue(null), _intValue(2));

4853 // }	4904 // }

4854 // void test_add_unknownInt_knownDouble() {	4905 // void test_add_unknownInt_knownDouble() {

4855 // _assertAdd(_doubleValue(null), _intValue(null), _doubleValue(2.0));	4906 // _assertAdd(_doubleValue(null), _intValue(null), _doubleValue(2.0));

4856 // }	4907 // }

4857 // void test_add_unknownInt_knownInt() {	4908 // void test_add_unknownInt_knownInt() {

4858 // _assertAdd(_intValue(null), _intValue(null), _intValue(2));	4909 // _assertAdd(_intValue(null), _intValue(null), _intValue(2));

4859 // }	4910 // }

4860 // void test_bitAnd_invalid_knownInt() {

4861 // _assertBitAnd(null, _stringValue("6"), _intValue(3));

4862 // }

4863 // void test_bitAnd_knownInt_invalid() {

4864 // _assertBitAnd(null, _intValue(6), _stringValue("3"));

4865 // }

4866 // void test_bitAnd_knownInt_knownInt() {	4911 // void test_bitAnd_knownInt_knownInt() {

4867 // _assertBitAnd(_intValue(2), _intValue(6), _intValue(3));	4912 // _assertBitAnd(_intValue(2), _intValue(6), _intValue(3));

4868 // }	4913 // }

	4914 // void test_bitAnd_knownInt_knownString() {

	4915 // _assertBitAnd(null, _intValue(6), _stringValue("3"));

	4916 // }

4869 // void test_bitAnd_knownInt_unknownInt() {	4917 // void test_bitAnd_knownInt_unknownInt() {

4870 // _assertBitAnd(_intValue(null), _intValue(6), _intValue(null));	4918 // _assertBitAnd(_intValue(null), _intValue(6), _intValue(null));

4871 // }	4919 // }

	4920 // void test_bitAnd_knownString_knownInt() {

	4921 // _assertBitAnd(null, _stringValue("6"), _intValue(3));

	4922 // }

4872 // void test_bitAnd_unknownInt_knownInt() {	4923 // void test_bitAnd_unknownInt_knownInt() {

4873 // _assertBitAnd(_intValue(null), _intValue(null), _intValue(3));	4924 // _assertBitAnd(_intValue(null), _intValue(null), _intValue(3));

4874 // }	4925 // }

4875 // void test_bitAnd_unknownInt_unknownInt() {	4926 // void test_bitAnd_unknownInt_unknownInt() {

4876 // _assertBitAnd(_intValue(null), _intValue(null), _intValue(null));	4927 // _assertBitAnd(_intValue(null), _intValue(null), _intValue(null));

4877 // }	4928 // }

4878 // void test_bitNot_invalid() {

4879 // _assertBitNot(null, _stringValue("6"));

4880 // }

4881 // void test_bitNot_knownInt() {	4929 // void test_bitNot_knownInt() {

4882 // _assertBitNot(_intValue(-4), _intValue(3));	4930 // _assertBitNot(_intValue(-4), _intValue(3));

4883 // }	4931 // }

	4932 // void test_bitNot_knownString() {

	4933 // _assertBitNot(null, _stringValue("6"));

	4934 // }

4884 // void test_bitNot_unknownInt() {	4935 // void test_bitNot_unknownInt() {

4885 // _assertBitNot(_intValue(null), _intValue(null));	4936 // _assertBitNot(_intValue(null), _intValue(null));

4886 // }	4937 // }

4887 // void test_bitOr_invalid_knownInt() {

4888 // _assertBitOr(null, _stringValue("6"), _intValue(3));

4889 // }

4890 // void test_bitOr_knownInt_invalid() {

4891 // _assertBitOr(null, _intValue(6), _stringValue("3"));

4892 // }

4893 // void test_bitOr_knownInt_knownInt() {	4938 // void test_bitOr_knownInt_knownInt() {

4894 // _assertBitOr(_intValue(7), _intValue(6), _intValue(3));	4939 // _assertBitOr(_intValue(7), _intValue(6), _intValue(3));

4895 // }	4940 // }

	4941 // void test_bitOr_knownInt_knownString() {

	4942 // _assertBitOr(null, _intValue(6), _stringValue("3"));

	4943 // }

4896 // void test_bitOr_knownInt_unknownInt() {	4944 // void test_bitOr_knownInt_unknownInt() {

4897 // _assertBitOr(_intValue(null), _intValue(6), _intValue(null));	4945 // _assertBitOr(_intValue(null), _intValue(6), _intValue(null));

4898 // }	4946 // }

	4947 // void test_bitOr_knownString_knownInt() {

	4948 // _assertBitOr(null, _stringValue("6"), _intValue(3));

	4949 // }

4899 // void test_bitOr_unknownInt_knownInt() {	4950 // void test_bitOr_unknownInt_knownInt() {

4900 // _assertBitOr(_intValue(null), _intValue(null), _intValue(3));	4951 // _assertBitOr(_intValue(null), _intValue(null), _intValue(3));

4901 // }	4952 // }

4902 // void test_bitOr_unknownInt_unknownInt() {	4953 // void test_bitOr_unknownInt_unknownInt() {

4903 // _assertBitOr(_intValue(null), _intValue(null), _intValue(null));	4954 // _assertBitOr(_intValue(null), _intValue(null), _intValue(null));

4904 // }	4955 // }

4905 // void test_bitXor_invalid_knownInt() {

4906 // _assertBitXor(null, _stringValue("6"), _intValue(3));

4907 // }

4908 // void test_bitXor_knownInt_invalid() {

4909 // _assertBitXor(null, _intValue(6), _stringValue("3"));

4910 // }

4911 // void test_bitXor_knownInt_knownInt() {	4956 // void test_bitXor_knownInt_knownInt() {

4912 // _assertBitXor(_intValue(5), _intValue(6), _intValue(3));	4957 // _assertBitXor(_intValue(5), _intValue(6), _intValue(3));

4913 // }	4958 // }

	4959 // void test_bitXor_knownInt_knownString() {

	4960 // _assertBitXor(null, _intValue(6), _stringValue("3"));

	4961 // }

4914 // void test_bitXor_knownInt_unknownInt() {	4962 // void test_bitXor_knownInt_unknownInt() {

4915 // _assertBitXor(_intValue(null), _intValue(6), _intValue(null));	4963 // _assertBitXor(_intValue(null), _intValue(6), _intValue(null));

4916 // }	4964 // }

	4965 // void test_bitXor_knownString_knownInt() {

	4966 // _assertBitXor(null, _stringValue("6"), _intValue(3));

	4967 // }

4917 // void test_bitXor_unknownInt_knownInt() {	4968 // void test_bitXor_unknownInt_knownInt() {

4918 // _assertBitXor(_intValue(null), _intValue(null), _intValue(3));	4969 // _assertBitXor(_intValue(null), _intValue(null), _intValue(3));

4919 // }	4970 // }

4920 // void test_bitXor_unknownInt_unknownInt() {	4971 // void test_bitXor_unknownInt_unknownInt() {

4921 // _assertBitXor(_intValue(null), _intValue(null), _intValue(null));	4972 // _assertBitXor(_intValue(null), _intValue(null), _intValue(null));

4922 // }	4973 // }

4923 // void test_concatenate_invalid_knownString() {	4974 // void test_concatenate_knownInt_knownString() {

4924 // _assertConcatenate(null, _intValue(2), _stringValue("def"));	4975 // _assertConcatenate(null, _intValue(2), _stringValue("def"));

4925 // }	4976 // }

4926 // void test_concatenate_knownString_invalid() {	4977 // void test_concatenate_knownString_knownInt() {

4927 // _assertConcatenate(null, _stringValue("abc"), _intValue(3));	4978 // _assertConcatenate(null, _stringValue("abc"), _intValue(3));

4928 // }	4979 // }

4929 // void test_concatenate_knownString_knownString() {	4980 // void test_concatenate_knownString_knownString() {

4930 // _assertConcatenate(_stringValue("abcdef"), _stringValue("abc"), _stringVa lue("def"));	4981 // _assertConcatenate(_stringValue("abcdef"), _stringValue("abc"), _stringVa lue("def"));

4931 // }	4982 // }

4932 // void test_concatenate_knownString_unknownString() {	4983 // void test_concatenate_knownString_unknownString() {

4933 // _assertConcatenate(_stringValue(null), _stringValue("abc"), _stringValue( null));	4984 // _assertConcatenate(_stringValue(null), _stringValue("abc"), _stringValue( null));

4934 // }	4985 // }

4935 // void test_concatenate_unknownString_knownString() {	4986 // void test_concatenate_unknownString_knownString() {

4936 // _assertConcatenate(_stringValue(null), _stringValue(null), _stringValue(" def"));	4987 // _assertConcatenate(_stringValue(null), _stringValue(null), _stringValue(" def"));

4937 // }	4988 // }

4938 // void test_divide_invalid_knownInt() {

4939 // _assertDivide(null, _stringValue("6"), _intValue(2));

4940 // }

4941 // void test_divide_knownDouble_knownDouble() {	4989 // void test_divide_knownDouble_knownDouble() {

4942 // _assertDivide(_doubleValue(3.0), _doubleValue(6.0), _doubleValue(2.0));	4990 // _assertDivide(_doubleValue(3.0), _doubleValue(6.0), _doubleValue(2.0));

4943 // }	4991 // }

4944 // void test_divide_knownDouble_knownInt() {	4992 // void test_divide_knownDouble_knownInt() {

4945 // _assertDivide(_doubleValue(3.0), _doubleValue(6.0), _intValue(2));	4993 // _assertDivide(_doubleValue(3.0), _doubleValue(6.0), _intValue(2));

4946 // }	4994 // }

4947 // void test_divide_knownDouble_unknownDouble() {	4995 // void test_divide_knownDouble_unknownDouble() {

4948 // _assertDivide(_doubleValue(null), _doubleValue(6.0), _doubleValue(null));	4996 // _assertDivide(_doubleValue(null), _doubleValue(6.0), _doubleValue(null));

4949 // }	4997 // }

4950 // void test_divide_knownDouble_unknownInt() {	4998 // void test_divide_knownDouble_unknownInt() {

4951 // _assertDivide(_doubleValue(null), _doubleValue(6.0), _intValue(null));	4999 // _assertDivide(_doubleValue(null), _doubleValue(6.0), _intValue(null));

4952 // }	5000 // }

4953 // void test_divide_knownInt_invalid() {

4954 // _assertDivide(null, _intValue(6), _stringValue("2"));

4955 // }

4956 // void test_divide_knownInt_knownInt() {	5001 // void test_divide_knownInt_knownInt() {

4957 // _assertDivide(_intValue(3), _intValue(6), _intValue(2));	5002 // _assertDivide(_intValue(3), _intValue(6), _intValue(2));

4958 // }	5003 // }

	5004 // void test_divide_knownInt_knownString() {

	5005 // _assertDivide(null, _intValue(6), _stringValue("2"));

	5006 // }

4959 // void test_divide_knownInt_unknownDouble() {	5007 // void test_divide_knownInt_unknownDouble() {

4960 // _assertDivide(_doubleValue(null), _intValue(6), _doubleValue(null));	5008 // _assertDivide(_doubleValue(null), _intValue(6), _doubleValue(null));

4961 // }	5009 // }

4962 // void test_divide_knownInt_unknownInt() {	5010 // void test_divide_knownInt_unknownInt() {

4963 // _assertDivide(_intValue(null), _intValue(6), _intValue(null));	5011 // _assertDivide(_intValue(null), _intValue(6), _intValue(null));

4964 // }	5012 // }

	5013 // void test_divide_knownString_knownInt() {

	5014 // _assertDivide(null, _stringValue("6"), _intValue(2));

	5015 // }

4965 // void test_divide_unknownDouble_knownDouble() {	5016 // void test_divide_unknownDouble_knownDouble() {

4966 // _assertDivide(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));	5017 // _assertDivide(_doubleValue(null), _doubleValue(null), _doubleValue(2.0));

4967 // }	5018 // }

4968 // void test_divide_unknownDouble_knownInt() {	5019 // void test_divide_unknownDouble_knownInt() {

4969 // _assertDivide(_doubleValue(null), _doubleValue(null), _intValue(2));	5020 // _assertDivide(_doubleValue(null), _doubleValue(null), _intValue(2));

4970 // }	5021 // }

4971 // void test_divide_unknownInt_knownDouble() {	5022 // void test_divide_unknownInt_knownDouble() {

4972 // _assertDivide(_doubleValue(null), _intValue(null), _doubleValue(2.0));	5023 // _assertDivide(_doubleValue(null), _intValue(null), _doubleValue(2.0));

4973 // }	5024 // }

4974 // void test_divide_unknownInt_knownInt() {	5025 // void test_divide_unknownInt_knownInt() {

(...skipping 121 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5096 // void test_getValue_null() {	5147 // void test_getValue_null() {

5097 // JUnitTestCase.assertNull(_nullValue().value);	5148 // JUnitTestCase.assertNull(_nullValue().value);

5098 // }	5149 // }

5099 // void test_getValue_string_known() {	5150 // void test_getValue_string_known() {

5100 // String value = "twenty-three";	5151 // String value = "twenty-three";

5101 // JUnitTestCase.assertEquals(value, _stringValue(value).value);	5152 // JUnitTestCase.assertEquals(value, _stringValue(value).value);

5102 // }	5153 // }

5103 // void test_getValue_string_unknown() {	5154 // void test_getValue_string_unknown() {

5104 // JUnitTestCase.assertNull(_stringValue(null).value);	5155 // JUnitTestCase.assertNull(_stringValue(null).value);

5105 // }	5156 // }

5106 // void test_greaterThan_invalid_knownInt() {

5107 // _assertGreaterThan(null, _stringValue("1"), _intValue(2));

5108 // }

5109 // void test_greaterThan_knownDouble_knownDouble_false() {	5157 // void test_greaterThan_knownDouble_knownDouble_false() {

5110 // _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _doubleValue(2.0 ));	5158 // _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _doubleValue(2.0 ));

5111 // }	5159 // }

5112 // void test_greaterThan_knownDouble_knownDouble_true() {	5160 // void test_greaterThan_knownDouble_knownDouble_true() {

5113 // _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _doubleValue(1.0) );	5161 // _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _doubleValue(1.0) );

5114 // }	5162 // }

5115 // void test_greaterThan_knownDouble_knownInt_false() {	5163 // void test_greaterThan_knownDouble_knownInt_false() {

5116 // _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _intValue(2));	5164 // _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _intValue(2));

5117 // }	5165 // }

5118 // void test_greaterThan_knownDouble_knownInt_true() {	5166 // void test_greaterThan_knownDouble_knownInt_true() {

5119 // _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _intValue(1));	5167 // _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _intValue(1));

5120 // }	5168 // }

5121 // void test_greaterThan_knownDouble_unknownDouble() {	5169 // void test_greaterThan_knownDouble_unknownDouble() {

5122 // _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null ));	5170 // _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null ));

5123 // }	5171 // }

5124 // void test_greaterThan_knownDouble_unknownInt() {	5172 // void test_greaterThan_knownDouble_unknownInt() {

5125 // _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _intValue(null));	5173 // _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _intValue(null));

5126 // }	5174 // }

5127 // void test_greaterThan_knownInt_invalid() {

5128 // _assertGreaterThan(null, _intValue(1), _stringValue("2"));

5129 // }

5130 // void test_greaterThan_knownInt_knownInt_false() {	5175 // void test_greaterThan_knownInt_knownInt_false() {

5131 // _assertGreaterThan(_boolValue(false), _intValue(1), _intValue(2));	5176 // _assertGreaterThan(_boolValue(false), _intValue(1), _intValue(2));

5132 // }	5177 // }

5133 // void test_greaterThan_knownInt_knownInt_true() {	5178 // void test_greaterThan_knownInt_knownInt_true() {

5134 // _assertGreaterThan(_boolValue(true), _intValue(2), _intValue(1));	5179 // _assertGreaterThan(_boolValue(true), _intValue(2), _intValue(1));

5135 // }	5180 // }

	5181 // void test_greaterThan_knownInt_knownString() {

	5182 // _assertGreaterThan(null, _intValue(1), _stringValue("2"));

	5183 // }

5136 // void test_greaterThan_knownInt_unknownDouble() {	5184 // void test_greaterThan_knownInt_unknownDouble() {

5137 // _assertGreaterThan(_boolValue(null), _intValue(1), _doubleValue(null));	5185 // _assertGreaterThan(_boolValue(null), _intValue(1), _doubleValue(null));

5138 // }	5186 // }

5139 // void test_greaterThan_knownInt_unknownInt() {	5187 // void test_greaterThan_knownInt_unknownInt() {

5140 // _assertGreaterThan(_boolValue(null), _intValue(1), _intValue(null));	5188 // _assertGreaterThan(_boolValue(null), _intValue(1), _intValue(null));

5141 // }	5189 // }

	5190 // void test_greaterThan_knownString_knownInt() {

	5191 // _assertGreaterThan(null, _stringValue("1"), _intValue(2));

	5192 // }

5142 // void test_greaterThan_unknownDouble_knownDouble() {	5193 // void test_greaterThan_unknownDouble_knownDouble() {

5143 // _assertGreaterThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0 ));	5194 // _assertGreaterThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0 ));

5144 // }	5195 // }

5145 // void test_greaterThan_unknownDouble_knownInt() {	5196 // void test_greaterThan_unknownDouble_knownInt() {

5146 // _assertGreaterThan(_boolValue(null), _doubleValue(null), _intValue(2));	5197 // _assertGreaterThan(_boolValue(null), _doubleValue(null), _intValue(2));

5147 // }	5198 // }

5148 // void test_greaterThan_unknownInt_knownDouble() {	5199 // void test_greaterThan_unknownInt_knownDouble() {

5149 // _assertGreaterThan(_boolValue(null), _intValue(null), _doubleValue(2.0));	5200 // _assertGreaterThan(_boolValue(null), _intValue(null), _doubleValue(2.0));

5150 // }	5201 // }

5151 // void test_greaterThan_unknownInt_knownInt() {	5202 // void test_greaterThan_unknownInt_knownInt() {

5152 // _assertGreaterThan(_boolValue(null), _intValue(null), _intValue(2));	5203 // _assertGreaterThan(_boolValue(null), _intValue(null), _intValue(2));

5153 // }	5204 // }

5154 // void test_greaterThanOrEqual_invalid_knownInt() {

5155 // _assertGreaterThanOrEqual(null, _stringValue("1"), _intValue(2));

5156 // }

5157 // void test_greaterThanOrEqual_knownDouble_knownDouble_false() {	5205 // void test_greaterThanOrEqual_knownDouble_knownDouble_false() {

5158 // _assertGreaterThanOrEqual(_boolValue(false), _doubleValue(1.0), _doubleVa lue(2.0));	5206 // _assertGreaterThanOrEqual(_boolValue(false), _doubleValue(1.0), _doubleVa lue(2.0));

5159 // }	5207 // }

5160 // void test_greaterThanOrEqual_knownDouble_knownDouble_true() {	5208 // void test_greaterThanOrEqual_knownDouble_knownDouble_true() {

5161 // _assertGreaterThanOrEqual(_boolValue(true), _doubleValue(2.0), _doubleVal ue(1.0));	5209 // _assertGreaterThanOrEqual(_boolValue(true), _doubleValue(2.0), _doubleVal ue(1.0));

5162 // }	5210 // }

5163 // void test_greaterThanOrEqual_knownDouble_knownInt_false() {	5211 // void test_greaterThanOrEqual_knownDouble_knownInt_false() {

5164 // _assertGreaterThanOrEqual(_boolValue(false), _doubleValue(1.0), _intValue (2));	5212 // _assertGreaterThanOrEqual(_boolValue(false), _doubleValue(1.0), _intValue (2));

5165 // }	5213 // }

5166 // void test_greaterThanOrEqual_knownDouble_knownInt_true() {	5214 // void test_greaterThanOrEqual_knownDouble_knownInt_true() {

5167 // _assertGreaterThanOrEqual(_boolValue(true), _doubleValue(2.0), _intValue( 1));	5215 // _assertGreaterThanOrEqual(_boolValue(true), _doubleValue(2.0), _intValue( 1));

5168 // }	5216 // }

5169 // void test_greaterThanOrEqual_knownDouble_unknownDouble() {	5217 // void test_greaterThanOrEqual_knownDouble_unknownDouble() {

5170 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(1.0), _doubleVal ue(null));	5218 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(1.0), _doubleVal ue(null));

5171 // }	5219 // }

5172 // void test_greaterThanOrEqual_knownDouble_unknownInt() {	5220 // void test_greaterThanOrEqual_knownDouble_unknownInt() {

5173 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(1.0), _intValue( null));	5221 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(1.0), _intValue( null));

5174 // }	5222 // }

5175 // void test_greaterThanOrEqual_knownInt_invalid() {

5176 // _assertGreaterThanOrEqual(null, _intValue(1), _stringValue("2"));

5177 // }

5178 // void test_greaterThanOrEqual_knownInt_knownInt_false() {	5223 // void test_greaterThanOrEqual_knownInt_knownInt_false() {

5179 // _assertGreaterThanOrEqual(_boolValue(false), _intValue(1), _intValue(2));	5224 // _assertGreaterThanOrEqual(_boolValue(false), _intValue(1), _intValue(2));

5180 // }	5225 // }

5181 // void test_greaterThanOrEqual_knownInt_knownInt_true() {	5226 // void test_greaterThanOrEqual_knownInt_knownInt_true() {

5182 // _assertGreaterThanOrEqual(_boolValue(true), _intValue(2), _intValue(2));	5227 // _assertGreaterThanOrEqual(_boolValue(true), _intValue(2), _intValue(2));

5183 // }	5228 // }

	5229 // void test_greaterThanOrEqual_knownInt_knownString() {

	5230 // _assertGreaterThanOrEqual(null, _intValue(1), _stringValue("2"));

	5231 // }

5184 // void test_greaterThanOrEqual_knownInt_unknownDouble() {	5232 // void test_greaterThanOrEqual_knownInt_unknownDouble() {

5185 // _assertGreaterThanOrEqual(_boolValue(null), _intValue(1), _doubleValue(nu ll));	5233 // _assertGreaterThanOrEqual(_boolValue(null), _intValue(1), _doubleValue(nu ll));

5186 // }	5234 // }

5187 // void test_greaterThanOrEqual_knownInt_unknownInt() {	5235 // void test_greaterThanOrEqual_knownInt_unknownInt() {

5188 // _assertGreaterThanOrEqual(_boolValue(null), _intValue(1), _intValue(null) );	5236 // _assertGreaterThanOrEqual(_boolValue(null), _intValue(1), _intValue(null) );

5189 // }	5237 // }

	5238 // void test_greaterThanOrEqual_knownString_knownInt() {

	5239 // _assertGreaterThanOrEqual(null, _stringValue("1"), _intValue(2));

	5240 // }

5190 // void test_greaterThanOrEqual_unknownDouble_knownDouble() {	5241 // void test_greaterThanOrEqual_unknownDouble_knownDouble() {

5191 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(null), _doubleVa lue(2.0));	5242 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(null), _doubleVa lue(2.0));

5192 // }	5243 // }

5193 // void test_greaterThanOrEqual_unknownDouble_knownInt() {	5244 // void test_greaterThanOrEqual_unknownDouble_knownInt() {

5194 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(null), _intValue (2));	5245 // _assertGreaterThanOrEqual(_boolValue(null), _doubleValue(null), _intValue (2));

5195 // }	5246 // }

5196 // void test_greaterThanOrEqual_unknownInt_knownDouble() {	5247 // void test_greaterThanOrEqual_unknownInt_knownDouble() {

5197 // _assertGreaterThanOrEqual(_boolValue(null), _intValue(null), _doubleValue (2.0));	5248 // _assertGreaterThanOrEqual(_boolValue(null), _intValue(null), _doubleValue (2.0));

5198 // }	5249 // }

5199 // void test_greaterThanOrEqual_unknownInt_knownInt() {	5250 // void test_greaterThanOrEqual_unknownInt_knownInt() {

(...skipping 49 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5249 // }	5300 // }

5250 // void test_hasExactValue_num() {	5301 // void test_hasExactValue_num() {

5251 // JUnitTestCase.assertFalse(_numValue().hasExactValue);	5302 // JUnitTestCase.assertFalse(_numValue().hasExactValue);

5252 // }	5303 // }

5253 // void test_hasExactValue_string_known() {	5304 // void test_hasExactValue_string_known() {

5254 // JUnitTestCase.assertTrue(_stringValue("twenty-three").hasExactValue);	5305 // JUnitTestCase.assertTrue(_stringValue("twenty-three").hasExactValue);

5255 // }	5306 // }

5256 // void test_hasExactValue_string_unknown() {	5307 // void test_hasExactValue_string_unknown() {

5257 // JUnitTestCase.assertTrue(_stringValue(null).hasExactValue);	5308 // JUnitTestCase.assertTrue(_stringValue(null).hasExactValue);

5258 // }	5309 // }

5259 // void test_integerDivide_invalid_knownInt() {

5260 // _assertIntegerDivide(null, _stringValue("6"), _intValue(2));

5261 // }

5262 // void test_integerDivide_knownDouble_knownDouble() {	5310 // void test_integerDivide_knownDouble_knownDouble() {

5263 // _assertIntegerDivide(_intValue(3), _doubleValue(6.0), _doubleValue(2.0));	5311 // _assertIntegerDivide(_intValue(3), _doubleValue(6.0), _doubleValue(2.0));

5264 // }	5312 // }

5265 // void test_integerDivide_knownDouble_knownInt() {	5313 // void test_integerDivide_knownDouble_knownInt() {

5266 // _assertIntegerDivide(_intValue(3), _doubleValue(6.0), _intValue(2));	5314 // _assertIntegerDivide(_intValue(3), _doubleValue(6.0), _intValue(2));

5267 // }	5315 // }

5268 // void test_integerDivide_knownDouble_unknownDouble() {	5316 // void test_integerDivide_knownDouble_unknownDouble() {

5269 // _assertIntegerDivide(_intValue(null), _doubleValue(6.0), _doubleValue(nul l));	5317 // _assertIntegerDivide(_intValue(null), _doubleValue(6.0), _doubleValue(nul l));

5270 // }	5318 // }

5271 // void test_integerDivide_knownDouble_unknownInt() {	5319 // void test_integerDivide_knownDouble_unknownInt() {

5272 // _assertIntegerDivide(_intValue(null), _doubleValue(6.0), _intValue(null)) ;	5320 // _assertIntegerDivide(_intValue(null), _doubleValue(6.0), _intValue(null)) ;

5273 // }	5321 // }

5274 // void test_integerDivide_knownInt_invalid() {

5275 // _assertIntegerDivide(null, _intValue(6), _stringValue("2"));

5276 // }

5277 // void test_integerDivide_knownInt_knownInt() {	5322 // void test_integerDivide_knownInt_knownInt() {

5278 // _assertIntegerDivide(_intValue(3), _intValue(6), _intValue(2));	5323 // _assertIntegerDivide(_intValue(3), _intValue(6), _intValue(2));

5279 // }	5324 // }

	5325 // void test_integerDivide_knownInt_knownString() {

	5326 // _assertIntegerDivide(null, _intValue(6), _stringValue("2"));

	5327 // }

5280 // void test_integerDivide_knownInt_unknownDouble() {	5328 // void test_integerDivide_knownInt_unknownDouble() {

5281 // _assertIntegerDivide(_intValue(null), _intValue(6), _doubleValue(null));	5329 // _assertIntegerDivide(_intValue(null), _intValue(6), _doubleValue(null));

5282 // }	5330 // }

5283 // void test_integerDivide_knownInt_unknownInt() {	5331 // void test_integerDivide_knownInt_unknownInt() {

5284 // _assertIntegerDivide(_intValue(null), _intValue(6), _intValue(null));	5332 // _assertIntegerDivide(_intValue(null), _intValue(6), _intValue(null));

5285 // }	5333 // }

	5334 // void test_integerDivide_knownString_knownInt() {

	5335 // _assertIntegerDivide(null, _stringValue("6"), _intValue(2));

	5336 // }

5286 // void test_integerDivide_unknownDouble_knownDouble() {	5337 // void test_integerDivide_unknownDouble_knownDouble() {

5287 // _assertIntegerDivide(_intValue(null), _doubleValue(null), _doubleValue(2. 0));	5338 // _assertIntegerDivide(_intValue(null), _doubleValue(null), _doubleValue(2. 0));

5288 // }	5339 // }

5289 // void test_integerDivide_unknownDouble_knownInt() {	5340 // void test_integerDivide_unknownDouble_knownInt() {

5290 // _assertIntegerDivide(_intValue(null), _doubleValue(null), _intValue(2));	5341 // _assertIntegerDivide(_intValue(null), _doubleValue(null), _intValue(2));

5291 // }	5342 // }

5292 // void test_integerDivide_unknownInt_knownDouble() {	5343 // void test_integerDivide_unknownInt_knownDouble() {

5293 // _assertIntegerDivide(_intValue(null), _intValue(null), _doubleValue(2.0)) ;	5344 // _assertIntegerDivide(_intValue(null), _intValue(null), _doubleValue(2.0)) ;

5294 // }	5345 // }

5295 // void test_integerDivide_unknownInt_knownInt() {	5346 // void test_integerDivide_unknownInt_knownInt() {

(...skipping 31 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5327 // }	5378 // }

5328 // void test_isBoolNumStringOrNull_num() {	5379 // void test_isBoolNumStringOrNull_num() {

5329 // JUnitTestCase.assertTrue(_numValue().isBoolNumStringOrNull);	5380 // JUnitTestCase.assertTrue(_numValue().isBoolNumStringOrNull);

5330 // }	5381 // }

5331 // void test_isBoolNumStringOrNull_string_known() {	5382 // void test_isBoolNumStringOrNull_string_known() {

5332 // JUnitTestCase.assertTrue(_stringValue("twenty-three").isBoolNumStringOrNu ll);	5383 // JUnitTestCase.assertTrue(_stringValue("twenty-three").isBoolNumStringOrNu ll);

5333 // }	5384 // }

5334 // void test_isBoolNumStringOrNull_string_unknown() {	5385 // void test_isBoolNumStringOrNull_string_unknown() {

5335 // JUnitTestCase.assertTrue(_stringValue(null).isBoolNumStringOrNull);	5386 // JUnitTestCase.assertTrue(_stringValue(null).isBoolNumStringOrNull);

5336 // }	5387 // }

5337 // void test_lessThan_invalid_knownInt() {

5338 // _assertLessThan(null, _stringValue("1"), _intValue(2));

5339 // }

5340 // void test_lessThan_knownDouble_knownDouble_false() {	5388 // void test_lessThan_knownDouble_knownDouble_false() {

5341 // _assertLessThan(_boolValue(false), _doubleValue(2.0), _doubleValue(1.0));	5389 // _assertLessThan(_boolValue(false), _doubleValue(2.0), _doubleValue(1.0));

5342 // }	5390 // }

5343 // void test_lessThan_knownDouble_knownDouble_true() {	5391 // void test_lessThan_knownDouble_knownDouble_true() {

5344 // _assertLessThan(_boolValue(true), _doubleValue(1.0), _doubleValue(2.0));	5392 // _assertLessThan(_boolValue(true), _doubleValue(1.0), _doubleValue(2.0));

5345 // }	5393 // }

5346 // void test_lessThan_knownDouble_knownInt_false() {	5394 // void test_lessThan_knownDouble_knownInt_false() {

5347 // _assertLessThan(_boolValue(false), _doubleValue(2.0), _intValue(1));	5395 // _assertLessThan(_boolValue(false), _doubleValue(2.0), _intValue(1));

5348 // }	5396 // }

5349 // void test_lessThan_knownDouble_knownInt_true() {	5397 // void test_lessThan_knownDouble_knownInt_true() {

5350 // _assertLessThan(_boolValue(true), _doubleValue(1.0), _intValue(2));	5398 // _assertLessThan(_boolValue(true), _doubleValue(1.0), _intValue(2));

5351 // }	5399 // }

5352 // void test_lessThan_knownDouble_unknownDouble() {	5400 // void test_lessThan_knownDouble_unknownDouble() {

5353 // _assertLessThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));	5401 // _assertLessThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));

5354 // }	5402 // }

5355 // void test_lessThan_knownDouble_unknownInt() {	5403 // void test_lessThan_knownDouble_unknownInt() {

5356 // _assertLessThan(_boolValue(null), _doubleValue(1.0), _intValue(null));	5404 // _assertLessThan(_boolValue(null), _doubleValue(1.0), _intValue(null));

5357 // }	5405 // }

5358 // void test_lessThan_knownInt_invalid() {

5359 // _assertLessThan(null, _intValue(1), _stringValue("2"));

5360 // }

5361 // void test_lessThan_knownInt_knownInt_false() {	5406 // void test_lessThan_knownInt_knownInt_false() {

5362 // _assertLessThan(_boolValue(false), _intValue(2), _intValue(1));	5407 // _assertLessThan(_boolValue(false), _intValue(2), _intValue(1));

5363 // }	5408 // }

5364 // void test_lessThan_knownInt_knownInt_true() {	5409 // void test_lessThan_knownInt_knownInt_true() {

5365 // _assertLessThan(_boolValue(true), _intValue(1), _intValue(2));	5410 // _assertLessThan(_boolValue(true), _intValue(1), _intValue(2));

5366 // }	5411 // }

	5412 // void test_lessThan_knownInt_knownString() {

	5413 // _assertLessThan(null, _intValue(1), _stringValue("2"));

	5414 // }

5367 // void test_lessThan_knownInt_unknownDouble() {	5415 // void test_lessThan_knownInt_unknownDouble() {

5368 // _assertLessThan(_boolValue(null), _intValue(1), _doubleValue(null));	5416 // _assertLessThan(_boolValue(null), _intValue(1), _doubleValue(null));

5369 // }	5417 // }

5370 // void test_lessThan_knownInt_unknownInt() {	5418 // void test_lessThan_knownInt_unknownInt() {

5371 // _assertLessThan(_boolValue(null), _intValue(1), _intValue(null));	5419 // _assertLessThan(_boolValue(null), _intValue(1), _intValue(null));

5372 // }	5420 // }

	5421 // void test_lessThan_knownString_knownInt() {

	5422 // _assertLessThan(null, _stringValue("1"), _intValue(2));

	5423 // }

5373 // void test_lessThan_unknownDouble_knownDouble() {	5424 // void test_lessThan_unknownDouble_knownDouble() {

5374 // _assertLessThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));	5425 // _assertLessThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));

5375 // }	5426 // }

5376 // void test_lessThan_unknownDouble_knownInt() {	5427 // void test_lessThan_unknownDouble_knownInt() {

5377 // _assertLessThan(_boolValue(null), _doubleValue(null), _intValue(2));	5428 // _assertLessThan(_boolValue(null), _doubleValue(null), _intValue(2));

5378 // }	5429 // }

5379 // void test_lessThan_unknownInt_knownDouble() {	5430 // void test_lessThan_unknownInt_knownDouble() {

5380 // _assertLessThan(_boolValue(null), _intValue(null), _doubleValue(2.0));	5431 // _assertLessThan(_boolValue(null), _intValue(null), _doubleValue(2.0));

5381 // }	5432 // }

5382 // void test_lessThan_unknownInt_knownInt() {	5433 // void test_lessThan_unknownInt_knownInt() {

5383 // _assertLessThan(_boolValue(null), _intValue(null), _intValue(2));	5434 // _assertLessThan(_boolValue(null), _intValue(null), _intValue(2));

5384 // }	5435 // }

5385 // void test_lessThanOrEqual_invalid_knownInt() {

5386 // _assertLessThanOrEqual(null, _stringValue("1"), _intValue(2));

5387 // }

5388 // void test_lessThanOrEqual_knownDouble_knownDouble_false() {	5436 // void test_lessThanOrEqual_knownDouble_knownDouble_false() {

5389 // _assertLessThanOrEqual(_boolValue(false), _doubleValue(2.0), _doubleValue (1.0));	5437 // _assertLessThanOrEqual(_boolValue(false), _doubleValue(2.0), _doubleValue (1.0));

5390 // }	5438 // }

5391 // void test_lessThanOrEqual_knownDouble_knownDouble_true() {	5439 // void test_lessThanOrEqual_knownDouble_knownDouble_true() {

5392 // _assertLessThanOrEqual(_boolValue(true), _doubleValue(1.0), _doubleValue( 2.0));	5440 // _assertLessThanOrEqual(_boolValue(true), _doubleValue(1.0), _doubleValue( 2.0));

5393 // }	5441 // }

5394 // void test_lessThanOrEqual_knownDouble_knownInt_false() {	5442 // void test_lessThanOrEqual_knownDouble_knownInt_false() {

5395 // _assertLessThanOrEqual(_boolValue(false), _doubleValue(2.0), _intValue(1) );	5443 // _assertLessThanOrEqual(_boolValue(false), _doubleValue(2.0), _intValue(1) );

5396 // }	5444 // }

5397 // void test_lessThanOrEqual_knownDouble_knownInt_true() {	5445 // void test_lessThanOrEqual_knownDouble_knownInt_true() {

5398 // _assertLessThanOrEqual(_boolValue(true), _doubleValue(1.0), _intValue(2)) ;	5446 // _assertLessThanOrEqual(_boolValue(true), _doubleValue(1.0), _intValue(2)) ;

5399 // }	5447 // }

5400 // void test_lessThanOrEqual_knownDouble_unknownDouble() {	5448 // void test_lessThanOrEqual_knownDouble_unknownDouble() {

5401 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(1.0), _doubleValue( null));	5449 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(1.0), _doubleValue( null));

5402 // }	5450 // }

5403 // void test_lessThanOrEqual_knownDouble_unknownInt() {	5451 // void test_lessThanOrEqual_knownDouble_unknownInt() {

5404 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(1.0), _intValue(nul l));	5452 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(1.0), _intValue(nul l));

5405 // }	5453 // }

5406 // void test_lessThanOrEqual_knownInt_invalid() {

5407 // _assertLessThanOrEqual(null, _intValue(1), _stringValue("2"));

5408 // }

5409 // void test_lessThanOrEqual_knownInt_knownInt_false() {	5454 // void test_lessThanOrEqual_knownInt_knownInt_false() {

5410 // _assertLessThanOrEqual(_boolValue(false), _intValue(2), _intValue(1));	5455 // _assertLessThanOrEqual(_boolValue(false), _intValue(2), _intValue(1));

5411 // }	5456 // }

5412 // void test_lessThanOrEqual_knownInt_knownInt_true() {	5457 // void test_lessThanOrEqual_knownInt_knownInt_true() {

5413 // _assertLessThanOrEqual(_boolValue(true), _intValue(1), _intValue(2));	5458 // _assertLessThanOrEqual(_boolValue(true), _intValue(1), _intValue(2));

5414 // }	5459 // }

	5460 // void test_lessThanOrEqual_knownInt_knownString() {

	5461 // _assertLessThanOrEqual(null, _intValue(1), _stringValue("2"));

	5462 // }

5415 // void test_lessThanOrEqual_knownInt_unknownDouble() {	5463 // void test_lessThanOrEqual_knownInt_unknownDouble() {

5416 // _assertLessThanOrEqual(_boolValue(null), _intValue(1), _doubleValue(null) );	5464 // _assertLessThanOrEqual(_boolValue(null), _intValue(1), _doubleValue(null) );

5417 // }	5465 // }

5418 // void test_lessThanOrEqual_knownInt_unknownInt() {	5466 // void test_lessThanOrEqual_knownInt_unknownInt() {

5419 // _assertLessThanOrEqual(_boolValue(null), _intValue(1), _intValue(null));	5467 // _assertLessThanOrEqual(_boolValue(null), _intValue(1), _intValue(null));

5420 // }	5468 // }

	5469 // void test_lessThanOrEqual_knownString_knownInt() {

	5470 // _assertLessThanOrEqual(null, _stringValue("1"), _intValue(2));

	5471 // }

5421 // void test_lessThanOrEqual_unknownDouble_knownDouble() {	5472 // void test_lessThanOrEqual_unknownDouble_knownDouble() {

5422 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(null), _doubleValue (2.0));	5473 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(null), _doubleValue (2.0));

5423 // }	5474 // }

5424 // void test_lessThanOrEqual_unknownDouble_knownInt() {	5475 // void test_lessThanOrEqual_unknownDouble_knownInt() {

5425 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(null), _intValue(2) );	5476 // _assertLessThanOrEqual(_boolValue(null), _doubleValue(null), _intValue(2) );

5426 // }	5477 // }

5427 // void test_lessThanOrEqual_unknownInt_knownDouble() {	5478 // void test_lessThanOrEqual_unknownInt_knownDouble() {

5428 // _assertLessThanOrEqual(_boolValue(null), _intValue(null), _doubleValue(2. 0));	5479 // _assertLessThanOrEqual(_boolValue(null), _intValue(null), _doubleValue(2. 0));

5429 // }	5480 // }

5430 // void test_lessThanOrEqual_unknownInt_knownInt() {	5481 // void test_lessThanOrEqual_unknownInt_knownInt() {

(...skipping 139 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5570 // void test_logicalOr_true_string() {	5621 // void test_logicalOr_true_string() {

5571 // try {	5622 // try {

5572 // _assertLogicalOr(_boolValue(true), _boolValue(true), _stringValue("true "));	5623 // _assertLogicalOr(_boolValue(true), _boolValue(true), _stringValue("true "));

5573 // JUnitTestCase.fail("Expected EvaluationException");	5624 // JUnitTestCase.fail("Expected EvaluationException");

5574 // } on EvaluationException catch (exception) {	5625 // } on EvaluationException catch (exception) {

5575 // }	5626 // }

5576 // }	5627 // }

5577 // void test_logicalOr_true_true() {	5628 // void test_logicalOr_true_true() {

5578 // _assertLogicalOr(_boolValue(true), _boolValue(true), _boolValue(true));	5629 // _assertLogicalOr(_boolValue(true), _boolValue(true), _boolValue(true));

5579 // }	5630 // }

5580 // void test_minus_invalid_knownInt() {

5581 // _assertMinus(null, _stringValue("4"), _intValue(3));

5582 // }

5583 // void test_minus_knownDouble_knownDouble() {	5631 // void test_minus_knownDouble_knownDouble() {

5584 // _assertMinus(_doubleValue(1.0), _doubleValue(4.0), _doubleValue(3.0));	5632 // _assertMinus(_doubleValue(1.0), _doubleValue(4.0), _doubleValue(3.0));

5585 // }	5633 // }

5586 // void test_minus_knownDouble_knownInt() {	5634 // void test_minus_knownDouble_knownInt() {

5587 // _assertMinus(_doubleValue(1.0), _doubleValue(4.0), _intValue(3));	5635 // _assertMinus(_doubleValue(1.0), _doubleValue(4.0), _intValue(3));

5588 // }	5636 // }

5589 // void test_minus_knownDouble_unknownDouble() {	5637 // void test_minus_knownDouble_unknownDouble() {

5590 // _assertMinus(_doubleValue(null), _doubleValue(4.0), _doubleValue(null));	5638 // _assertMinus(_doubleValue(null), _doubleValue(4.0), _doubleValue(null));

5591 // }	5639 // }

5592 // void test_minus_knownDouble_unknownInt() {	5640 // void test_minus_knownDouble_unknownInt() {

5593 // _assertMinus(_doubleValue(null), _doubleValue(4.0), _intValue(null));	5641 // _assertMinus(_doubleValue(null), _doubleValue(4.0), _intValue(null));

5594 // }	5642 // }

5595 // void test_minus_knownInt_invalid() {

5596 // _assertMinus(null, _intValue(4), _stringValue("3"));

5597 // }

5598 // void test_minus_knownInt_knownInt() {	5643 // void test_minus_knownInt_knownInt() {

5599 // _assertMinus(_intValue(1), _intValue(4), _intValue(3));	5644 // _assertMinus(_intValue(1), _intValue(4), _intValue(3));

5600 // }	5645 // }

	5646 // void test_minus_knownInt_knownString() {

	5647 // _assertMinus(null, _intValue(4), _stringValue("3"));

	5648 // }

5601 // void test_minus_knownInt_unknownDouble() {	5649 // void test_minus_knownInt_unknownDouble() {

5602 // _assertMinus(_doubleValue(null), _intValue(4), _doubleValue(null));	5650 // _assertMinus(_doubleValue(null), _intValue(4), _doubleValue(null));

5603 // }	5651 // }

5604 // void test_minus_knownInt_unknownInt() {	5652 // void test_minus_knownInt_unknownInt() {

5605 // _assertMinus(_intValue(null), _intValue(4), _intValue(null));	5653 // _assertMinus(_intValue(null), _intValue(4), _intValue(null));

5606 // }	5654 // }

	5655 // void test_minus_knownString_knownInt() {

	5656 // _assertMinus(null, _stringValue("4"), _intValue(3));

	5657 // }

5607 // void test_minus_unknownDouble_knownDouble() {	5658 // void test_minus_unknownDouble_knownDouble() {

5608 // _assertMinus(_doubleValue(null), _doubleValue(null), _doubleValue(3.0));	5659 // _assertMinus(_doubleValue(null), _doubleValue(null), _doubleValue(3.0));

5609 // }	5660 // }

5610 // void test_minus_unknownDouble_knownInt() {	5661 // void test_minus_unknownDouble_knownInt() {

5611 // _assertMinus(_doubleValue(null), _doubleValue(null), _intValue(3));	5662 // _assertMinus(_doubleValue(null), _doubleValue(null), _intValue(3));

5612 // }	5663 // }

5613 // void test_minus_unknownInt_knownDouble() {	5664 // void test_minus_unknownInt_knownDouble() {

5614 // _assertMinus(_doubleValue(null), _intValue(null), _doubleValue(3.0));	5665 // _assertMinus(_doubleValue(null), _intValue(null), _doubleValue(3.0));

5615 // }	5666 // }

5616 // void test_minus_unknownInt_knownInt() {	5667 // void test_minus_unknownInt_knownInt() {

(...skipping 76 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
5693 // }	5744 // }

5694 // void test_performToString_null() {	5745 // void test_performToString_null() {

5695 // _assertPerformToString(_stringValue("null"), _nullValue());	5746 // _assertPerformToString(_stringValue("null"), _nullValue());

5696 // }	5747 // }

5697 // void test_performToString_string_known() {	5748 // void test_performToString_string_known() {

5698 // _assertPerformToString(_stringValue("abc"), _stringValue("abc"));	5749 // _assertPerformToString(_stringValue("abc"), _stringValue("abc"));

5699 // }	5750 // }

5700 // void test_performToString_string_unknown() {	5751 // void test_performToString_string_unknown() {

5701 // _assertPerformToString(_stringValue(null), _stringValue(null));	5752 // _assertPerformToString(_stringValue(null), _stringValue(null));

5702 // }	5753 // }

5703 // void test_remainder_invalid_knownInt() {

5704 // _assertRemainder(null, _stringValue("7"), _intValue(2));

5705 // }

5706 // void test_remainder_knownDouble_knownDouble() {	5754 // void test_remainder_knownDouble_knownDouble() {

5707 // _assertRemainder(_doubleValue(1.0), _doubleValue(7.0), _doubleValue(2.0)) ;	5755 // _assertRemainder(_doubleValue(1.0), _doubleValue(7.0), _doubleValue(2.0)) ;

5708 // }	5756 // }

5709 // void test_remainder_knownDouble_knownInt() {	5757 // void test_remainder_knownDouble_knownInt() {

5710 // _assertRemainder(_doubleValue(1.0), _doubleValue(7.0), _intValue(2));	5758 // _assertRemainder(_doubleValue(1.0), _doubleValue(7.0), _intValue(2));

5711 // }	5759 // }

5712 // void test_remainder_knownDouble_unknownDouble() {	5760 // void test_remainder_knownDouble_unknownDouble() {

5713 // _assertRemainder(_doubleValue(null), _doubleValue(7.0), _doubleValue(null ));	5761 // _assertRemainder(_doubleValue(null), _doubleValue(7.0), _doubleValue(null ));

5714 // }	5762 // }

5715 // void test_remainder_knownDouble_unknownInt() {	5763 // void test_remainder_knownDouble_unknownInt() {

5716 // _assertRemainder(_doubleValue(null), _doubleValue(6.0), _intValue(null));	5764 // _assertRemainder(_doubleValue(null), _doubleValue(6.0), _intValue(null));

5717 // }	5765 // }

5718 // void test_remainder_knownInt_invalid() {

5719 // _assertRemainder(null, _intValue(7), _stringValue("2"));

5720 // }

5721 // void test_remainder_knownInt_knownInt() {	5766 // void test_remainder_knownInt_knownInt() {

5722 // _assertRemainder(_intValue(1), _intValue(7), _intValue(2));	5767 // _assertRemainder(_intValue(1), _intValue(7), _intValue(2));

5723 // }	5768 // }

	5769 // void test_remainder_knownInt_knownString() {

	5770 // _assertRemainder(null, _intValue(7), _stringValue("2"));

	5771 // }

5724 // void test_remainder_knownInt_unknownDouble() {	5772 // void test_remainder_knownInt_unknownDouble() {

5725 // _assertRemainder(_doubleValue(null), _intValue(7), _doubleValue(null));	5773 // _assertRemainder(_doubleValue(null), _intValue(7), _doubleValue(null));

5726 // }	5774 // }

5727 // void test_remainder_knownInt_unknownInt() {	5775 // void test_remainder_knownInt_unknownInt() {

5728 // _assertRemainder(_intValue(null), _intValue(7), _intValue(null));	5776 // _assertRemainder(_intValue(null), _intValue(7), _intValue(null));

5729 // }	5777 // }

	5778 // void test_remainder_knownString_knownInt() {

	5779 // _assertRemainder(null, _stringValue("7"), _intValue(2));

	5780 // }

5730 // void test_remainder_unknownDouble_knownDouble() {	5781 // void test_remainder_unknownDouble_knownDouble() {

5731 // _assertRemainder(_doubleValue(null), _doubleValue(null), _doubleValue(2.0 ));	5782 // _assertRemainder(_doubleValue(null), _doubleValue(null), _doubleValue(2.0 ));

5732 // }	5783 // }

5733 // void test_remainder_unknownDouble_knownInt() {	5784 // void test_remainder_unknownDouble_knownInt() {

5734 // _assertRemainder(_doubleValue(null), _doubleValue(null), _intValue(2));	5785 // _assertRemainder(_doubleValue(null), _doubleValue(null), _intValue(2));

5735 // }	5786 // }

5736 // void test_remainder_unknownInt_knownDouble() {	5787 // void test_remainder_unknownInt_knownDouble() {

5737 // _assertRemainder(_doubleValue(null), _intValue(null), _doubleValue(2.0));	5788 // _assertRemainder(_doubleValue(null), _intValue(null), _doubleValue(2.0));

5738 // }	5789 // }

5739 // void test_remainder_unknownInt_knownInt() {	5790 // void test_remainder_unknownInt_knownInt() {

5740 // _assertRemainder(_intValue(null), _intValue(null), _intValue(2));	5791 // _assertRemainder(_intValue(null), _intValue(null), _intValue(2));

5741 // }	5792 // }

5742 // void test_shiftLeft_invalid_knownInt() {

5743 // _assertShiftLeft(null, _stringValue(null), _intValue(3));

5744 // }

5745 // void test_shiftLeft_knownInt_invalid() {

5746 // _assertShiftLeft(null, _intValue(6), _stringValue(null));

5747 // }

5748 // void test_shiftLeft_knownInt_knownInt() {	5793 // void test_shiftLeft_knownInt_knownInt() {

5749 // _assertShiftLeft(_intValue(48), _intValue(6), _intValue(3));	5794 // _assertShiftLeft(_intValue(48), _intValue(6), _intValue(3));

5750 // }	5795 // }

	5796 // void test_shiftLeft_knownInt_knownString() {

	5797 // _assertShiftLeft(null, _intValue(6), _stringValue(null));

	5798 // }

5751 // void test_shiftLeft_knownInt_tooLarge() {	5799 // void test_shiftLeft_knownInt_tooLarge() {

5752 // _assertShiftLeft(_intValue(null), _intValue(6), new DartObjectImpl(_typeP rovider.intType, new IntState(Long.MAX_VALUE)));	5800 // _assertShiftLeft(_intValue(null), _intValue(6), new DartObjectImpl(_typeP rovider.intType, new IntState(Long.MAX_VALUE)));

5753 // }	5801 // }

5754 // void test_shiftLeft_knownInt_unknownInt() {	5802 // void test_shiftLeft_knownInt_unknownInt() {

5755 // _assertShiftLeft(_intValue(null), _intValue(6), _intValue(null));	5803 // _assertShiftLeft(_intValue(null), _intValue(6), _intValue(null));

5756 // }	5804 // }

	5805 // void test_shiftLeft_knownString_knownInt() {

	5806 // _assertShiftLeft(null, _stringValue(null), _intValue(3));

	5807 // }

5757 // void test_shiftLeft_unknownInt_knownInt() {	5808 // void test_shiftLeft_unknownInt_knownInt() {

5758 // _assertShiftLeft(_intValue(null), _intValue(null), _intValue(3));	5809 // _assertShiftLeft(_intValue(null), _intValue(null), _intValue(3));

5759 // }	5810 // }

5760 // void test_shiftLeft_unknownInt_unknownInt() {	5811 // void test_shiftLeft_unknownInt_unknownInt() {

5761 // _assertShiftLeft(_intValue(null), _intValue(null), _intValue(null));	5812 // _assertShiftLeft(_intValue(null), _intValue(null), _intValue(null));

5762 // }	5813 // }

5763 // void test_shiftRight_invalid_knownInt() {

5764 // _assertShiftRight(null, _stringValue(null), _intValue(3));

5765 // }

5766 // void test_shiftRight_knownInt_invalid() {

5767 // _assertShiftRight(null, _intValue(48), _stringValue(null));

5768 // }

5769 // void test_shiftRight_knownInt_knownInt() {	5814 // void test_shiftRight_knownInt_knownInt() {

5770 // _assertShiftRight(_intValue(6), _intValue(48), _intValue(3));	5815 // _assertShiftRight(_intValue(6), _intValue(48), _intValue(3));

5771 // }	5816 // }

	5817 // void test_shiftRight_knownInt_knownString() {

	5818 // _assertShiftRight(null, _intValue(48), _stringValue(null));

	5819 // }

5772 // void test_shiftRight_knownInt_tooLarge() {	5820 // void test_shiftRight_knownInt_tooLarge() {

5773 // _assertShiftRight(_intValue(null), _intValue(48), new DartObjectImpl(_typ eProvider.intType, new IntState(Long.MAX_VALUE)));	5821 // _assertShiftRight(_intValue(null), _intValue(48), new DartObjectImpl(_typ eProvider.intType, new IntState(Long.MAX_VALUE)));

5774 // }	5822 // }

5775 // void test_shiftRight_knownInt_unknownInt() {	5823 // void test_shiftRight_knownInt_unknownInt() {

5776 // _assertShiftRight(_intValue(null), _intValue(48), _intValue(null));	5824 // _assertShiftRight(_intValue(null), _intValue(48), _intValue(null));

5777 // }	5825 // }

	5826 // void test_shiftRight_knownString_knownInt() {

	5827 // _assertShiftRight(null, _stringValue(null), _intValue(3));

	5828 // }

5778 // void test_shiftRight_unknownInt_knownInt() {	5829 // void test_shiftRight_unknownInt_knownInt() {

5779 // _assertShiftRight(_intValue(null), _intValue(null), _intValue(3));	5830 // _assertShiftRight(_intValue(null), _intValue(null), _intValue(3));

5780 // }	5831 // }

5781 // void test_shiftRight_unknownInt_unknownInt() {	5832 // void test_shiftRight_unknownInt_unknownInt() {

5782 // _assertShiftRight(_intValue(null), _intValue(null), _intValue(null));	5833 // _assertShiftRight(_intValue(null), _intValue(null), _intValue(null));

5783 // }	5834 // }

5784 // void test_times_invalid_knownInt() {	5835 // void test_stringLength_int() {

5785 // _assertTimes(null, _stringValue("2"), _intValue(3));	5836 // try {

	5837 // _assertStringLength(_intValue(null), _intValue(0));

	5838 // JUnitTestCase.fail("Expected EvaluationException");

	5839 // } on EvaluationException catch (exception) {

	5840 // }

	5841 // }

	5842 // void test_stringLength_knownString() {

	5843 // _assertStringLength(_intValue(3), _stringValue("abc"));

	5844 // }

	5845 // void test_stringLength_unknownString() {

	5846 // _assertStringLength(_intValue(null), _stringValue(null));

5786 // }	5847 // }

5787 // void test_times_knownDouble_knownDouble() {	5848 // void test_times_knownDouble_knownDouble() {

5788 // _assertTimes(_doubleValue(6.0), _doubleValue(2.0), _doubleValue(3.0));	5849 // _assertTimes(_doubleValue(6.0), _doubleValue(2.0), _doubleValue(3.0));

5789 // }	5850 // }

5790 // void test_times_knownDouble_knownInt() {	5851 // void test_times_knownDouble_knownInt() {

5791 // _assertTimes(_doubleValue(6.0), _doubleValue(2.0), _intValue(3));	5852 // _assertTimes(_doubleValue(6.0), _doubleValue(2.0), _intValue(3));

5792 // }	5853 // }

5793 // void test_times_knownDouble_unknownDouble() {	5854 // void test_times_knownDouble_unknownDouble() {

5794 // _assertTimes(_doubleValue(null), _doubleValue(2.0), _doubleValue(null));	5855 // _assertTimes(_doubleValue(null), _doubleValue(2.0), _doubleValue(null));

5795 // }	5856 // }

5796 // void test_times_knownDouble_unknownInt() {	5857 // void test_times_knownDouble_unknownInt() {

5797 // _assertTimes(_doubleValue(null), _doubleValue(2.0), _intValue(null));	5858 // _assertTimes(_doubleValue(null), _doubleValue(2.0), _intValue(null));

5798 // }	5859 // }

5799 // void test_times_knownInt_invalid() {

5800 // _assertTimes(null, _intValue(2), _stringValue("3"));

5801 // }

5802 // void test_times_knownInt_knownInt() {	5860 // void test_times_knownInt_knownInt() {

5803 // _assertTimes(_intValue(6), _intValue(2), _intValue(3));	5861 // _assertTimes(_intValue(6), _intValue(2), _intValue(3));

5804 // }	5862 // }

	5863 // void test_times_knownInt_knownString() {

	5864 // _assertTimes(null, _intValue(2), _stringValue("3"));

	5865 // }

5805 // void test_times_knownInt_unknownDouble() {	5866 // void test_times_knownInt_unknownDouble() {

5806 // _assertTimes(_doubleValue(null), _intValue(2), _doubleValue(null));	5867 // _assertTimes(_doubleValue(null), _intValue(2), _doubleValue(null));

5807 // }	5868 // }

5808 // void test_times_knownInt_unknownInt() {	5869 // void test_times_knownInt_unknownInt() {

5809 // _assertTimes(_intValue(null), _intValue(2), _intValue(null));	5870 // _assertTimes(_intValue(null), _intValue(2), _intValue(null));

5810 // }	5871 // }

	5872 // void test_times_knownString_knownInt() {

	5873 // _assertTimes(null, _stringValue("2"), _intValue(3));

	5874 // }

5811 // void test_times_unknownDouble_knownDouble() {	5875 // void test_times_unknownDouble_knownDouble() {

5812 // _assertTimes(_doubleValue(null), _doubleValue(null), _doubleValue(3.0));	5876 // _assertTimes(_doubleValue(null), _doubleValue(null), _doubleValue(3.0));

5813 // }	5877 // }

5814 // void test_times_unknownDouble_knownInt() {	5878 // void test_times_unknownDouble_knownInt() {

5815 // _assertTimes(_doubleValue(null), _doubleValue(null), _intValue(3));	5879 // _assertTimes(_doubleValue(null), _doubleValue(null), _intValue(3));

5816 // }	5880 // }

5817 // void test_times_unknownInt_knownDouble() {	5881 // void test_times_unknownInt_knownDouble() {

5818 // _assertTimes(_doubleValue(null), _intValue(null), _doubleValue(3.0));	5882 // _assertTimes(_doubleValue(null), _intValue(null), _doubleValue(3.0));

5819 // }	5883 // }

5820 // void test_times_unknownInt_knownInt() {	5884 // void test_times_unknownInt_knownInt() {

(...skipping 498 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6319 // JUnitTestCase.fail("Expected an EvaluationException");	6383 // JUnitTestCase.fail("Expected an EvaluationException");

6320 // } on EvaluationException catch (exception) {	6384 // } on EvaluationException catch (exception) {

6321 // }	6385 // }

6322 // } else {	6386 // } else {

6323 // DartObjectImpl result = leftOperand.shiftRight(_typeProvider, rightOper and);	6387 // DartObjectImpl result = leftOperand.shiftRight(_typeProvider, rightOper and);

6324 // JUnitTestCase.assertNotNull(result);	6388 // JUnitTestCase.assertNotNull(result);

6325 // JUnitTestCase.assertEquals(expected, result);	6389 // JUnitTestCase.assertEquals(expected, result);

6326 // }	6390 // }

6327 // }	6391 // }

6328 // /**	6392 // /**

	6393 // * Assert that the length of the operand is the expected value, or that the operation throws an

	6394 // * exception if the expected value is `null`.

	6395 // *

	6396 // * @param expected the expected result of the operation

	6397 // * @param operand the operand to the operation

	6398 // * @throws EvaluationException if the result is an exception when it should not be

	6399 // */

	6400 // void _assertStringLength(DartObjectImpl expected, DartObjectImpl operand) {

	6401 // if (expected == null) {

	6402 // try {

	6403 // operand.stringLength(_typeProvider);

	6404 // JUnitTestCase.fail("Expected an EvaluationException");

	6405 // } on EvaluationException catch (exception) {

	6406 // }

	6407 // } else {

	6408 // DartObjectImpl result = operand.stringLength(_typeProvider);

	6409 // JUnitTestCase.assertNotNull(result);

	6410 // JUnitTestCase.assertEquals(expected, result);

	6411 // }

	6412 // }

	6413 // /**

6329 // * Assert that the result of multiplying the left and right operands is the expected value, or	6414 // * Assert that the result of multiplying the left and right operands is the expected value, or

6330 // * that the operation throws an exception if the expected value is `null`.	6415 // * that the operation throws an exception if the expected value is `null`.

6331 // *	6416 // *

6332 // * @param expected the expected result of the operation	6417 // * @param expected the expected result of the operation

6333 // * @param leftOperand the left operand to the operation	6418 // * @param leftOperand the left operand to the operation

6334 // * @param rightOperand the left operand to the operation	6419 // * @param rightOperand the left operand to the operation

6335 // * @throws EvaluationException if the result is an exception when it should not be	6420 // * @throws EvaluationException if the result is an exception when it should not be

6336 // */	6421 // */

6337 // void _assertTimes(DartObjectImpl expected, DartObjectImpl leftOperand, Dart ObjectImpl rightOperand) {	6422 // void _assertTimes(DartObjectImpl expected, DartObjectImpl leftOperand, Dart ObjectImpl rightOperand) {

6338 // if (expected == null) {	6423 // if (expected == null) {

(...skipping 48 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6387 // DartObjectImpl _stringValue(String value) {	6472 // DartObjectImpl _stringValue(String value) {

6388 // if (value == null) {	6473 // if (value == null) {

6389 // return new DartObjectImpl(_typeProvider.stringType, StringState.UNKNOWN _VALUE);	6474 // return new DartObjectImpl(_typeProvider.stringType, StringState.UNKNOWN _VALUE);

6390 // } else {	6475 // } else {

6391 // return new DartObjectImpl(_typeProvider.stringType, new StringState(val ue));	6476 // return new DartObjectImpl(_typeProvider.stringType, new StringState(val ue));

6392 // }	6477 // }

6393 // }	6478 // }

6394 // DartObjectImpl _symbolValue(String value) => new DartObjectImpl(_typeProvid er.symbolType, new SymbolState(value));	6479 // DartObjectImpl _symbolValue(String value) => new DartObjectImpl(_typeProvid er.symbolType, new SymbolState(value));

6395 // static dartSuite() {	6480 // static dartSuite() {

6396 // _ut.group('DartObjectImplTest', () {	6481 // _ut.group('DartObjectImplTest', () {

6397 // _ut.test('test_add_invalid_knownInt', () {

6398 // final __test = new DartObjectImplTest();

6399 // runJUnitTest(__test, __test.test_add_invalid_knownInt);

6400 // });

6401 // _ut.test('test_add_knownDouble_knownDouble', () {	6482 // _ut.test('test_add_knownDouble_knownDouble', () {

6402 // final __test = new DartObjectImplTest();	6483 // final __test = new DartObjectImplTest();

6403 // runJUnitTest(__test, __test.test_add_knownDouble_knownDouble);	6484 // runJUnitTest(__test, __test.test_add_knownDouble_knownDouble);

6404 // });	6485 // });

6405 // _ut.test('test_add_knownDouble_knownInt', () {	6486 // _ut.test('test_add_knownDouble_knownInt', () {

6406 // final __test = new DartObjectImplTest();	6487 // final __test = new DartObjectImplTest();

6407 // runJUnitTest(__test, __test.test_add_knownDouble_knownInt);	6488 // runJUnitTest(__test, __test.test_add_knownDouble_knownInt);

6408 // });	6489 // });

6409 // _ut.test('test_add_knownDouble_unknownDouble', () {	6490 // _ut.test('test_add_knownDouble_unknownDouble', () {

6410 // final __test = new DartObjectImplTest();	6491 // final __test = new DartObjectImplTest();

6411 // runJUnitTest(__test, __test.test_add_knownDouble_unknownDouble);	6492 // runJUnitTest(__test, __test.test_add_knownDouble_unknownDouble);

6412 // });	6493 // });

6413 // _ut.test('test_add_knownDouble_unknownInt', () {	6494 // _ut.test('test_add_knownDouble_unknownInt', () {

6414 // final __test = new DartObjectImplTest();	6495 // final __test = new DartObjectImplTest();

6415 // runJUnitTest(__test, __test.test_add_knownDouble_unknownInt);	6496 // runJUnitTest(__test, __test.test_add_knownDouble_unknownInt);

6416 // });	6497 // });

6417 // _ut.test('test_add_knownInt_invalid', () {

6418 // final __test = new DartObjectImplTest();

6419 // runJUnitTest(__test, __test.test_add_knownInt_invalid);

6420 // });

6421 // _ut.test('test_add_knownInt_knownInt', () {	6498 // _ut.test('test_add_knownInt_knownInt', () {

6422 // final __test = new DartObjectImplTest();	6499 // final __test = new DartObjectImplTest();

6423 // runJUnitTest(__test, __test.test_add_knownInt_knownInt);	6500 // runJUnitTest(__test, __test.test_add_knownInt_knownInt);

6424 // });	6501 // });

	6502 // _ut.test('test_add_knownInt_knownString', () {

	6503 // final __test = new DartObjectImplTest();

	6504 // runJUnitTest(__test, __test.test_add_knownInt_knownString);

	6505 // });

6425 // _ut.test('test_add_knownInt_unknownDouble', () {	6506 // _ut.test('test_add_knownInt_unknownDouble', () {

6426 // final __test = new DartObjectImplTest();	6507 // final __test = new DartObjectImplTest();

6427 // runJUnitTest(__test, __test.test_add_knownInt_unknownDouble);	6508 // runJUnitTest(__test, __test.test_add_knownInt_unknownDouble);

6428 // });	6509 // });

6429 // _ut.test('test_add_knownInt_unknownInt', () {	6510 // _ut.test('test_add_knownInt_unknownInt', () {

6430 // final __test = new DartObjectImplTest();	6511 // final __test = new DartObjectImplTest();

6431 // runJUnitTest(__test, __test.test_add_knownInt_unknownInt);	6512 // runJUnitTest(__test, __test.test_add_knownInt_unknownInt);

6432 // });	6513 // });

	6514 // _ut.test('test_add_knownString_knownInt', () {

	6515 // final __test = new DartObjectImplTest();

	6516 // runJUnitTest(__test, __test.test_add_knownString_knownInt);

	6517 // });

6433 // _ut.test('test_add_unknownDouble_knownDouble', () {	6518 // _ut.test('test_add_unknownDouble_knownDouble', () {

6434 // final __test = new DartObjectImplTest();	6519 // final __test = new DartObjectImplTest();

6435 // runJUnitTest(__test, __test.test_add_unknownDouble_knownDouble);	6520 // runJUnitTest(__test, __test.test_add_unknownDouble_knownDouble);

6436 // });	6521 // });

6437 // _ut.test('test_add_unknownDouble_knownInt', () {	6522 // _ut.test('test_add_unknownDouble_knownInt', () {

6438 // final __test = new DartObjectImplTest();	6523 // final __test = new DartObjectImplTest();

6439 // runJUnitTest(__test, __test.test_add_unknownDouble_knownInt);	6524 // runJUnitTest(__test, __test.test_add_unknownDouble_knownInt);

6440 // });	6525 // });

6441 // _ut.test('test_add_unknownInt_knownDouble', () {	6526 // _ut.test('test_add_unknownInt_knownDouble', () {

6442 // final __test = new DartObjectImplTest();	6527 // final __test = new DartObjectImplTest();

6443 // runJUnitTest(__test, __test.test_add_unknownInt_knownDouble);	6528 // runJUnitTest(__test, __test.test_add_unknownInt_knownDouble);

6444 // });	6529 // });

6445 // _ut.test('test_add_unknownInt_knownInt', () {	6530 // _ut.test('test_add_unknownInt_knownInt', () {

6446 // final __test = new DartObjectImplTest();	6531 // final __test = new DartObjectImplTest();

6447 // runJUnitTest(__test, __test.test_add_unknownInt_knownInt);	6532 // runJUnitTest(__test, __test.test_add_unknownInt_knownInt);

6448 // });	6533 // });

6449 // _ut.test('test_bitAnd_invalid_knownInt', () {

6450 // final __test = new DartObjectImplTest();

6451 // runJUnitTest(__test, __test.test_bitAnd_invalid_knownInt);

6452 // });

6453 // _ut.test('test_bitAnd_knownInt_invalid', () {

6454 // final __test = new DartObjectImplTest();

6455 // runJUnitTest(__test, __test.test_bitAnd_knownInt_invalid);

6456 // });

6457 // _ut.test('test_bitAnd_knownInt_knownInt', () {	6534 // _ut.test('test_bitAnd_knownInt_knownInt', () {

6458 // final __test = new DartObjectImplTest();	6535 // final __test = new DartObjectImplTest();

6459 // runJUnitTest(__test, __test.test_bitAnd_knownInt_knownInt);	6536 // runJUnitTest(__test, __test.test_bitAnd_knownInt_knownInt);

6460 // });	6537 // });

	6538 // _ut.test('test_bitAnd_knownInt_knownString', () {

	6539 // final __test = new DartObjectImplTest();

	6540 // runJUnitTest(__test, __test.test_bitAnd_knownInt_knownString);

	6541 // });

6461 // _ut.test('test_bitAnd_knownInt_unknownInt', () {	6542 // _ut.test('test_bitAnd_knownInt_unknownInt', () {

6462 // final __test = new DartObjectImplTest();	6543 // final __test = new DartObjectImplTest();

6463 // runJUnitTest(__test, __test.test_bitAnd_knownInt_unknownInt);	6544 // runJUnitTest(__test, __test.test_bitAnd_knownInt_unknownInt);

6464 // });	6545 // });

	6546 // _ut.test('test_bitAnd_knownString_knownInt', () {

	6547 // final __test = new DartObjectImplTest();

	6548 // runJUnitTest(__test, __test.test_bitAnd_knownString_knownInt);

	6549 // });

6465 // _ut.test('test_bitAnd_unknownInt_knownInt', () {	6550 // _ut.test('test_bitAnd_unknownInt_knownInt', () {

6466 // final __test = new DartObjectImplTest();	6551 // final __test = new DartObjectImplTest();

6467 // runJUnitTest(__test, __test.test_bitAnd_unknownInt_knownInt);	6552 // runJUnitTest(__test, __test.test_bitAnd_unknownInt_knownInt);

6468 // });	6553 // });

6469 // _ut.test('test_bitAnd_unknownInt_unknownInt', () {	6554 // _ut.test('test_bitAnd_unknownInt_unknownInt', () {

6470 // final __test = new DartObjectImplTest();	6555 // final __test = new DartObjectImplTest();

6471 // runJUnitTest(__test, __test.test_bitAnd_unknownInt_unknownInt);	6556 // runJUnitTest(__test, __test.test_bitAnd_unknownInt_unknownInt);

6472 // });	6557 // });

6473 // _ut.test('test_bitNot_invalid', () {

6474 // final __test = new DartObjectImplTest();

6475 // runJUnitTest(__test, __test.test_bitNot_invalid);

6476 // });

6477 // _ut.test('test_bitNot_knownInt', () {	6558 // _ut.test('test_bitNot_knownInt', () {

6478 // final __test = new DartObjectImplTest();	6559 // final __test = new DartObjectImplTest();

6479 // runJUnitTest(__test, __test.test_bitNot_knownInt);	6560 // runJUnitTest(__test, __test.test_bitNot_knownInt);

6480 // });	6561 // });

	6562 // _ut.test('test_bitNot_knownString', () {

	6563 // final __test = new DartObjectImplTest();

	6564 // runJUnitTest(__test, __test.test_bitNot_knownString);

	6565 // });

6481 // _ut.test('test_bitNot_unknownInt', () {	6566 // _ut.test('test_bitNot_unknownInt', () {

6482 // final __test = new DartObjectImplTest();	6567 // final __test = new DartObjectImplTest();

6483 // runJUnitTest(__test, __test.test_bitNot_unknownInt);	6568 // runJUnitTest(__test, __test.test_bitNot_unknownInt);

6484 // });	6569 // });

6485 // _ut.test('test_bitOr_invalid_knownInt', () {

6486 // final __test = new DartObjectImplTest();

6487 // runJUnitTest(__test, __test.test_bitOr_invalid_knownInt);

6488 // });

6489 // _ut.test('test_bitOr_knownInt_invalid', () {

6490 // final __test = new DartObjectImplTest();

6491 // runJUnitTest(__test, __test.test_bitOr_knownInt_invalid);

6492 // });

6493 // _ut.test('test_bitOr_knownInt_knownInt', () {	6570 // _ut.test('test_bitOr_knownInt_knownInt', () {

6494 // final __test = new DartObjectImplTest();	6571 // final __test = new DartObjectImplTest();

6495 // runJUnitTest(__test, __test.test_bitOr_knownInt_knownInt);	6572 // runJUnitTest(__test, __test.test_bitOr_knownInt_knownInt);

6496 // });	6573 // });

	6574 // _ut.test('test_bitOr_knownInt_knownString', () {

	6575 // final __test = new DartObjectImplTest();

	6576 // runJUnitTest(__test, __test.test_bitOr_knownInt_knownString);

	6577 // });

6497 // _ut.test('test_bitOr_knownInt_unknownInt', () {	6578 // _ut.test('test_bitOr_knownInt_unknownInt', () {

6498 // final __test = new DartObjectImplTest();	6579 // final __test = new DartObjectImplTest();

6499 // runJUnitTest(__test, __test.test_bitOr_knownInt_unknownInt);	6580 // runJUnitTest(__test, __test.test_bitOr_knownInt_unknownInt);

6500 // });	6581 // });

	6582 // _ut.test('test_bitOr_knownString_knownInt', () {

	6583 // final __test = new DartObjectImplTest();

	6584 // runJUnitTest(__test, __test.test_bitOr_knownString_knownInt);

	6585 // });

6501 // _ut.test('test_bitOr_unknownInt_knownInt', () {	6586 // _ut.test('test_bitOr_unknownInt_knownInt', () {

6502 // final __test = new DartObjectImplTest();	6587 // final __test = new DartObjectImplTest();

6503 // runJUnitTest(__test, __test.test_bitOr_unknownInt_knownInt);	6588 // runJUnitTest(__test, __test.test_bitOr_unknownInt_knownInt);

6504 // });	6589 // });

6505 // _ut.test('test_bitOr_unknownInt_unknownInt', () {	6590 // _ut.test('test_bitOr_unknownInt_unknownInt', () {

6506 // final __test = new DartObjectImplTest();	6591 // final __test = new DartObjectImplTest();

6507 // runJUnitTest(__test, __test.test_bitOr_unknownInt_unknownInt);	6592 // runJUnitTest(__test, __test.test_bitOr_unknownInt_unknownInt);

6508 // });	6593 // });

6509 // _ut.test('test_bitXor_invalid_knownInt', () {

6510 // final __test = new DartObjectImplTest();

6511 // runJUnitTest(__test, __test.test_bitXor_invalid_knownInt);

6512 // });

6513 // _ut.test('test_bitXor_knownInt_invalid', () {

6514 // final __test = new DartObjectImplTest();

6515 // runJUnitTest(__test, __test.test_bitXor_knownInt_invalid);

6516 // });

6517 // _ut.test('test_bitXor_knownInt_knownInt', () {	6594 // _ut.test('test_bitXor_knownInt_knownInt', () {

6518 // final __test = new DartObjectImplTest();	6595 // final __test = new DartObjectImplTest();

6519 // runJUnitTest(__test, __test.test_bitXor_knownInt_knownInt);	6596 // runJUnitTest(__test, __test.test_bitXor_knownInt_knownInt);

6520 // });	6597 // });

	6598 // _ut.test('test_bitXor_knownInt_knownString', () {

	6599 // final __test = new DartObjectImplTest();

	6600 // runJUnitTest(__test, __test.test_bitXor_knownInt_knownString);

	6601 // });

6521 // _ut.test('test_bitXor_knownInt_unknownInt', () {	6602 // _ut.test('test_bitXor_knownInt_unknownInt', () {

6522 // final __test = new DartObjectImplTest();	6603 // final __test = new DartObjectImplTest();

6523 // runJUnitTest(__test, __test.test_bitXor_knownInt_unknownInt);	6604 // runJUnitTest(__test, __test.test_bitXor_knownInt_unknownInt);

6524 // });	6605 // });

	6606 // _ut.test('test_bitXor_knownString_knownInt', () {

	6607 // final __test = new DartObjectImplTest();

	6608 // runJUnitTest(__test, __test.test_bitXor_knownString_knownInt);

	6609 // });

6525 // _ut.test('test_bitXor_unknownInt_knownInt', () {	6610 // _ut.test('test_bitXor_unknownInt_knownInt', () {

6526 // final __test = new DartObjectImplTest();	6611 // final __test = new DartObjectImplTest();

6527 // runJUnitTest(__test, __test.test_bitXor_unknownInt_knownInt);	6612 // runJUnitTest(__test, __test.test_bitXor_unknownInt_knownInt);

6528 // });	6613 // });

6529 // _ut.test('test_bitXor_unknownInt_unknownInt', () {	6614 // _ut.test('test_bitXor_unknownInt_unknownInt', () {

6530 // final __test = new DartObjectImplTest();	6615 // final __test = new DartObjectImplTest();

6531 // runJUnitTest(__test, __test.test_bitXor_unknownInt_unknownInt);	6616 // runJUnitTest(__test, __test.test_bitXor_unknownInt_unknownInt);

6532 // });	6617 // });

6533 // _ut.test('test_concatenate_invalid_knownString', () {	6618 // _ut.test('test_concatenate_knownInt_knownString', () {

6534 // final __test = new DartObjectImplTest();	6619 // final __test = new DartObjectImplTest();

6535 // runJUnitTest(__test, __test.test_concatenate_invalid_knownString);	6620 // runJUnitTest(__test, __test.test_concatenate_knownInt_knownString);

6536 // });	6621 // });

6537 // _ut.test('test_concatenate_knownString_invalid', () {	6622 // _ut.test('test_concatenate_knownString_knownInt', () {

6538 // final __test = new DartObjectImplTest();	6623 // final __test = new DartObjectImplTest();

6539 // runJUnitTest(__test, __test.test_concatenate_knownString_invalid);	6624 // runJUnitTest(__test, __test.test_concatenate_knownString_knownInt);

6540 // });	6625 // });

6541 // _ut.test('test_concatenate_knownString_knownString', () {	6626 // _ut.test('test_concatenate_knownString_knownString', () {

6542 // final __test = new DartObjectImplTest();	6627 // final __test = new DartObjectImplTest();

6543 // runJUnitTest(__test, __test.test_concatenate_knownString_knownString) ;	6628 // runJUnitTest(__test, __test.test_concatenate_knownString_knownString) ;

6544 // });	6629 // });

6545 // _ut.test('test_concatenate_knownString_unknownString', () {	6630 // _ut.test('test_concatenate_knownString_unknownString', () {

6546 // final __test = new DartObjectImplTest();	6631 // final __test = new DartObjectImplTest();

6547 // runJUnitTest(__test, __test.test_concatenate_knownString_unknownStrin g);	6632 // runJUnitTest(__test, __test.test_concatenate_knownString_unknownStrin g);

6548 // });	6633 // });

6549 // _ut.test('test_concatenate_unknownString_knownString', () {	6634 // _ut.test('test_concatenate_unknownString_knownString', () {

6550 // final __test = new DartObjectImplTest();	6635 // final __test = new DartObjectImplTest();

6551 // runJUnitTest(__test, __test.test_concatenate_unknownString_knownStrin g);	6636 // runJUnitTest(__test, __test.test_concatenate_unknownString_knownStrin g);

6552 // });	6637 // });

6553 // _ut.test('test_divide_invalid_knownInt', () {

6554 // final __test = new DartObjectImplTest();

6555 // runJUnitTest(__test, __test.test_divide_invalid_knownInt);

6556 // });

6557 // _ut.test('test_divide_knownDouble_knownDouble', () {	6638 // _ut.test('test_divide_knownDouble_knownDouble', () {

6558 // final __test = new DartObjectImplTest();	6639 // final __test = new DartObjectImplTest();

6559 // runJUnitTest(__test, __test.test_divide_knownDouble_knownDouble);	6640 // runJUnitTest(__test, __test.test_divide_knownDouble_knownDouble);

6560 // });	6641 // });

6561 // _ut.test('test_divide_knownDouble_knownInt', () {	6642 // _ut.test('test_divide_knownDouble_knownInt', () {

6562 // final __test = new DartObjectImplTest();	6643 // final __test = new DartObjectImplTest();

6563 // runJUnitTest(__test, __test.test_divide_knownDouble_knownInt);	6644 // runJUnitTest(__test, __test.test_divide_knownDouble_knownInt);

6564 // });	6645 // });

6565 // _ut.test('test_divide_knownDouble_unknownDouble', () {	6646 // _ut.test('test_divide_knownDouble_unknownDouble', () {

6566 // final __test = new DartObjectImplTest();	6647 // final __test = new DartObjectImplTest();

6567 // runJUnitTest(__test, __test.test_divide_knownDouble_unknownDouble);	6648 // runJUnitTest(__test, __test.test_divide_knownDouble_unknownDouble);

6568 // });	6649 // });

6569 // _ut.test('test_divide_knownDouble_unknownInt', () {	6650 // _ut.test('test_divide_knownDouble_unknownInt', () {

6570 // final __test = new DartObjectImplTest();	6651 // final __test = new DartObjectImplTest();

6571 // runJUnitTest(__test, __test.test_divide_knownDouble_unknownInt);	6652 // runJUnitTest(__test, __test.test_divide_knownDouble_unknownInt);

6572 // });	6653 // });

6573 // _ut.test('test_divide_knownInt_invalid', () {

6574 // final __test = new DartObjectImplTest();

6575 // runJUnitTest(__test, __test.test_divide_knownInt_invalid);

6576 // });

6577 // _ut.test('test_divide_knownInt_knownInt', () {	6654 // _ut.test('test_divide_knownInt_knownInt', () {

6578 // final __test = new DartObjectImplTest();	6655 // final __test = new DartObjectImplTest();

6579 // runJUnitTest(__test, __test.test_divide_knownInt_knownInt);	6656 // runJUnitTest(__test, __test.test_divide_knownInt_knownInt);

6580 // });	6657 // });

	6658 // _ut.test('test_divide_knownInt_knownString', () {

	6659 // final __test = new DartObjectImplTest();

	6660 // runJUnitTest(__test, __test.test_divide_knownInt_knownString);

	6661 // });

6581 // _ut.test('test_divide_knownInt_unknownDouble', () {	6662 // _ut.test('test_divide_knownInt_unknownDouble', () {

6582 // final __test = new DartObjectImplTest();	6663 // final __test = new DartObjectImplTest();

6583 // runJUnitTest(__test, __test.test_divide_knownInt_unknownDouble);	6664 // runJUnitTest(__test, __test.test_divide_knownInt_unknownDouble);

6584 // });	6665 // });

6585 // _ut.test('test_divide_knownInt_unknownInt', () {	6666 // _ut.test('test_divide_knownInt_unknownInt', () {

6586 // final __test = new DartObjectImplTest();	6667 // final __test = new DartObjectImplTest();

6587 // runJUnitTest(__test, __test.test_divide_knownInt_unknownInt);	6668 // runJUnitTest(__test, __test.test_divide_knownInt_unknownInt);

6588 // });	6669 // });

	6670 // _ut.test('test_divide_knownString_knownInt', () {

	6671 // final __test = new DartObjectImplTest();

	6672 // runJUnitTest(__test, __test.test_divide_knownString_knownInt);

	6673 // });

6589 // _ut.test('test_divide_unknownDouble_knownDouble', () {	6674 // _ut.test('test_divide_unknownDouble_knownDouble', () {

6590 // final __test = new DartObjectImplTest();	6675 // final __test = new DartObjectImplTest();

6591 // runJUnitTest(__test, __test.test_divide_unknownDouble_knownDouble);	6676 // runJUnitTest(__test, __test.test_divide_unknownDouble_knownDouble);

6592 // });	6677 // });

6593 // _ut.test('test_divide_unknownDouble_knownInt', () {	6678 // _ut.test('test_divide_unknownDouble_knownInt', () {

6594 // final __test = new DartObjectImplTest();	6679 // final __test = new DartObjectImplTest();

6595 // runJUnitTest(__test, __test.test_divide_unknownDouble_knownInt);	6680 // runJUnitTest(__test, __test.test_divide_unknownDouble_knownInt);

6596 // });	6681 // });

6597 // _ut.test('test_divide_unknownInt_knownDouble', () {	6682 // _ut.test('test_divide_unknownInt_knownDouble', () {

6598 // final __test = new DartObjectImplTest();	6683 // final __test = new DartObjectImplTest();

(...skipping 148 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6747 // runJUnitTest(__test, __test.test_getValue_null);	6832 // runJUnitTest(__test, __test.test_getValue_null);

6748 // });	6833 // });

6749 // _ut.test('test_getValue_string_known', () {	6834 // _ut.test('test_getValue_string_known', () {

6750 // final __test = new DartObjectImplTest();	6835 // final __test = new DartObjectImplTest();

6751 // runJUnitTest(__test, __test.test_getValue_string_known);	6836 // runJUnitTest(__test, __test.test_getValue_string_known);

6752 // });	6837 // });

6753 // _ut.test('test_getValue_string_unknown', () {	6838 // _ut.test('test_getValue_string_unknown', () {

6754 // final __test = new DartObjectImplTest();	6839 // final __test = new DartObjectImplTest();

6755 // runJUnitTest(__test, __test.test_getValue_string_unknown);	6840 // runJUnitTest(__test, __test.test_getValue_string_unknown);

6756 // });	6841 // });

6757 // _ut.test('test_greaterThanOrEqual_invalid_knownInt', () {

6758 // final __test = new DartObjectImplTest();

6759 // runJUnitTest(__test, __test.test_greaterThanOrEqual_invalid_knownInt) ;

6760 // });

6761 // _ut.test('test_greaterThanOrEqual_knownDouble_knownDouble_false', () {	6842 // _ut.test('test_greaterThanOrEqual_knownDouble_knownDouble_false', () {

6762 // final __test = new DartObjectImplTest();	6843 // final __test = new DartObjectImplTest();

6763 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Double_false);	6844 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Double_false);

6764 // });	6845 // });

6765 // _ut.test('test_greaterThanOrEqual_knownDouble_knownDouble_true', () {	6846 // _ut.test('test_greaterThanOrEqual_knownDouble_knownDouble_true', () {

6766 // final __test = new DartObjectImplTest();	6847 // final __test = new DartObjectImplTest();

6767 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Double_true);	6848 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Double_true);

6768 // });	6849 // });

6769 // _ut.test('test_greaterThanOrEqual_knownDouble_knownInt_false', () {	6850 // _ut.test('test_greaterThanOrEqual_knownDouble_knownInt_false', () {

6770 // final __test = new DartObjectImplTest();	6851 // final __test = new DartObjectImplTest();

6771 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Int_false);	6852 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Int_false);

6772 // });	6853 // });

6773 // _ut.test('test_greaterThanOrEqual_knownDouble_knownInt_true', () {	6854 // _ut.test('test_greaterThanOrEqual_knownDouble_knownInt_true', () {

6774 // final __test = new DartObjectImplTest();	6855 // final __test = new DartObjectImplTest();

6775 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Int_true);	6856 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_known Int_true);

6776 // });	6857 // });

6777 // _ut.test('test_greaterThanOrEqual_knownDouble_unknownDouble', () {	6858 // _ut.test('test_greaterThanOrEqual_knownDouble_unknownDouble', () {

6778 // final __test = new DartObjectImplTest();	6859 // final __test = new DartObjectImplTest();

6779 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_unkno wnDouble);	6860 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_unkno wnDouble);

6780 // });	6861 // });

6781 // _ut.test('test_greaterThanOrEqual_knownDouble_unknownInt', () {	6862 // _ut.test('test_greaterThanOrEqual_knownDouble_unknownInt', () {

6782 // final __test = new DartObjectImplTest();	6863 // final __test = new DartObjectImplTest();

6783 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_unkno wnInt);	6864 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownDouble_unkno wnInt);

6784 // });	6865 // });

6785 // _ut.test('test_greaterThanOrEqual_knownInt_invalid', () {

6786 // final __test = new DartObjectImplTest();

6787 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_invalid) ;

6788 // });

6789 // _ut.test('test_greaterThanOrEqual_knownInt_knownInt_false', () {	6866 // _ut.test('test_greaterThanOrEqual_knownInt_knownInt_false', () {

6790 // final __test = new DartObjectImplTest();	6867 // final __test = new DartObjectImplTest();

6791 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_knownInt _false);	6868 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_knownInt _false);

6792 // });	6869 // });

6793 // _ut.test('test_greaterThanOrEqual_knownInt_knownInt_true', () {	6870 // _ut.test('test_greaterThanOrEqual_knownInt_knownInt_true', () {

6794 // final __test = new DartObjectImplTest();	6871 // final __test = new DartObjectImplTest();

6795 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_knownInt _true);	6872 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_knownInt _true);

6796 // });	6873 // });

	6874 // _ut.test('test_greaterThanOrEqual_knownInt_knownString', () {

	6875 // final __test = new DartObjectImplTest();

	6876 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_knownStr ing);

	6877 // });

6797 // _ut.test('test_greaterThanOrEqual_knownInt_unknownDouble', () {	6878 // _ut.test('test_greaterThanOrEqual_knownInt_unknownDouble', () {

6798 // final __test = new DartObjectImplTest();	6879 // final __test = new DartObjectImplTest();

6799 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_unknownD ouble);	6880 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_unknownD ouble);

6800 // });	6881 // });

6801 // _ut.test('test_greaterThanOrEqual_knownInt_unknownInt', () {	6882 // _ut.test('test_greaterThanOrEqual_knownInt_unknownInt', () {

6802 // final __test = new DartObjectImplTest();	6883 // final __test = new DartObjectImplTest();

6803 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_unknownI nt);	6884 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownInt_unknownI nt);

6804 // });	6885 // });

	6886 // _ut.test('test_greaterThanOrEqual_knownString_knownInt', () {

	6887 // final __test = new DartObjectImplTest();

	6888 // runJUnitTest(__test, __test.test_greaterThanOrEqual_knownString_known Int);

	6889 // });

6805 // _ut.test('test_greaterThanOrEqual_unknownDouble_knownDouble', () {	6890 // _ut.test('test_greaterThanOrEqual_unknownDouble_knownDouble', () {

6806 // final __test = new DartObjectImplTest();	6891 // final __test = new DartObjectImplTest();

6807 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownDouble_kno wnDouble);	6892 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownDouble_kno wnDouble);

6808 // });	6893 // });

6809 // _ut.test('test_greaterThanOrEqual_unknownDouble_knownInt', () {	6894 // _ut.test('test_greaterThanOrEqual_unknownDouble_knownInt', () {

6810 // final __test = new DartObjectImplTest();	6895 // final __test = new DartObjectImplTest();

6811 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownDouble_kno wnInt);	6896 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownDouble_kno wnInt);

6812 // });	6897 // });

6813 // _ut.test('test_greaterThanOrEqual_unknownInt_knownDouble', () {	6898 // _ut.test('test_greaterThanOrEqual_unknownInt_knownDouble', () {

6814 // final __test = new DartObjectImplTest();	6899 // final __test = new DartObjectImplTest();

6815 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownInt_knownD ouble);	6900 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownInt_knownD ouble);

6816 // });	6901 // });

6817 // _ut.test('test_greaterThanOrEqual_unknownInt_knownInt', () {	6902 // _ut.test('test_greaterThanOrEqual_unknownInt_knownInt', () {

6818 // final __test = new DartObjectImplTest();	6903 // final __test = new DartObjectImplTest();

6819 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownInt_knownI nt);	6904 // runJUnitTest(__test, __test.test_greaterThanOrEqual_unknownInt_knownI nt);

6820 // });	6905 // });

6821 // _ut.test('test_greaterThan_invalid_knownInt', () {

6822 // final __test = new DartObjectImplTest();

6823 // runJUnitTest(__test, __test.test_greaterThan_invalid_knownInt);

6824 // });

6825 // _ut.test('test_greaterThan_knownDouble_knownDouble_false', () {	6906 // _ut.test('test_greaterThan_knownDouble_knownDouble_false', () {

6826 // final __test = new DartObjectImplTest();	6907 // final __test = new DartObjectImplTest();

6827 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownDouble_ false);	6908 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownDouble_ false);

6828 // });	6909 // });

6829 // _ut.test('test_greaterThan_knownDouble_knownDouble_true', () {	6910 // _ut.test('test_greaterThan_knownDouble_knownDouble_true', () {

6830 // final __test = new DartObjectImplTest();	6911 // final __test = new DartObjectImplTest();

6831 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownDouble_ true);	6912 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownDouble_ true);

6832 // });	6913 // });

6833 // _ut.test('test_greaterThan_knownDouble_knownInt_false', () {	6914 // _ut.test('test_greaterThan_knownDouble_knownInt_false', () {

6834 // final __test = new DartObjectImplTest();	6915 // final __test = new DartObjectImplTest();

6835 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownInt_fal se);	6916 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownInt_fal se);

6836 // });	6917 // });

6837 // _ut.test('test_greaterThan_knownDouble_knownInt_true', () {	6918 // _ut.test('test_greaterThan_knownDouble_knownInt_true', () {

6838 // final __test = new DartObjectImplTest();	6919 // final __test = new DartObjectImplTest();

6839 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownInt_tru e);	6920 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_knownInt_tru e);

6840 // });	6921 // });

6841 // _ut.test('test_greaterThan_knownDouble_unknownDouble', () {	6922 // _ut.test('test_greaterThan_knownDouble_unknownDouble', () {

6842 // final __test = new DartObjectImplTest();	6923 // final __test = new DartObjectImplTest();

6843 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_unknownDoubl e);	6924 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_unknownDoubl e);

6844 // });	6925 // });

6845 // _ut.test('test_greaterThan_knownDouble_unknownInt', () {	6926 // _ut.test('test_greaterThan_knownDouble_unknownInt', () {

6846 // final __test = new DartObjectImplTest();	6927 // final __test = new DartObjectImplTest();

6847 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_unknownInt);	6928 // runJUnitTest(__test, __test.test_greaterThan_knownDouble_unknownInt);

6848 // });	6929 // });

6849 // _ut.test('test_greaterThan_knownInt_invalid', () {

6850 // final __test = new DartObjectImplTest();

6851 // runJUnitTest(__test, __test.test_greaterThan_knownInt_invalid);

6852 // });

6853 // _ut.test('test_greaterThan_knownInt_knownInt_false', () {	6930 // _ut.test('test_greaterThan_knownInt_knownInt_false', () {

6854 // final __test = new DartObjectImplTest();	6931 // final __test = new DartObjectImplTest();

6855 // runJUnitTest(__test, __test.test_greaterThan_knownInt_knownInt_false) ;	6932 // runJUnitTest(__test, __test.test_greaterThan_knownInt_knownInt_false) ;

6856 // });	6933 // });

6857 // _ut.test('test_greaterThan_knownInt_knownInt_true', () {	6934 // _ut.test('test_greaterThan_knownInt_knownInt_true', () {

6858 // final __test = new DartObjectImplTest();	6935 // final __test = new DartObjectImplTest();

6859 // runJUnitTest(__test, __test.test_greaterThan_knownInt_knownInt_true);	6936 // runJUnitTest(__test, __test.test_greaterThan_knownInt_knownInt_true);

6860 // });	6937 // });

	6938 // _ut.test('test_greaterThan_knownInt_knownString', () {

	6939 // final __test = new DartObjectImplTest();

	6940 // runJUnitTest(__test, __test.test_greaterThan_knownInt_knownString);

	6941 // });

6861 // _ut.test('test_greaterThan_knownInt_unknownDouble', () {	6942 // _ut.test('test_greaterThan_knownInt_unknownDouble', () {

6862 // final __test = new DartObjectImplTest();	6943 // final __test = new DartObjectImplTest();

6863 // runJUnitTest(__test, __test.test_greaterThan_knownInt_unknownDouble);	6944 // runJUnitTest(__test, __test.test_greaterThan_knownInt_unknownDouble);

6864 // });	6945 // });

6865 // _ut.test('test_greaterThan_knownInt_unknownInt', () {	6946 // _ut.test('test_greaterThan_knownInt_unknownInt', () {

6866 // final __test = new DartObjectImplTest();	6947 // final __test = new DartObjectImplTest();

6867 // runJUnitTest(__test, __test.test_greaterThan_knownInt_unknownInt);	6948 // runJUnitTest(__test, __test.test_greaterThan_knownInt_unknownInt);

6868 // });	6949 // });

	6950 // _ut.test('test_greaterThan_knownString_knownInt', () {

	6951 // final __test = new DartObjectImplTest();

	6952 // runJUnitTest(__test, __test.test_greaterThan_knownString_knownInt);

	6953 // });

6869 // _ut.test('test_greaterThan_unknownDouble_knownDouble', () {	6954 // _ut.test('test_greaterThan_unknownDouble_knownDouble', () {

6870 // final __test = new DartObjectImplTest();	6955 // final __test = new DartObjectImplTest();

6871 // runJUnitTest(__test, __test.test_greaterThan_unknownDouble_knownDoubl e);	6956 // runJUnitTest(__test, __test.test_greaterThan_unknownDouble_knownDoubl e);

6872 // });	6957 // });

6873 // _ut.test('test_greaterThan_unknownDouble_knownInt', () {	6958 // _ut.test('test_greaterThan_unknownDouble_knownInt', () {

6874 // final __test = new DartObjectImplTest();	6959 // final __test = new DartObjectImplTest();

6875 // runJUnitTest(__test, __test.test_greaterThan_unknownDouble_knownInt);	6960 // runJUnitTest(__test, __test.test_greaterThan_unknownDouble_knownInt);

6876 // });	6961 // });

6877 // _ut.test('test_greaterThan_unknownInt_knownDouble', () {	6962 // _ut.test('test_greaterThan_unknownInt_knownDouble', () {

6878 // final __test = new DartObjectImplTest();	6963 // final __test = new DartObjectImplTest();

(...skipping 72 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
6951 // runJUnitTest(__test, __test.test_hasExactValue_num);	7036 // runJUnitTest(__test, __test.test_hasExactValue_num);

6952 // });	7037 // });

6953 // _ut.test('test_hasExactValue_string_known', () {	7038 // _ut.test('test_hasExactValue_string_known', () {

6954 // final __test = new DartObjectImplTest();	7039 // final __test = new DartObjectImplTest();

6955 // runJUnitTest(__test, __test.test_hasExactValue_string_known);	7040 // runJUnitTest(__test, __test.test_hasExactValue_string_known);

6956 // });	7041 // });

6957 // _ut.test('test_hasExactValue_string_unknown', () {	7042 // _ut.test('test_hasExactValue_string_unknown', () {

6958 // final __test = new DartObjectImplTest();	7043 // final __test = new DartObjectImplTest();

6959 // runJUnitTest(__test, __test.test_hasExactValue_string_unknown);	7044 // runJUnitTest(__test, __test.test_hasExactValue_string_unknown);

6960 // });	7045 // });

6961 // _ut.test('test_integerDivide_invalid_knownInt', () {

6962 // final __test = new DartObjectImplTest();

6963 // runJUnitTest(__test, __test.test_integerDivide_invalid_knownInt);

6964 // });

6965 // _ut.test('test_integerDivide_knownDouble_knownDouble', () {	7046 // _ut.test('test_integerDivide_knownDouble_knownDouble', () {

6966 // final __test = new DartObjectImplTest();	7047 // final __test = new DartObjectImplTest();

6967 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_knownDoubl e);	7048 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_knownDoubl e);

6968 // });	7049 // });

6969 // _ut.test('test_integerDivide_knownDouble_knownInt', () {	7050 // _ut.test('test_integerDivide_knownDouble_knownInt', () {

6970 // final __test = new DartObjectImplTest();	7051 // final __test = new DartObjectImplTest();

6971 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_knownInt);	7052 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_knownInt);

6972 // });	7053 // });

6973 // _ut.test('test_integerDivide_knownDouble_unknownDouble', () {	7054 // _ut.test('test_integerDivide_knownDouble_unknownDouble', () {

6974 // final __test = new DartObjectImplTest();	7055 // final __test = new DartObjectImplTest();

6975 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_unknownDou ble);	7056 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_unknownDou ble);

6976 // });	7057 // });

6977 // _ut.test('test_integerDivide_knownDouble_unknownInt', () {	7058 // _ut.test('test_integerDivide_knownDouble_unknownInt', () {

6978 // final __test = new DartObjectImplTest();	7059 // final __test = new DartObjectImplTest();

6979 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_unknownInt );	7060 // runJUnitTest(__test, __test.test_integerDivide_knownDouble_unknownInt );

6980 // });	7061 // });

6981 // _ut.test('test_integerDivide_knownInt_invalid', () {

6982 // final __test = new DartObjectImplTest();

6983 // runJUnitTest(__test, __test.test_integerDivide_knownInt_invalid);

6984 // });

6985 // _ut.test('test_integerDivide_knownInt_knownInt', () {	7062 // _ut.test('test_integerDivide_knownInt_knownInt', () {

6986 // final __test = new DartObjectImplTest();	7063 // final __test = new DartObjectImplTest();

6987 // runJUnitTest(__test, __test.test_integerDivide_knownInt_knownInt);	7064 // runJUnitTest(__test, __test.test_integerDivide_knownInt_knownInt);

6988 // });	7065 // });

	7066 // _ut.test('test_integerDivide_knownInt_knownString', () {

	7067 // final __test = new DartObjectImplTest();

	7068 // runJUnitTest(__test, __test.test_integerDivide_knownInt_knownString);

	7069 // });

6989 // _ut.test('test_integerDivide_knownInt_unknownDouble', () {	7070 // _ut.test('test_integerDivide_knownInt_unknownDouble', () {

6990 // final __test = new DartObjectImplTest();	7071 // final __test = new DartObjectImplTest();

6991 // runJUnitTest(__test, __test.test_integerDivide_knownInt_unknownDouble );	7072 // runJUnitTest(__test, __test.test_integerDivide_knownInt_unknownDouble );

6992 // });	7073 // });

6993 // _ut.test('test_integerDivide_knownInt_unknownInt', () {	7074 // _ut.test('test_integerDivide_knownInt_unknownInt', () {

6994 // final __test = new DartObjectImplTest();	7075 // final __test = new DartObjectImplTest();

6995 // runJUnitTest(__test, __test.test_integerDivide_knownInt_unknownInt);	7076 // runJUnitTest(__test, __test.test_integerDivide_knownInt_unknownInt);

6996 // });	7077 // });

	7078 // _ut.test('test_integerDivide_knownString_knownInt', () {

	7079 // final __test = new DartObjectImplTest();

	7080 // runJUnitTest(__test, __test.test_integerDivide_knownString_knownInt);

	7081 // });

6997 // _ut.test('test_integerDivide_unknownDouble_knownDouble', () {	7082 // _ut.test('test_integerDivide_unknownDouble_knownDouble', () {

6998 // final __test = new DartObjectImplTest();	7083 // final __test = new DartObjectImplTest();

6999 // runJUnitTest(__test, __test.test_integerDivide_unknownDouble_knownDou ble);	7084 // runJUnitTest(__test, __test.test_integerDivide_unknownDouble_knownDou ble);

7000 // });	7085 // });

7001 // _ut.test('test_integerDivide_unknownDouble_knownInt', () {	7086 // _ut.test('test_integerDivide_unknownDouble_knownInt', () {

7002 // final __test = new DartObjectImplTest();	7087 // final __test = new DartObjectImplTest();

7003 // runJUnitTest(__test, __test.test_integerDivide_unknownDouble_knownInt );	7088 // runJUnitTest(__test, __test.test_integerDivide_unknownDouble_knownInt );

7004 // });	7089 // });

7005 // _ut.test('test_integerDivide_unknownInt_knownDouble', () {	7090 // _ut.test('test_integerDivide_unknownInt_knownDouble', () {

7006 // final __test = new DartObjectImplTest();	7091 // final __test = new DartObjectImplTest();

(...skipping 48 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
7055 // runJUnitTest(__test, __test.test_isBoolNumStringOrNull_num);	7140 // runJUnitTest(__test, __test.test_isBoolNumStringOrNull_num);

7056 // });	7141 // });

7057 // _ut.test('test_isBoolNumStringOrNull_string_known', () {	7142 // _ut.test('test_isBoolNumStringOrNull_string_known', () {

7058 // final __test = new DartObjectImplTest();	7143 // final __test = new DartObjectImplTest();

7059 // runJUnitTest(__test, __test.test_isBoolNumStringOrNull_string_known);	7144 // runJUnitTest(__test, __test.test_isBoolNumStringOrNull_string_known);

7060 // });	7145 // });

7061 // _ut.test('test_isBoolNumStringOrNull_string_unknown', () {	7146 // _ut.test('test_isBoolNumStringOrNull_string_unknown', () {

7062 // final __test = new DartObjectImplTest();	7147 // final __test = new DartObjectImplTest();

7063 // runJUnitTest(__test, __test.test_isBoolNumStringOrNull_string_unknown );	7148 // runJUnitTest(__test, __test.test_isBoolNumStringOrNull_string_unknown );

7064 // });	7149 // });

7065 // _ut.test('test_lessThanOrEqual_invalid_knownInt', () {

7066 // final __test = new DartObjectImplTest();

7067 // runJUnitTest(__test, __test.test_lessThanOrEqual_invalid_knownInt);

7068 // });

7069 // _ut.test('test_lessThanOrEqual_knownDouble_knownDouble_false', () {	7150 // _ut.test('test_lessThanOrEqual_knownDouble_knownDouble_false', () {

7070 // final __test = new DartObjectImplTest();	7151 // final __test = new DartObjectImplTest();

7071 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownDou ble_false);	7152 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownDou ble_false);

7072 // });	7153 // });

7073 // _ut.test('test_lessThanOrEqual_knownDouble_knownDouble_true', () {	7154 // _ut.test('test_lessThanOrEqual_knownDouble_knownDouble_true', () {

7074 // final __test = new DartObjectImplTest();	7155 // final __test = new DartObjectImplTest();

7075 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownDou ble_true);	7156 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownDou ble_true);

7076 // });	7157 // });

7077 // _ut.test('test_lessThanOrEqual_knownDouble_knownInt_false', () {	7158 // _ut.test('test_lessThanOrEqual_knownDouble_knownInt_false', () {

7078 // final __test = new DartObjectImplTest();	7159 // final __test = new DartObjectImplTest();

7079 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownInt _false);	7160 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownInt _false);

7080 // });	7161 // });

7081 // _ut.test('test_lessThanOrEqual_knownDouble_knownInt_true', () {	7162 // _ut.test('test_lessThanOrEqual_knownDouble_knownInt_true', () {

7082 // final __test = new DartObjectImplTest();	7163 // final __test = new DartObjectImplTest();

7083 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownInt _true);	7164 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_knownInt _true);

7084 // });	7165 // });

7085 // _ut.test('test_lessThanOrEqual_knownDouble_unknownDouble', () {	7166 // _ut.test('test_lessThanOrEqual_knownDouble_unknownDouble', () {

7086 // final __test = new DartObjectImplTest();	7167 // final __test = new DartObjectImplTest();

7087 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_unknownD ouble);	7168 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_unknownD ouble);

7088 // });	7169 // });

7089 // _ut.test('test_lessThanOrEqual_knownDouble_unknownInt', () {	7170 // _ut.test('test_lessThanOrEqual_knownDouble_unknownInt', () {

7090 // final __test = new DartObjectImplTest();	7171 // final __test = new DartObjectImplTest();

7091 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_unknownI nt);	7172 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownDouble_unknownI nt);

7092 // });	7173 // });

7093 // _ut.test('test_lessThanOrEqual_knownInt_invalid', () {

7094 // final __test = new DartObjectImplTest();

7095 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_invalid);

7096 // });

7097 // _ut.test('test_lessThanOrEqual_knownInt_knownInt_false', () {	7174 // _ut.test('test_lessThanOrEqual_knownInt_knownInt_false', () {

7098 // final __test = new DartObjectImplTest();	7175 // final __test = new DartObjectImplTest();

7099 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_knownInt_fa lse);	7176 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_knownInt_fa lse);

7100 // });	7177 // });

7101 // _ut.test('test_lessThanOrEqual_knownInt_knownInt_true', () {	7178 // _ut.test('test_lessThanOrEqual_knownInt_knownInt_true', () {

7102 // final __test = new DartObjectImplTest();	7179 // final __test = new DartObjectImplTest();

7103 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_knownInt_tr ue);	7180 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_knownInt_tr ue);

7104 // });	7181 // });

	7182 // _ut.test('test_lessThanOrEqual_knownInt_knownString', () {

	7183 // final __test = new DartObjectImplTest();

	7184 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_knownString );

	7185 // });

7105 // _ut.test('test_lessThanOrEqual_knownInt_unknownDouble', () {	7186 // _ut.test('test_lessThanOrEqual_knownInt_unknownDouble', () {

7106 // final __test = new DartObjectImplTest();	7187 // final __test = new DartObjectImplTest();

7107 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_unknownDoub le);	7188 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_unknownDoub le);

7108 // });	7189 // });

7109 // _ut.test('test_lessThanOrEqual_knownInt_unknownInt', () {	7190 // _ut.test('test_lessThanOrEqual_knownInt_unknownInt', () {

7110 // final __test = new DartObjectImplTest();	7191 // final __test = new DartObjectImplTest();

7111 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_unknownInt) ;	7192 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownInt_unknownInt) ;

7112 // });	7193 // });

	7194 // _ut.test('test_lessThanOrEqual_knownString_knownInt', () {

	7195 // final __test = new DartObjectImplTest();

	7196 // runJUnitTest(__test, __test.test_lessThanOrEqual_knownString_knownInt );

	7197 // });

7113 // _ut.test('test_lessThanOrEqual_unknownDouble_knownDouble', () {	7198 // _ut.test('test_lessThanOrEqual_unknownDouble_knownDouble', () {

7114 // final __test = new DartObjectImplTest();	7199 // final __test = new DartObjectImplTest();

7115 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownDouble_knownD ouble);	7200 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownDouble_knownD ouble);

7116 // });	7201 // });

7117 // _ut.test('test_lessThanOrEqual_unknownDouble_knownInt', () {	7202 // _ut.test('test_lessThanOrEqual_unknownDouble_knownInt', () {

7118 // final __test = new DartObjectImplTest();	7203 // final __test = new DartObjectImplTest();

7119 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownDouble_knownI nt);	7204 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownDouble_knownI nt);

7120 // });	7205 // });

7121 // _ut.test('test_lessThanOrEqual_unknownInt_knownDouble', () {	7206 // _ut.test('test_lessThanOrEqual_unknownInt_knownDouble', () {

7122 // final __test = new DartObjectImplTest();	7207 // final __test = new DartObjectImplTest();

7123 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownInt_knownDoub le);	7208 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownInt_knownDoub le);

7124 // });	7209 // });

7125 // _ut.test('test_lessThanOrEqual_unknownInt_knownInt', () {	7210 // _ut.test('test_lessThanOrEqual_unknownInt_knownInt', () {

7126 // final __test = new DartObjectImplTest();	7211 // final __test = new DartObjectImplTest();

7127 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownInt_knownInt) ;	7212 // runJUnitTest(__test, __test.test_lessThanOrEqual_unknownInt_knownInt) ;

7128 // });	7213 // });

7129 // _ut.test('test_lessThan_invalid_knownInt', () {

7130 // final __test = new DartObjectImplTest();

7131 // runJUnitTest(__test, __test.test_lessThan_invalid_knownInt);

7132 // });

7133 // _ut.test('test_lessThan_knownDouble_knownDouble_false', () {	7214 // _ut.test('test_lessThan_knownDouble_knownDouble_false', () {

7134 // final __test = new DartObjectImplTest();	7215 // final __test = new DartObjectImplTest();

7135 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownDouble_fal se);	7216 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownDouble_fal se);

7136 // });	7217 // });

7137 // _ut.test('test_lessThan_knownDouble_knownDouble_true', () {	7218 // _ut.test('test_lessThan_knownDouble_knownDouble_true', () {

7138 // final __test = new DartObjectImplTest();	7219 // final __test = new DartObjectImplTest();

7139 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownDouble_tru e);	7220 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownDouble_tru e);

7140 // });	7221 // });

7141 // _ut.test('test_lessThan_knownDouble_knownInt_false', () {	7222 // _ut.test('test_lessThan_knownDouble_knownInt_false', () {

7142 // final __test = new DartObjectImplTest();	7223 // final __test = new DartObjectImplTest();

7143 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownInt_false) ;	7224 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownInt_false) ;

7144 // });	7225 // });

7145 // _ut.test('test_lessThan_knownDouble_knownInt_true', () {	7226 // _ut.test('test_lessThan_knownDouble_knownInt_true', () {

7146 // final __test = new DartObjectImplTest();	7227 // final __test = new DartObjectImplTest();

7147 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownInt_true);	7228 // runJUnitTest(__test, __test.test_lessThan_knownDouble_knownInt_true);

7148 // });	7229 // });

7149 // _ut.test('test_lessThan_knownDouble_unknownDouble', () {	7230 // _ut.test('test_lessThan_knownDouble_unknownDouble', () {

7150 // final __test = new DartObjectImplTest();	7231 // final __test = new DartObjectImplTest();

7151 // runJUnitTest(__test, __test.test_lessThan_knownDouble_unknownDouble);	7232 // runJUnitTest(__test, __test.test_lessThan_knownDouble_unknownDouble);

7152 // });	7233 // });

7153 // _ut.test('test_lessThan_knownDouble_unknownInt', () {	7234 // _ut.test('test_lessThan_knownDouble_unknownInt', () {

7154 // final __test = new DartObjectImplTest();	7235 // final __test = new DartObjectImplTest();

7155 // runJUnitTest(__test, __test.test_lessThan_knownDouble_unknownInt);	7236 // runJUnitTest(__test, __test.test_lessThan_knownDouble_unknownInt);

7156 // });	7237 // });

7157 // _ut.test('test_lessThan_knownInt_invalid', () {

7158 // final __test = new DartObjectImplTest();

7159 // runJUnitTest(__test, __test.test_lessThan_knownInt_invalid);

7160 // });

7161 // _ut.test('test_lessThan_knownInt_knownInt_false', () {	7238 // _ut.test('test_lessThan_knownInt_knownInt_false', () {

7162 // final __test = new DartObjectImplTest();	7239 // final __test = new DartObjectImplTest();

7163 // runJUnitTest(__test, __test.test_lessThan_knownInt_knownInt_false);	7240 // runJUnitTest(__test, __test.test_lessThan_knownInt_knownInt_false);

7164 // });	7241 // });

7165 // _ut.test('test_lessThan_knownInt_knownInt_true', () {	7242 // _ut.test('test_lessThan_knownInt_knownInt_true', () {

7166 // final __test = new DartObjectImplTest();	7243 // final __test = new DartObjectImplTest();

7167 // runJUnitTest(__test, __test.test_lessThan_knownInt_knownInt_true);	7244 // runJUnitTest(__test, __test.test_lessThan_knownInt_knownInt_true);

7168 // });	7245 // });

	7246 // _ut.test('test_lessThan_knownInt_knownString', () {

	7247 // final __test = new DartObjectImplTest();

	7248 // runJUnitTest(__test, __test.test_lessThan_knownInt_knownString);

	7249 // });

7169 // _ut.test('test_lessThan_knownInt_unknownDouble', () {	7250 // _ut.test('test_lessThan_knownInt_unknownDouble', () {

7170 // final __test = new DartObjectImplTest();	7251 // final __test = new DartObjectImplTest();

7171 // runJUnitTest(__test, __test.test_lessThan_knownInt_unknownDouble);	7252 // runJUnitTest(__test, __test.test_lessThan_knownInt_unknownDouble);

7172 // });	7253 // });

7173 // _ut.test('test_lessThan_knownInt_unknownInt', () {	7254 // _ut.test('test_lessThan_knownInt_unknownInt', () {

7174 // final __test = new DartObjectImplTest();	7255 // final __test = new DartObjectImplTest();

7175 // runJUnitTest(__test, __test.test_lessThan_knownInt_unknownInt);	7256 // runJUnitTest(__test, __test.test_lessThan_knownInt_unknownInt);

7176 // });	7257 // });

	7258 // _ut.test('test_lessThan_knownString_knownInt', () {

	7259 // final __test = new DartObjectImplTest();

	7260 // runJUnitTest(__test, __test.test_lessThan_knownString_knownInt);

	7261 // });

7177 // _ut.test('test_lessThan_unknownDouble_knownDouble', () {	7262 // _ut.test('test_lessThan_unknownDouble_knownDouble', () {

7178 // final __test = new DartObjectImplTest();	7263 // final __test = new DartObjectImplTest();

7179 // runJUnitTest(__test, __test.test_lessThan_unknownDouble_knownDouble);	7264 // runJUnitTest(__test, __test.test_lessThan_unknownDouble_knownDouble);

7180 // });	7265 // });

7181 // _ut.test('test_lessThan_unknownDouble_knownInt', () {	7266 // _ut.test('test_lessThan_unknownDouble_knownInt', () {

7182 // final __test = new DartObjectImplTest();	7267 // final __test = new DartObjectImplTest();

7183 // runJUnitTest(__test, __test.test_lessThan_unknownDouble_knownInt);	7268 // runJUnitTest(__test, __test.test_lessThan_unknownDouble_knownInt);

7184 // });	7269 // });

7185 // _ut.test('test_lessThan_unknownInt_knownDouble', () {	7270 // _ut.test('test_lessThan_unknownInt_knownDouble', () {

7186 // final __test = new DartObjectImplTest();	7271 // final __test = new DartObjectImplTest();

(...skipping 112 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
7299 // runJUnitTest(__test, __test.test_logicalOr_true_null);	7384 // runJUnitTest(__test, __test.test_logicalOr_true_null);

7300 // });	7385 // });

7301 // _ut.test('test_logicalOr_true_string', () {	7386 // _ut.test('test_logicalOr_true_string', () {

7302 // final __test = new DartObjectImplTest();	7387 // final __test = new DartObjectImplTest();

7303 // runJUnitTest(__test, __test.test_logicalOr_true_string);	7388 // runJUnitTest(__test, __test.test_logicalOr_true_string);

7304 // });	7389 // });

7305 // _ut.test('test_logicalOr_true_true', () {	7390 // _ut.test('test_logicalOr_true_true', () {

7306 // final __test = new DartObjectImplTest();	7391 // final __test = new DartObjectImplTest();

7307 // runJUnitTest(__test, __test.test_logicalOr_true_true);	7392 // runJUnitTest(__test, __test.test_logicalOr_true_true);

7308 // });	7393 // });

7309 // _ut.test('test_minus_invalid_knownInt', () {

7310 // final __test = new DartObjectImplTest();

7311 // runJUnitTest(__test, __test.test_minus_invalid_knownInt);

7312 // });

7313 // _ut.test('test_minus_knownDouble_knownDouble', () {	7394 // _ut.test('test_minus_knownDouble_knownDouble', () {

7314 // final __test = new DartObjectImplTest();	7395 // final __test = new DartObjectImplTest();

7315 // runJUnitTest(__test, __test.test_minus_knownDouble_knownDouble);	7396 // runJUnitTest(__test, __test.test_minus_knownDouble_knownDouble);

7316 // });	7397 // });

7317 // _ut.test('test_minus_knownDouble_knownInt', () {	7398 // _ut.test('test_minus_knownDouble_knownInt', () {

7318 // final __test = new DartObjectImplTest();	7399 // final __test = new DartObjectImplTest();

7319 // runJUnitTest(__test, __test.test_minus_knownDouble_knownInt);	7400 // runJUnitTest(__test, __test.test_minus_knownDouble_knownInt);

7320 // });	7401 // });

7321 // _ut.test('test_minus_knownDouble_unknownDouble', () {	7402 // _ut.test('test_minus_knownDouble_unknownDouble', () {

7322 // final __test = new DartObjectImplTest();	7403 // final __test = new DartObjectImplTest();

7323 // runJUnitTest(__test, __test.test_minus_knownDouble_unknownDouble);	7404 // runJUnitTest(__test, __test.test_minus_knownDouble_unknownDouble);

7324 // });	7405 // });

7325 // _ut.test('test_minus_knownDouble_unknownInt', () {	7406 // _ut.test('test_minus_knownDouble_unknownInt', () {

7326 // final __test = new DartObjectImplTest();	7407 // final __test = new DartObjectImplTest();

7327 // runJUnitTest(__test, __test.test_minus_knownDouble_unknownInt);	7408 // runJUnitTest(__test, __test.test_minus_knownDouble_unknownInt);

7328 // });	7409 // });

7329 // _ut.test('test_minus_knownInt_invalid', () {

7330 // final __test = new DartObjectImplTest();

7331 // runJUnitTest(__test, __test.test_minus_knownInt_invalid);

7332 // });

7333 // _ut.test('test_minus_knownInt_knownInt', () {	7410 // _ut.test('test_minus_knownInt_knownInt', () {

7334 // final __test = new DartObjectImplTest();	7411 // final __test = new DartObjectImplTest();

7335 // runJUnitTest(__test, __test.test_minus_knownInt_knownInt);	7412 // runJUnitTest(__test, __test.test_minus_knownInt_knownInt);

7336 // });	7413 // });

	7414 // _ut.test('test_minus_knownInt_knownString', () {

	7415 // final __test = new DartObjectImplTest();

	7416 // runJUnitTest(__test, __test.test_minus_knownInt_knownString);

	7417 // });

7337 // _ut.test('test_minus_knownInt_unknownDouble', () {	7418 // _ut.test('test_minus_knownInt_unknownDouble', () {

7338 // final __test = new DartObjectImplTest();	7419 // final __test = new DartObjectImplTest();

7339 // runJUnitTest(__test, __test.test_minus_knownInt_unknownDouble);	7420 // runJUnitTest(__test, __test.test_minus_knownInt_unknownDouble);

7340 // });	7421 // });

7341 // _ut.test('test_minus_knownInt_unknownInt', () {	7422 // _ut.test('test_minus_knownInt_unknownInt', () {

7342 // final __test = new DartObjectImplTest();	7423 // final __test = new DartObjectImplTest();

7343 // runJUnitTest(__test, __test.test_minus_knownInt_unknownInt);	7424 // runJUnitTest(__test, __test.test_minus_knownInt_unknownInt);

7344 // });	7425 // });

	7426 // _ut.test('test_minus_knownString_knownInt', () {

	7427 // final __test = new DartObjectImplTest();

	7428 // runJUnitTest(__test, __test.test_minus_knownString_knownInt);

	7429 // });

7345 // _ut.test('test_minus_unknownDouble_knownDouble', () {	7430 // _ut.test('test_minus_unknownDouble_knownDouble', () {

7346 // final __test = new DartObjectImplTest();	7431 // final __test = new DartObjectImplTest();

7347 // runJUnitTest(__test, __test.test_minus_unknownDouble_knownDouble);	7432 // runJUnitTest(__test, __test.test_minus_unknownDouble_knownDouble);

7348 // });	7433 // });

7349 // _ut.test('test_minus_unknownDouble_knownInt', () {	7434 // _ut.test('test_minus_unknownDouble_knownInt', () {

7350 // final __test = new DartObjectImplTest();	7435 // final __test = new DartObjectImplTest();

7351 // runJUnitTest(__test, __test.test_minus_unknownDouble_knownInt);	7436 // runJUnitTest(__test, __test.test_minus_unknownDouble_knownInt);

7352 // });	7437 // });

7353 // _ut.test('test_minus_unknownInt_knownDouble', () {	7438 // _ut.test('test_minus_unknownInt_knownDouble', () {

7354 // final __test = new DartObjectImplTest();	7439 // final __test = new DartObjectImplTest();

(...skipping 108 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
7463 // runJUnitTest(__test, __test.test_performToString_null);	7548 // runJUnitTest(__test, __test.test_performToString_null);

7464 // });	7549 // });

7465 // _ut.test('test_performToString_string_known', () {	7550 // _ut.test('test_performToString_string_known', () {

7466 // final __test = new DartObjectImplTest();	7551 // final __test = new DartObjectImplTest();

7467 // runJUnitTest(__test, __test.test_performToString_string_known);	7552 // runJUnitTest(__test, __test.test_performToString_string_known);

7468 // });	7553 // });

7469 // _ut.test('test_performToString_string_unknown', () {	7554 // _ut.test('test_performToString_string_unknown', () {

7470 // final __test = new DartObjectImplTest();	7555 // final __test = new DartObjectImplTest();

7471 // runJUnitTest(__test, __test.test_performToString_string_unknown);	7556 // runJUnitTest(__test, __test.test_performToString_string_unknown);

7472 // });	7557 // });

7473 // _ut.test('test_remainder_invalid_knownInt', () {

7474 // final __test = new DartObjectImplTest();

7475 // runJUnitTest(__test, __test.test_remainder_invalid_knownInt);

7476 // });

7477 // _ut.test('test_remainder_knownDouble_knownDouble', () {	7558 // _ut.test('test_remainder_knownDouble_knownDouble', () {

7478 // final __test = new DartObjectImplTest();	7559 // final __test = new DartObjectImplTest();

7479 // runJUnitTest(__test, __test.test_remainder_knownDouble_knownDouble);	7560 // runJUnitTest(__test, __test.test_remainder_knownDouble_knownDouble);

7480 // });	7561 // });

7481 // _ut.test('test_remainder_knownDouble_knownInt', () {	7562 // _ut.test('test_remainder_knownDouble_knownInt', () {

7482 // final __test = new DartObjectImplTest();	7563 // final __test = new DartObjectImplTest();

7483 // runJUnitTest(__test, __test.test_remainder_knownDouble_knownInt);	7564 // runJUnitTest(__test, __test.test_remainder_knownDouble_knownInt);

7484 // });	7565 // });

7485 // _ut.test('test_remainder_knownDouble_unknownDouble', () {	7566 // _ut.test('test_remainder_knownDouble_unknownDouble', () {

7486 // final __test = new DartObjectImplTest();	7567 // final __test = new DartObjectImplTest();

7487 // runJUnitTest(__test, __test.test_remainder_knownDouble_unknownDouble) ;	7568 // runJUnitTest(__test, __test.test_remainder_knownDouble_unknownDouble) ;

7488 // });	7569 // });

7489 // _ut.test('test_remainder_knownDouble_unknownInt', () {	7570 // _ut.test('test_remainder_knownDouble_unknownInt', () {

7490 // final __test = new DartObjectImplTest();	7571 // final __test = new DartObjectImplTest();

7491 // runJUnitTest(__test, __test.test_remainder_knownDouble_unknownInt);	7572 // runJUnitTest(__test, __test.test_remainder_knownDouble_unknownInt);

7492 // });	7573 // });

7493 // _ut.test('test_remainder_knownInt_invalid', () {

7494 // final __test = new DartObjectImplTest();

7495 // runJUnitTest(__test, __test.test_remainder_knownInt_invalid);

7496 // });

7497 // _ut.test('test_remainder_knownInt_knownInt', () {	7574 // _ut.test('test_remainder_knownInt_knownInt', () {

7498 // final __test = new DartObjectImplTest();	7575 // final __test = new DartObjectImplTest();

7499 // runJUnitTest(__test, __test.test_remainder_knownInt_knownInt);	7576 // runJUnitTest(__test, __test.test_remainder_knownInt_knownInt);

7500 // });	7577 // });

	7578 // _ut.test('test_remainder_knownInt_knownString', () {

	7579 // final __test = new DartObjectImplTest();

	7580 // runJUnitTest(__test, __test.test_remainder_knownInt_knownString);

	7581 // });

7501 // _ut.test('test_remainder_knownInt_unknownDouble', () {	7582 // _ut.test('test_remainder_knownInt_unknownDouble', () {

7502 // final __test = new DartObjectImplTest();	7583 // final __test = new DartObjectImplTest();

7503 // runJUnitTest(__test, __test.test_remainder_knownInt_unknownDouble);	7584 // runJUnitTest(__test, __test.test_remainder_knownInt_unknownDouble);

7504 // });	7585 // });

7505 // _ut.test('test_remainder_knownInt_unknownInt', () {	7586 // _ut.test('test_remainder_knownInt_unknownInt', () {

7506 // final __test = new DartObjectImplTest();	7587 // final __test = new DartObjectImplTest();

7507 // runJUnitTest(__test, __test.test_remainder_knownInt_unknownInt);	7588 // runJUnitTest(__test, __test.test_remainder_knownInt_unknownInt);

7508 // });	7589 // });

	7590 // _ut.test('test_remainder_knownString_knownInt', () {

	7591 // final __test = new DartObjectImplTest();

	7592 // runJUnitTest(__test, __test.test_remainder_knownString_knownInt);

	7593 // });

7509 // _ut.test('test_remainder_unknownDouble_knownDouble', () {	7594 // _ut.test('test_remainder_unknownDouble_knownDouble', () {

7510 // final __test = new DartObjectImplTest();	7595 // final __test = new DartObjectImplTest();

7511 // runJUnitTest(__test, __test.test_remainder_unknownDouble_knownDouble) ;	7596 // runJUnitTest(__test, __test.test_remainder_unknownDouble_knownDouble) ;

7512 // });	7597 // });

7513 // _ut.test('test_remainder_unknownDouble_knownInt', () {	7598 // _ut.test('test_remainder_unknownDouble_knownInt', () {

7514 // final __test = new DartObjectImplTest();	7599 // final __test = new DartObjectImplTest();

7515 // runJUnitTest(__test, __test.test_remainder_unknownDouble_knownInt);	7600 // runJUnitTest(__test, __test.test_remainder_unknownDouble_knownInt);

7516 // });	7601 // });

7517 // _ut.test('test_remainder_unknownInt_knownDouble', () {	7602 // _ut.test('test_remainder_unknownInt_knownDouble', () {

7518 // final __test = new DartObjectImplTest();	7603 // final __test = new DartObjectImplTest();

7519 // runJUnitTest(__test, __test.test_remainder_unknownInt_knownDouble);	7604 // runJUnitTest(__test, __test.test_remainder_unknownInt_knownDouble);

7520 // });	7605 // });

7521 // _ut.test('test_remainder_unknownInt_knownInt', () {	7606 // _ut.test('test_remainder_unknownInt_knownInt', () {

7522 // final __test = new DartObjectImplTest();	7607 // final __test = new DartObjectImplTest();

7523 // runJUnitTest(__test, __test.test_remainder_unknownInt_knownInt);	7608 // runJUnitTest(__test, __test.test_remainder_unknownInt_knownInt);

7524 // });	7609 // });

7525 // _ut.test('test_shiftLeft_invalid_knownInt', () {

7526 // final __test = new DartObjectImplTest();

7527 // runJUnitTest(__test, __test.test_shiftLeft_invalid_knownInt);

7528 // });

7529 // _ut.test('test_shiftLeft_knownInt_invalid', () {

7530 // final __test = new DartObjectImplTest();

7531 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_invalid);

7532 // });

7533 // _ut.test('test_shiftLeft_knownInt_knownInt', () {	7610 // _ut.test('test_shiftLeft_knownInt_knownInt', () {

7534 // final __test = new DartObjectImplTest();	7611 // final __test = new DartObjectImplTest();

7535 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_knownInt);	7612 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_knownInt);

7536 // });	7613 // });

	7614 // _ut.test('test_shiftLeft_knownInt_knownString', () {

	7615 // final __test = new DartObjectImplTest();

	7616 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_knownString);

	7617 // });

7537 // _ut.test('test_shiftLeft_knownInt_tooLarge', () {	7618 // _ut.test('test_shiftLeft_knownInt_tooLarge', () {

7538 // final __test = new DartObjectImplTest();	7619 // final __test = new DartObjectImplTest();

7539 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_tooLarge);	7620 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_tooLarge);

7540 // });	7621 // });

7541 // _ut.test('test_shiftLeft_knownInt_unknownInt', () {	7622 // _ut.test('test_shiftLeft_knownInt_unknownInt', () {

7542 // final __test = new DartObjectImplTest();	7623 // final __test = new DartObjectImplTest();

7543 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_unknownInt);	7624 // runJUnitTest(__test, __test.test_shiftLeft_knownInt_unknownInt);

7544 // });	7625 // });

	7626 // _ut.test('test_shiftLeft_knownString_knownInt', () {

	7627 // final __test = new DartObjectImplTest();

	7628 // runJUnitTest(__test, __test.test_shiftLeft_knownString_knownInt);

	7629 // });

7545 // _ut.test('test_shiftLeft_unknownInt_knownInt', () {	7630 // _ut.test('test_shiftLeft_unknownInt_knownInt', () {

7546 // final __test = new DartObjectImplTest();	7631 // final __test = new DartObjectImplTest();

7547 // runJUnitTest(__test, __test.test_shiftLeft_unknownInt_knownInt);	7632 // runJUnitTest(__test, __test.test_shiftLeft_unknownInt_knownInt);

7548 // });	7633 // });

7549 // _ut.test('test_shiftLeft_unknownInt_unknownInt', () {	7634 // _ut.test('test_shiftLeft_unknownInt_unknownInt', () {

7550 // final __test = new DartObjectImplTest();	7635 // final __test = new DartObjectImplTest();

7551 // runJUnitTest(__test, __test.test_shiftLeft_unknownInt_unknownInt);	7636 // runJUnitTest(__test, __test.test_shiftLeft_unknownInt_unknownInt);

7552 // });	7637 // });

7553 // _ut.test('test_shiftRight_invalid_knownInt', () {

7554 // final __test = new DartObjectImplTest();

7555 // runJUnitTest(__test, __test.test_shiftRight_invalid_knownInt);

7556 // });

7557 // _ut.test('test_shiftRight_knownInt_invalid', () {

7558 // final __test = new DartObjectImplTest();

7559 // runJUnitTest(__test, __test.test_shiftRight_knownInt_invalid);

7560 // });

7561 // _ut.test('test_shiftRight_knownInt_knownInt', () {	7638 // _ut.test('test_shiftRight_knownInt_knownInt', () {

7562 // final __test = new DartObjectImplTest();	7639 // final __test = new DartObjectImplTest();

7563 // runJUnitTest(__test, __test.test_shiftRight_knownInt_knownInt);	7640 // runJUnitTest(__test, __test.test_shiftRight_knownInt_knownInt);

7564 // });	7641 // });

	7642 // _ut.test('test_shiftRight_knownInt_knownString', () {

	7643 // final __test = new DartObjectImplTest();

	7644 // runJUnitTest(__test, __test.test_shiftRight_knownInt_knownString);

	7645 // });

7565 // _ut.test('test_shiftRight_knownInt_tooLarge', () {	7646 // _ut.test('test_shiftRight_knownInt_tooLarge', () {

7566 // final __test = new DartObjectImplTest();	7647 // final __test = new DartObjectImplTest();

7567 // runJUnitTest(__test, __test.test_shiftRight_knownInt_tooLarge);	7648 // runJUnitTest(__test, __test.test_shiftRight_knownInt_tooLarge);

7568 // });	7649 // });

7569 // _ut.test('test_shiftRight_knownInt_unknownInt', () {	7650 // _ut.test('test_shiftRight_knownInt_unknownInt', () {

7570 // final __test = new DartObjectImplTest();	7651 // final __test = new DartObjectImplTest();

7571 // runJUnitTest(__test, __test.test_shiftRight_knownInt_unknownInt);	7652 // runJUnitTest(__test, __test.test_shiftRight_knownInt_unknownInt);

7572 // });	7653 // });

	7654 // _ut.test('test_shiftRight_knownString_knownInt', () {

	7655 // final __test = new DartObjectImplTest();

	7656 // runJUnitTest(__test, __test.test_shiftRight_knownString_knownInt);

	7657 // });

7573 // _ut.test('test_shiftRight_unknownInt_knownInt', () {	7658 // _ut.test('test_shiftRight_unknownInt_knownInt', () {

7574 // final __test = new DartObjectImplTest();	7659 // final __test = new DartObjectImplTest();

7575 // runJUnitTest(__test, __test.test_shiftRight_unknownInt_knownInt);	7660 // runJUnitTest(__test, __test.test_shiftRight_unknownInt_knownInt);

7576 // });	7661 // });

7577 // _ut.test('test_shiftRight_unknownInt_unknownInt', () {	7662 // _ut.test('test_shiftRight_unknownInt_unknownInt', () {

7578 // final __test = new DartObjectImplTest();	7663 // final __test = new DartObjectImplTest();

7579 // runJUnitTest(__test, __test.test_shiftRight_unknownInt_unknownInt);	7664 // runJUnitTest(__test, __test.test_shiftRight_unknownInt_unknownInt);

7580 // });	7665 // });

7581 // _ut.test('test_times_invalid_knownInt', () {	7666 // _ut.test('test_stringLength_int', () {

7582 // final __test = new DartObjectImplTest();	7667 // final __test = new DartObjectImplTest();

7583 // runJUnitTest(__test, __test.test_times_invalid_knownInt);	7668 // runJUnitTest(__test, __test.test_stringLength_int);

	7669 // });

	7670 // _ut.test('test_stringLength_knownString', () {

	7671 // final __test = new DartObjectImplTest();

	7672 // runJUnitTest(__test, __test.test_stringLength_knownString);

	7673 // });

	7674 // _ut.test('test_stringLength_unknownString', () {

	7675 // final __test = new DartObjectImplTest();

	7676 // runJUnitTest(__test, __test.test_stringLength_unknownString);

7584 // });	7677 // });

7585 // _ut.test('test_times_knownDouble_knownDouble', () {	7678 // _ut.test('test_times_knownDouble_knownDouble', () {

7586 // final __test = new DartObjectImplTest();	7679 // final __test = new DartObjectImplTest();

7587 // runJUnitTest(__test, __test.test_times_knownDouble_knownDouble);	7680 // runJUnitTest(__test, __test.test_times_knownDouble_knownDouble);

7588 // });	7681 // });

7589 // _ut.test('test_times_knownDouble_knownInt', () {	7682 // _ut.test('test_times_knownDouble_knownInt', () {

7590 // final __test = new DartObjectImplTest();	7683 // final __test = new DartObjectImplTest();

7591 // runJUnitTest(__test, __test.test_times_knownDouble_knownInt);	7684 // runJUnitTest(__test, __test.test_times_knownDouble_knownInt);

7592 // });	7685 // });

7593 // _ut.test('test_times_knownDouble_unknownDouble', () {	7686 // _ut.test('test_times_knownDouble_unknownDouble', () {

7594 // final __test = new DartObjectImplTest();	7687 // final __test = new DartObjectImplTest();

7595 // runJUnitTest(__test, __test.test_times_knownDouble_unknownDouble);	7688 // runJUnitTest(__test, __test.test_times_knownDouble_unknownDouble);

7596 // });	7689 // });

7597 // _ut.test('test_times_knownDouble_unknownInt', () {	7690 // _ut.test('test_times_knownDouble_unknownInt', () {

7598 // final __test = new DartObjectImplTest();	7691 // final __test = new DartObjectImplTest();

7599 // runJUnitTest(__test, __test.test_times_knownDouble_unknownInt);	7692 // runJUnitTest(__test, __test.test_times_knownDouble_unknownInt);

7600 // });	7693 // });

7601 // _ut.test('test_times_knownInt_invalid', () {

7602 // final __test = new DartObjectImplTest();

7603 // runJUnitTest(__test, __test.test_times_knownInt_invalid);

7604 // });

7605 // _ut.test('test_times_knownInt_knownInt', () {	7694 // _ut.test('test_times_knownInt_knownInt', () {

7606 // final __test = new DartObjectImplTest();	7695 // final __test = new DartObjectImplTest();

7607 // runJUnitTest(__test, __test.test_times_knownInt_knownInt);	7696 // runJUnitTest(__test, __test.test_times_knownInt_knownInt);

7608 // });	7697 // });

	7698 // _ut.test('test_times_knownInt_knownString', () {

	7699 // final __test = new DartObjectImplTest();

	7700 // runJUnitTest(__test, __test.test_times_knownInt_knownString);

	7701 // });

7609 // _ut.test('test_times_knownInt_unknownDouble', () {	7702 // _ut.test('test_times_knownInt_unknownDouble', () {

7610 // final __test = new DartObjectImplTest();	7703 // final __test = new DartObjectImplTest();

7611 // runJUnitTest(__test, __test.test_times_knownInt_unknownDouble);	7704 // runJUnitTest(__test, __test.test_times_knownInt_unknownDouble);

7612 // });	7705 // });

7613 // _ut.test('test_times_knownInt_unknownInt', () {	7706 // _ut.test('test_times_knownInt_unknownInt', () {

7614 // final __test = new DartObjectImplTest();	7707 // final __test = new DartObjectImplTest();

7615 // runJUnitTest(__test, __test.test_times_knownInt_unknownInt);	7708 // runJUnitTest(__test, __test.test_times_knownInt_unknownInt);

7616 // });	7709 // });

	7710 // _ut.test('test_times_knownString_knownInt', () {

	7711 // final __test = new DartObjectImplTest();

	7712 // runJUnitTest(__test, __test.test_times_knownString_knownInt);

	7713 // });

7617 // _ut.test('test_times_unknownDouble_knownDouble', () {	7714 // _ut.test('test_times_unknownDouble_knownDouble', () {

7618 // final __test = new DartObjectImplTest();	7715 // final __test = new DartObjectImplTest();

7619 // runJUnitTest(__test, __test.test_times_unknownDouble_knownDouble);	7716 // runJUnitTest(__test, __test.test_times_unknownDouble_knownDouble);

7620 // });	7717 // });

7621 // _ut.test('test_times_unknownDouble_knownInt', () {	7718 // _ut.test('test_times_unknownDouble_knownInt', () {

7622 // final __test = new DartObjectImplTest();	7719 // final __test = new DartObjectImplTest();

7623 // runJUnitTest(__test, __test.test_times_unknownDouble_knownInt);	7720 // runJUnitTest(__test, __test.test_times_unknownDouble_knownInt);

7624 // });	7721 // });

7625 // _ut.test('test_times_unknownInt_knownDouble', () {	7722 // _ut.test('test_times_unknownInt_knownDouble', () {

7626 // final __test = new DartObjectImplTest();	7723 // final __test = new DartObjectImplTest();

(...skipping 3931 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
11558 // "<script type=\"application/dart\">bar=2;</script>",	11655 // "<script type=\"application/dart\">bar=2;</script>",

11559 // "<script type=\"application/dart\" src=\"other.dart\"/>",	11656 // "<script type=\"application/dart\" src=\"other.dart\"/>",

11560 // "<script src=\"dart.js\"/>",	11657 // "<script src=\"dart.js\"/>",

11561 // "</html>"]));	11658 // "</html>"]));

11562 // _validate(element, [_s(_l([_v("bar")])), _s2("other.dart")]);	11659 // _validate(element, [_s(_l([_v("bar")])), _s2("other.dart")]);

11563 // }	11660 // }

11564 // @override	11661 // @override

11565 // void setUp() {	11662 // void setUp() {

11566 // _context = AnalysisContextFactory.contextWithCore();	11663 // _context = AnalysisContextFactory.contextWithCore();

11567 // }	11664 // }

	11665 // @override

	11666 // void tearDown() {

	11667 // _context = null;

	11668 // super.tearDown();

	11669 // }

11568 // HtmlUnitBuilderTest_ExpectedLibrary _l(List<HtmlUnitBuilderTest_ExpectedVar iable> expectedVariables) => new HtmlUnitBuilderTest_ExpectedLibrary(this, expec tedVariables);	11670 // HtmlUnitBuilderTest_ExpectedLibrary _l(List<HtmlUnitBuilderTest_ExpectedVar iable> expectedVariables) => new HtmlUnitBuilderTest_ExpectedLibrary(this, expec tedVariables);

11569 // HtmlElementImpl _build(String contents) {	11671 // HtmlElementImpl _build(String contents) {

11570 // TestSource source = new TestSource.con1(FileUtilities2.createFile("/test. html"), contents);	11672 // TestSource source = new TestSource.con1(FileUtilities2.createFile("/test. html"), contents);

11571 // ChangeSet changeSet = new ChangeSet();	11673 // ChangeSet changeSet = new ChangeSet();

11572 // changeSet.addedSource(source);	11674 // changeSet.addedSource(source);

11573 // _context.applyChanges(changeSet);	11675 // _context.applyChanges(changeSet);

11574 // HtmlUnitBuilder builder = new HtmlUnitBuilder(_context);	11676 // HtmlUnitBuilder builder = new HtmlUnitBuilder(_context);

11575 // return builder.buildHtmlElement(source, _context.getModificationStamp(sou rce), _context.parseHtmlUnit(source));	11677 // return builder.buildHtmlElement(source, _context.getModificationStamp(sou rce), _context.parseHtmlUnit(source));

11576 // }	11678 // }

11577 // HtmlUnitBuilderTest_ExpectedScript _s(HtmlUnitBuilderTest_ExpectedLibrary e xpectedLibrary) => new HtmlUnitBuilderTest_ExpectedScript.con1(expectedLibrary);	11679 // HtmlUnitBuilderTest_ExpectedScript _s(HtmlUnitBuilderTest_ExpectedLibrary e xpectedLibrary) => new HtmlUnitBuilderTest_ExpectedScript.con1(expectedLibrary);

(...skipping 140 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
11718 // "<script type='application/dart' src='other.dart'/>",	11820 // "<script type='application/dart' src='other.dart'/>",

11719 // "</html>"]), [HtmlWarningCode.URI_DOES_NOT_EXIST]);	11821 // "</html>"]), [HtmlWarningCode.URI_DOES_NOT_EXIST]);

11720 // _assertErrorLocation2(_errors[0], "other.dart");	11822 // _assertErrorLocation2(_errors[0], "other.dart");

11721 // }	11823 // }

11722 // @override	11824 // @override

11723 // void setUp() {	11825 // void setUp() {

11724 // _sourceFactory = new SourceFactory([new FileUriResolver()]);	11826 // _sourceFactory = new SourceFactory([new FileUriResolver()]);

11725 // _context = new AnalysisContextImpl();	11827 // _context = new AnalysisContextImpl();

11726 // _context.sourceFactory = _sourceFactory;	11828 // _context.sourceFactory = _sourceFactory;

11727 // }	11829 // }

	11830 // @override

	11831 // void tearDown() {

	11832 // _sourceFactory = null;

	11833 // _context = null;

	11834 // _contents = null;

	11835 // _errors = null;

	11836 // super.tearDown();

	11837 // }

11728 // void _assertErrorLocation(AnalysisError error, int expectedOffset, int expe ctedLength) {	11838 // void _assertErrorLocation(AnalysisError error, int expectedOffset, int expe ctedLength) {

11729 // JUnitTestCase.assertEqualsMsg(error.toString(), expectedOffset, error.off set);	11839 // JUnitTestCase.assertEqualsMsg(error.toString(), expectedOffset, error.off set);

11730 // JUnitTestCase.assertEqualsMsg(error.toString(), expectedLength, error.len gth);	11840 // JUnitTestCase.assertEqualsMsg(error.toString(), expectedLength, error.len gth);

11731 // }	11841 // }

11732 // void _assertErrorLocation2(AnalysisError error, String expectedString) {	11842 // void _assertErrorLocation2(AnalysisError error, String expectedString) {

11733 // _assertErrorLocation(error, _contents.indexOf(expectedString), expectedSt ring.length);	11843 // _assertErrorLocation(error, _contents.indexOf(expectedString), expectedSt ring.length);

11734 // }	11844 // }

11735 // void _verify(String contents, List<ErrorCode> expectedErrorCodes) {	11845 // void _verify(String contents, List<ErrorCode> expectedErrorCodes) {

11736 // this._contents = contents;	11846 // this._contents = contents;

11737 // TestSource source = new TestSource.con1(FileUtilities2.createFile("/test. html"), contents);	11847 // TestSource source = new TestSource.con1(FileUtilities2.createFile("/test. html"), contents);

(...skipping 1597 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
13335 // }	13445 // }

13336 // }	13446 // }

13337 // class TestAll {	13447 // class TestAll {

13338 // static Test suite() {	13448 // static Test suite() {

13339 // TestSuite suite = new ExtendedTestSuite("Tests in ${TestAll.getPackage(). getName()}");	13449 // TestSuite suite = new ExtendedTestSuite("Tests in ${TestAll.getPackage(). getName()}");

13340 // suite.addTestSuite(DeclarationMatcherTest);	13450 // suite.addTestSuite(DeclarationMatcherTest);

13341 // suite.addTestSuite(ElementResolverTest);	13451 // suite.addTestSuite(ElementResolverTest);

13342 // suite.addTestSuite(IncrementalResolverTest);	13452 // suite.addTestSuite(IncrementalResolverTest);

13343 // suite.addTestSuite(InheritanceManagerTest);	13453 // suite.addTestSuite(InheritanceManagerTest);

13344 // suite.addTestSuite(LibraryElementBuilderTest);	13454 // suite.addTestSuite(LibraryElementBuilderTest);

	13455 // suite.addTestSuite(LibraryResolver2Test);

	13456 // suite.addTestSuite(LibraryResolverTest);

13345 // suite.addTestSuite(LibraryTest);	13457 // suite.addTestSuite(LibraryTest);

13346 // suite.addTestSuite(StaticTypeAnalyzerTest);	13458 // suite.addTestSuite(StaticTypeAnalyzerTest);

13347 // suite.addTestSuite(SubtypeManagerTest);	13459 // suite.addTestSuite(SubtypeManagerTest);

13348 // suite.addTestSuite(TypeOverrideManagerTest);	13460 // suite.addTestSuite(TypeOverrideManagerTest);

13349 // suite.addTestSuite(TypeProviderImplTest);	13461 // suite.addTestSuite(TypeProviderImplTest);

13350 // suite.addTestSuite(TypeResolverVisitorTest);	13462 // suite.addTestSuite(TypeResolverVisitorTest);

13351 // return suite;	13463 // return suite;

13352 // }	13464 // }

13353 // }	13465 // }

13354 // class TestAll {	13466 // class TestAll {

(...skipping 51 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
13406 // suite.addTestSuite(NonErrorParserTest);	13518 // suite.addTestSuite(NonErrorParserTest);

13407 // suite.addTestSuite(RecoveryParserTest);	13519 // suite.addTestSuite(RecoveryParserTest);

13408 // suite.addTestSuite(ResolutionCopierTest);	13520 // suite.addTestSuite(ResolutionCopierTest);

13409 // suite.addTestSuite(SimpleParserTest);	13521 // suite.addTestSuite(SimpleParserTest);

13410 // return suite;	13522 // return suite;

13411 // }	13523 // }

13412 // }	13524 // }

13413 // class TestAll {	13525 // class TestAll {

13414 // static Test suite() {	13526 // static Test suite() {

13415 // TestSuite suite = new ExtendedTestSuite("Tests in ${TestAll.getPackage(). getName()}");	13527 // TestSuite suite = new ExtendedTestSuite("Tests in ${TestAll.getPackage(). getName()}");

	13528 // suite.addTestSuite(CheckedModeCompileTimeErrorCodeTest);

13416 // suite.addTestSuite(CompileTimeErrorCodeTest);	13529 // suite.addTestSuite(CompileTimeErrorCodeTest);

13417 // suite.addTestSuite(ErrorResolverTest);	13530 // suite.addTestSuite(ErrorResolverTest);

13418 // suite.addTestSuite(HintCodeTest);	13531 // suite.addTestSuite(HintCodeTest);

13419 // suite.addTestSuite(MemberMapTest);	13532 // suite.addTestSuite(MemberMapTest);

13420 // suite.addTestSuite(NonErrorResolverTest);	13533 // suite.addTestSuite(NonErrorResolverTest);

13421 // suite.addTestSuite(NonHintCodeTest);	13534 // suite.addTestSuite(NonHintCodeTest);

13422 // //suite.addTestSuite(PubSuggestionCodeTest.class);	13535 // //suite.addTestSuite(PubSuggestionCodeTest.class);

13423 // suite.addTestSuite(SimpleResolverTest);	13536 // suite.addTestSuite(SimpleResolverTest);

13424 // suite.addTestSuite(StaticTypeWarningCodeTest);	13537 // suite.addTestSuite(StaticTypeWarningCodeTest);

13425 // suite.addTestSuite(StaticWarningCodeTest);	13538 // suite.addTestSuite(StaticWarningCodeTest);

(...skipping 516 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
13942 // final List<String> _keyValuePairs;	14055 // final List<String> _keyValuePairs;

13943 // XmlValidator_Attributes(this._keyValuePairs);	14056 // XmlValidator_Attributes(this._keyValuePairs);

13944 // }	14057 // }

13945 // class XmlValidator_Tag {	14058 // class XmlValidator_Tag {

13946 // final String _tag;	14059 // final String _tag;

13947 // final XmlValidator_Attributes _attributes;	14060 // final XmlValidator_Attributes _attributes;

13948 // final String _content;	14061 // final String _content;

13949 // final List<XmlValidator_Tag> _children;	14062 // final List<XmlValidator_Tag> _children;

13950 // XmlValidator_Tag(this._tag, this._attributes, this._content, this._children );	14063 // XmlValidator_Tag(this._tag, this._attributes, this._content, this._children );

13951 // }	14064 // }

OLD	NEW

« no previous file with comments | « pkg/analyzer/pubspec.yaml ('k') | pkg/analyzer/test/generated/element_test.dart » ('j') | no next file with comments »