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).as_slice() == "1");
  20     assert!(format!("{}", 1i8).as_slice() == "1");
  21     assert!(format!("{}", 1i16).as_slice() == "1");
  22     assert!(format!("{}", 1i32).as_slice() == "1");
  23     assert!(format!("{}", 1i64).as_slice() == "1");
  24     assert!(format!("{:d}", -1i).as_slice() == "-1");
  25     assert!(format!("{:d}", -1i8).as_slice() == "-1");
  26     assert!(format!("{:d}", -1i16).as_slice() == "-1");
  27     assert!(format!("{:d}", -1i32).as_slice() == "-1");
  28     assert!(format!("{:d}", -1i64).as_slice() == "-1");
  29     assert!(format!("{:t}", 1i).as_slice() == "1");
  30     assert!(format!("{:t}", 1i8).as_slice() == "1");
  31     assert!(format!("{:t}", 1i16).as_slice() == "1");
  32     assert!(format!("{:t}", 1i32).as_slice() == "1");
  33     assert!(format!("{:t}", 1i64).as_slice() == "1");
  34     assert!(format!("{:x}", 1i).as_slice() == "1");
  35     assert!(format!("{:x}", 1i8).as_slice() == "1");
  36     assert!(format!("{:x}", 1i16).as_slice() == "1");
  37     assert!(format!("{:x}", 1i32).as_slice() == "1");
  38     assert!(format!("{:x}", 1i64).as_slice() == "1");
  39     assert!(format!("{:X}", 1i).as_slice() == "1");
  40     assert!(format!("{:X}", 1i8).as_slice() == "1");
  41     assert!(format!("{:X}", 1i16).as_slice() == "1");
  42     assert!(format!("{:X}", 1i32).as_slice() == "1");
  43     assert!(format!("{:X}", 1i64).as_slice() == "1");
  44     assert!(format!("{:o}", 1i).as_slice() == "1");
  45     assert!(format!("{:o}", 1i8).as_slice() == "1");
  46     assert!(format!("{:o}", 1i16).as_slice() == "1");
  47     assert!(format!("{:o}", 1i32).as_slice() == "1");
  48     assert!(format!("{:o}", 1i64).as_slice() == "1");
  49
  50     assert!(format!("{}", 1u).as_slice() == "1");
  51     assert!(format!("{}", 1u8).as_slice() == "1");
  52     assert!(format!("{}", 1u16).as_slice() == "1");
  53     assert!(format!("{}", 1u32).as_slice() == "1");
  54     assert!(format!("{}", 1u64).as_slice() == "1");
  55     assert!(format!("{:u}", 1u).as_slice() == "1");
  56     assert!(format!("{:u}", 1u8).as_slice() == "1");
  57     assert!(format!("{:u}", 1u16).as_slice() == "1");
  58     assert!(format!("{:u}", 1u32).as_slice() == "1");
  59     assert!(format!("{:u}", 1u64).as_slice() == "1");
  60     assert!(format!("{:t}", 1u).as_slice() == "1");
  61     assert!(format!("{:t}", 1u8).as_slice() == "1");
  62     assert!(format!("{:t}", 1u16).as_slice() == "1");
  63     assert!(format!("{:t}", 1u32).as_slice() == "1");
  64     assert!(format!("{:t}", 1u64).as_slice() == "1");
  65     assert!(format!("{:x}", 1u).as_slice() == "1");
  66     assert!(format!("{:x}", 1u8).as_slice() == "1");
  67     assert!(format!("{:x}", 1u16).as_slice() == "1");
  68     assert!(format!("{:x}", 1u32).as_slice() == "1");
  69     assert!(format!("{:x}", 1u64).as_slice() == "1");
  70     assert!(format!("{:X}", 1u).as_slice() == "1");
  71     assert!(format!("{:X}", 1u8).as_slice() == "1");
  72     assert!(format!("{:X}", 1u16).as_slice() == "1");
  73     assert!(format!("{:X}", 1u32).as_slice() == "1");
  74     assert!(format!("{:X}", 1u64).as_slice() == "1");
  75     assert!(format!("{:o}", 1u).as_slice() == "1");
  76     assert!(format!("{:o}", 1u8).as_slice() == "1");
  77     assert!(format!("{:o}", 1u16).as_slice() == "1");
  78     assert!(format!("{:o}", 1u32).as_slice() == "1");
  79     assert!(format!("{:o}", 1u64).as_slice() == "1");
  80
  81     // Test a larger number
  82     assert!(format!("{:t}", 55i).as_slice() == "110111");
  83     assert!(format!("{:o}", 55i).as_slice() == "67");
  84     assert!(format!("{:d}", 55i).as_slice() == "55");
  85     assert!(format!("{:x}", 55i).as_slice() == "37");
  86     assert!(format!("{:X}", 55i).as_slice() == "37");
  87 }
  88
  89 #[test]
  90 fn test_format_int_zero() {
  91     assert!(format!("{}", 0i).as_slice() == "0");
  92     assert!(format!("{:d}", 0i).as_slice() == "0");
  93     assert!(format!("{:t}", 0i).as_slice() == "0");
  94     assert!(format!("{:o}", 0i).as_slice() == "0");
  95     assert!(format!("{:x}", 0i).as_slice() == "0");
  96     assert!(format!("{:X}", 0i).as_slice() == "0");
  97
  98     assert!(format!("{}", 0u).as_slice() == "0");
  99     assert!(format!("{:u}", 0u).as_slice() == "0");
 100     assert!(format!("{:t}", 0u).as_slice() == "0");
 101     assert!(format!("{:o}", 0u).as_slice() == "0");
 102     assert!(format!("{:x}", 0u).as_slice() == "0");
 103     assert!(format!("{:X}", 0u).as_slice() == "0");
 104 }
 105
 106 #[test]
 107 fn test_format_int_flags() {
 108     assert!(format!("{:3d}", 1i).as_slice() == "  1");
 109     assert!(format!("{:>3d}", 1i).as_slice() == "  1");
 110     assert!(format!("{:>+3d}", 1i).as_slice() == " +1");
 111     assert!(format!("{:<3d}", 1i).as_slice() == "1  ");
 112     assert!(format!("{:#d}", 1i).as_slice() == "1");
 113     assert!(format!("{:#x}", 10i).as_slice() == "0xa");
 114     assert!(format!("{:#X}", 10i).as_slice() == "0xA");
 115     assert!(format!("{:#5x}", 10i).as_slice() == "  0xa");
 116     assert!(format!("{:#o}", 10i).as_slice() == "0o12");
 117     assert!(format!("{:08x}", 10i).as_slice() == "0000000a");
 118     assert!(format!("{:8x}", 10i).as_slice() == "       a");
 119     assert!(format!("{:<8x}", 10i).as_slice() == "a       ");
 120     assert!(format!("{:>8x}", 10i).as_slice() == "       a");
 121     assert!(format!("{:#08x}", 10i).as_slice() == "0x00000a");
 122     assert!(format!("{:08d}", -10i).as_slice() == "-0000010");
 123     assert!(format!("{:x}", -1u8).as_slice() == "ff");
 124     assert!(format!("{:X}", -1u8).as_slice() == "FF");
 125     assert!(format!("{:t}", -1u8).as_slice() == "11111111");
 126     assert!(format!("{:o}", -1u8).as_slice() == "377");
 127     assert!(format!("{:#x}", -1u8).as_slice() == "0xff");
 128     assert!(format!("{:#X}", -1u8).as_slice() == "0xFF");
 129     assert!(format!("{:#t}", -1u8).as_slice() == "0b11111111");
 130     assert!(format!("{:#o}", -1u8).as_slice() == "0o377");
 131 }
 132
 133 #[test]
 134 fn test_format_int_sign_padding() {
 135     assert!(format!("{:+5d}", 1i).as_slice() == "   +1");
 136     assert!(format!("{:+5d}", -1i).as_slice() == "   -1");
 137     assert!(format!("{:05d}", 1i).as_slice() == "00001");
 138     assert!(format!("{:05d}", -1i).as_slice() == "-0001");
 139     assert!(format!("{:+05d}", 1i).as_slice() == "+0001");
 140     assert!(format!("{:+05d}", -1i).as_slice() == "-0001");
 141 }
 142
 143 #[test]
 144 fn test_format_int_twos_complement() {
 145     use core::{i8, i16, i32, i64};
 146     assert!(format!("{}", i8::MIN).as_slice() == "-128");
 147     assert!(format!("{}", i16::MIN).as_slice() == "-32768");
 148     assert!(format!("{}", i32::MIN).as_slice() == "-2147483648");
 149     assert!(format!("{}", i64::MIN).as_slice() == "-9223372036854775808");
 150 }
 151
 152 #[test]
 153 fn test_format_radix() {
 154     assert!(format!("{:04}", radix(3i, 2)).as_slice() == "0011");
 155     assert!(format!("{}", radix(55i, 36)).as_slice() == "1j");
 156 }
 157
 158 #[test]
 159 #[should_fail]
 160 fn test_radix_base_too_large() {
 161     let _ = radix(55i, 37);
 162 }
 163
 164 mod uint {
 165     use test::Bencher;
 166     use core::fmt::radix;
 167     use std::rand::{weak_rng, Rng};
 168
 169     #[bench]
 170     fn format_bin(b: &mut Bencher) {
 171         let mut rng = weak_rng();
 172         b.iter(|| { format!("{:t}", rng.gen::<uint>()); })
 173     }
 174
 175     #[bench]
 176     fn format_oct(b: &mut Bencher) {
 177         let mut rng = weak_rng();
 178         b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
 179     }
 180
 181     #[bench]
 182     fn format_dec(b: &mut Bencher) {
 183         let mut rng = weak_rng();
 184         b.iter(|| { format!("{:u}", rng.gen::<uint>()); })
 185     }
 186
 187     #[bench]
 188     fn format_hex(b: &mut Bencher) {
 189         let mut rng = weak_rng();
 190         b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
 191     }
 192
 193     #[bench]
 194     fn format_base_36(b: &mut Bencher) {
 195         let mut rng = weak_rng();
 196         b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
 197     }
 198 }
 199
 200 mod int {
 201     use test::Bencher;
 202     use core::fmt::radix;
 203     use std::rand::{weak_rng, Rng};
 204
 205     #[bench]
 206     fn format_bin(b: &mut Bencher) {
 207         let mut rng = weak_rng();
 208         b.iter(|| { format!("{:t}", rng.gen::<int>()); })
 209     }
 210
 211     #[bench]
 212     fn format_oct(b: &mut Bencher) {
 213         let mut rng = weak_rng();
 214         b.iter(|| { format!("{:o}", rng.gen::<int>()); })
 215     }
 216
 217     #[bench]
 218     fn format_dec(b: &mut Bencher) {
 219         let mut rng = weak_rng();
 220         b.iter(|| { format!("{:d}", rng.gen::<int>()); })
 221     }
 222
 223     #[bench]
 224     fn format_hex(b: &mut Bencher) {
 225         let mut rng = weak_rng();
 226         b.iter(|| { format!("{:x}", rng.gen::<int>()); })
 227     }
 228
 229     #[bench]
 230     fn format_base_36(b: &mut Bencher) {
 231         let mut rng = weak_rng();
 232         b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
 233     }
 234 }