src/libcoretest/fmt/num.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10 #![allow(unsigned_negation)]
  11
  12 use core::fmt::radix;
  13
  14 #[test]
  15 fn test_format_int() {
  16     // Formatting integers should select the right implementation based off
  17     // the type of the argument. Also, hex/octal/binary should be defined
  18     // for integers, but they shouldn't emit the negative sign.
  19     assert!(format!("{}", 1isize) == "1");
  20     assert!(format!("{}", 1i8) == "1");
  21     assert!(format!("{}", 1i16) == "1");
  22     assert!(format!("{}", 1i32) == "1");
  23     assert!(format!("{}", 1i64) == "1");
  24     assert!(format!("{}", -1isize) == "-1");
  25     assert!(format!("{}", -1i8) == "-1");
  26     assert!(format!("{}", -1i16) == "-1");
  27     assert!(format!("{}", -1i32) == "-1");
  28     assert!(format!("{}", -1i64) == "-1");
  29     assert!(format!("{:?}", 1isize) == "1");
  30     assert!(format!("{:?}", 1i8) == "1");
  31     assert!(format!("{:?}", 1i16) == "1");
  32     assert!(format!("{:?}", 1i32) == "1");
  33     assert!(format!("{:?}", 1i64) == "1");
  34     assert!(format!("{:b}", 1isize) == "1");
  35     assert!(format!("{:b}", 1i8) == "1");
  36     assert!(format!("{:b}", 1i16) == "1");
  37     assert!(format!("{:b}", 1i32) == "1");
  38     assert!(format!("{:b}", 1i64) == "1");
  39     assert!(format!("{:x}", 1isize) == "1");
  40     assert!(format!("{:x}", 1i8) == "1");
  41     assert!(format!("{:x}", 1i16) == "1");
  42     assert!(format!("{:x}", 1i32) == "1");
  43     assert!(format!("{:x}", 1i64) == "1");
  44     assert!(format!("{:X}", 1isize) == "1");
  45     assert!(format!("{:X}", 1i8) == "1");
  46     assert!(format!("{:X}", 1i16) == "1");
  47     assert!(format!("{:X}", 1i32) == "1");
  48     assert!(format!("{:X}", 1i64) == "1");
  49     assert!(format!("{:o}", 1isize) == "1");
  50     assert!(format!("{:o}", 1i8) == "1");
  51     assert!(format!("{:o}", 1i16) == "1");
  52     assert!(format!("{:o}", 1i32) == "1");
  53     assert!(format!("{:o}", 1i64) == "1");
  54
  55     assert!(format!("{}", 1usize) == "1");
  56     assert!(format!("{}", 1u8) == "1");
  57     assert!(format!("{}", 1u16) == "1");
  58     assert!(format!("{}", 1u32) == "1");
  59     assert!(format!("{}", 1u64) == "1");
  60     assert!(format!("{:?}", 1usize) == "1");
  61     assert!(format!("{:?}", 1u8) == "1");
  62     assert!(format!("{:?}", 1u16) == "1");
  63     assert!(format!("{:?}", 1u32) == "1");
  64     assert!(format!("{:?}", 1u64) == "1");
  65     assert!(format!("{:b}", 1usize) == "1");
  66     assert!(format!("{:b}", 1u8) == "1");
  67     assert!(format!("{:b}", 1u16) == "1");
  68     assert!(format!("{:b}", 1u32) == "1");
  69     assert!(format!("{:b}", 1u64) == "1");
  70     assert!(format!("{:x}", 1usize) == "1");
  71     assert!(format!("{:x}", 1u8) == "1");
  72     assert!(format!("{:x}", 1u16) == "1");
  73     assert!(format!("{:x}", 1u32) == "1");
  74     assert!(format!("{:x}", 1u64) == "1");
  75     assert!(format!("{:X}", 1usize) == "1");
  76     assert!(format!("{:X}", 1u8) == "1");
  77     assert!(format!("{:X}", 1u16) == "1");
  78     assert!(format!("{:X}", 1u32) == "1");
  79     assert!(format!("{:X}", 1u64) == "1");
  80     assert!(format!("{:o}", 1usize) == "1");
  81     assert!(format!("{:o}", 1u8) == "1");
  82     assert!(format!("{:o}", 1u16) == "1");
  83     assert!(format!("{:o}", 1u32) == "1");
  84     assert!(format!("{:o}", 1u64) == "1");
  85
  86     // Test a larger number
  87     assert!(format!("{:b}", 55) == "110111");
  88     assert!(format!("{:o}", 55) == "67");
  89     assert!(format!("{}", 55) == "55");
  90     assert!(format!("{:x}", 55) == "37");
  91     assert!(format!("{:X}", 55) == "37");
  92 }
  93
  94 #[test]
  95 fn test_format_int_zero() {
  96     assert!(format!("{}", 0) == "0");
  97     assert!(format!("{:?}", 0) == "0");
  98     assert!(format!("{:b}", 0) == "0");
  99     assert!(format!("{:o}", 0) == "0");
 100     assert!(format!("{:x}", 0) == "0");
 101     assert!(format!("{:X}", 0) == "0");
 102
 103     assert!(format!("{}", 0u32) == "0");
 104     assert!(format!("{:?}", 0u32) == "0");
 105     assert!(format!("{:b}", 0u32) == "0");
 106     assert!(format!("{:o}", 0u32) == "0");
 107     assert!(format!("{:x}", 0u32) == "0");
 108     assert!(format!("{:X}", 0u32) == "0");
 109 }
 110
 111 #[test]
 112 fn test_format_int_flags() {
 113     assert!(format!("{:3}", 1) == "  1");
 114     assert!(format!("{:>3}", 1) == "  1");
 115     assert!(format!("{:>+3}", 1) == " +1");
 116     assert!(format!("{:<3}", 1) == "1  ");
 117     assert!(format!("{:#}", 1) == "1");
 118     assert!(format!("{:#x}", 10) == "0xa");
 119     assert!(format!("{:#X}", 10) == "0xA");
 120     assert!(format!("{:#5x}", 10) == "  0xa");
 121     assert!(format!("{:#o}", 10) == "0o12");
 122     assert!(format!("{:08x}", 10) == "0000000a");
 123     assert!(format!("{:8x}", 10) == "       a");
 124     assert!(format!("{:<8x}", 10) == "a       ");
 125     assert!(format!("{:>8x}", 10) == "       a");
 126     assert!(format!("{:#08x}", 10) == "0x00000a");
 127     assert!(format!("{:08}", -10) == "-0000010");
 128     assert!(format!("{:x}", !0u8) == "ff");
 129     assert!(format!("{:X}", !0u8) == "FF");
 130     assert!(format!("{:b}", !0u8) == "11111111");
 131     assert!(format!("{:o}", !0u8) == "377");
 132     assert!(format!("{:#x}", !0u8) == "0xff");
 133     assert!(format!("{:#X}", !0u8) == "0xFF");
 134     assert!(format!("{:#b}", !0u8) == "0b11111111");
 135     assert!(format!("{:#o}", !0u8) == "0o377");
 136 }
 137
 138 #[test]
 139 fn test_format_int_sign_padding() {
 140     assert!(format!("{:+5}", 1) == "   +1");
 141     assert!(format!("{:+5}", -1) == "   -1");
 142     assert!(format!("{:05}", 1) == "00001");
 143     assert!(format!("{:05}", -1) == "-0001");
 144     assert!(format!("{:+05}", 1) == "+0001");
 145     assert!(format!("{:+05}", -1) == "-0001");
 146 }
 147
 148 #[test]
 149 fn test_format_int_twos_complement() {
 150     use core::{i8, i16, i32, i64};
 151     assert!(format!("{}", i8::MIN) == "-128");
 152     assert!(format!("{}", i16::MIN) == "-32768");
 153     assert!(format!("{}", i32::MIN) == "-2147483648");
 154     assert!(format!("{}", i64::MIN) == "-9223372036854775808");
 155 }
 156
 157 #[test]
 158 fn test_format_radix() {
 159     assert!(format!("{:04}", radix(3, 2)) == "0011");
 160     assert!(format!("{}", radix(55, 36)) == "1j");
 161 }
 162
 163 #[test]
 164 #[should_panic]
 165 fn test_radix_base_too_large() {
 166     let _ = radix(55, 37);
 167 }
 168
 169 mod u32 {
 170     use test::Bencher;
 171     use core::fmt::radix;
 172     use std::__rand::{thread_rng, Rng};
 173     use std::io::{Write, sink};
 174
 175     #[bench]
 176     fn format_bin(b: &mut Bencher) {
 177         let mut rng = thread_rng();
 178         b.iter(|| { write!(&mut sink(), "{:b}", rng.gen::<u32>()) })
 179     }
 180
 181     #[bench]
 182     fn format_oct(b: &mut Bencher) {
 183         let mut rng = thread_rng();
 184         b.iter(|| { write!(&mut sink(), "{:o}", rng.gen::<u32>()) })
 185     }
 186
 187     #[bench]
 188     fn format_dec(b: &mut Bencher) {
 189         let mut rng = thread_rng();
 190         b.iter(|| { write!(&mut sink(), "{}", rng.gen::<u32>()) })
 191     }
 192
 193     #[bench]
 194     fn format_hex(b: &mut Bencher) {
 195         let mut rng = thread_rng();
 196         b.iter(|| { write!(&mut sink(), "{:x}", rng.gen::<u32>()) })
 197     }
 198
 199     #[bench]
 200     fn format_show(b: &mut Bencher) {
 201         let mut rng = thread_rng();
 202         b.iter(|| { write!(&mut sink(), "{:?}", rng.gen::<u32>()) })
 203     }
 204
 205     #[bench]
 206     fn format_base_36(b: &mut Bencher) {
 207         let mut rng = thread_rng();
 208         b.iter(|| { write!(&mut sink(), "{}", radix(rng.gen::<u32>(), 36)) })
 209     }
 210 }
 211
 212 mod i32 {
 213     use test::Bencher;
 214     use core::fmt::radix;
 215     use std::__rand::{thread_rng, Rng};
 216     use std::io::{Write, sink};
 217
 218     #[bench]
 219     fn format_bin(b: &mut Bencher) {
 220         let mut rng = thread_rng();
 221         b.iter(|| { write!(&mut sink(), "{:b}", rng.gen::<i32>()) })
 222     }
 223
 224     #[bench]
 225     fn format_oct(b: &mut Bencher) {
 226         let mut rng = thread_rng();
 227         b.iter(|| { write!(&mut sink(), "{:o}", rng.gen::<i32>()) })
 228     }
 229
 230     #[bench]
 231     fn format_dec(b: &mut Bencher) {
 232         let mut rng = thread_rng();
 233         b.iter(|| { write!(&mut sink(), "{}", rng.gen::<i32>()) })
 234     }
 235
 236     #[bench]
 237     fn format_hex(b: &mut Bencher) {
 238         let mut rng = thread_rng();
 239         b.iter(|| { write!(&mut sink(), "{:x}", rng.gen::<i32>()) })
 240     }
 241
 242     #[bench]
 243     fn format_show(b: &mut Bencher) {
 244         let mut rng = thread_rng();
 245         b.iter(|| { write!(&mut sink(), "{:?}", rng.gen::<i32>()) })
 246     }
 247
 248     #[bench]
 249     fn format_base_36(b: &mut Bencher) {
 250         let mut rng = thread_rng();
 251         b.iter(|| { write!(&mut sink(), "{}", radix(rng.gen::<i32>(), 36)) })
 252     }
 253 }