user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #24681 - tamird:unignore-android, r=alexcrichton

Browse source 
There are still quite a few ignored Android tests kicking around, most of which were added in 445faca844, which has a pretty unfortunate commit message.

r? @alexcrichton
This commit is contained in:
bors 2015-04-29 04:09:45 +00:00
commit d4cedea80a
15 changed files with 72 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/test/auxiliary/cross_crate_spans.rs
View file

@ -9,6 +9,8 @@
// except according to those terms.
#![crate_type = "rlib"]
#![allow(unused_variables)]
#![omit_gdb_pretty_printer_section]
// no-prefer-dynamic

5
src/test/auxiliary/linkage-visibility.rs
View file

@ -10,6 +10,10 @@
#![feature(std_misc)]
// We're testing linkage visibility; the compiler warns us, but we want to
// do the runtime check that these functions aren't exported.
#![allow(private_no_mangle_fns)]
use std::dynamic_lib::DynamicLibrary;
#[no_mangle]
@ -25,6 +29,7 @@ pub fn foo2<T>() {
#[no_mangle]
fn bar() { }
#[allow(dead_code)]
#[no_mangle]
fn baz() { }

8
src/test/bench/shootout-k-nucleotide-pipes.rs
View file

@ -8,13 +8,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// ignore-android: FIXME(#10393)
// ignore-android: FIXME(#10393) hangs without output
// ignore-pretty very bad with line comments
// multi tasking k-nucleotide
#![allow(bad_style)]
use std::ascii::AsciiExt;
use std::cmp::Ordering::{self, Less, Greater, Equal};
use std::collections::HashMap;
@ -47,7 +45,7 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , usize>, total: usize) -> String {
}
// sort by key, then by value
fn sortKV(mut orig: Vec<(Vec<u8> ,f64)> ) -> Vec<(Vec<u8> ,f64)> {
fn sort_kv(mut orig: Vec<(Vec<u8> ,f64)> ) -> Vec<(Vec<u8> ,f64)> {
orig.sort_by(|&(ref a, _), &(ref b, _)| a.cmp(b));
orig.sort_by(|&(_, a), &(_, b)| f64_cmp(b, a));
orig
@ -60,7 +58,7 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , usize>, total: usize) -> String {
pairs.push(((*key).clone(), pct(val, total)));
}
let pairs_sorted = sortKV(pairs);
let pairs_sorted = sort_kv(pairs);
let mut buffer = String::new();
for &(ref k, v) in &pairs_sorted {

2
src/test/bench/shootout-k-nucleotide.rs
View file

@ -38,7 +38,7 @@
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
// ignore-android see #10393 #13206
// ignore-android: FIXME(#10393) hangs without output
#![feature(box_syntax, std_misc, collections)]

4
src/test/bench/shootout-reverse-complement.rs
View file

@ -38,7 +38,7 @@
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
// ignore-android see #10393 #13206
// ignore-android: FIXME(#10393) hangs without output
#![feature(libc, scoped)]
@ -205,7 +205,7 @@ fn parallel<I: Iterator, F>(iter: I, ref f: F)
fn main() {
let mut data = Vec::with_capacity(1024 * 1024);
io::stdin().read_to_end(&mut data);
io::stdin().read_to_end(&mut data).unwrap();
let tables = &Tables::new();
parallel(mut_dna_seqs(&mut data), |seq| reverse_complement(seq, tables));
io::stdout().write_all(&data).unwrap();

3
src/test/debuginfo/constant-debug-locs.rs
View file

@ -13,8 +13,7 @@
// compile-flags:-g
#![allow(unused_variables)]
#![allow(dead_code)]
#![allow(dead_code, unused_variables)]
#![omit_gdb_pretty_printer_section]
#![feature(std_misc, core)]

3
src/test/debuginfo/constant-in-match-pattern.rs
View file

@ -13,8 +13,7 @@
// compile-flags:-g
#![allow(unused_variables)]
#![allow(dead_code)]
#![allow(dead_code, unused_variables)]
#![omit_gdb_pretty_printer_section]
// This test makes sure that the compiler doesn't crash when trying to assign

4
src/test/debuginfo/cross-crate-spans.rs
View file

@ -21,7 +21,7 @@ extern crate cross_crate_spans;
// === GDB TESTS ===================================================================================
// gdb-command:break cross_crate_spans.rs:21
// gdb-command:break cross_crate_spans.rs:23
// gdb-command:run
// gdb-command:print result
@ -44,7 +44,7 @@ extern crate cross_crate_spans;
// === LLDB TESTS ==================================================================================
// lldb-command:b cross_crate_spans.rs:21
// lldb-command:b cross_crate_spans.rs:23
// lldb-command:run
// lldb-command:print result

2
src/test/debuginfo/function-prologue-stepping-no-stack-check.rs
View file

@ -246,7 +246,7 @@
// lldb-check:[...]$31 = 45
// lldb-command:continue
#![allow(unused_variables)]
#![allow(dead_code, unused_assignments, unused_variables)]
#![omit_gdb_pretty_printer_section]
#[no_stack_check]

2
src/test/debuginfo/gdb-pretty-std.rs
View file

@ -35,6 +35,8 @@
// gdb-command: print none
// gdb-check:$6 = None
#![allow(unused_variables)]
fn main() {
// &[]

2
src/test/debuginfo/gdb-pretty-struct-and-enums-pre-gdb-7-7.rs
View file

@ -37,6 +37,8 @@
// gdb-command: print c_style_enum3
// gdb-check:$5 = CStyleEnumVar3
#![allow(dead_code, unused_variables)]
struct RegularStruct {
the_first_field: isize,
the_second_field: f64,

2
src/test/debuginfo/gdb-pretty-struct-and-enums.rs
View file

@ -76,6 +76,8 @@
// gdb-command: print none_check2
// gdb-check:$18 = None
#![allow(dead_code, unused_variables)]
use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3};
use self::MixedEnum::{MixedEnumCStyleVar, MixedEnumTupleVar, MixedEnumStructVar};
use self::NestedEnum::{NestedVariant1, NestedVariant2};

90
src/test/debuginfo/type-names.rs
View file

@ -21,7 +21,7 @@
// gdb-check:type = struct Struct1
// gdb-command:whatis generic_struct1
// gdb-check:type = struct GenericStruct<type_names::Mod1::Struct2, type_names::Mod1::Mod2::Struct3>
// gdb-check:type = struct GenericStruct<type_names::mod1::Struct2, type_names::mod1::mod2::Struct3>
// gdb-command:whatis generic_struct2
// gdb-check:type = struct GenericStruct<type_names::Struct1, extern "fastcall" fn(isize) -> usize>
@ -41,7 +41,7 @@
// gdb-check:type = union Enum2
// gdb-command:whatis generic_enum_1
// gdb-check:type = union Enum3<type_names::Mod1::Struct2>
// gdb-check:type = union Enum3<type_names::mod1::Struct2>
// gdb-command:whatis generic_enum_2
// gdb-check:type = union Enum3<type_names::Struct1>
@ -49,10 +49,10 @@
// TUPLES
// gdb-command:whatis tuple1
// gdb-check:type = struct (u32, type_names::Struct1, type_names::Mod1::Mod2::Enum3<type_names::Mod1::Struct2>)
// gdb-check:type = struct (u32, type_names::Struct1, type_names::mod1::mod2::Enum3<type_names::mod1::Struct2>)
// gdb-command:whatis tuple2
// gdb-check:type = struct ((type_names::Struct1, type_names::Mod1::Mod2::Struct3), type_names::Mod1::Enum2, char)
// gdb-check:type = struct ((type_names::Struct1, type_names::mod1::mod2::Struct3), type_names::mod1::Enum2, char)
// BOX
@ -60,7 +60,7 @@
// gdb-check:type = struct (Box<f32>, i32)
// gdb-command:whatis box2
// gdb-check:type = struct (Box<type_names::Mod1::Mod2::Enum3<f32>>, i32)
// gdb-check:type = struct (Box<type_names::mod1::mod2::Enum3<f32>>, i32)
// REFERENCES
@ -74,7 +74,7 @@
// gdb-check:type = struct (&mut type_names::Struct1, i32)
// gdb-command:whatis mut_ref2
// gdb-check:type = struct (&mut type_names::GenericStruct<type_names::Mod1::Enum2, f64>, i32)
// gdb-check:type = struct (&mut type_names::GenericStruct<type_names::mod1::Enum2, f64>, i32)
// RAW POINTERS
@ -85,7 +85,7 @@
// gdb-check:type = struct (*mut isize, isize)
// gdb-command:whatis mut_ptr3
// gdb-check:type = struct (*mut type_names::Mod1::Mod2::Enum3<type_names::Struct1>, isize)
// gdb-check:type = struct (*mut type_names::mod1::mod2::Enum3<type_names::Struct1>, isize)
// gdb-command:whatis const_ptr1
// gdb-check:type = struct (*const type_names::Struct1, isize)
@ -94,7 +94,7 @@
// gdb-check:type = struct (*const isize, isize)
// gdb-command:whatis const_ptr3
// gdb-check:type = struct (*const type_names::Mod1::Mod2::Enum3<type_names::Struct1>, isize)
// gdb-check:type = struct (*const type_names::mod1::mod2::Enum3<type_names::Struct1>, isize)
// VECTORS
@ -108,7 +108,7 @@
// gdb-check:type = struct &[usize]
// gdb-command:whatis slice2
// gdb-check:type = struct &[type_names::Mod1::Enum2]
// gdb-check:type = struct &[type_names::mod1::Enum2]
// TRAITS
@ -122,18 +122,18 @@
// gdb-check:type = struct &mut Trait1
// gdb-command:whatis generic_box_trait
// gdb-check:type = struct Box<Trait2<i32, type_names::Mod1::Struct2>>
// gdb-check:type = struct Box<Trait2<i32, type_names::mod1::Struct2>>
// gdb-command:whatis generic_ref_trait
// gdb-check:type = struct &Trait2<type_names::Struct1, type_names::Struct1>
// gdb-command:whatis generic_mut_ref_trait
// gdb-check:type = struct &mut Trait2<type_names::Mod1::Mod2::Struct3, type_names::GenericStruct<usize, isize>>
// gdb-check:type = struct &mut Trait2<type_names::mod1::mod2::Struct3, type_names::GenericStruct<usize, isize>>
// BARE FUNCTIONS
// gdb-command:whatis rust_fn
// gdb-check:type = struct (fn(core::option::Option<isize>, core::option::Option<&type_names::Mod1::Struct2>), usize)
// gdb-check:type = struct (fn(core::option::Option<isize>, core::option::Option<&type_names::mod1::Struct2>), usize)
// gdb-command:whatis extern_c_fn
// gdb-check:type = struct (extern "C" fn(isize), usize)
@ -151,7 +151,7 @@
// gdb-check:type = struct (extern "C" fn() -> type_names::Struct1, usize)
// gdb-command:whatis unsafe_fn_with_return_value
// gdb-check:type = struct (unsafe fn(type_names::GenericStruct<u16, u8>) -> type_names::Mod1::Struct2, usize)
// gdb-check:type = struct (unsafe fn(type_names::GenericStruct<u16, u8>) -> type_names::mod1::Struct2, usize)
// gdb-command:whatis extern_stdcall_fn_with_return_value
// gdb-check:type = struct (extern "stdcall" fn(Box<isize>) -> usize, usize)
@ -160,7 +160,7 @@
// gdb-check:type = struct (fn(isize) -> isize, usize)
// gdb-command:whatis generic_function_struct3
// gdb-check:type = struct (fn(type_names::Mod1::Mod2::Struct3) -> type_names::Mod1::Mod2::Struct3, usize)
// gdb-check:type = struct (fn(type_names::mod1::mod2::Struct3) -> type_names::mod1::mod2::Struct3, usize)
// gdb-command:whatis variadic_function
// gdb-check:type = struct (unsafe extern "C" fn(*const u8, ...) -> isize, usize)
@ -174,9 +174,10 @@
// gdb-check:type = struct (closure, usize)
#![feature(box_syntax)]
#![allow(unused_variables)]
#![omit_gdb_pretty_printer_section]
use self::Enum1::{Variant1_1, Variant1_2};
use self::Enum1::{Variant1, Variant2};
use std::marker::PhantomData;
use std::ptr;
@ -184,26 +185,26 @@ struct Struct1;
struct GenericStruct<T1, T2>(PhantomData<(T1,T2)>);
enum Enum1 {
Variant1_1,
Variant1_2(isize)
Variant1,
Variant2(isize),
}
mod Mod1 {
pub use self::Enum2::{Variant2_1, Variant2_2};
mod mod1 {
pub use self::Enum2::{Variant1, Variant2};
pub struct Struct2;
pub enum Enum2 {
Variant2_1,
Variant2_2(super::Struct1)
Variant1,
Variant2(super::Struct1),
}
pub mod Mod2 {
pub use self::Enum3::{Variant3_1, Variant3_2};
pub mod mod2 {
pub use self::Enum3::{Variant1, Variant2};
pub struct Struct3;
pub enum Enum3<T> {
Variant3_1,
Variant3_2(T),
Variant1,
Variant2(T),
}
}
}
@ -214,18 +215,19 @@ trait Trait2<T1, T2> { fn dummy(&self, _: T1, _:T2) { } }
impl Trait1 for isize {}
impl<T1, T2> Trait2<T1, T2> for isize {}
fn rust_fn(_: Option<isize>, _: Option<&Mod1::Struct2>) {}
fn rust_fn(_: Option<isize>, _: Option<&mod1::Struct2>) {}
extern "C" fn extern_c_fn(_: isize) {}
unsafe fn unsafe_fn(_: Result<char, f64>) {}
extern "stdcall" fn extern_stdcall_fn() {}
fn rust_fn_with_return_value(_: f64) -> usize { 4 }
extern "C" fn extern_c_fn_with_return_value() -> Struct1 { Struct1 }
unsafe fn unsafe_fn_with_return_value(_: GenericStruct<u16, u8>) -> Mod1::Struct2 { Mod1::Struct2 }
unsafe fn unsafe_fn_with_return_value(_: GenericStruct<u16, u8>) -> mod1::Struct2 { mod1::Struct2 }
extern "stdcall" fn extern_stdcall_fn_with_return_value(_: Box<isize>) -> usize { 0 }
fn generic_function<T>(x: T) -> T { x }
#[allow(improper_ctypes)]
extern {
fn printf(_:*const u8, ...) -> isize;
}
@ -241,45 +243,45 @@ fn main() {
// Structs
let simple_struct = Struct1;
let generic_struct1: GenericStruct<Mod1::Struct2, Mod1::Mod2::Struct3> =
let generic_struct1: GenericStruct<mod1::Struct2, mod1::mod2::Struct3> =
GenericStruct(PhantomData);
let generic_struct2: GenericStruct<Struct1, extern "fastcall" fn(isize) -> usize> =
GenericStruct(PhantomData);
let mod_struct = Mod1::Struct2;
let mod_struct = mod1::Struct2;
// Enums
let simple_enum_1 = Variant1_1;
let simple_enum_2 = Variant1_2(0);
let simple_enum_3 = Mod1::Variant2_2(Struct1);
let simple_enum_1 = Variant1;
let simple_enum_2 = Variant2(0);
let simple_enum_3 = mod1::Variant2(Struct1);
let generic_enum_1: Mod1::Mod2::Enum3<Mod1::Struct2> = Mod1::Mod2::Variant3_1;
let generic_enum_2 = Mod1::Mod2::Variant3_2(Struct1);
let generic_enum_1: mod1::mod2::Enum3<mod1::Struct2> = mod1::mod2::Variant1;
let generic_enum_2 = mod1::mod2::Variant2(Struct1);
// Tuples
let tuple1 = (8u32, Struct1, Mod1::Mod2::Variant3_2(Mod1::Struct2));
let tuple2 = ((Struct1, Mod1::Mod2::Struct3), Mod1::Variant2_1, 'x');
let tuple1 = (8u32, Struct1, mod1::mod2::Variant2(mod1::Struct2));
let tuple2 = ((Struct1, mod1::mod2::Struct3), mod1::Variant1, 'x');
// Box
let box1 = (box 1f32, 0i32);
let box2 = (box Mod1::Mod2::Variant3_2(1f32), 0i32);
let box2 = (box mod1::mod2::Variant2(1f32), 0i32);
// References
let ref1 = (&Struct1, 0i32);
let ref2 = (&GenericStruct::<char, Struct1>(PhantomData), 0i32);
let mut mut_struct1 = Struct1;
let mut mut_generic_struct = GenericStruct::<Mod1::Enum2, f64>(PhantomData);
let mut mut_generic_struct = GenericStruct::<mod1::Enum2, f64>(PhantomData);
let mut_ref1 = (&mut mut_struct1, 0i32);
let mut_ref2 = (&mut mut_generic_struct, 0i32);
// Raw Pointers
let mut_ptr1: (*mut Struct1, isize) = (ptr::null_mut(), 0);
let mut_ptr2: (*mut isize, isize) = (ptr::null_mut(), 0);
let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, isize) = (ptr::null_mut(), 0);
let mut_ptr3: (*mut mod1::mod2::Enum3<Struct1>, isize) = (ptr::null_mut(), 0);
let const_ptr1: (*const Struct1, isize) = (ptr::null(), 0);
let const_ptr2: (*const isize, isize) = (ptr::null(), 0);
let const_ptr3: (*const Mod1::Mod2::Enum3<Struct1>, isize) = (ptr::null(), 0);
let const_ptr3: (*const mod1::mod2::Enum3<Struct1>, isize) = (ptr::null(), 0);
// Vectors
let fixed_size_vec1 = ([Struct1, Struct1, Struct1], 0i16);
@ -287,7 +289,7 @@ fn main() {
let vec1 = vec![0_usize, 2, 3];
let slice1 = &*vec1;
let vec2 = vec![Mod1::Variant2_2(Struct1)];
let vec2 = vec![mod1::Variant2(Struct1)];
let slice2 = &*vec2;
// Trait Objects
@ -296,12 +298,12 @@ fn main() {
let mut mut_int1 = 0_isize;
let mut_ref_trait = (&mut mut_int1) as &mut Trait1;
let generic_box_trait = (box 0_isize) as Box<Trait2<i32, Mod1::Struct2>>;
let generic_box_trait = (box 0_isize) as Box<Trait2<i32, mod1::Struct2>>;
let generic_ref_trait = (&0_isize) as &Trait2<Struct1, Struct1>;
let mut generic_mut_ref_trait_impl = 0_isize;
let generic_mut_ref_trait = (&mut generic_mut_ref_trait_impl) as
&mut Trait2<Mod1::Mod2::Struct3, GenericStruct<usize, isize>>;
&mut Trait2<mod1::mod2::Struct3, GenericStruct<usize, isize>>;
// Bare Functions
let rust_fn = (rust_fn, 0_usize);
@ -315,7 +317,7 @@ fn main() {
let extern_stdcall_fn_with_return_value = (extern_stdcall_fn_with_return_value, 0_usize);
let generic_function_int = (generic_function::<isize>, 0_usize);
let generic_function_struct3 = (generic_function::<Mod1::Mod2::Struct3>, 0_usize);
let generic_function_struct3 = (generic_function::<mod1::mod2::Struct3>, 0_usize);
let variadic_function = (printf, 0_usize);

2
src/test/debuginfo/vec-slices.rs
View file

@ -77,7 +77,7 @@
// lldb-command:print padded_struct
// lldb-check:[...]$5 = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }]
#![allow(unused_variables)]
#![allow(dead_code, unused_variables)]
#![omit_gdb_pretty_printer_section]
struct AStruct {

2
src/test/run-pass/linkage-visibility.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
// aux-build:linkage-visibility.rs
// ignore-android: FIXME(#10379)
// ignore-android: FIXME(#10356)
// ignore-windows: std::dynamic_lib does not work on Windows well
// ignore-musl