dart-lang#1401. [Patterns] relational pattern tests added

Author: sgrekhov

LanguageFeatures/Patterns/relational_A01_t01.dart

@@ -0,0 +1,56 @@
+// Copyright (c) 2022, 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 relationalPattern ::=
+///   ( equalityOperator | relationalOperator) relationalExpression
+///
+/// A relational pattern lets you compare the matched value to a given constant
+/// using any of the equality or relational operators: ==, !=, <, >, <=, and >=.
+/// The pattern matches when calling the appropriate operator on the matched
+/// value with the constant as an argument returns true. It is a compile-time
+/// error if relationalExpression is not a valid constant expression.
+///
+/// @description Checks a relational pattern in a switch expression
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+String test1(num num) {
+  return switch (num) {
+    case < 0 => "negative";
+    case == 0 => "zero";
+    case > 0 => "positive";
+    default => "Impossible!";
+  };
+}
+
+String test2(double num) {
+  return switch (num) {
+    case != 0 => "non-zero";
+    case == 0 => "zero";
+    default => "Impossible!";
+  };
+}
+
+String test3(int num) {
+  return switch (num) {
+    case >= 1 => "positive";
+    case <= 0 => "zero or negative";
+    default => "Impossible!";
+  };
+}
+
+main() {
+  Expect.equals("negative", test1(-1.1));
+  Expect.equals("positive", test1(42));
+  Expect.equals("zero", test1(0));
+  Expect.equals("non-zero", test2(3.14));
+  Expect.equals("zero", test2(0));
+  Expect.equals("zero or negative", test3(0));
+  Expect.equals("zero or negative", test3(-1));
+  Expect.equals("positive", test3(1));
+  Expect.equals("positive", test3(42));
+}

LanguageFeatures/Patterns/relational_A01_t02.dart

@@ -0,0 +1,37 @@
+// Copyright (c) 2022, 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 relationalPattern ::=
+///   ( equalityOperator | relationalOperator) relationalExpression
+///
+/// A relational pattern lets you compare the matched value to a given constant
+/// using any of the equality or relational operators: ==, !=, <, >, <=, and >=.
+/// The pattern matches when calling the appropriate operator on the matched
+/// value with the constant as an argument returns true. It is a compile-time
+/// error if relationalExpression is not a valid constant expression.
+///
+/// @description Checks a relational subpattern in a switch expression
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+String test(List<num> list) => switch (list) {
+  case [> 0 & <= 2] => "case 1";
+  case [== 42] => "case 2";
+  case [>= 10 & < 20] => "case 3";
+  case [!= 100] => "case 4";
+  default => "default";
+};
+
+main() {
+  Expect.equals("case 1", test([1.1]));
+  Expect.equals("case 1", test([2]));
+  Expect.equals("case 2", test([42]));
+  Expect.equals("case 3", test([10]));
+  Expect.equals("case 3", test([11.1]));
+  Expect.equals("case 4", test([20]));
+  Expect.equals("default", test([100]));
+}

LanguageFeatures/Patterns/relational_A02_t01.dart

@@ -0,0 +1,73 @@
+// Copyright (c) 2022, 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 relationalPattern ::=
+///   ( equalityOperator | relationalOperator) relationalExpression
+///
+/// A relational pattern lets you compare the matched value to a given constant
+/// using any of the equality or relational operators: ==, !=, <, >, <=, and >=.
+/// The pattern matches when calling the appropriate operator on the matched
+/// value with the constant as an argument returns true. It is a compile-time
+/// error if relationalExpression is not a valid constant expression.
+///
+/// @description Checks a relational pattern in a switch statement
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+void test1(double value, String expected) {
+  switch (value) {
+    case < 0:
+      Expect.equals("negative", expected);
+      break;
+    case == 0:
+      Expect.equals("zero", expected);
+      break;
+    case > 0:
+      Expect.equals("positive", expected);
+      break;
+    default:
+      Expect.fail("One of the cases above should match");
+  }
+}
+
+void test2(num value, String expected) {
+  switch (value) {
+    case != 0:
+      Expect.equals("non-zero", expected);
+      break;
+    case == 0:
+      Expect.equals("zero", expected);
+      break;
+    default:
+      Expect.fail("One of the cases above should match");
+  }
+}
+
+void test3(int value, String expected) {
+  switch (value) {
+    case >= 1:
+      Expect.equals("positive", expected);
+      break;
+    case <= 0:
+      Expect.equals("zero or negative", expected);
+      break;
+    default:
+      Expect.fail("One of the cases above should match");
+  }
+}
+
+main() {
+  test1(-1.1, "negative");
+  test1(42.42, "positive");
+  test1(0, "zero");
+  test2(3.14, "non-zero");
+  test2(0, "zero");
+  test3(0, "zero or negative");
+  test3(-100, "zero or negative");
+  test3(1, "positive");
+  test3(42, "positive");
+}

