This is required by the check-fast target because each test is slurped up into a
submodule.
if not ("xfail-test" in s or
"xfail-fast" in s or
"xfail-win32" in s):
+ if not "pub fn main" in s and "fn main" in s:
+ print("Warning: no public entry point in " + t)
stage2_tests.append(t)
f.close()
fn drop(&mut self) { }
}
-fn main() {
+pub fn main() {
assert_eq!(size_of::<int>(), size_of::<Test<int>>());
}
fn check_id(&mut self, s: int) { fail!() }
}
-fn main() { }
+pub fn main() { }
}
}
-fn main() {
+pub fn main() {
}
// Regression test for issue #7740
-fn main() {
+pub fn main() {
static A: &'static char = &'A';
}
struct wrapper(noncopyable);
-fn main() {
+pub fn main() {
let x1 = wrapper(noncopyable());
let _x2 = *x1;
}
borrow(v.f.g.h); // OK
}
-fn main() {
+pub fn main() {
}
// run-fail/borrowck-wg-autoderef-and-autoborrowvec-combined-fail-issue-6272.rs
-fn main() {
+pub fn main() {
let a = @mut 3i;
let b = @mut [a];
let c = @mut [3];
}
-fn main() {
+pub fn main() {
assert_eq!(3.hi(), ~"hello: 3");
assert_eq!(Some(Some(3)).hi(), ~"something!something!hello: 3");
assert_eq!(None::<int>.hi(), ~"hello - none");
chan.send(val);
}
-fn main() {
+pub fn main() {
let (p,c) = comm::stream();
foo(31337, c);
assert!(p.recv() == 31337);
chan.send(val);
}
-fn main() {
+pub fn main() {
let (p,c) = comm::stream();
foo(31337, c);
assert!(p.recv() == 31337);
impl <T> Foo for X<T> { }
-fn main() { }
+pub fn main() { }
impl <T: Send> Foo for T { }
-fn main() {
+pub fn main() {
let (p,c) = comm::stream();
1193182.foo(c);
assert!(p.recv() == 1193182);
impl Foo for int { }
-fn main() { }
+pub fn main() { }
impl <T: Send> Foo for T { }
-fn main() { }
+pub fn main() { }
t.foo();
}
-fn main() {
+pub fn main() {
let s = @mut S { unused: 0 };
let s2 = s as @mut T;
s2.foo();
bar(s2);
bar(s as @mut T);
-}
\ No newline at end of file
+}
blk();
}
-fn main() {
+pub fn main() {
let (p,c) = comm::stream();
do foo {
c.send(());
static an: bool = 2 > -2;
static ao: bool = 1.0 > -2.0;
-fn main() {
+pub fn main() {
assert_eq!(a, -1);
assert_eq!(a2, 6);
assert_approx_eq!(b, 5.7);
static bar: Bar = Bar { i: 0, v: IntVal(0) };
-fn main() {}
+pub fn main() {}
fn m(&self, _:int) { }
}
-fn main() { }
+pub fn main() { }
impl Z for int;
-fn main() {
+pub fn main() {
assert_eq!(12.x(), 12);
}
C
}
-fn main() {
+pub fn main() {
let _ = A::<int, int>(1i).clone();
let _ = B(1i, 1.234).deep_clone();
}
#[deriving(Clone, DeepClone)]
struct S<T>(T, ());
-fn main() {
+pub fn main() {
let _ = S(1i, ()).clone().deep_clone();
}
_nil: ()
}
-fn main() {}
+pub fn main() {}
y: FailCmp
}
-fn main() {
+pub fn main() {
let a = ShortCircuit { x: 1, y: FailCmp };
let b = ShortCircuit { x: 2, y: FailCmp };
x: &'self int
}
-fn main() {
+pub fn main() {
let a = A { x: &1 };
let b = A { x: &2 };
fn to_str(&self) -> ~str { ~"yay" }
}
-fn main() {
+pub fn main() {
assert_eq!(B1.to_str(), ~"B1");
assert_eq!(B2.to_str(), ~"B2");
assert_eq!(C1(3).to_str(), ~"C1(3)");
j: (),
}
-fn main() {
+pub fn main() {
let lots: Lots = Zero::zero();
assert!(lots.is_zero());
}
Spiderman = -4
}
-fn main() {
+pub fn main() {
let pet: Animal = Snake;
let hero: Hero = Superman;
assert!(pet as uint == 3);
static BAR:uint = Bunny as uint;
static BAR2:uint = BAR;
-fn main() {
+pub fn main() {
let _v = [0, .. Bunny as uint];
let _v = [0, .. BAR];
let _v = [0, .. BAR2];
use std::io::println;
-fn main() {
+pub fn main() {
let v: ~[int] = ~[ 1, ..5 ];
println(v[0].to_str());
println(v[1].to_str());
extern fn f(x: uint) -> uint { x * 2 }
-fn main() {
+pub fn main() {
#[fixed_stack_segment];
let x = f(22);
extern fn uintuintuintuintret(x: uint, y: uint, z: uint) -> uint { x+y+z }
-fn main() {
+pub fn main() {
assert_eq!(voidret1, voidret1);
assert!(voidret1 != voidret2);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
assert!(option_env!("__HOPEFULLY_DOESNT_EXIST__").is_none());
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
// Make sure that this view item is filtered out because otherwise it would
// trigger a compilation error
#[cfg(not_present)] use foo = bar;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = [1,..100];
let mut y = 0;
for i in x.iter() {
// outside the loop, breaks, then _picks back up_ and continues
// iterating with it.
-fn main() {
+pub fn main() {
let mut h = HashMap::new();
let kvs = [(1, 10), (2, 20), (3, 30)];
for &(k,v) in kvs.iter() {
assert_eq!(x, 6);
assert_eq!(y, 60);
-}
\ No newline at end of file
+}
use std::hashmap::HashMap;
-fn main() {
+pub fn main() {
let mut h = HashMap::new();
let kvs = [(1, 10), (2, 20), (3, 30)];
for &(k,v) in kvs.iter() {
}
assert_eq!(x, 6);
assert_eq!(y, 60);
-}
\ No newline at end of file
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = [1,..100];
let mut y = 0;
for (n,i) in x.iter().enumerate() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = [1,..100];
let y = [2,..100];
let mut p = 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = [1,..100];
let mut y = 0;
for i in x.iter() {
y += *i
}
assert!(y == 100);
-}
\ No newline at end of file
+}
addr
}
-fn main() {
+pub fn main() {
let obj = ~1;
let objptr: *uint = &*obj;
let f = Foo {x: obj, y: ~2};
let xptr = foo(f);
assert_eq!(objptr, xptr);
-}
\ No newline at end of file
+}
*x
}
-fn main() {
+pub fn main() {
let obj = ~1;
let objptr: *uint = &*obj;
let xptr = getaddr(obj);
x
}
-fn main() {
+pub fn main() {
assert_eq!(foo((22, 23)), 22);
}
}
}
-fn main() {
+pub fn main() {
assert_eq!(vec_utils::map_(&~[1,2,3], |&x| x+1), ~[2,3,4]);
}
pub fn g() -> uint {14}
}
-fn main(){
+pub fn main(){
// should *not* shadow the module x:
let x = 9;
// use it to avoid warnings:
fn b<F,G>(_x: F) -> F { fail!() } //~ ERROR in method `b`, type parameter 0 has 1 bound, but
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {}
+pub fn main() {}
use std::io;
-fn main() {
+pub fn main() {
let stdout = &io::stdout() as &io::WriterUtil;
stdout.write_line("Hello!");
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let (port, chan) = stream();
do spawn {
}
}
-fn main() {
+pub fn main() {
let t = ~0;
let p = unsafe { transmute::<~int, *c_void>(t) };
let _z = NonCopyable(p);
println(fmt!("debug_name = %s", x.debug_name()));
}
-fn main() {
+pub fn main() {
let thing = Thing::new();
print_name(&thing as &Debuggable);
}
})
)
-fn main() {
+pub fn main() {
print_hd_tl!(x, y, z, w)
}
}
}
-fn main() {
+pub fn main() {
let _sched = Scheduler::new(~UvEventLoop::new() as ~EventLoop);
}
// Regression test for issue #5239
-fn main() {
+pub fn main() {
let _f: &fn(int) -> int = |ref x: int| { *x };
let foo = 10;
assert!(_f(foo) == 10);
}
}
-fn main() {
+pub fn main() {
5.tag_to_str();
}
struct A(bool);
-fn main() {
+pub fn main() {
let f = A;
f(true);
}
}
}
-fn main() {
+pub fn main() {
2.yes();
}
}
}
-fn main() {}
+pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let box1 = @mut 42;
let _x = *(&mut *box1) == 42 || *(&mut *box1) == 31337;
}
#[allow(dead_assignment)];
-fn main() {
+pub fn main() {
let s: ~str = ~"foobar";
let mut t: &str = s;
t = t.slice(0, 3); // for master: str::view(t, 0, 3) maybe
fn foo<T: ::std::cmp::Eq>(_t: T) { }
-fn main() { }
+pub fn main() { }
struct X { vec: &'static [int] }
static V: &'static [X] = &[X { vec: &[1, 2, 3] }];
-fn main() {
+pub fn main() {
for &v in V.iter() {
println(fmt!("%?", v.vec));
}
}
}
-fn main() {
+pub fn main() {
let inner = 5;
let outer = Outer::new(&inner as &Inner);
outer.inner.print();
use std::io;
-fn main() {
+pub fn main() {
return;
while io::stdin().read_line() != ~"quit" { };
}
struct T (&'static [int]);
static t : T = T (&'static [5, 4, 3]);
-fn main () {
+pub fn main () {
assert_eq!(t[0], 5);
}
}
}
-fn main() {
+pub fn main() {
let g : ~HashMap<int, int> = ~HashMap::new();
let _g2 : ~Graph<int,int> = g as ~Graph<int,int>;
}
#[deny(type_limits)];
-fn main() {
+pub fn main() {
let i: uint = 0;
assert!(i <= 0xFFFF_FFFF_u);
f()
}
-fn main() {
+pub fn main() {
let f: ~fn() = || ();
run(f);
-}
\ No newline at end of file
+}
f(x)
}
-fn main() {
+pub fn main() {
let v = swap(|mut x| { x.push(4); x });
let w = do swap |mut x| { x.push(4); x };
assert_eq!(v, w);
fn drop(&mut self) {}
}
-fn main() {}
\ No newline at end of file
+pub fn main() {}
fn drop(&mut self) {}
}
-fn main() {
+pub fn main() {
let a = A { x: 0 };
let A { x: ref x } = a;
fn drop(&mut self) {}
}
-fn main() {
+pub fn main() {
let a = A { x: 0 };
match a {
pattern: &[0x243f6a88u32,0x85a308d3u32,0x13198a2eu32,0x03707344u32,0xa4093822u32,0x299f31d0u32]
};
-fn main() {
+pub fn main() {
let test = &[0x243f6a88u32,0x85a308d3u32,0x13198a2eu32,0x03707344u32,0xa4093822u32,0x299f31d0u32];
println(fmt!("%b",test==test1.pattern));
}
if "" == "" {}
}
-fn main() {
+pub fn main() {
bar();
baz();
}
fn foo(():()) { }
-fn main() {
+pub fn main() {
foo(());
}
*/
-fn main() {}
+pub fn main() {}
trait A {}
impl<T: 'static> A for T {}
impl TraitWithDefaultMethod for MyStruct { }
-fn main() {
+pub fn main() {
MyStruct.method();
}
}
}
-fn main(){}
+pub fn main(){}
fn foo(_: &mut A) {}
-fn main() {
+pub fn main() {
let mut b = B;
foo(&mut b as &mut A);
}
C{ foo: a };
}
-fn main() {
+pub fn main() {
}
a.write([])
}
-fn main(){}
+pub fn main(){}
~""
}
-fn main() {}
+pub fn main() {}
silly_macro!()
-fn main() {}
+pub fn main() {}
-fn main() {
+pub fn main() {
let x = ~"hello";
let ref y = x;
assert_eq!(x.slice(0, x.len()), y.slice(0, y.len()));
// shouldn't affect evaluation of $ex:
macro_rules! bad_macro (($ex:expr) => ({let _x = 9; $ex}))
-fn main() {
+pub fn main() {
let _x = 8;
assert_eq!(bad_macro!(_x),8)
}
#[link_section="__DATA,__mut"]
static mut frobulator: uint = 0xdeadbeef;
-fn main() {
+pub fn main() {
unsafe {
frobulator = 0xcafebabe;
printfln!("%? %? %?", i_live_in_more_text(), magic, frobulator);
}
}
-fn main() {
+pub fn main() {
}
static ラ: uint = 0;
-fn main() {}
+pub fn main() {}
static mut bar: int = 2;
-fn main() {}
+pub fn main() {}
local_data_key!(pub baz: float)
}
-fn main() {
+pub fn main() {
local_data::get(foo, |x| assert!(x.is_none()));
local_data::get(bar::baz, |y| assert!(y.is_none()));
return ~""
}
-fn main() {
+pub fn main() {
io::println(parse_args());
}
)
)
-fn main() {
+pub fn main() {
assert_eq!(match_inside_expansion!(),129);
}
}
}
-fn main() {
+pub fn main() {
test1();
test2();
test3();
static s: int = 1;
static e: int = 42;
-fn main() {
+pub fn main() {
match 7 {
s..e => (),
_ => (),
// Tests that matching rvalues with drops does not crash.
-fn main() {
+pub fn main() {
match ~[1, 2, 3] {
x => {
assert_eq!(x.len(), 3);
}
}
-fn main() {
+pub fn main() {
let _ = S::<int>::new::<float>(1, 1.0);
let _: S2 = Trait::<int>::new::<float>(1, 1.0);
}
sb.s
}
-fn main() {
+pub fn main() {
let mut sb = StringBuffer {s: ~""};
sb.append("Hello, ");
sb.append("World!");
// except according to those terms.
// Test that multibyte characters don't crash the compiler
-fn main() {
+pub fn main() {
println("마이너스 사인이 없으면");
}
}
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {
+pub fn main() {
let n = X;
assert_eq!(n.f(), 0);
assert_eq!(n.g(), 1);
}
}
-fn main() {
+pub fn main() {
let y = @mut 32;
{
let _x = Foo(y);
Foo(42)
}
-fn main() {
+pub fn main() {
assert_eq!(*foo(), 42);
}
assert_eq!(v, y);
}
-fn main() {
+pub fn main() {
let mut x = 22_u;
let obj = &mut x as &mut Foo;
do_it_mut(obj);
assert_eq!(v, y);
}
-fn main() {
+pub fn main() {
let x = @mut 22u as @mut Foo;
do_it_mut(x);
do_it_imm(x, 23u);
fn f<T: 'static>(_x: T) {}
-fn main() {
+pub fn main() {
f(~5);
}
baz: uint
}
-fn main() {
+pub fn main() {
let foo = Foo { bar: 1, baz: 2 };
let brw = &foo.baz;
c: S
}
-fn main() {
+pub fn main() {
unsafe {
let s = S { a: 0xff_ff_ff_ffu32, b: 1, c: 0xaa_aa_aa_aa as i32 };
let transd : [u8, .. 9] = cast::transmute(s);
c: S
}
-fn main() {
+pub fn main() {
assert_eq!(sys::size_of::<S<u8, u8>>(), 3);
assert_eq!(sys::size_of::<S<u64, u16>>(), 11);
b: u32
}
-fn main() {
+pub fn main() {
unsafe {
let s4 = S4 { a: 1, b: [2,3,4] };
let transd : [u8, .. 4] = cast::transmute(s4);
baz: uint
}
-fn main() {
+pub fn main() {
let foo = Foo { bar: 1, baz: 2 };
match foo {
Foo {bar, baz} => {
}
-fn main() {
+pub fn main() {
assert_eq!(sys::size_of::<S4>(), 4);
assert_eq!(sys::size_of::<S5>(), 5);
assert_eq!(sys::size_of::<S13_str>(), 13 + sys::size_of::<~str>());
baz: u64
}
-fn main() {
+pub fn main() {
let foos = [Foo { bar: 1, baz: 2 }, .. 10];
assert_eq!(sys::size_of::<[Foo, .. 10]>(), 90);
#[packed]
struct S5(u8,u32);
-fn main() {
+pub fn main() {
unsafe {
let s4 = S4(1, [2,3,4]);
let transd : [u8, .. 4] = cast::transmute(s4);
#[packed]
struct S7_Option(f32, u8, u16, Option<@mut f64>);
-fn main() {
+pub fn main() {
assert_eq!(sys::size_of::<S4>(), 4);
assert_eq!(sys::size_of::<S5>(), 5);
}
#[fixed_stack_segment] #[inline(never)]
-fn main() {
+pub fn main() {
unsafe {
a::free(transmute(0));
}
subslice(subslice(v))
}
-fn main() {
+pub fn main() {
both(main);
}
subslice1(subslice1(v))
}
-fn main() {
+pub fn main() {
let v = ~[1,2,3];
both(v);
}
use std::hashmap::HashMap;
use std::option::Some;
-fn main() {
+pub fn main() {
let mut map: HashMap<SendStr, uint> = HashMap::new();
assert!(map.insert(SendStrStatic("foo"), 42));
assert!(!map.insert(SendStrOwned(~"foo"), 42));
use self::extra::treemap::TreeMap;
use std::option::Some;
-fn main() {
+pub fn main() {
let mut map: TreeMap<SendStr, uint> = TreeMap::new();
assert!(map.insert(SendStrStatic("foo"), 42));
assert!(!map.insert(SendStrOwned(~"foo"), 42));
e2
}
-fn main() {
+pub fn main() {
assert_eq!(test_int(3i32), 9i32);
assert_eq!(test_float(3f32), 9f32);
}
a: f32
}
-fn main() {}
+pub fn main() {}
fn bar<T: Sized>() { }
fn foo<T>() { bar::<&T>() }
-fn main() { }
+pub fn main() { }
fn bar<T: Sized>() { }
fn foo<T>() { bar::<~T>() }
-fn main() { }
+pub fn main() { }
#[static_assert]
static f: bool = (4/2) == 2;
-fn main() {
+pub fn main() {
}
assert_eq!(c.noncopy.v, 22);
}
-fn main() {
+pub fn main() {
test0();
test1();
test2();
static static_vec: &'static [u8] = bytes!("abc", 0xFF, '!');
-fn main() {
+pub fn main() {
let vec = bytes!("abc");
assert_eq!(vec, &[97_u8, 98_u8, 99_u8]);
blue = 2,
}
-fn main() {}
+pub fn main() {}
b(x);
}
-fn main() { }
+pub fn main() { }
fn id<T:J<T>>(x:T) -> T { x.j() }
}
-fn main() { }
+pub fn main() { }
fn method(&self, _x: Type<(u8,V)>) -> int { 0 }
}
-fn main () {
+pub fn main () {
let a = @() as @Trait<u8, u8>;
assert_eq!(a.method(Constant), 0);
}
}
-fn main() {
+pub fn main() {
assert_eq!(3.do_get2(), (3, 3));
assert_eq!(Some(~"hi").do_get2(), (~"hi", ~"hi"));
}
fn foo(&self, mut v: int) { v = 1; }
}
-fn main() {}
+pub fn main() {}
// Issue #7988
// Transmuting non-immediate type to immediate type
-fn main() {
+pub fn main() {
unsafe {
::std::cast::transmute::<[int,..1],int>([1])
};
#[deriving(Eq)]
struct Bar(int, int);
-fn main() {
+pub fn main() {
let f: extern fn(int) -> Foo = Foo;
let g: extern fn(int, int) -> Bar = Bar;
assert_eq!(f(42), Foo(42));
test!(x + y)
-fn main() {
+pub fn main() {
foo(A(1), A(2));
-}
\ No newline at end of file
+}
// Unfold had a bug with 'self that mean it didn't work
// cross-crate
-fn main() {
+pub fn main() {
fn count(st: &mut uint) -> Option<uint> {
if *st < 10 {
let ret = Some(*st);
projects / rust.git / commitdiff