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!("{}", 1i) == "1");
  20     assert!(format!("{}", 1i8) == "1");
  21     assert!(format!("{}", 1i16) == "1");
  22     assert!(format!("{}", 1i32) == "1");
  23     assert!(format!("{}", 1i64) == "1");
  24     assert!(format!("{}", -1i) == "-1");
  25     assert!(format!("{}", -1i8) == "-1");
  26     assert!(format!("{}", -1i16) == "-1");
  27     assert!(format!("{}", -1i32) == "-1");
  28     assert!(format!("{}", -1i64) == "-1");
  29     assert!(format!("{:?}", 1i) == "1i");
  30     assert!(format!("{:?}", 1i8) == "1i8");
  31     assert!(format!("{:?}", 1i16) == "1i16");
  32     assert!(format!("{:?}", 1i32) == "1i32");
  33     assert!(format!("{:?}", 1i64) == "1i64");
  34     assert!(format!("{:b}", 1i) == "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}", 1i) == "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}", 1i) == "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}", 1i) == "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!("{}", 1u) == "1");
  56     assert!(format!("{}", 1u8) == "1");
  57     assert!(format!("{}", 1u16) == "1");
  58     assert!(format!("{}", 1u32) == "1");
  59     assert!(format!("{}", 1u64) == "1");
  60     assert!(format!("{:?}", 1u) == "1u");
  61     assert!(format!("{:?}", 1u8) == "1u8");
  62     assert!(format!("{:?}", 1u16) == "1u16");
  63     assert!(format!("{:?}", 1u32) == "1u32");
  64     assert!(format!("{:?}", 1u64) == "1u64");
  65     assert!(format!("{:b}", 1u) == "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}", 1u) == "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}", 1u) == "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}", 1u) == "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}", 55i) == "110111");
  88     assert!(format!("{:o}", 55i) == "67");
  89     assert!(format!("{}", 55i) == "55");
  90     assert!(format!("{:x}", 55i) == "37");
  91     assert!(format!("{:X}", 55i) == "37");
  92 }
  93
  94 #[test]
  95 fn test_format_int_zero() {
  96     assert!(format!("{}", 0i) == "0");
  97     assert!(format!("{:?}", 0i) == "0i");
  98     assert!(format!("{:b}", 0i) == "0");
  99     assert!(format!("{:o}", 0i) == "0");
 100     assert!(format!("{:x}", 0i) == "0");
 101     assert!(format!("{:X}", 0i) == "0");
 102
 103     assert!(format!("{}", 0u) == "0");
 104     assert!(format!("{:?}", 0u) == "0u");
 105     assert!(format!("{:b}", 0u) == "0");
 106     assert!(format!("{:o}", 0u) == "0");
 107     assert!(format!("{:x}", 0u) == "0");
 108     assert!(format!("{:X}", 0u) == "0");
 109 }
 110
 111 #[test]
 112 fn test_format_int_flags() {
 113     assert!(format!("{:3}", 1i) == "  1");
 114     assert!(format!("{:>3}", 1i) == "  1");
 115     assert!(format!("{:>+3}", 1i) == " +1");
 116     assert!(format!("{:<3}", 1i) == "1  ");
 117     assert!(format!("{:#}", 1i) == "1");
 118     assert!(format!("{:#x}", 10i) == "0xa");
 119     assert!(format!("{:#X}", 10i) == "0xA");
 120     assert!(format!("{:#5x}", 10i) == "  0xa");
 121     assert!(format!("{:#o}", 10i) == "0o12");
 122     assert!(format!("{:08x}", 10i) == "0000000a");
 123     assert!(format!("{:8x}", 10i) == "       a");
 124     assert!(format!("{:<8x}", 10i) == "a       ");
 125     assert!(format!("{:>8x}", 10i) == "       a");
 126     assert!(format!("{:#08x}", 10i) == "0x00000a");
 127     assert!(format!("{:08}", -10i) == "-0000010");
 128     assert!(format!("{:x}", -1u8) == "ff");
 129     assert!(format!("{:X}", -1u8) == "FF");
 130     assert!(format!("{:b}", -1u8) == "11111111");
 131     assert!(format!("{:o}", -1u8) == "377");
 132     assert!(format!("{:#x}", -1u8) == "0xff");
 133     assert!(format!("{:#X}", -1u8) == "0xFF");
 134     assert!(format!("{:#b}", -1u8) == "0b11111111");
 135     assert!(format!("{:#o}", -1u8) == "0o377");
 136 }
 137
 138 #[test]
 139 fn test_format_int_sign_padding() {
 140     assert!(format!("{:+5}", 1i) == "   +1");
 141     assert!(format!("{:+5}", -1i) == "   -1");
 142     assert!(format!("{:05}", 1i) == "00001");
 143     assert!(format!("{:05}", -1i) == "-0001");
 144     assert!(format!("{:+05}", 1i) == "+0001");
 145     assert!(format!("{:+05}", -1i) == "-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(3i, 2)) == "0011");
 160     assert!(format!("{}", radix(55i, 36)) == "1j");
 161 }
 162
 163 #[test]
 164 #[should_fail]
 165 fn test_radix_base_too_large() {
 166     let _ = radix(55i, 37);
 167 }
 168
 169 mod uint {
 170     use test::Bencher;
 171     use core::fmt::radix;
 172     use std::rand::{weak_rng, Rng};
 173
 174     #[bench]
 175     fn format_bin(b: &mut Bencher) {
 176         let mut rng = weak_rng();
 177         b.iter(|| { format!("{:b}", rng.gen::<uint>()); })
 178     }
 179
 180     #[bench]
 181     fn format_oct(b: &mut Bencher) {
 182         let mut rng = weak_rng();
 183         b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
 184     }
 185
 186     #[bench]
 187     fn format_dec(b: &mut Bencher) {
 188         let mut rng = weak_rng();
 189         b.iter(|| { format!("{}", rng.gen::<uint>()); })
 190     }
 191
 192     #[bench]
 193     fn format_hex(b: &mut Bencher) {
 194         let mut rng = weak_rng();
 195         b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
 196     }
 197
 198     #[bench]
 199     fn format_show(b: &mut Bencher) {
 200         let mut rng = weak_rng();
 201         b.iter(|| { format!("{:?}", rng.gen::<uint>()); })
 202     }
 203
 204     #[bench]
 205     fn format_base_36(b: &mut Bencher) {
 206         let mut rng = weak_rng();
 207         b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
 208     }
 209 }
 210
 211 mod int {
 212     use test::Bencher;
 213     use core::fmt::radix;
 214     use std::rand::{weak_rng, Rng};
 215
 216     #[bench]
 217     fn format_bin(b: &mut Bencher) {
 218         let mut rng = weak_rng();
 219         b.iter(|| { format!("{:b}", rng.gen::<int>()); })
 220     }
 221
 222     #[bench]
 223     fn format_oct(b: &mut Bencher) {
 224         let mut rng = weak_rng();
 225         b.iter(|| { format!("{:o}", rng.gen::<int>()); })
 226     }
 227
 228     #[bench]
 229     fn format_dec(b: &mut Bencher) {
 230         let mut rng = weak_rng();
 231         b.iter(|| { format!("{}", rng.gen::<int>()); })
 232     }
 233
 234     #[bench]
 235     fn format_hex(b: &mut Bencher) {
 236         let mut rng = weak_rng();
 237         b.iter(|| { format!("{:x}", rng.gen::<int>()); })
 238     }
 239
 240     #[bench]
 241     fn format_show(b: &mut Bencher) {
 242         let mut rng = weak_rng();
 243         b.iter(|| { format!("{:?}", rng.gen::<int>()); })
 244     }
 245
 246     #[bench]
 247     fn format_base_36(b: &mut Bencher) {
 248         let mut rng = weak_rng();
 249         b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
 250     }
 251 }