LanguageFeatures/Patterns/relational_A02_t02.dart

@@ -0,0 +1,48 @@
+// Copyright (c) 2022, 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 relationalPattern ::=
+///   ( equalityOperator | relationalOperator) relationalExpression
+///
+/// A relational pattern lets you compare the matched value to a given constant
+/// using any of the equality or relational operators: ==, !=, <, >, <=, and >=.
+/// The pattern matches when calling the appropriate operator on the matched
+/// value with the constant as an argument returns true. It is a compile-time
+/// error if relationalExpression is not a valid constant expression.
+///
+/// @description Checks a relational subpattern in a switch statement
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+import "../../Utils/expect.dart";
+
+void test(List<num> list, String expected) {
+  switch (list) {
+    case [> 0 & <= 2]:
+      Expect.equals("case 1", expected);
+      break;
+    case [== 42]:
+      Expect.equals("case 2", expected);
+      break;
+    case [>= 10 & < 20]:
+      Expect.equals("case 3", expected);
+      break;
+    case [!= 100]:
+      Expect.equals("case 4", expected);
+      break;
+    default:
+      Expect.equals("default", expected);
+  }
+}
+
+main() {
+  test([1], "case 1");
+  test([2], "case 1");
+  test([2.1], "case 2");
+  test([10], "case 3");
+  test([10.1], "case 3");
+  test([20], "case 4");
+  test([100], "default");
+}

LanguageFeatures/Patterns/relational_A03_t01.dart

@@ -0,0 +1,57 @@
+// Copyright (c) 2022, 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 relationalPattern ::=
+///   ( equalityOperator | relationalOperator) relationalExpression
+///
+/// A relational pattern lets you compare the matched value to a given constant
+/// using any of the equality or relational operators: ==, !=, <, >, <=, and >=.
+/// The pattern matches when calling the appropriate operator on the matched
+/// value with the constant as an argument returns true. It is a compile-time
+/// error if relationalExpression is not a valid constant expression.
+///
+/// @description Check that it is a compile-time error if relationalExpression
+/// is not a valid constant expression. Test switch statement
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+main() {
+  int i = 0;
+  int value = 42;
+
+  switch (value) {
+    case < i:
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+      break;
+    case == 0 + i:
+//          ^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+      break;
+    case > i++:
+//         ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+      break;
+    default:
+  }
+
+  final j = 0;
+  switch (value) {
+    case != j:
+//          ^
+// [analyzer] unspecified
+// [cfe] unspecified
+      break;
+    case == j:
+//          ^
+// [analyzer] unspecified
+// [cfe] unspecified
+      break;
+    default:
+  }
+}

LanguageFeatures/Patterns/relational_A03_t02.dart

@@ -0,0 +1,57 @@
+// Copyright (c) 2022, 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 relationalPattern ::=
+///   ( equalityOperator | relationalOperator) relationalExpression
+///
+/// A relational pattern lets you compare the matched value to a given constant
+/// using any of the equality or relational operators: ==, !=, <, >, <=, and >=.
+/// The pattern matches when calling the appropriate operator on the matched
+/// value with the constant as an argument returns true. It is a compile-time
+/// error if relationalExpression is not a valid constant expression.
+///
+/// @description Check that it is a compile-time error if relationalExpression
+/// is not a valid constant expression. Test switch expression
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=patterns
+
+String test1(int num) {
+  int i = 0;
+  return switch (num) {
+    case < i => "negative";
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case == i => "zero";
+//          ^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case > i => "positive";
+//         ^
+// [analyzer] unspecified
+// [cfe] unspecified
+    default => "Impossible!";
+  };
+}
+
+String test2(int num) {
+  final j = 0;
+  return switch (num) {
+    case != j => "non-zero";
+//          ^
+// [analyzer] unspecified
+// [cfe] unspecified
+    case == j => "zero";
+//          ^
+// [analyzer] unspecified
+// [cfe] unspecified
+    default => "Impossible!";
+  };
+}
+
+main() {
+  test1(1);
+  test2(2);
+}