LanguageFeatures/Patterns/pattern_context_A07_t01.dart

// Copyright (c) 2023, 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
/// You can also use var _ or final _ to write a wildcard in a matching context
/// because it would require additional specification to explicitly forbid it,
/// but doing so is discouraged.
///
/// @description Checks that var _ or final _ can be used as a wildcard in a
/// matching context. Test switch statement
/// @author sgrekhov22@gmail.com

import "../../Utils/expect.dart";
import "patterns_lib.dart";

String testLogicalOr1(int x) {
  switch (x) {
    case var _ || var _:
      return "match";
    default:
      return "no match";
  }
}

String testLogicalOr2(int x) {
  switch (x) {
    case final _ || final _:
      return "match";
    default:
      return "no match";
  }
}

String testLogicalOr3(int x) {
  switch (x) {
    case final int _ || final int _:
      return "match";
    default:
      return "no match";
  }
}

String testLogicalOr4(int x) {
  switch (x) {
    case int _ || int _:
      return "match";
    default:
      return "no match";
  }
}

String testLogicalAnd1(int x) {
  switch (x) {
    case var _ && var _:
      return "match";
    default:
      return "no match";
  }
}

String testLogicalAnd2(int x) {
  switch (x) {
    case final _ && final _:
      return "match";
    default:
      return "no match";
  }
}

String testLogicalAnd3(int x) {
  switch (x) {
    case final int _ && final int _:
      return "match";
    default:
      return "no match";
  }
}

String testLogicalAnd4(int x) {
  switch (x) {
    case int _ && int _:
      return "match";
    default:
      return "no match";
  }
}

String testCast1(num x) {
  switch (x) {
    case var _ as int:
      return "match";
  }
}

String testCast2(num x) {
  switch (x) {
    case final _ as int:
      return "match";
  }
}

String testCast3(num x) {
  switch (x) {
    case num _ as int:
      return "match";
  }
}

String testCast4(num x) {
  switch (x) {
    case final int _ as int:
      return "match";
  }
}

String testNullCheck1(int? x) {
  switch (x) {
    case var _?:
      return "match";
    default:
      return "no match";
  }
}

String testNullCheck2(int? x) {
  switch (x) {
    case final _?:
      return "match";
    default:
      return "no match";
  }
}

String testNullCheck3(int? x) {
  switch (x) {
    case int _?:
      return "match";
    default:
      return "no match";
  }
}

String testNullCheck4(int? x) {
  switch (x) {
    case final int _?:
      return "match";
    default:
      return "no match";
  }
}

String testNullAssert1(int? x) {
  switch (x) {
    case var _!:
      return "match";
    default:
      return "no match";
  }
}

String testNullAssert2(int? x) {
  switch (x) {
    case final _!:
      return "match";
    default:
      return "no match";
  }
}

String testNullAssert3(int? x) {
  switch (x) {
    case int? _!:
      return "match";
    default:
      return "no match";
  }
}

String testNullAssert4(int? x) {
  switch (x) {
    case final int? _!:
      return "match";
    default:
      return "no match";
  }
}

String testVariable1(int x) {
  switch (x) {
    case var _:
      return "match";
    default:
      return "no match";
  }
}

String testVariable2(int x) {
  switch (x) {
    case final _:
      return "match";
    default:
      return "no match";
  }
}

String testVariable3(int x) {
  switch (x) {
    case int _:
      return "match";
    default:
      return "no match";
  }
}

String testVariable4(int x) {
  switch (x) {
    case final int _:
      return "match";
    default:
      return "no match";
  }
}

String testParenthesized1(int x) {
  switch (x) {
    case (var _):
      return "match";
    default:
      return "no match";
  }
}

String testParenthesized2(int x) {
  switch (x) {
    case (final _):
      return "match";
    default:
      return "no match";
  }
}

String testParenthesized3(int x) {
  switch (x) {
    case (int _):
      return "match";
    default:
      return "no match";
  }
}

String testParenthesized4(int x) {
  switch (x) {
    case (final int _):
      return "match";
    default:
      return "no match";
  }
}

String testList1(List<int> x) {
  switch (x) {
    case [var _]:
      return "match";
    default:
      return "no match";
  }
}

String testList2(List<int> x) {
  switch (x) {
    case [final _]:
      return "match";
    default:
      return "no match";
  }
}

String testList3(List<int> x) {
  switch (x) {
    case [int _]:
      return "match";
    default:
      return "no match";
  }
}

String testList4(List<int> x) {
  switch (x) {
    case [final int _]:
      return "match";
    default:
      return "no match";
  }
}

String testMap1(Map<String, int> x) {
  switch (x) {
    case {"key1": var _}:
      return "match";
    default:
      return "no match";
  }
}

String testMap2(Map<String, int> x) {
  switch (x) {
    case {"key1": final _}:
      return "match";
    default:
      return "no match";
  }
}

String testMap3(Map<String, int> x) {
  switch (x) {
    case {"key1": int _}:
      return "match";
    default:
      return "no match";
  }
}

String testMap4(Map<String, int> x) {
  switch (x) {
    case {"key1": final int _}:
      return "match";
    default:
      return "no match";
  }
}

