src/test/ui/for-loop-while/label_break_value.rs

   1 // run-pass
   2 #![allow(dead_code)]
   3 #![allow(unused_assignments)]
   4 #![feature(label_break_value)]
   5
   6 // Test control flow to follow label_break_value semantics
   7 fn label_break(a: bool, b: bool) -> u32 {
   8     let mut v = 0;
   9     'b: {
  10         v = 1;
  11         if a {
  12             break 'b;
  13         }
  14         v = 2;
  15         if b {
  16             break 'b;
  17         }
  18         v = 3;
  19     }
  20     return v;
  21 }
  22
  23 // Test that values can be returned
  24 fn break_value(a: bool, b: bool) -> u32 {
  25     let result = 'block: {
  26         if a { break 'block 1; }
  27         if b { break 'block 2; }
  28         3
  29     };
  30     result
  31 }
  32
  33 // Test nesting of labeled blocks
  34 // here we only check that it compiles
  35 fn label_break_nested() {
  36     'b: {
  37         println!("hi");
  38         if false {
  39             break 'b;
  40         }
  41         'c: {
  42             if false {
  43                 break 'b;
  44             }
  45             break 'c;
  46         }
  47         println!("hello");
  48         if true {
  49             break 'b;
  50         }
  51     }
  52 }
  53
  54 // Tests for mixing labeled blocks with loop constructs
  55 // This function should be the identity function
  56 fn label_break_mixed(v: u32) -> u32 {
  57     let mut r = 0;
  58     'b: {
  59         // Unlabeled break still works
  60         // (only crossing boundaries is an error)
  61         loop {
  62             break;
  63         }
  64         if v == 0 {
  65             break 'b;
  66         }
  67         // Labeled breaking an inner loop still works
  68         'c: loop {
  69             if r == 1 {
  70                 break 'c;
  71             }
  72             r += 1;
  73         }
  74         assert_eq!(r, 1);
  75         if v == 1 {
  76             break 'b;
  77         }
  78         // Labeled breaking an outer loop still works
  79         'd: loop {
  80             {
  81                 if v == r {
  82                     break 'b;
  83                 }
  84                 if r == 5 {
  85                     break 'd;
  86                 }
  87                 r += 1;
  88             }
  89         }
  90         assert_eq!(r, 5);
  91         assert!(v > r);
  92         // Here we test return from inside a labeled block
  93         return v;
  94     }
  95     r
  96 }
  97
  98 pub fn main() {
  99     assert_eq!(label_break(true, false), 1);
 100     assert_eq!(label_break(false, true), 2);
 101     assert_eq!(label_break(false, false), 3);
 102
 103     assert_eq!(break_value(true, false), 1);
 104     assert_eq!(break_value(false, true), 2);
 105     assert_eq!(break_value(false, false), 3);
 106
 107     assert_eq!(label_break_mixed(0), 0);
 108     assert_eq!(label_break_mixed(1), 1);
 109     assert_eq!(label_break_mixed(2), 2);
 110     assert_eq!(label_break_mixed(3), 3);
 111     assert_eq!(label_break_mixed(4), 4);
 112     assert_eq!(label_break_mixed(5), 5);
 113     assert_eq!(label_break_mixed(6), 6);
 114
 115     // FIXME: ensure that labeled blocks work if produced by macros and in match arms
 116 }