auto merge of #6327 : z0w0/rust/rm-notest, r=brson

Makes it more consistent, imo.

Author: bors

src/libcore/at_vec.rs

@@ -166,7 +166,7 @@ pub fn from_slice<T:Copy>(v: &[T]) -> @[T] {
     from_fn(v.len(), |i| v[i])
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 pub mod traits {
     use at_vec::append;
     use kinds::Copy;

src/libcore/bool.rs

@@ -10,7 +10,7 @@
 
 //! Boolean logic
 
-#[cfg(notest)]
+#[cfg(not(test))]
 use cmp::{Eq, Ord, TotalOrd, Ordering};
 use option::{None, Option, Some};
 use from_str::FromStr;
@@ -75,7 +75,7 @@ pub fn all_values(blk: &fn(v: bool)) {
 #[inline(always)]
 pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Ord for bool {
     #[inline(always)]
     fn lt(&self, other: &bool) -> bool { to_bit(*self) < to_bit(*other) }
@@ -87,13 +87,13 @@ impl Ord for bool {
     fn ge(&self, other: &bool) -> bool { to_bit(*self) >= to_bit(*other) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl TotalOrd for bool {
     #[inline(always)]
     fn cmp(&self, other: &bool) -> Ordering { to_bit(*self).cmp(&to_bit(*other)) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Eq for bool {
     #[inline(always)]
     fn eq(&self, other: &bool) -> bool { (*self) == (*other) }

src/libcore/char.rs

@@ -10,15 +10,15 @@
 
 //! Utilities for manipulating the char type
 
-#[cfg(notest)]
+#[cfg(not(test))]
 use cmp::Ord;
 use option::{None, Option, Some};
 use str;
 use u32;
 use uint;
 use unicode::{derived_property, general_category};
 
-#[cfg(notest)] use cmp::Eq;
+#[cfg(not(test))] use cmp::Eq;
 
 /*
     Lu  Uppercase_Letter    an uppercase letter
@@ -244,15 +244,15 @@ pub fn len_utf8_bytes(c: char) -> uint {
     else { fail!(~"invalid character!") }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Eq for char {
     #[inline(always)]
     fn eq(&self, other: &char) -> bool { (*self) == (*other) }
     #[inline(always)]
     fn ne(&self, other: &char) -> bool { (*self) != (*other) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Ord for char {
     #[inline(always)]
     fn lt(&self, other: &char) -> bool { *self < *other }

src/libcore/cleanup.rs

@@ -15,9 +15,9 @@ use ptr::mut_null;
 use repr::BoxRepr;
 use sys::TypeDesc;
 use cast::transmute;
-#[cfg(notest)] use unstable::lang::clear_task_borrow_list;
+#[cfg(not(test))] use unstable::lang::clear_task_borrow_list;
 
-#[cfg(notest)] use ptr::to_unsafe_ptr;
+#[cfg(not(test))] use ptr::to_unsafe_ptr;
 
 /**
  * Runtime structures
@@ -164,7 +164,7 @@ fn debug_mem() -> bool {
 }
 
 /// Destroys all managed memory (i.e. @ boxes) held by the current task.
-#[cfg(notest)]
+#[cfg(not(test))]
 #[lang="annihilate"]
 pub unsafe fn annihilate() {
     use unstable::lang::local_free;

src/libcore/core.rc

@@ -179,9 +179,9 @@ pub mod managed;
 
 /* Core language traits */
 
-#[cfg(notest)] pub mod kinds;
-#[cfg(notest)] pub mod ops;
-#[cfg(notest)] pub mod cmp;
+#[cfg(not(test))] pub mod kinds;
+#[cfg(not(test))] pub mod ops;
+#[cfg(not(test))] pub mod cmp;
 
 
 /* Common traits */

src/libcore/logging.rs

@@ -42,7 +42,7 @@ pub fn console_off() {
     }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 #[lang="log_type"]
 pub fn log_type<T>(level: u32, object: &T) {
     use cast::transmute;

src/libcore/managed.rs

@@ -12,7 +12,7 @@
 
 use ptr::to_unsafe_ptr;
 
-#[cfg(notest)] use cmp::{Eq, Ord};
+#[cfg(not(test))] use cmp::{Eq, Ord};
 
 pub mod raw {
     use intrinsic::TyDesc;
@@ -49,23 +49,23 @@ pub fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool {
     a_ptr == b_ptr
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl<T:Eq> Eq for @T {
     #[inline(always)]
     fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) }
     #[inline(always)]
     fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl<T:Eq> Eq for @mut T {
     #[inline(always)]
     fn eq(&self, other: &@mut T) -> bool { *(*self) == *(*other) }
     #[inline(always)]
     fn ne(&self, other: &@mut T) -> bool { *(*self) != *(*other) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl<T:Ord> Ord for @T {
     #[inline(always)]
     fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) }
@@ -77,7 +77,7 @@ impl<T:Ord> Ord for @T {
     fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl<T:Ord> Ord for @mut T {
     #[inline(always)]
     fn lt(&self, other: &@mut T) -> bool { *(*self) < *(*other) }

src/libcore/nil.rs

@@ -14,18 +14,18 @@ Functions for the unit type.
 
 */
 
-#[cfg(notest)]
+#[cfg(not(test))]
 use prelude::*;
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Eq for () {
     #[inline(always)]
     fn eq(&self, _other: &()) -> bool { true }
     #[inline(always)]
     fn ne(&self, _other: &()) -> bool { false }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Ord for () {
     #[inline(always)]
     fn lt(&self, _other: &()) -> bool { false }
@@ -37,13 +37,13 @@ impl Ord for () {
     fn gt(&self, _other: &()) -> bool { false }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl TotalOrd for () {
     #[inline(always)]
     fn cmp(&self, _other: &()) -> Ordering { Equal }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl TotalEq for () {
     #[inline(always)]
     fn equals(&self, _other: &()) -> bool { true }

src/libcore/num/f32.rs

@@ -198,15 +198,15 @@ pub mod consts {
 
 impl Num for f32 {}
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Eq for f32 {
     #[inline(always)]
     fn eq(&self, other: &f32) -> bool { (*self) == (*other) }
     #[inline(always)]
     fn ne(&self, other: &f32) -> bool { (*self) != (*other) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl ApproxEq<f32> for f32 {
     #[inline(always)]
     fn approx_epsilon() -> f32 { 1.0e-6 }
@@ -222,7 +222,7 @@ impl ApproxEq<f32> for f32 {
     }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Ord for f32 {
     #[inline(always)]
     fn lt(&self, other: &f32) -> bool { (*self) < (*other) }
@@ -272,37 +272,37 @@ impl One for f32 {
     fn one() -> f32 { 1.0 }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Add<f32,f32> for f32 {
     #[inline(always)]
     fn add(&self, other: &f32) -> f32 { *self + *other }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Sub<f32,f32> for f32 {
     #[inline(always)]
     fn sub(&self, other: &f32) -> f32 { *self - *other }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Mul<f32,f32> for f32 {
     #[inline(always)]
     fn mul(&self, other: &f32) -> f32 { *self * *other }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Div<f32,f32> for f32 {
     #[inline(always)]
     fn div(&self, other: &f32) -> f32 { *self / *other }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Rem<f32,f32> for f32 {
     #[inline(always)]
     fn rem(&self, other: &f32) -> f32 { *self % *other }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Neg<f32> for f32 {
     #[inline(always)]
     fn neg(&self) -> f32 { -*self }

src/libcore/num/f64.rs

@@ -221,15 +221,15 @@ pub mod consts {
 
 impl Num for f64 {}
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Eq for f64 {
     #[inline(always)]
     fn eq(&self, other: &f64) -> bool { (*self) == (*other) }
     #[inline(always)]
     fn ne(&self, other: &f64) -> bool { (*self) != (*other) }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl ApproxEq<f64> for f64 {
     #[inline(always)]
     fn approx_epsilon() -> f64 { 1.0e-6 }
@@ -245,7 +245,7 @@ impl ApproxEq<f64> for f64 {
     }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Ord for f64 {
     #[inline(always)]
     fn lt(&self, other: &f64) -> bool { (*self) < (*other) }
@@ -295,28 +295,28 @@ impl One for f64 {
     fn one() -> f64 { 1.0 }
 }
 
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Add<f64,f64> for f64 {
     fn add(&self, other: &f64) -> f64 { *self + *other }
 }
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Sub<f64,f64> for f64 {
     fn sub(&self, other: &f64) -> f64 { *self - *other }
 }
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Mul<f64,f64> for f64 {
     fn mul(&self, other: &f64) -> f64 { *self * *other }
 }
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Div<f64,f64> for f64 {
     fn div(&self, other: &f64) -> f64 { *self / *other }
 }
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Rem<f64,f64> for f64 {
     #[inline(always)]
     fn rem(&self, other: &f64) -> f64 { *self % *other }
 }
-#[cfg(notest)]
+#[cfg(not(test))]
 impl Neg<f64> for f64 {
     fn neg(&self) -> f64 { -*self }
 }