String testRecord1(Record x) {
  switch (x) {
    case (var _,):
      return "match";
    default:
      return "no match";
  }
}

String testRecord2(Record x) {
  switch (x) {
    case (final _,):
      return "match";
    default:
      return "no match";
  }
}

String testRecord3(Record x) {
  switch (x) {
    case (int _,):
      return "match";
    default:
      return "no match";
  }
}

String testRecord4(Record x) {
  switch (x) {
    case (final int _,):
      return "match";
    default:
      return "no match";
  }
}

String testObject1(Shape shape) {
  switch (shape) {
    case Square(areaAsInt: var _):
      return "match";
    default:
      return "no match";
  }
}

String testObject2(Shape shape) {
  switch (shape) {
    case Square(areaAsInt: final _):
      return "match";
    default:
      return "no match";
  }
}

String testObject3(Shape shape) {
  switch (shape) {
    case Square(areaAsInt: int _):
      return "match";
    default:
      return "no match";
  }
}

String testObject4(Shape shape) {
  switch (shape) {
    case Square(areaAsInt: final int _):
      return "match";
    default:
      return "no match";
  }
}

main() {
  Expect.equals("match", testLogicalOr1(2));
  Expect.equals("match", testLogicalOr2(1));
  Expect.equals("match", testLogicalOr3(2));
  Expect.equals("match", testLogicalOr4(1));
  Expect.equals("match", testLogicalAnd1(2));
  Expect.equals("match", testLogicalAnd2(1));
  Expect.equals("match", testLogicalAnd3(2));
  Expect.equals("match", testLogicalAnd4(1));
  Expect.equals("match", testCast1(1));
  Expect.equals("match", testCast2(1));
  Expect.equals("match", testCast3(1));
  Expect.equals("match", testCast4(1));
  Expect.throws(() {testCast1(3.14);});
  Expect.throws(() {testCast2(3.14);});
  Expect.throws(() {testCast3(3.14);});
  Expect.throws(() {testCast4(3.14);});
  Expect.equals("match", testNullCheck1(1));
  Expect.equals("match", testNullCheck2(1));
  Expect.equals("match", testNullCheck3(1));
  Expect.equals("match", testNullCheck4(1));
  Expect.equals("no match", testNullCheck1(null));
  Expect.equals("no match", testNullCheck2(null));
  Expect.equals("no match", testNullCheck3(null));
  Expect.equals("no match", testNullCheck4(null));
  Expect.equals("match", testNullAssert1(1));
  Expect.equals("match", testNullAssert2(1));
  Expect.equals("match", testNullAssert3(1));
  Expect.equals("match", testNullAssert4(1));
  Expect.throws(() {testNullAssert1(null);});
  Expect.throws(() {testNullAssert2(null);});
  Expect.throws(() {testNullAssert3(null);});
  Expect.throws(() {testNullAssert4(null);});
  Expect.equals("match", testVariable1(1));
  Expect.equals("match", testVariable2(1));
  Expect.equals("match", testVariable3(1));
  Expect.equals("match", testVariable4(1));
  Expect.equals("match", testParenthesized1(1));
  Expect.equals("match", testParenthesized2(1));
  Expect.equals("match", testParenthesized3(1));
  Expect.equals("match", testParenthesized4(1));
  Expect.equals("match", testList1([1]));
  Expect.equals("match", testList2([1]));
  Expect.equals("match", testList3([1]));
  Expect.equals("match", testList4([1]));
  Expect.equals("no match", testList1([1, 2]));
  Expect.equals("no match", testList2([1, 2]));
  Expect.equals("no match", testList3([1, 2]));
  Expect.equals("no match", testList4([1, 2]));
  Expect.equals("match", testMap1({"key1": 1}));
  Expect.equals("match", testMap2({"key1": 1}));
  Expect.equals("match", testMap3({"key1": 1}));
  Expect.equals("match", testMap4({"key1": 1}));
  Expect.equals("match", testMap1({"key1": 1, "key2": 2}));
  Expect.equals("match", testMap2({"key1": 1, "key2": 2}));
  Expect.equals("match", testMap3({"key1": 1, "key2": 2}));
  Expect.equals("match", testMap4({"key1": 1, "key2": 2}));
  Expect.equals("match", testRecord1((1,)));
  Expect.equals("match", testRecord2((1,)));
  Expect.equals("match", testRecord3((1,)));
  Expect.equals("match", testRecord4((1,)));
  Expect.equals("no match", testRecord1((1, name: "one")));
  Expect.equals("no match", testRecord2((1, name: "one")));
  Expect.equals("no match", testRecord3((1, name: "one")));
  Expect.equals("no match", testRecord4((1, name: "one")));
  Expect.equals("match", testObject1(Square(1)));
  Expect.equals("match", testObject2(Square(1)));
  Expect.equals("match", testObject3(Square(1)));
  Expect.equals("match", testObject4(Square(1)));
  Expect.equals("no match", testObject1(Circle(1)));
  Expect.equals("no match", testObject2(Circle(1)));
  Expect.equals("no match", testObject3(Circle(1)));
  Expect.equals("no match", testObject4(Circle(1)));
}