src/test/ui/uniform-paths/same-crate.rs

   1 // run-pass
   2 // edition:2018
   3
   4 pub const A: usize = 0;
   5
   6 pub mod foo {
   7     pub const B: usize = 1;
   8
   9     pub mod bar {
  10         pub const C: usize = 2;
  11
  12         pub enum E {
  13             V1(usize),
  14             V2(String),
  15         }
  16
  17         pub fn test() -> String {
  18             format!("{} {} {}", crate::A, crate::foo::B, C)
  19         }
  20
  21         pub fn test_use() -> String {
  22             use crate::A;
  23             use crate::foo::B;
  24
  25             format!("{} {} {}", A, B, C)
  26         }
  27
  28         pub fn test_enum() -> String {
  29             use E::*;
  30             match E::V1(10) {
  31                 V1(i) => { format!("V1: {}", i) }
  32                 V2(s) => { format!("V2: {}", s) }
  33             }
  34         }
  35     }
  36
  37     pub fn test() -> String {
  38         format!("{} {} {}", crate::A, B, bar::C)
  39     }
  40
  41     pub fn test_use() -> String {
  42         use crate::A;
  43         use bar::C;
  44
  45         format!("{} {} {}", A, B, C)
  46     }
  47
  48     pub fn test_enum() -> String {
  49         use bar::E::*;
  50         match bar::E::V1(10) {
  51             V1(i) => { format!("V1: {}", i) }
  52             V2(s) => { format!("V2: {}", s) }
  53         }
  54     }
  55 }
  56
  57 pub fn test() -> String {
  58     format!("{} {} {}", A, foo::B, foo::bar::C)
  59 }
  60
  61 pub fn test_use() -> String {
  62     use foo::B;
  63     use foo::bar::C;
  64
  65     format!("{} {} {}", A, B, C)
  66 }
  67
  68 pub fn test_enum() -> String {
  69     use foo::bar::E::*;
  70     match foo::bar::E::V1(10) {
  71         V1(i) => { format!("V1: {}", i) }
  72         V2(s) => { format!("V2: {}", s) }
  73     }
  74 }
  75
  76 fn main() {
  77     let output = [
  78         test(),
  79         foo::test(),
  80         foo::bar::test(),
  81         test_use(),
  82         foo::test_use(),
  83         foo::bar::test_use(),
  84         test_enum(),
  85         foo::test_enum(),
  86         foo::bar::test_enum(),
  87     ].join("\n");
  88     assert_eq!(output, "\
  89 0 1 2
  90 0 1 2
  91 0 1 2
  92 0 1 2
  93 0 1 2
  94 0 1 2
  95 V1: 10
  96 V1: 10
  97 V1: 10");
  98 }