Fixes #1199. Change the way of checking of constants identity
diff --git a/Language/Expressions/Instance_Creation/Const/canonicalized_t03.dart b/Language/Expressions/Instance_Creation/Const/canonicalized_t03.dart
index dd0f82e..0c876d7 100644
--- a/Language/Expressions/Instance_Creation/Const/canonicalized_t03.dart
+++ b/Language/Expressions/Instance_Creation/Const/canonicalized_t03.dart
@@ -23,7 +23,7 @@
/// objects if all fields in constructed instances are identical.
/// @author msyabro
-import '../../../../Utils/expect.dart';
+import "../../../../Utils/expect.dart";
class A {
const A(): x = 1;
@@ -36,10 +36,7 @@
}
main() {
- var o = const A();
- for (int i = 0; i < 10; i++) {
- Expect.identical(o, const A());
- }
-
- Expect.identical(const B(const Object()), const B(const Object()));
+ const o = const A();
+ const CheckIdentical(o, const A());
+ const CheckIdentical(const B(const Object()), const B(const Object()));
}
diff --git a/Language/Expressions/Instance_Creation/Const/canonicalized_t04.dart b/Language/Expressions/Instance_Creation/Const/canonicalized_t04.dart
index cac9496..62630d9 100644
--- a/Language/Expressions/Instance_Creation/Const/canonicalized_t04.dart
+++ b/Language/Expressions/Instance_Creation/Const/canonicalized_t04.dart
@@ -32,14 +32,12 @@
}
main() {
- var o1 = const A(1);
- var o2 = const A(2);
- Expect.isFalse(identical(o1, o2));
+ const o1 = const A(1);
+ const o2 = const A(2);
+ const CheckNotIdentical(o1, o2);
- for (int i = 0; i < 10; i++) {
- Expect.identical(o1, const A(1));
- Expect.isFalse(identical(const A(1), o2));
- Expect.identical(o2, const A(2));
- Expect.isFalse(identical(const A(2), o1));
- }
+ const CheckIdentical(o1, const A(1));
+ const CheckNotIdentical(const A(1), o2);
+ const CheckIdentical(o2, const A(2));
+ const CheckNotIdentical(const A(2), o1);
}
diff --git a/Language/Expressions/Strings/escape_backspace_t01.dart b/Language/Expressions/Strings/escape_backspace_t01.dart
index 41f4168..4887c9c 100644
--- a/Language/Expressions/Strings/escape_backspace_t01.dart
+++ b/Language/Expressions/Strings/escape_backspace_t01.dart
@@ -12,8 +12,8 @@
import '../../../Utils/expect.dart';
main() {
- var escapeB = '\b';
- var escapeX = '\x08';
+ const escapeB = '\b';
+ const escapeX = '\x08';
- Expect.identical(escapeB, escapeX);
+ const CheckIdentical(escapeB, escapeX);
}
diff --git a/Language/Expressions/Strings/escape_carriage_return_t01.dart b/Language/Expressions/Strings/escape_carriage_return_t01.dart
index 292ac9e..fe55dc1 100644
--- a/Language/Expressions/Strings/escape_carriage_return_t01.dart
+++ b/Language/Expressions/Strings/escape_carriage_return_t01.dart
@@ -12,8 +12,8 @@
import '../../../Utils/expect.dart';
main() {
- var escapeR = '\r';
- var escapeX = '\x0D';
+ const escapeR = '\r';
+ const escapeX = '\x0D';
- Expect.identical(escapeR, escapeX);
+ const CheckIdentical(escapeR, escapeX);
}
diff --git a/Language/Expressions/Strings/escape_characters_t01.dart b/Language/Expressions/Strings/escape_characters_t01.dart
index f858b3d..6edab79 100644
--- a/Language/Expressions/Strings/escape_characters_t01.dart
+++ b/Language/Expressions/Strings/escape_characters_t01.dart
@@ -10,46 +10,45 @@
/// @description Checks that \k indicates the character k for any k not in
/// {n, r, f, b, t, v, x, u}.
/// @author msyabro
-/// @reviewer rodionov
import '../../../Utils/expect.dart';
main() {
- Expect.identical('\a', 'a');
- Expect.identical('\c', 'c');
- Expect.identical('\d', 'd');
- Expect.identical('\e', 'e');
- Expect.identical('\g', 'g');
- Expect.identical('\h', 'h');
- Expect.identical('\i', 'i');
- Expect.identical('\j', 'j');
- Expect.identical('\k', 'k');
- Expect.identical('\l', 'l');
- Expect.identical('\m', 'm');
- Expect.identical('\o', 'o');
- Expect.identical('\p', 'p');
- Expect.identical('\q', 'q');
- Expect.identical('\s', 's');
- Expect.identical('\w', 'w');
- Expect.identical('\y', 'y');
- Expect.identical('\z', 'z');
+ const CheckIdentical('\a', 'a');
+ const CheckIdentical('\c', 'c');
+ const CheckIdentical('\d', 'd');
+ const CheckIdentical('\e', 'e');
+ const CheckIdentical('\g', 'g');
+ const CheckIdentical('\h', 'h');
+ const CheckIdentical('\i', 'i');
+ const CheckIdentical('\j', 'j');
+ const CheckIdentical('\k', 'k');
+ const CheckIdentical('\l', 'l');
+ const CheckIdentical('\m', 'm');
+ const CheckIdentical('\o', 'o');
+ const CheckIdentical('\p', 'p');
+ const CheckIdentical('\q', 'q');
+ const CheckIdentical('\s', 's');
+ const CheckIdentical('\w', 'w');
+ const CheckIdentical('\y', 'y');
+ const CheckIdentical('\z', 'z');
- Expect.identical('\1', '1');
- Expect.identical('\2', '2');
- Expect.identical('\3', '3');
- Expect.identical('\4', '4');
- Expect.identical('\5', '5');
- Expect.identical('\6', '6');
- Expect.identical('\7', '7');
- Expect.identical('\8', '8');
- Expect.identical('\9', '9');
- Expect.identical('\0', '0');
+ const CheckIdentical('\1', '1');
+ const CheckIdentical('\2', '2');
+ const CheckIdentical('\3', '3');
+ const CheckIdentical('\4', '4');
+ const CheckIdentical('\5', '5');
+ const CheckIdentical('\6', '6');
+ const CheckIdentical('\7', '7');
+ const CheckIdentical('\8', '8');
+ const CheckIdentical('\9', '9');
+ const CheckIdentical('\0', '0');
- Expect.identical('\!', '!');
- Expect.identical('\@', '@');
- Expect.identical('\#', '#');
- Expect.identical('\%', '%');
- Expect.identical('\^', '^');
- Expect.identical('\&', '&');
- Expect.identical('\*', '*');
+ const CheckIdentical('\!', '!');
+ const CheckIdentical('\@', '@');
+ const CheckIdentical('\#', '#');
+ const CheckIdentical('\%', '%');
+ const CheckIdentical('\^', '^');
+ const CheckIdentical('\&', '&');
+ const CheckIdentical('\*', '*');
}
diff --git a/Language/Expressions/Strings/escape_form_feed_t01.dart b/Language/Expressions/Strings/escape_form_feed_t01.dart
index fed6c95..53aae32 100644
--- a/Language/Expressions/Strings/escape_form_feed_t01.dart
+++ b/Language/Expressions/Strings/escape_form_feed_t01.dart
@@ -12,8 +12,8 @@
import '../../../Utils/expect.dart';
main() {
- var escapeF = '\f';
- var escapeX = '\x0C';
+ const escapeF = '\f';
+ const escapeX = '\x0C';
- Expect.identical(escapeF, escapeX);
+ const CheckIdentical(escapeF, escapeX);
}
diff --git a/Language/Expressions/Strings/escape_hex_digit_t01.dart b/Language/Expressions/Strings/escape_hex_digit_t01.dart
index 3004ff3..b351dae 100644
--- a/Language/Expressions/Strings/escape_hex_digit_t01.dart
+++ b/Language/Expressions/Strings/escape_hex_digit_t01.dart
@@ -13,275 +13,275 @@
import '../../../Utils/expect.dart';
main() {
- Expect.identical('\x00', '\u{00}');
- Expect.identical('\x01', '\u{01}');
- Expect.identical('\x02', '\u{02}');
- Expect.identical('\x03', '\u{03}');
- Expect.identical('\x04', '\u{04}');
- Expect.identical('\x05', '\u{05}');
- Expect.identical('\x06', '\u{06}');
- Expect.identical('\x07', '\u{07}');
- Expect.identical('\x08', '\u{08}');
- Expect.identical('\x09', '\u{09}');
- Expect.identical('\x0a', '\u{0a}');
- Expect.identical('\x0B', '\u{0B}');
- Expect.identical('\x0C', '\u{0c}');
- Expect.identical('\x0D', '\u{0D}');
- Expect.identical('\x0e', '\u{0E}');
- Expect.identical('\x0f', '\u{0f}');
+ const CheckIdentical('\x00', '\u{00}');
+ const CheckIdentical('\x01', '\u{01}');
+ const CheckIdentical('\x02', '\u{02}');
+ const CheckIdentical('\x03', '\u{03}');
+ const CheckIdentical('\x04', '\u{04}');
+ const CheckIdentical('\x05', '\u{05}');
+ const CheckIdentical('\x06', '\u{06}');
+ const CheckIdentical('\x07', '\u{07}');
+ const CheckIdentical('\x08', '\u{08}');
+ const CheckIdentical('\x09', '\u{09}');
+ const CheckIdentical('\x0a', '\u{0a}');
+ const CheckIdentical('\x0B', '\u{0B}');
+ const CheckIdentical('\x0C', '\u{0c}');
+ const CheckIdentical('\x0D', '\u{0D}');
+ const CheckIdentical('\x0e', '\u{0E}');
+ const CheckIdentical('\x0f', '\u{0f}');
- Expect.identical('\x10', '\u{10}');
- Expect.identical('\x11', '\u{11}');
- Expect.identical('\x12', '\u{12}');
- Expect.identical('\x13', '\u{13}');
- Expect.identical('\x14', '\u{14}');
- Expect.identical('\x15', '\u{15}');
- Expect.identical('\x16', '\u{16}');
- Expect.identical('\x17', '\u{17}');
- Expect.identical('\x18', '\u{18}');
- Expect.identical('\x19', '\u{19}');
- Expect.identical('\x1a', '\u{1a}');
- Expect.identical('\x1B', '\u{1B}');
- Expect.identical('\x1C', '\u{1c}');
- Expect.identical('\x1D', '\u{1D}');
- Expect.identical('\x1e', '\u{1E}');
- Expect.identical('\x1f', '\u{1f}');
+ const CheckIdentical('\x10', '\u{10}');
+ const CheckIdentical('\x11', '\u{11}');
+ const CheckIdentical('\x12', '\u{12}');
+ const CheckIdentical('\x13', '\u{13}');
+ const CheckIdentical('\x14', '\u{14}');
+ const CheckIdentical('\x15', '\u{15}');
+ const CheckIdentical('\x16', '\u{16}');
+ const CheckIdentical('\x17', '\u{17}');
+ const CheckIdentical('\x18', '\u{18}');
+ const CheckIdentical('\x19', '\u{19}');
+ const CheckIdentical('\x1a', '\u{1a}');
+ const CheckIdentical('\x1B', '\u{1B}');
+ const CheckIdentical('\x1C', '\u{1c}');
+ const CheckIdentical('\x1D', '\u{1D}');
+ const CheckIdentical('\x1e', '\u{1E}');
+ const CheckIdentical('\x1f', '\u{1f}');
- Expect.identical('\x20', '\u{20}');
- Expect.identical('\x21', '\u{21}');
- Expect.identical('\x22', '\u{22}');
- Expect.identical('\x23', '\u{23}');
- Expect.identical('\x24', '\u{24}');
- Expect.identical('\x25', '\u{25}');
- Expect.identical('\x26', '\u{26}');
- Expect.identical('\x27', '\u{27}');
- Expect.identical('\x28', '\u{28}');
- Expect.identical('\x29', '\u{29}');
- Expect.identical('\x2a', '\u{2a}');
- Expect.identical('\x2B', '\u{2B}');
- Expect.identical('\x2C', '\u{2c}');
- Expect.identical('\x2D', '\u{2D}');
- Expect.identical('\x2e', '\u{2E}');
- Expect.identical('\x2f', '\u{2f}');
+ const CheckIdentical('\x20', '\u{20}');
+ const CheckIdentical('\x21', '\u{21}');
+ const CheckIdentical('\x22', '\u{22}');
+ const CheckIdentical('\x23', '\u{23}');
+ const CheckIdentical('\x24', '\u{24}');
+ const CheckIdentical('\x25', '\u{25}');
+ const CheckIdentical('\x26', '\u{26}');
+ const CheckIdentical('\x27', '\u{27}');
+ const CheckIdentical('\x28', '\u{28}');
+ const CheckIdentical('\x29', '\u{29}');
+ const CheckIdentical('\x2a', '\u{2a}');
+ const CheckIdentical('\x2B', '\u{2B}');
+ const CheckIdentical('\x2C', '\u{2c}');
+ const CheckIdentical('\x2D', '\u{2D}');
+ const CheckIdentical('\x2e', '\u{2E}');
+ const CheckIdentical('\x2f', '\u{2f}');
- Expect.identical('\x30', '\u{30}');
- Expect.identical('\x31', '\u{31}');
- Expect.identical('\x32', '\u{32}');
- Expect.identical('\x33', '\u{33}');
- Expect.identical('\x34', '\u{34}');
- Expect.identical('\x35', '\u{35}');
- Expect.identical('\x36', '\u{36}');
- Expect.identical('\x37', '\u{37}');
- Expect.identical('\x38', '\u{38}');
- Expect.identical('\x39', '\u{39}');
- Expect.identical('\x3a', '\u{3a}');
- Expect.identical('\x3B', '\u{3B}');
- Expect.identical('\x3C', '\u{3c}');
- Expect.identical('\x3D', '\u{3D}');
- Expect.identical('\x3e', '\u{3E}');
- Expect.identical('\x3f', '\u{3f}');
+ const CheckIdentical('\x30', '\u{30}');
+ const CheckIdentical('\x31', '\u{31}');
+ const CheckIdentical('\x32', '\u{32}');
+ const CheckIdentical('\x33', '\u{33}');
+ const CheckIdentical('\x34', '\u{34}');
+ const CheckIdentical('\x35', '\u{35}');
+ const CheckIdentical('\x36', '\u{36}');
+ const CheckIdentical('\x37', '\u{37}');
+ const CheckIdentical('\x38', '\u{38}');
+ const CheckIdentical('\x39', '\u{39}');
+ const CheckIdentical('\x3a', '\u{3a}');
+ const CheckIdentical('\x3B', '\u{3B}');
+ const CheckIdentical('\x3C', '\u{3c}');
+ const CheckIdentical('\x3D', '\u{3D}');
+ const CheckIdentical('\x3e', '\u{3E}');
+ const CheckIdentical('\x3f', '\u{3f}');
- Expect.identical('\x40', '\u{40}');
- Expect.identical('\x41', '\u{41}');
- Expect.identical('\x42', '\u{42}');
- Expect.identical('\x43', '\u{43}');
- Expect.identical('\x44', '\u{44}');
- Expect.identical('\x45', '\u{45}');
- Expect.identical('\x46', '\u{46}');
- Expect.identical('\x47', '\u{47}');
- Expect.identical('\x48', '\u{48}');
- Expect.identical('\x49', '\u{49}');
- Expect.identical('\x4a', '\u{4a}');
- Expect.identical('\x4B', '\u{4B}');
- Expect.identical('\x4C', '\u{4c}');
- Expect.identical('\x4D', '\u{4D}');
- Expect.identical('\x4e', '\u{4E}');
- Expect.identical('\x4f', '\u{4f}');
+ const CheckIdentical('\x40', '\u{40}');
+ const CheckIdentical('\x41', '\u{41}');
+ const CheckIdentical('\x42', '\u{42}');
+ const CheckIdentical('\x43', '\u{43}');
+ const CheckIdentical('\x44', '\u{44}');
+ const CheckIdentical('\x45', '\u{45}');
+ const CheckIdentical('\x46', '\u{46}');
+ const CheckIdentical('\x47', '\u{47}');
+ const CheckIdentical('\x48', '\u{48}');
+ const CheckIdentical('\x49', '\u{49}');
+ const CheckIdentical('\x4a', '\u{4a}');
+ const CheckIdentical('\x4B', '\u{4B}');
+ const CheckIdentical('\x4C', '\u{4c}');
+ const CheckIdentical('\x4D', '\u{4D}');
+ const CheckIdentical('\x4e', '\u{4E}');
+ const CheckIdentical('\x4f', '\u{4f}');
- Expect.identical('\x50', '\u{50}');
- Expect.identical('\x51', '\u{51}');
- Expect.identical('\x52', '\u{52}');
- Expect.identical('\x53', '\u{53}');
- Expect.identical('\x54', '\u{54}');
- Expect.identical('\x55', '\u{55}');
- Expect.identical('\x56', '\u{56}');
- Expect.identical('\x57', '\u{57}');
- Expect.identical('\x58', '\u{58}');
- Expect.identical('\x59', '\u{59}');
- Expect.identical('\x5a', '\u{5a}');
- Expect.identical('\x5B', '\u{5B}');
- Expect.identical('\x5C', '\u{5c}');
- Expect.identical('\x5D', '\u{5D}');
- Expect.identical('\x5e', '\u{5E}');
- Expect.identical('\x5f', '\u{5f}');
+ const CheckIdentical('\x50', '\u{50}');
+ const CheckIdentical('\x51', '\u{51}');
+ const CheckIdentical('\x52', '\u{52}');
+ const CheckIdentical('\x53', '\u{53}');
+ const CheckIdentical('\x54', '\u{54}');
+ const CheckIdentical('\x55', '\u{55}');
+ const CheckIdentical('\x56', '\u{56}');
+ const CheckIdentical('\x57', '\u{57}');
+ const CheckIdentical('\x58', '\u{58}');
+ const CheckIdentical('\x59', '\u{59}');
+ const CheckIdentical('\x5a', '\u{5a}');
+ const CheckIdentical('\x5B', '\u{5B}');
+ const CheckIdentical('\x5C', '\u{5c}');
+ const CheckIdentical('\x5D', '\u{5D}');
+ const CheckIdentical('\x5e', '\u{5E}');
+ const CheckIdentical('\x5f', '\u{5f}');
- Expect.identical('\x60', '\u{60}');
- Expect.identical('\x61', '\u{61}');
- Expect.identical('\x62', '\u{62}');
- Expect.identical('\x63', '\u{63}');
- Expect.identical('\x64', '\u{64}');
- Expect.identical('\x65', '\u{65}');
- Expect.identical('\x66', '\u{66}');
- Expect.identical('\x67', '\u{67}');
- Expect.identical('\x68', '\u{68}');
- Expect.identical('\x69', '\u{69}');
- Expect.identical('\x6a', '\u{6a}');
- Expect.identical('\x6B', '\u{6B}');
- Expect.identical('\x6C', '\u{6c}');
- Expect.identical('\x6D', '\u{6D}');
- Expect.identical('\x6e', '\u{6E}');
- Expect.identical('\x6f', '\u{6f}');
+ const CheckIdentical('\x60', '\u{60}');
+ const CheckIdentical('\x61', '\u{61}');
+ const CheckIdentical('\x62', '\u{62}');
+ const CheckIdentical('\x63', '\u{63}');
+ const CheckIdentical('\x64', '\u{64}');
+ const CheckIdentical('\x65', '\u{65}');
+ const CheckIdentical('\x66', '\u{66}');
+ const CheckIdentical('\x67', '\u{67}');
+ const CheckIdentical('\x68', '\u{68}');
+ const CheckIdentical('\x69', '\u{69}');
+ const CheckIdentical('\x6a', '\u{6a}');
+ const CheckIdentical('\x6B', '\u{6B}');
+ const CheckIdentical('\x6C', '\u{6c}');
+ const CheckIdentical('\x6D', '\u{6D}');
+ const CheckIdentical('\x6e', '\u{6E}');
+ const CheckIdentical('\x6f', '\u{6f}');
- Expect.identical('\x70', '\u{70}');
- Expect.identical('\x71', '\u{71}');
- Expect.identical('\x72', '\u{72}');
- Expect.identical('\x73', '\u{73}');
- Expect.identical('\x74', '\u{74}');
- Expect.identical('\x75', '\u{75}');
- Expect.identical('\x76', '\u{76}');
- Expect.identical('\x77', '\u{77}');
- Expect.identical('\x78', '\u{78}');
- Expect.identical('\x79', '\u{79}');
- Expect.identical('\x7a', '\u{7a}');
- Expect.identical('\x7B', '\u{7B}');
- Expect.identical('\x7C', '\u{7c}');
- Expect.identical('\x7D', '\u{7D}');
- Expect.identical('\x7e', '\u{7E}');
- Expect.identical('\x7f', '\u{7f}');
+ const CheckIdentical('\x70', '\u{70}');
+ const CheckIdentical('\x71', '\u{71}');
+ const CheckIdentical('\x72', '\u{72}');
+ const CheckIdentical('\x73', '\u{73}');
+ const CheckIdentical('\x74', '\u{74}');
+ const CheckIdentical('\x75', '\u{75}');
+ const CheckIdentical('\x76', '\u{76}');
+ const CheckIdentical('\x77', '\u{77}');
+ const CheckIdentical('\x78', '\u{78}');
+ const CheckIdentical('\x79', '\u{79}');
+ const CheckIdentical('\x7a', '\u{7a}');
+ const CheckIdentical('\x7B', '\u{7B}');
+ const CheckIdentical('\x7C', '\u{7c}');
+ const CheckIdentical('\x7D', '\u{7D}');
+ const CheckIdentical('\x7e', '\u{7E}');
+ const CheckIdentical('\x7f', '\u{7f}');
- Expect.identical('\x80', '\u{80}');
- Expect.identical('\x81', '\u{81}');
- Expect.identical('\x82', '\u{82}');
- Expect.identical('\x83', '\u{83}');
- Expect.identical('\x84', '\u{84}');
- Expect.identical('\x85', '\u{85}');
- Expect.identical('\x86', '\u{86}');
- Expect.identical('\x87', '\u{87}');
- Expect.identical('\x88', '\u{88}');
- Expect.identical('\x89', '\u{89}');
- Expect.identical('\x8a', '\u{8a}');
- Expect.identical('\x8B', '\u{8B}');
- Expect.identical('\x8C', '\u{8c}');
- Expect.identical('\x8D', '\u{8D}');
- Expect.identical('\x8e', '\u{8E}');
- Expect.identical('\x8f', '\u{8f}');
+ const CheckIdentical('\x80', '\u{80}');
+ const CheckIdentical('\x81', '\u{81}');
+ const CheckIdentical('\x82', '\u{82}');
+ const CheckIdentical('\x83', '\u{83}');
+ const CheckIdentical('\x84', '\u{84}');
+ const CheckIdentical('\x85', '\u{85}');
+ const CheckIdentical('\x86', '\u{86}');
+ const CheckIdentical('\x87', '\u{87}');
+ const CheckIdentical('\x88', '\u{88}');
+ const CheckIdentical('\x89', '\u{89}');
+ const CheckIdentical('\x8a', '\u{8a}');
+ const CheckIdentical('\x8B', '\u{8B}');
+ const CheckIdentical('\x8C', '\u{8c}');
+ const CheckIdentical('\x8D', '\u{8D}');
+ const CheckIdentical('\x8e', '\u{8E}');
+ const CheckIdentical('\x8f', '\u{8f}');
- Expect.identical('\x90', '\u{90}');
- Expect.identical('\x91', '\u{91}');
- Expect.identical('\x92', '\u{92}');
- Expect.identical('\x93', '\u{93}');
- Expect.identical('\x94', '\u{94}');
- Expect.identical('\x95', '\u{95}');
- Expect.identical('\x96', '\u{96}');
- Expect.identical('\x97', '\u{97}');
- Expect.identical('\x98', '\u{98}');
- Expect.identical('\x99', '\u{99}');
- Expect.identical('\x9a', '\u{9a}');
- Expect.identical('\x9B', '\u{9B}');
- Expect.identical('\x9C', '\u{9c}');
- Expect.identical('\x9D', '\u{9D}');
- Expect.identical('\x9e', '\u{9E}');
- Expect.identical('\x9f', '\u{9f}');
+ const CheckIdentical('\x90', '\u{90}');
+ const CheckIdentical('\x91', '\u{91}');
+ const CheckIdentical('\x92', '\u{92}');
+ const CheckIdentical('\x93', '\u{93}');
+ const CheckIdentical('\x94', '\u{94}');
+ const CheckIdentical('\x95', '\u{95}');
+ const CheckIdentical('\x96', '\u{96}');
+ const CheckIdentical('\x97', '\u{97}');
+ const CheckIdentical('\x98', '\u{98}');
+ const CheckIdentical('\x99', '\u{99}');
+ const CheckIdentical('\x9a', '\u{9a}');
+ const CheckIdentical('\x9B', '\u{9B}');
+ const CheckIdentical('\x9C', '\u{9c}');
+ const CheckIdentical('\x9D', '\u{9D}');
+ const CheckIdentical('\x9e', '\u{9E}');
+ const CheckIdentical('\x9f', '\u{9f}');
- Expect.identical('\xA0', '\u{A0}');
- Expect.identical('\xA1', '\u{A1}');
- Expect.identical('\xA2', '\u{A2}');
- Expect.identical('\xA3', '\u{A3}');
- Expect.identical('\xA4', '\u{A4}');
- Expect.identical('\xA5', '\u{A5}');
- Expect.identical('\xA6', '\u{A6}');
- Expect.identical('\xA7', '\u{A7}');
- Expect.identical('\xA8', '\u{A8}');
- Expect.identical('\xA9', '\u{A9}');
- Expect.identical('\xAa', '\u{Aa}');
- Expect.identical('\xAB', '\u{AB}');
- Expect.identical('\xAC', '\u{Ac}');
- Expect.identical('\xAD', '\u{AD}');
- Expect.identical('\xAe', '\u{AE}');
- Expect.identical('\xAf', '\u{Af}');
+ const CheckIdentical('\xA0', '\u{A0}');
+ const CheckIdentical('\xA1', '\u{A1}');
+ const CheckIdentical('\xA2', '\u{A2}');
+ const CheckIdentical('\xA3', '\u{A3}');
+ const CheckIdentical('\xA4', '\u{A4}');
+ const CheckIdentical('\xA5', '\u{A5}');
+ const CheckIdentical('\xA6', '\u{A6}');
+ const CheckIdentical('\xA7', '\u{A7}');
+ const CheckIdentical('\xA8', '\u{A8}');
+ const CheckIdentical('\xA9', '\u{A9}');
+ const CheckIdentical('\xAa', '\u{Aa}');
+ const CheckIdentical('\xAB', '\u{AB}');
+ const CheckIdentical('\xAC', '\u{Ac}');
+ const CheckIdentical('\xAD', '\u{AD}');
+ const CheckIdentical('\xAe', '\u{AE}');
+ const CheckIdentical('\xAf', '\u{Af}');
- Expect.identical('\xb0', '\u{b0}');
- Expect.identical('\xb1', '\u{b1}');
- Expect.identical('\xb2', '\u{b2}');
- Expect.identical('\xb3', '\u{b3}');
- Expect.identical('\xb4', '\u{b4}');
- Expect.identical('\xb5', '\u{b5}');
- Expect.identical('\xb6', '\u{b6}');
- Expect.identical('\xb7', '\u{b7}');
- Expect.identical('\xb8', '\u{b8}');
- Expect.identical('\xb9', '\u{b9}');
- Expect.identical('\xba', '\u{ba}');
- Expect.identical('\xbB', '\u{bB}');
- Expect.identical('\xbC', '\u{bc}');
- Expect.identical('\xbD', '\u{bD}');
- Expect.identical('\xbe', '\u{bE}');
- Expect.identical('\xbf', '\u{bf}');
+ const CheckIdentical('\xb0', '\u{b0}');
+ const CheckIdentical('\xb1', '\u{b1}');
+ const CheckIdentical('\xb2', '\u{b2}');
+ const CheckIdentical('\xb3', '\u{b3}');
+ const CheckIdentical('\xb4', '\u{b4}');
+ const CheckIdentical('\xb5', '\u{b5}');
+ const CheckIdentical('\xb6', '\u{b6}');
+ const CheckIdentical('\xb7', '\u{b7}');
+ const CheckIdentical('\xb8', '\u{b8}');
+ const CheckIdentical('\xb9', '\u{b9}');
+ const CheckIdentical('\xba', '\u{ba}');
+ const CheckIdentical('\xbB', '\u{bB}');
+ const CheckIdentical('\xbC', '\u{bc}');
+ const CheckIdentical('\xbD', '\u{bD}');
+ const CheckIdentical('\xbe', '\u{bE}');
+ const CheckIdentical('\xbf', '\u{bf}');
- Expect.identical('\xc0', '\u{c0}');
- Expect.identical('\xc1', '\u{c1}');
- Expect.identical('\xc2', '\u{c2}');
- Expect.identical('\xc3', '\u{c3}');
- Expect.identical('\xc4', '\u{c4}');
- Expect.identical('\xc5', '\u{c5}');
- Expect.identical('\xc6', '\u{c6}');
- Expect.identical('\xc7', '\u{c7}');
- Expect.identical('\xc8', '\u{c8}');
- Expect.identical('\xc9', '\u{c9}');
- Expect.identical('\xca', '\u{ca}');
- Expect.identical('\xcB', '\u{cB}');
- Expect.identical('\xcC', '\u{cc}');
- Expect.identical('\xcD', '\u{cD}');
- Expect.identical('\xce', '\u{cE}');
- Expect.identical('\xcf', '\u{cf}');
+ const CheckIdentical('\xc0', '\u{c0}');
+ const CheckIdentical('\xc1', '\u{c1}');
+ const CheckIdentical('\xc2', '\u{c2}');
+ const CheckIdentical('\xc3', '\u{c3}');
+ const CheckIdentical('\xc4', '\u{c4}');
+ const CheckIdentical('\xc5', '\u{c5}');
+ const CheckIdentical('\xc6', '\u{c6}');
+ const CheckIdentical('\xc7', '\u{c7}');
+ const CheckIdentical('\xc8', '\u{c8}');
+ const CheckIdentical('\xc9', '\u{c9}');
+ const CheckIdentical('\xca', '\u{ca}');
+ const CheckIdentical('\xcB', '\u{cB}');
+ const CheckIdentical('\xcC', '\u{cc}');
+ const CheckIdentical('\xcD', '\u{cD}');
+ const CheckIdentical('\xce', '\u{cE}');
+ const CheckIdentical('\xcf', '\u{cf}');
- Expect.identical('\xD0', '\u{D0}');
- Expect.identical('\xD1', '\u{D1}');
- Expect.identical('\xD2', '\u{D2}');
- Expect.identical('\xD3', '\u{D3}');
- Expect.identical('\xD4', '\u{D4}');
- Expect.identical('\xD5', '\u{D5}');
- Expect.identical('\xD6', '\u{D6}');
- Expect.identical('\xD7', '\u{D7}');
- Expect.identical('\xD8', '\u{D8}');
- Expect.identical('\xD9', '\u{D9}');
- Expect.identical('\xDa', '\u{Da}');
- Expect.identical('\xDB', '\u{DB}');
- Expect.identical('\xDC', '\u{Dc}');
- Expect.identical('\xDD', '\u{DD}');
- Expect.identical('\xDe', '\u{DE}');
- Expect.identical('\xDf', '\u{Df}');
+ const CheckIdentical('\xD0', '\u{D0}');
+ const CheckIdentical('\xD1', '\u{D1}');
+ const CheckIdentical('\xD2', '\u{D2}');
+ const CheckIdentical('\xD3', '\u{D3}');
+ const CheckIdentical('\xD4', '\u{D4}');
+ const CheckIdentical('\xD5', '\u{D5}');
+ const CheckIdentical('\xD6', '\u{D6}');
+ const CheckIdentical('\xD7', '\u{D7}');
+ const CheckIdentical('\xD8', '\u{D8}');
+ const CheckIdentical('\xD9', '\u{D9}');
+ const CheckIdentical('\xDa', '\u{Da}');
+ const CheckIdentical('\xDB', '\u{DB}');
+ const CheckIdentical('\xDC', '\u{Dc}');
+ const CheckIdentical('\xDD', '\u{DD}');
+ const CheckIdentical('\xDe', '\u{DE}');
+ const CheckIdentical('\xDf', '\u{Df}');
- Expect.identical('\xE0', '\u{E0}');
- Expect.identical('\xE1', '\u{E1}');
- Expect.identical('\xE2', '\u{E2}');
- Expect.identical('\xE3', '\u{E3}');
- Expect.identical('\xE4', '\u{E4}');
- Expect.identical('\xE5', '\u{E5}');
- Expect.identical('\xE6', '\u{E6}');
- Expect.identical('\xE7', '\u{E7}');
- Expect.identical('\xE8', '\u{E8}');
- Expect.identical('\xE9', '\u{E9}');
- Expect.identical('\xEa', '\u{Ea}');
- Expect.identical('\xEB', '\u{EB}');
- Expect.identical('\xEC', '\u{Ec}');
- Expect.identical('\xED', '\u{ED}');
- Expect.identical('\xEe', '\u{EE}');
- Expect.identical('\xEf', '\u{Ef}');
+ const CheckIdentical('\xE0', '\u{E0}');
+ const CheckIdentical('\xE1', '\u{E1}');
+ const CheckIdentical('\xE2', '\u{E2}');
+ const CheckIdentical('\xE3', '\u{E3}');
+ const CheckIdentical('\xE4', '\u{E4}');
+ const CheckIdentical('\xE5', '\u{E5}');
+ const CheckIdentical('\xE6', '\u{E6}');
+ const CheckIdentical('\xE7', '\u{E7}');
+ const CheckIdentical('\xE8', '\u{E8}');
+ const CheckIdentical('\xE9', '\u{E9}');
+ const CheckIdentical('\xEa', '\u{Ea}');
+ const CheckIdentical('\xEB', '\u{EB}');
+ const CheckIdentical('\xEC', '\u{Ec}');
+ const CheckIdentical('\xED', '\u{ED}');
+ const CheckIdentical('\xEe', '\u{EE}');
+ const CheckIdentical('\xEf', '\u{Ef}');
- Expect.identical('\xf0', '\u{f0}');
- Expect.identical('\xf1', '\u{f1}');
- Expect.identical('\xf2', '\u{f2}');
- Expect.identical('\xf3', '\u{f3}');
- Expect.identical('\xf4', '\u{f4}');
- Expect.identical('\xf5', '\u{f5}');
- Expect.identical('\xf6', '\u{f6}');
- Expect.identical('\xf7', '\u{f7}');
- Expect.identical('\xf8', '\u{f8}');
- Expect.identical('\xf9', '\u{f9}');
- Expect.identical('\xfa', '\u{fa}');
- Expect.identical('\xfB', '\u{fB}');
- Expect.identical('\xfC', '\u{fc}');
- Expect.identical('\xfD', '\u{fD}');
- Expect.identical('\xfe', '\u{fE}');
- Expect.identical('\xff', '\u{ff}');
+ const CheckIdentical('\xf0', '\u{f0}');
+ const CheckIdentical('\xf1', '\u{f1}');
+ const CheckIdentical('\xf2', '\u{f2}');
+ const CheckIdentical('\xf3', '\u{f3}');
+ const CheckIdentical('\xf4', '\u{f4}');
+ const CheckIdentical('\xf5', '\u{f5}');
+ const CheckIdentical('\xf6', '\u{f6}');
+ const CheckIdentical('\xf7', '\u{f7}');
+ const CheckIdentical('\xf8', '\u{f8}');
+ const CheckIdentical('\xf9', '\u{f9}');
+ const CheckIdentical('\xfa', '\u{fa}');
+ const CheckIdentical('\xfB', '\u{fB}');
+ const CheckIdentical('\xfC', '\u{fc}');
+ const CheckIdentical('\xfD', '\u{fD}');
+ const CheckIdentical('\xfe', '\u{fE}');
+ const CheckIdentical('\xff', '\u{ff}');
}
diff --git a/Language/Expressions/Strings/escape_newline_t01.dart b/Language/Expressions/Strings/escape_newline_t01.dart
index 79c67bc..abe1ed4 100644
--- a/Language/Expressions/Strings/escape_newline_t01.dart
+++ b/Language/Expressions/Strings/escape_newline_t01.dart
@@ -11,12 +11,12 @@
import '../../../Utils/expect.dart';
main() {
- var escapeN = '\n';
- var escapeX = '\x0A';
- var newline = """
+ const escapeN = '\n';
+ const escapeX = '\x0A';
+ const newline = """
""";
- Expect.identical(escapeN, escapeX);
- Expect.identical(escapeN, newline);
+ const CheckIdentical(escapeN, escapeX);
+ const CheckIdentical(escapeN, newline);
}
diff --git a/Language/Expressions/Strings/escape_tab_t01.dart b/Language/Expressions/Strings/escape_tab_t01.dart
index e6548f4..12ba6dd 100644
--- a/Language/Expressions/Strings/escape_tab_t01.dart
+++ b/Language/Expressions/Strings/escape_tab_t01.dart
@@ -12,8 +12,8 @@
import '../../../Utils/expect.dart';
main() {
- var escapeT = '\t';
- var escapeX = '\x09';
+ const escapeT = '\t';
+ const escapeX = '\x09';
- Expect.identical(escapeT, escapeX);
+ const CheckIdentical(escapeT, escapeX);
}
diff --git a/Language/Expressions/Strings/escape_unicode_scalar_value_t01.dart b/Language/Expressions/Strings/escape_unicode_scalar_value_t01.dart
index 7df703f..ab48ced 100644
--- a/Language/Expressions/Strings/escape_unicode_scalar_value_t01.dart
+++ b/Language/Expressions/Strings/escape_unicode_scalar_value_t01.dart
@@ -19,43 +19,43 @@
import '../../../Utils/expect.dart';
main() {
- Expect.identical('\u{61}', 'a');
- Expect.identical('\u{62}', 'b');
- Expect.identical('\u{63}', 'c');
- Expect.identical('\u{64}', 'd');
+ const CheckIdentical('\u{61}', 'a');
+ const CheckIdentical('\u{62}', 'b');
+ const CheckIdentical('\u{63}', 'c');
+ const CheckIdentical('\u{64}', 'd');
- Expect.identical('\u{41}', 'A');
- Expect.identical('\u{42}', 'B');
- Expect.identical('\u{43}', 'C');
- Expect.identical('\u{44}', 'D');
+ const CheckIdentical('\u{41}', 'A');
+ const CheckIdentical('\u{42}', 'B');
+ const CheckIdentical('\u{43}', 'C');
+ const CheckIdentical('\u{44}', 'D');
- Expect.identical('\u{31}', '1');
- Expect.identical('\u{32}', '2');
- Expect.identical('\u{33}', '3');
- Expect.identical('\u{34}', '4');
+ const CheckIdentical('\u{31}', '1');
+ const CheckIdentical('\u{32}', '2');
+ const CheckIdentical('\u{33}', '3');
+ const CheckIdentical('\u{34}', '4');
- Expect.identical('\u{100}', 'Ā');
- Expect.identical('\u{101}', 'ā');
- Expect.identical('\u{102}', 'Ă');
- Expect.identical('\u{103}', 'ă');
+ const CheckIdentical('\u{100}', 'Ā');
+ const CheckIdentical('\u{101}', 'ā');
+ const CheckIdentical('\u{102}', 'Ă');
+ const CheckIdentical('\u{103}', 'ă');
- Expect.identical('\u{1E60}', 'Ṡ');
- Expect.identical('\u{1E61}', 'ṡ');
- Expect.identical('\u{1E62}', 'Ṣ');
- Expect.identical('\u{1E63}', 'ṣ');
+ const CheckIdentical('\u{1E60}', 'Ṡ');
+ const CheckIdentical('\u{1E61}', 'ṡ');
+ const CheckIdentical('\u{1E62}', 'Ṣ');
+ const CheckIdentical('\u{1E63}', 'ṣ');
- Expect.identical('\u{2295}', '⊕');
- Expect.identical('\u{2296}', '⊖');
- Expect.identical('\u{2297}', '⊗');
- Expect.identical('\u{2298}', '⊘');
+ const CheckIdentical('\u{2295}', '⊕');
+ const CheckIdentical('\u{2296}', '⊖');
+ const CheckIdentical('\u{2297}', '⊗');
+ const CheckIdentical('\u{2298}', '⊘');
- Expect.identical('\u{df}', 'ß');
- Expect.identical('\u{b5}', 'µ');
- Expect.identical('\u{ae}', '®');
- Expect.identical('\u{a5}', '¥');
+ const CheckIdentical('\u{df}', 'ß');
+ const CheckIdentical('\u{b5}', 'µ');
+ const CheckIdentical('\u{ae}', '®');
+ const CheckIdentical('\u{a5}', '¥');
- Expect.identical('\u{a5}', '\u{0000a5}');
- Expect.identical('\u{a5}', '\u{000a5}');
- Expect.identical('\u{a5}', '\u{00a5}');
- Expect.identical('\u{a5}', '\u{0a5}');
+ const CheckIdentical('\u{a5}', '\u{0000a5}');
+ const CheckIdentical('\u{a5}', '\u{000a5}');
+ const CheckIdentical('\u{a5}', '\u{00a5}');
+ const CheckIdentical('\u{a5}', '\u{0a5}');
}
diff --git a/Language/Expressions/Strings/escape_unicode_t01.dart b/Language/Expressions/Strings/escape_unicode_t01.dart
index 0cab59a..1fdb3ae 100644
--- a/Language/Expressions/Strings/escape_unicode_t01.dart
+++ b/Language/Expressions/Strings/escape_unicode_t01.dart
@@ -14,27 +14,27 @@
import '../../../Utils/expect.dart';
main() {
- Expect.identical('\u0000', '\u{0000}');
- Expect.identical('\u0001', '\u{0001}');
- Expect.identical('\u0002', '\u{0002}');
- Expect.identical('\u0003', '\u{0003}');
- Expect.identical('\u0004', '\u{0004}');
- Expect.identical('\u0005', '\u{0005}');
- Expect.identical('\u0006', '\u{0006}');
- Expect.identical('\u0007', '\u{0007}');
- Expect.identical('\u0008', '\u{0008}');
- Expect.identical('\u0009', '\u{0009}');
- Expect.identical('\u000a', '\u{000a}');
- Expect.identical('\u000B', '\u{000B}');
- Expect.identical('\u000C', '\u{000c}');
- Expect.identical('\u000D', '\u{000D}');
- Expect.identical('\u000e', '\u{000E}');
- Expect.identical('\u000f', '\u{000f}');
+ const CheckIdentical('\u0000', '\u{0000}');
+ const CheckIdentical('\u0001', '\u{0001}');
+ const CheckIdentical('\u0002', '\u{0002}');
+ const CheckIdentical('\u0003', '\u{0003}');
+ const CheckIdentical('\u0004', '\u{0004}');
+ const CheckIdentical('\u0005', '\u{0005}');
+ const CheckIdentical('\u0006', '\u{0006}');
+ const CheckIdentical('\u0007', '\u{0007}');
+ const CheckIdentical('\u0008', '\u{0008}');
+ const CheckIdentical('\u0009', '\u{0009}');
+ const CheckIdentical('\u000a', '\u{000a}');
+ const CheckIdentical('\u000B', '\u{000B}');
+ const CheckIdentical('\u000C', '\u{000c}');
+ const CheckIdentical('\u000D', '\u{000D}');
+ const CheckIdentical('\u000e', '\u{000E}');
+ const CheckIdentical('\u000f', '\u{000f}');
- Expect.identical('\uabcd', '\u{ABCD}');
- Expect.identical('\u1f1f', '\u{1f1f}');
- Expect.identical('\ua0b0', '\u{a0b0}');
- Expect.identical('\u1a12', '\u{1a12}');
- Expect.identical('\uEEEE', '\u{EEEE}');
- Expect.identical('\uffff', '\u{ffff}');
+ const CheckIdentical('\uabcd', '\u{ABCD}');
+ const CheckIdentical('\u1f1f', '\u{1f1f}');
+ const CheckIdentical('\ua0b0', '\u{a0b0}');
+ const CheckIdentical('\u1a12', '\u{1a12}');
+ const CheckIdentical('\uEEEE', '\u{EEEE}');
+ const CheckIdentical('\uffff', '\u{ffff}');
}
diff --git a/Language/Expressions/Strings/escape_vertical_tab_t01.dart b/Language/Expressions/Strings/escape_vertical_tab_t01.dart
index 4164223..0c92247 100644
--- a/Language/Expressions/Strings/escape_vertical_tab_t01.dart
+++ b/Language/Expressions/Strings/escape_vertical_tab_t01.dart
@@ -12,8 +12,8 @@
import '../../../Utils/expect.dart';
main() {
- var escapeV = '\v';
- var escapeX = '\x0B';
+ const escapeV = '\v';
+ const escapeX = '\x0B';
- Expect.identical(escapeV, escapeX);
+ const CheckIdentical(escapeV, escapeX);
}
diff --git a/Language/Expressions/Symbols/syntax_t01.dart b/Language/Expressions/Symbols/syntax_t01.dart
index afe4f72..0805c92 100644
--- a/Language/Expressions/Symbols/syntax_t01.dart
+++ b/Language/Expressions/Symbols/syntax_t01.dart
@@ -20,8 +20,8 @@
import '../../../Utils/expect.dart';
main() {
- Expect.identical(const Symbol('foo'), #foo);
- Expect.identical(const Symbol(r'foo_.bar123$'), #foo_.bar123$);
+ const CheckIdentical(const Symbol('foo'), #foo);
+ const CheckIdentical(const Symbol(r'foo_.bar123$'), #foo_.bar123$);
}
diff --git a/Language/Expressions/Symbols/syntax_t02.dart b/Language/Expressions/Symbols/syntax_t02.dart
index 7347791..b66e75e 100644
--- a/Language/Expressions/Symbols/syntax_t02.dart
+++ b/Language/Expressions/Symbols/syntax_t02.dart
@@ -17,36 +17,35 @@
/// and it is equivalent to corresponding const Symbol object.
/// @author ilya
-
import '../../../Utils/expect.dart';
main() {
- Expect.identical(const Symbol('~'), #~);
- Expect.identical(const Symbol('=='), #==);
- Expect.identical(const Symbol('[]'), #[]);
- Expect.identical(const Symbol('[]='), #[]=);
+ const CheckIdentical(const Symbol('~'), #~);
+ const CheckIdentical(const Symbol('=='), #==);
+ const CheckIdentical(const Symbol('[]'), #[]);
+ const CheckIdentical(const Symbol('[]='), #[]=);
- Expect.identical(const Symbol('*'), #*);
- Expect.identical(const Symbol('/'), #/);
- Expect.identical(const Symbol('%'), #%);
- Expect.identical(const Symbol('~/'), #~/);
+ const CheckIdentical(const Symbol('*'), #*);
+ const CheckIdentical(const Symbol('/'), #/);
+ const CheckIdentical(const Symbol('%'), #%);
+ const CheckIdentical(const Symbol('~/'), #~/);
- Expect.identical(const Symbol('+'), #+);
- Expect.identical(const Symbol('-'), #-);
+ const CheckIdentical(const Symbol('+'), #+);
+ const CheckIdentical(const Symbol('-'), #-);
- Expect.identical(const Symbol('<<'), #<<);
- Expect.identical(const Symbol('>>'), #>>);
+ const CheckIdentical(const Symbol('<<'), #<<);
+ const CheckIdentical(const Symbol('>>'), #>>);
- Expect.identical(const Symbol('>>>'), #>>>);
+ const CheckIdentical(const Symbol('>>>'), #>>>);
- Expect.identical(const Symbol('<'), #<);
- Expect.identical(const Symbol('<='), #<=);
- Expect.identical(const Symbol('>'), #>);
- Expect.identical(const Symbol('>='), #>=);
+ const CheckIdentical(const Symbol('<'), #<);
+ const CheckIdentical(const Symbol('<='), #<=);
+ const CheckIdentical(const Symbol('>'), #>);
+ const CheckIdentical(const Symbol('>='), #>=);
- Expect.identical(const Symbol('&'), #&);
- Expect.identical(const Symbol('^'), #^);
- Expect.identical(const Symbol('|'), #|);
+ const CheckIdentical(const Symbol('&'), #&);
+ const CheckIdentical(const Symbol('^'), #^);
+ const CheckIdentical(const Symbol('|'), #|);
}
diff --git a/Language/Expressions/Symbols/syntax_t03.dart b/Language/Expressions/Symbols/syntax_t03.dart
deleted file mode 100644
index a16bff8..0000000
--- a/Language/Expressions/Symbols/syntax_t03.dart
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-/// @assertion A symbol literal denotes the name of a declaration in a Dart
-/// program.
-/// symbolLiteral:
-/// `#' (operator | (identifier (`.' identifier)*))
-/// ;
-/// A symbol literal #id where id does not begin with an underscore (_) is
-/// equivalent to the expression const Symbol(id).
-/// A symbol literal #_id evaluates to the object that would be returned by
-/// the call mirror.getPrivateSymbol(id) where mirror is an instance of the
-/// class LibraryMirror defined in the library dart:mirrors, reflecting the
-/// current library.
-/// @description Checks that symbol literal whose name starts with an
-/// underscore evaluates to the object returned by mirror.getPrivateSymbol(id)
-/// @note Test is commented out. Language tests should not import extra libraries.
-/// @author ilya
-
-
-/*
-library test;
-
-import "dart:mirrors";
-import "../../Utils/expect.dart";
-
-var _private;
-
-main() {
- var l = currentMirrorSystem().findLibrary(#test).first;
- //print(l.getPrivateSymbol); // can't check, method not implemented
-}
-*/
-
-main() {
-}
-
diff --git a/Language/Variables/constant_initialization_t02.dart b/Language/Variables/constant_initialization_t02.dart
index 9429be9..f8a8fa5 100644
--- a/Language/Variables/constant_initialization_t02.dart
+++ b/Language/Variables/constant_initialization_t02.dart
@@ -8,12 +8,11 @@
/// is initialized to a non compile-time constant.
/// @author msyabro
-import "../../Utils/expect.dart";
-
class Foo {}
const Foo foo = new Foo();
// ^
// [analyzer] unspecified
// [cfe] unspecified
-main() {}
+main() {
+}
diff --git a/Language/Variables/constant_initialization_t03.dart b/Language/Variables/constant_initialization_t03.dart
index adbe867..539c0dc 100644
--- a/Language/Variables/constant_initialization_t03.dart
+++ b/Language/Variables/constant_initialization_t03.dart
@@ -9,7 +9,6 @@
/// @author msyabro
import "../../Utils/expect.dart";
-
import "dart:math" as Math;
class Foo {
@@ -20,20 +19,20 @@
const bool b = false;
const String s = "string";
const double pi = Math.pi;
-const Foo foo = const Foo();
-const List<int> l = const [0, 1, 2, 3];
-const Map<String, int> m = const {'a': 1, 'b': 2};
+const Foo foo = Foo();
+const List<int> l = [0, 1, 2, 3];
+const Map<String, int> m = {'a': 1, 'b': 2};
const bool bOr = true || false;
const int iPlus = 5 + i;
main() {
- Expect.identical(-100, i);
- Expect.identical(false, b);
- Expect.identical("string", s);
- Expect.identical(Math.pi, pi);
- Expect.identical(const Foo(), foo);
- Expect.identical(const [0, 1, 2, 3], l);
- Expect.identical(const {'a': 1, 'b': 2}, m);
- Expect.identical(true || false, bOr);
- Expect.identical(-95, iPlus);
+ const CheckIdentical(-100, i);
+ const CheckIdentical(false, b);
+ const CheckIdentical("string", s);
+ const CheckIdentical(Math.pi, pi);
+ const CheckIdentical(Foo(), foo);
+ const CheckIdentical([0, 1, 2, 3], l);
+ const CheckIdentical({'a': 1, 'b': 2}, m);
+ const CheckIdentical(true || false, bOr);
+ const CheckIdentical(-95, iPlus);
}
diff --git a/Language/Variables/constant_initialization_t04.dart b/Language/Variables/constant_initialization_t04.dart
new file mode 100644
index 0000000..e3f386c
--- /dev/null
+++ b/Language/Variables/constant_initialization_t04.dart
@@ -0,0 +1,28 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion A constant variable must be initialized to a compile-time
+/// constant or a compile-time error occurs.
+///
+/// @description Checks that it is a compile time error if constant variable is
+/// initialized by not a compile-time constant.
+/// @author sgrekhov@unipro.ru
+
+class Foo {
+ int get length => 42;
+ const Foo();
+}
+
+main() {
+ const f = Foo();
+ const l1 = f.length;
+// ^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ const b = 42.isEven;
+// ^^^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/Language/Variables/constant_initialization_t05.dart b/Language/Variables/constant_initialization_t05.dart
new file mode 100644
index 0000000..9f6fbce
--- /dev/null
+++ b/Language/Variables/constant_initialization_t05.dart
@@ -0,0 +1,18 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// @assertion A constant variable must be initialized to a compile-time
+/// constant or a compile-time error occurs.
+/// @description Checks that constant variables can be initialized by
+/// `String.length`.
+/// @author sgrekhov@unipro.ru
+
+import "../../Utils/expect.dart";
+
+const int l = "string".length;
+
+main() {
+ const CheckIdentical(6, l);
+ const CheckIdentical("string".length, l);
+}
diff --git a/Language/Variables/constant_variable_t09.dart b/Language/Variables/constant_variable_t09.dart
index 324eaef..cc48912 100644
--- a/Language/Variables/constant_variable_t09.dart
+++ b/Language/Variables/constant_variable_t09.dart
@@ -23,13 +23,13 @@
const String e = "OneTwo";
const y = 2;
- Expect.identical(-100, i);
- Expect.identical(false, b);
- Expect.identical("string", s);
- Expect.identical(Math.pi, pi);
- Expect.identical(const [0, 1, 2, 3], l);
- Expect.identical(const {'a': 1, 'b': 2}, m);
- Expect.identical("OneTwo", e);
- Expect.identical(1, x);
- Expect.identical(2, y);
+ const CheckIdentical(-100, i);
+ const CheckIdentical(false, b);
+ const CheckIdentical("string", s);
+ const CheckIdentical(Math.pi, pi);
+ const CheckIdentical(const [0, 1, 2, 3], l);
+ const CheckIdentical(const {'a': 1, 'b': 2}, m);
+ const CheckIdentical("OneTwo", e);
+ const CheckIdentical(1, x);
+ const CheckIdentical(2, y);
}
diff --git a/Language/Variables/implicit_setter_t03.dart b/Language/Variables/implicit_setter_t03.dart
index e9a3f75..c03f712 100644
--- a/Language/Variables/implicit_setter_t03.dart
+++ b/Language/Variables/implicit_setter_t03.dart
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
/// @assertion A non-final variable declaration of the form var v;
-/// or the form var v = e; always induces an implicit setter function
+/// or the form var v = e; always induces an implicit setter function
/// with signature
/// set v = (x)
/// whose execution sets the value of v to the incoming argument x.
@@ -14,7 +14,7 @@
import "../../Utils/expect.dart";
class A {}
-
+
//--library static variables
var x1;
var x2 = null;
@@ -23,7 +23,7 @@
//--instance variables
var y1;
var y2 = null;
-
+
//--class static variables
static var z1;
static var z2 = null;
@@ -32,14 +32,20 @@
main() {
A a = new A();
- x1 = a; Expect.identical(x1, a);
- x2 = a; Expect.identical(x2, a);
+ x1 = a;
+ Expect.identical(x1, a);
+ x2 = a;
+ Expect.identical(x2, a);
C c = new C();
-
- c.y1 = a; Expect.identical(c.y1, a);
- c.y2 = a; Expect.identical(c.y2, a);
- C.z1 = a; Expect.identical(C.z1, a);
- C.z2 = a; Expect.identical(C.z2, a);
+ c.y1 = a;
+ Expect.identical(c.y1, a);
+ c.y2 = a;
+ Expect.identical(c.y2, a);
+
+ C.z1 = a;
+ Expect.identical(C.z1, a);
+ C.z2 = a;
+ Expect.identical(C.z2, a);
}
diff --git a/Language/Variables/implicit_setter_void_t07.dart b/Language/Variables/implicit_setter_void_t07.dart
index fc71c40..2fe89ce 100644
--- a/Language/Variables/implicit_setter_void_t07.dart
+++ b/Language/Variables/implicit_setter_void_t07.dart
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
/// @assertion A non-final variable declaration of the form T v;
-/// or the form T v = e; always induces an implicit setter function
+/// or the form T v = e; always induces an implicit setter function
/// with signature
/// void set v = (T x)
/// whose execution sets the value of v to the incoming argument x.
@@ -14,7 +14,7 @@
import "../../Utils/expect.dart";
class A {}
-
+
//--library static variables
A? x1;
A x2 = new A();
@@ -23,7 +23,7 @@
//--instance variables
A? y1;
A y2 = new A();
-
+
//--class static variables
static A? z1;
static A z2 = new A();
@@ -31,14 +31,20 @@
main() {
A a = new A();
- x1 = a; Expect.identical(x1, a);
- x2 = a; Expect.identical(x2, a);
+ x1 = a;
+ Expect.identical(x1, a);
+ x2 = a;
+ Expect.identical(x2, a);
C c = new C();
-
- c.y1 = a; Expect.identical(c.y1, a);
- c.y2 = a; Expect.identical(c.y2, a);
- C.z1 = a; Expect.identical(C.z1, a);
- C.z2 = a; Expect.identical(C.z2, a);
+ c.y1 = a;
+ Expect.identical(c.y1, a);
+ c.y2 = a;
+ Expect.identical(c.y2, a);
+
+ C.z1 = a;
+ Expect.identical(C.z1, a);
+ C.z2 = a;
+ Expect.identical(C.z2, a);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t01.dart b/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t01.dart
index 2bc962b..b019ad8 100644
--- a/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t01.dart
+++ b/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t01.dart
@@ -45,14 +45,14 @@
main() {
const e1 = foo<int>;
const e2 = foo<int>;
- Expect.identical(e1, e2);
+ const CheckIdentical(e1, e2);
const e3 = bar<int>;
Expect.notEquals(e3, e1);
const e4 = C.stat1<int>;
const e5 = C.stat1<int>;
- Expect.identical(e4, e5);
+ const CheckIdentical(e4, e5);
Expect.notEquals(e1, e4);
const e6 = C.stat2<int>;
@@ -60,7 +60,7 @@
const e7 = Ext.estat1<int>;
const e8 = Ext.estat1<int>;
- Expect.identical(e7, e8);
+ const CheckIdentical(e7, e8);
Expect.notEquals(e7, e1);
Expect.notEquals(e7, e4);
@@ -74,7 +74,7 @@
const e11 = M.mstat1<int>;
const e12 = M.mstat1<int>;
- Expect.identical(e11, e12);
+ const CheckIdentical(e11, e12);
Expect.notEquals(e7, e11);
Expect.notEquals(e4, e11);
Expect.notEquals(e1, e11);
diff --git a/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t03.dart b/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t03.dart
index 4a0a390..f21ada8 100644
--- a/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/function_tearoffs_A03_t03.dart
@@ -38,22 +38,22 @@
main() {
const e1 = foo<int>;
const e2 = foo<IntAlias>;
- Expect.identical(e1, e2);
+ const CheckIdentical(e1, e2);
const e4 = C.stat<int>;
const e5 = C.stat<IntAlias>;
- Expect.identical(e4, e5);
+ const CheckIdentical(e4, e5);
Expect.notEquals(e2, e4);
const e7 = Ext.estat<int>;
const e8 = Ext.estat<IntAlias>;
- Expect.identical(e7, e8);
+ const CheckIdentical(e7, e8);
Expect.notEquals(e7, e2);
Expect.notEquals(e7, e5);
const e9 = M.mstat<int>;
const e10 = M.mstat<IntAlias>;
- Expect.identical(e9, e10);
+ const CheckIdentical(e9, e10);
Expect.notEquals(e9, e2);
Expect.notEquals(e9, e5);
Expect.notEquals(e9, e8);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t01.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t01.dart
index 6523b68..7798128 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t01.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t01.dart
@@ -21,8 +21,8 @@
}
main() {
- var v1 = C.new;
- var v2 = C.new;
+ const v1 = C.new;
+ const v2 = C.new;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t02.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t02.dart
index c607316..38b8106 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t02.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t02.dart
@@ -23,20 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.name3;
- var v8 = C.name3;
+ const v7 = C.name3;
+ const v8 = C.name3;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t03.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t03.dart
index e0548d7..dc5661a 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t03.dart
@@ -24,20 +24,20 @@
}
main() {
- var v1 = C.new;
- var v2 = C.new;
+ const v1 = C.new;
+ const v2 = C.new;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.constr1;
var v5 = C.constr1;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.constr2;
- var v8 = C.constr2;
+ const v7 = C.constr2;
+ const v8 = C.constr2;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t04.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t04.dart
index eedc192..622a0c7 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t04.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t04.dart
@@ -23,19 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.name3;
- var v8 = C.name3;
+ const v7 = C.name3;
+ const v8 = C.name3;
Expect.equals(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t05.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t05.dart
index 5a9bc86..ca4a38e 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t05.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t05.dart
@@ -23,20 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.name3;
- var v8 = C.name3;
+ const v7 = C.name3;
+ const v8 = C.name3;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t06.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t06.dart
index a6fde6e..d06887b 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t06.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t06.dart
@@ -24,20 +24,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t07.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t07.dart
index 3cc6cd9..0727385 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t07.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t07.dart
@@ -24,20 +24,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t08.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t08.dart
index 161d941..da2b88b 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t08.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t08.dart
@@ -24,20 +24,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t09.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t09.dart
index 4f11ffc..31d38c3 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t09.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t09.dart
@@ -23,20 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t10.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t10.dart
index 60aafba..accb2ca 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t10.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t10.dart
@@ -23,20 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t11.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t11.dart
index 2861013..7ccdb64 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t11.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t11.dart
@@ -23,20 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t12.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t12.dart
index ca5135b..3989dff 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t12.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t12.dart
@@ -23,20 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t13.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t13.dart
index 4c858a5..349055b 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t13.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t13.dart
@@ -23,20 +23,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t14.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t14.dart
index 330dcc5..88cd97f 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t14.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t14.dart
@@ -24,20 +24,20 @@
}
main() {
- var v1 = C.name1;
- var v2 = C.name1;
+ const v1 = C.name1;
+ const v2 = C.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C.name2;
var v5 = C.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C.new;
- var v8 = C.new;
+ const v7 = C.new;
+ const v8 = C.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t15.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t15.dart
index 21ab0df..0d23259 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t15.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A07_t15.dart
@@ -24,20 +24,20 @@
}
main() {
- var v1 = C<int>.name1;
- var v2 = C<int>.name1;
+ const v1 = C<int>.name1;
+ const v2 = C<int>.name1;
Expect.equals(v1, v2);
- Expect.identical(v1, v2);
+ const CheckIdentical(v1, v2);
var v4 = C<int>.name2;
var v5 = C<int>.name2;
Expect.equals(v4, v5);
Expect.identical(v4, v5);
- var v7 = C<int>.new;
- var v8 = C<int>.new;
+ const v7 = C<int>.new;
+ const v8 = C<int>.new;
Expect.equals(v7, v8);
- Expect.identical(v7, v8);
+ const CheckIdentical(v7, v8);
Expect.notEquals(v1, v4);
Expect.notEquals(v2, v7);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A08_t02.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A08_t02.dart
index 7d37515..9ea3686 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A08_t02.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A08_t02.dart
@@ -33,10 +33,10 @@
const v7 = MyClass<int>.new;
const v8 = MyClass<String>.constr;
- Expect.identical(v1, v5);
- Expect.identical(v2, v6);
- Expect.identical(v3, v7);
- Expect.identical(v4, v8);
+ const CheckIdentical(v1, v5);
+ const CheckIdentical(v2, v6);
+ const CheckIdentical(v3, v7);
+ const CheckIdentical(v4, v8);
var c1 = v1(3, 14);
var c2 = v1(3, 14);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t01.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t01.dart
index cbe8bf9..29b852b 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t01.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t01.dart
@@ -36,10 +36,10 @@
Expect.equals(v3, v4);
Expect.identical(v3, v4);
- var v5 = C.constr2;
- var v6 = (C.constr2);
+ const v5 = C.constr2;
+ const v6 = (C.constr2);
Expect.equals(v5, v6);
- Expect.identical(v5, v6);
+ const CheckIdentical(v5, v6);
var v7 = C.constr3;
var v8 = (C.constr3);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t02.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t02.dart
index 4a92e39..d7ff0a3 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t02.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t02.dart
@@ -36,10 +36,10 @@
Expect.equals(v3, v4);
Expect.identical(v3, v4);
- var v5 = C.constr2;
- var v6 = (C.constr2);
+ const v5 = C.constr2;
+ const v6 = (C.constr2);
Expect.equals(v5, v6);
- Expect.identical(v5, v6);
+ const CheckIdentical(v5, v6);
var v7 = C.constr3;
var v8 = (C.constr3);
diff --git a/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t03.dart b/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t03.dart
index a7f7baa..e9044fb 100644
--- a/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/named_constructor_A09_t03.dart
@@ -36,10 +36,10 @@
Expect.equals(v4, v6);
Expect.identical(v4, v6);
- var v7 = C<Null>.constr2;
- var v9 = (C.constr2)<Null>;
+ const v7 = C<Null>.constr2;
+ const v9 = (C.constr2)<Null>;
Expect.equals(v7, v9);
- Expect.identical(v7, v9);
+ const CheckIdentical(v7, v9);
var v10 = C<List>.constr3;
var v12 = (C.constr3)<List>;
diff --git a/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A03_t07.dart b/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A03_t07.dart
index f4bc75f..ec97d00 100644
--- a/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A03_t07.dart
+++ b/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A03_t07.dart
@@ -11,6 +11,7 @@
/// constant and canonicalized when the alias is instantiated.
///
/// @author iarkh@unipro.ru
+/// @issue 47267
// SharedOptions=--enable-experiment=constructor-tearoffs
@@ -26,12 +27,12 @@
Expect.identical(v1, v2);
Expect.identical(v1, v3);
- var v4 = MyList<int>.filled;
- var v5 = MyList<int>.filled;
- var v6 = (MyList.filled)<int>;
+ const v4 = MyList<int>.filled;
+ const v5 = MyList<int>.filled;
+ const v6 = (MyList.filled)<int>;
- Expect.identical(v4, v5);
- Expect.identical(v4, v6);
+ const CheckIdentical(v4, v5);
+ const CheckIdentical(v4, v6);
Expect.notEquals(v1, v4);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t02.dart b/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t02.dart
index 570dabe..adb8ff6 100644
--- a/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t02.dart
+++ b/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t02.dart
@@ -21,9 +21,9 @@
main() {
var v1 = IntList.filled;
- var v2 = IntList.filled;
- var v3 = IntList.filled;
+ const v2 = IntList.filled;
+ const v3 = IntList.filled;
Expect.identical(v1, v2);
- Expect.identical(v1, v3);
+ const CheckIdentical(v2, v3);
}
diff --git a/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t03.dart b/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t03.dart
index 86284d2..a145338 100644
--- a/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t03.dart
+++ b/LanguageFeatures/Constructor-tear-offs/tearing_off_from_typedef_A04_t03.dart
@@ -29,11 +29,11 @@
testList() {
var v1 = IntList.filled;
- var v2 = IntList.filled;
- var v3 = IntList.filled;
+ const v2 = IntList.filled;
+ const v3 = IntList.filled;
Expect.identical(v1, v2);
- Expect.identical(v1, v3);
+ const CheckIdentical(v2, v3);
var v4 = (IntList.filled);
Expect.identical(v1, v4);
diff --git a/Utils/expect_common.dart b/Utils/expect_common.dart
index da4ade1..4e384d0 100644
--- a/Utils/expect_common.dart
+++ b/Utils/expect_common.dart
@@ -350,3 +350,12 @@
/// Is true iff js compiler is used
final bool isJS = identical(1.0, 1);
+
+/// Checks that objects are identical at the compile time
+class CheckIdentical {
+ const CheckIdentical(Object? o1, Object? o2) : assert(identical(o1, o2));
+}
+/// Checks that objects are not identical at the compile time
+class CheckNotIdentical {
+ const CheckNotIdentical(Object? o1, Object? o2) : assert(!identical(o1, o2));
+}
