Skip to content
Permalink
Browse files

basic run-pass tests for or-patterns

Add some basic run-pass ui tests for or-patterns.
  • Loading branch information...
dlrobertson committed Jul 14, 2019
1 parent 254014a commit 1991dbdc2196d1159edfa2826480d13494b67ddc
@@ -0,0 +1,32 @@
// Test basic or-patterns when the target pattern type will be lowered to a
// `SwitchInt` (an `enum`).
// run-pass
#![feature(or_patterns)]
//~^ WARN the feature `or_patterns` is incomplete and may cause the compiler to crash

#[derive(Debug)]
enum Test {
Foo,
Bar,
Baz,
Qux
}

fn test(x: Option<Test>) -> bool {
match x {
// most simple case
Some(Test::Bar | Test::Qux) => true,
// wild case
Some(_) => false,
// empty case
None => false,
}
}

fn main() {
assert!(!test(Some(Test::Foo)));
assert!(test(Some(Test::Bar)));
assert!(!test(Some(Test::Baz)));
assert!(test(Some(Test::Qux)));
assert!(!test(None))
}
@@ -0,0 +1,8 @@
warning: the feature `or_patterns` is incomplete and may cause the compiler to crash
--> $DIR/basic-switch.rs:4:12
|
LL | #![feature(or_patterns)]
| ^^^^^^^^^^^
|
= note: `#[warn(incomplete_features)]` on by default

@@ -0,0 +1,53 @@
// Test basic or-patterns when the target pattern type will be lowered to
// a `Switch`. This will happen when the target type is an integer.
// run-pass
#![feature(or_patterns)]
//~^ WARN the feature `or_patterns` is incomplete and may cause the compiler to crash

#[derive(Debug, PartialEq)]
enum MatchArm {
Arm(usize),
Wild
}

#[derive(Debug)]
enum Foo {
One(usize),
Two(usize, usize),
}

fn test_foo(x: Foo) -> MatchArm {
match x {
// normal pattern.
Foo::One(0) | Foo::One(1) | Foo::One(2) => MatchArm::Arm(0),
// most simple or-pattern.
Foo::One(42 | 255) => MatchArm::Arm(1),
// multiple or-patterns for one structure.
Foo::Two(42 | 255, 1024 | 2048) => MatchArm::Arm(2),
// mix of pattern types in one or-pattern (range).
Foo::One(100 | 110..=120 | 210..=220) => MatchArm::Arm(3),
// multiple or-patterns with wild.
Foo::Two(0..=10 | 100..=110, 0 | _) => MatchArm::Arm(4),
// wild
_ => MatchArm::Wild
}
}

fn main() {
// `Foo` tests.
assert_eq!(test_foo(Foo::One(0)), MatchArm::Arm(0));
assert_eq!(test_foo(Foo::One(42)), MatchArm::Arm(1));
assert_eq!(test_foo(Foo::One(43)), MatchArm::Wild);
assert_eq!(test_foo(Foo::One(255)), MatchArm::Arm(1));
assert_eq!(test_foo(Foo::One(256)), MatchArm::Wild);
assert_eq!(test_foo(Foo::Two(42, 1023)), MatchArm::Wild);
assert_eq!(test_foo(Foo::Two(255, 2048)), MatchArm::Arm(2));
assert_eq!(test_foo(Foo::One(100)), MatchArm::Arm(3));
assert_eq!(test_foo(Foo::One(115)), MatchArm::Arm(3));
assert_eq!(test_foo(Foo::One(105)), MatchArm::Wild);
assert_eq!(test_foo(Foo::One(215)), MatchArm::Arm(3));
assert_eq!(test_foo(Foo::One(121)), MatchArm::Wild);
assert_eq!(test_foo(Foo::Two(0, 42)), MatchArm::Arm(4));
assert_eq!(test_foo(Foo::Two(100, 0)), MatchArm::Arm(4));
assert_eq!(test_foo(Foo::Two(42, 0)), MatchArm::Wild);
}
@@ -0,0 +1,8 @@
warning: the feature `or_patterns` is incomplete and may cause the compiler to crash
--> $DIR/basic-switchint.rs:4:12
|
LL | #![feature(or_patterns)]
| ^^^^^^^^^^^
|
= note: `#[warn(incomplete_features)]` on by default

@@ -0,0 +1,20 @@
// Test that an or-pattern works with a wild pattern. This tests two things:
//
// 1) The Wild pattern should cause the pattern to always succeed.
// 2) or-patterns should work with simplifyable patterns.
//
// run-pass
#![feature(or_patterns)]
//~^ WARN the feature `or_patterns` is incomplete and may cause the compiler to crash

pub fn test(x: Option<usize>) -> bool {
match x {
Some(0 | _) => true,
_ => false
}
}

fn main() {
assert!(test(Some(42)));
assert!(!test(None));
}
@@ -0,0 +1,8 @@
warning: the feature `or_patterns` is incomplete and may cause the compiler to crash
--> $DIR/mix-with-wild.rs:7:12
|
LL | #![feature(or_patterns)]
| ^^^^^^^^^^^
|
= note: `#[warn(incomplete_features)]` on by default

0 comments on commit 1991dbd

Please sign in to comment.
You can’t perform that action at this time.