separator-0.4.0/.gitignore010064400017500001750000000000221337630077600137320ustar0000000000000000target Cargo.lock separator-0.4.0/.travis.yml010064400017500001750000000001131337630077600140540ustar0000000000000000language: rust script: - cargo build --verbose - cargo test --verbose separator-0.4.0/Cargo.toml.orig010064400017500001750000000005171337630103600146300ustar0000000000000000[package] name = "separator" version = "0.4.0" authors = ["Saghm Rossi "] description = "Formats numbers into strings with thousands separators for readability." repository = "https://github.com/saghm/rust-separator" readme = "README.md" keywords = ["comma", "separate", "num", "number", "split"] license = "MIT" separator-0.4.0/Cargo.toml0000644000000015330000000000000110740ustar00# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g. crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] name = "separator" version = "0.4.0" authors = ["Saghm Rossi "] description = "Formats numbers into strings with thousands separators for readability." readme = "README.md" keywords = ["comma", "separate", "num", "number", "split"] license = "MIT" repository = "https://github.com/saghm/rust-separator" separator-0.4.0/LICENSE010064400017500001750000000020671337630077600127620ustar0000000000000000The MIT License (MIT) Copyright (c) 2015 Saghm Rossi Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. separator-0.4.0/README.md010064400017500001750000000016131337630077600132300ustar0000000000000000[![crates.io](https://img.shields.io/crates/v/separator.svg)](https://crates.io/crates/separator) [![Build Status](https://travis-ci.org/saghm/rust-separator.svg?branch=master)](https://travis-ci.org/saghm/rust-separator) rust-separator ============== Formats numbers into strings with thousands separators for readability. It currently supports floating-points (`f32` and `f64`), unsigned integers (`u16`, `u32`, `u64`, `u128`), signed integers (`i16`, `i32`, `i64`, `i128`), and size types (`isize` and `usize`). Usage ----- First, put `separator` as a dependency in your `Cargo.toml` as usual: ``` [dependencies] separator = "0.3.1" ``` Then, import the `Separatable` trait, and call the `separated_string` on a number: ``` extern crate separator; use separator::Separatable; fn main() { let f = -120000000.34345; // Prints "-12,000,000.34345" println!("{}", f.separated_string()); } ``` separator-0.4.0/src/float/fixed_place_separatable.rs010064400017500001750000000010141337630077600210140ustar0000000000000000pub trait FixedPlaceSeparatable { fn separated_string_with_fixed_place(&self, places: usize) -> String; } impl FixedPlaceSeparatable for f32 { fn separated_string_with_fixed_place(&self, places: usize) -> String { let string = format!("{:.*}", places, self); separated_float!(string) } } impl FixedPlaceSeparatable for f64 { fn separated_string_with_fixed_place(&self, places: usize) -> String { let string = format!("{:.*}", places, self); separated_float!(string) } } separator-0.4.0/src/float/mod.rs010064400017500001750000000001551337630077600147720ustar0000000000000000mod separatable; mod fixed_place_separatable; pub use self::fixed_place_separatable::FixedPlaceSeparatable; separator-0.4.0/src/float/separatable.rs010064400017500001750000000022251337630077600164760ustar0000000000000000use Separatable; macro_rules! separated_float { ($string:expr) => {{ let idx = match $string.find('.') { Some(i) => i, None => $string.len() }; let int_part = &$string[..idx]; let fract_part = &$string[idx..]; let mut output = String::new(); let magnitude = if int_part.starts_with('-') { output.push('-'); int_part[1..].to_owned() } else { int_part.to_owned() }; let mut place = magnitude.len(); let mut later_loop = false; for ch in magnitude.chars() { if later_loop && place % 3 == 0 { output.push(','); } output.push(ch); later_loop = true; place -= 1; }; output.push_str(fract_part); output }}; } impl Separatable for f32 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_float!(string) } } impl Separatable for f64 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_float!(string) } } separator-0.4.0/src/isize.rs010064400017500001750000000002531337630077600142300ustar0000000000000000use Separatable; impl Separatable for usize { fn separated_string(&self) -> String { let string = format!("{}", self); separated_int!(string) } } separator-0.4.0/src/lib.rs010064400017500001750000000005441337630077600136560ustar0000000000000000#[macro_use] mod macros; pub mod float; pub mod signed_int; pub mod unsigned_int; pub mod usize; pub use float::FixedPlaceSeparatable; /// Used for numbers that can be printed with separators for the thousands places. pub trait Separatable { /// Converts the number to a string with thousands separator. fn separated_string(&self) -> String; } separator-0.4.0/src/macros.rs010064400017500001750000000024471337630077600144000ustar0000000000000000#[macro_export] macro_rules! separated_uint_with_output { ($string:expr, $output:expr) => {{ let mut place = $string.len(); let mut later_loop = false; for ch in $string.chars() { if later_loop && place % 3 == 0 { $output.push(','); } $output.push(ch); later_loop = true; place -= 1; }; $output }}; } #[macro_export] macro_rules! separated_uint { ($string:expr) => {{ let mut output = String::new(); separated_uint_with_output!($string, output) }} } #[macro_export] macro_rules! separated_int { ($string:expr) => {{ let mut output = String::new(); let magnitude = if $string.starts_with('-') { output.push('-'); (&$string)[1..].to_owned() } else { $string }; separated_uint_with_output!(magnitude, output) }}; } #[macro_export] macro_rules! separated_float { ($string:expr) => {{ let idx = match $string.find('.') { Some(i) => i, None => $string.len() }; let int_part = (&$string[..idx]).to_owned(); let fract_part = &$string[idx..]; let output = separated_int!(int_part); output + fract_part }}; } separator-0.4.0/src/signed_int.rs010064400017500001750000000011621337630077600152300ustar0000000000000000use Separatable; impl Separatable for i16 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_int!(string) } } impl Separatable for i32 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_int!(string) } } impl Separatable for i64 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_int!(string) } } impl Separatable for i128 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_int!(string) } } separator-0.4.0/src/unsigned_int.rs010064400017500001750000000011661337630077600155770ustar0000000000000000use Separatable; impl Separatable for u16 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_uint!(string) } } impl Separatable for u32 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_uint!(string) } } impl Separatable for u64 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_uint!(string) } } impl Separatable for u128 { fn separated_string(&self) -> String { let string = format!("{}", self); separated_uint!(string) } } separator-0.4.0/src/usize.rs010064400017500001750000000002541337630077600142450ustar0000000000000000use Separatable; impl Separatable for usize { fn separated_string(&self) -> String { let string = format!("{}", self); separated_uint!(string) } } separator-0.4.0/tests/custom.rs010064400017500001750000000005711337630077600147750ustar0000000000000000#[macro_use] extern crate separator; use separator::Separatable; struct CustomNum(u32); impl Separatable for CustomNum { fn separated_string(&self) -> String { let string = format!("{}", self.0); separated_uint!(string) } } #[test] fn nine_hundred_million() { let i = CustomNum(900000000); assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/float/f32/mod.rs010064400017500001750000000017141337630077600157410ustar0000000000000000use separator::{FixedPlaceSeparatable, Separatable}; #[test] fn nine_million() { let f : f32 = 9000000.0; assert_eq!("9,000,000", &f.separated_string()); } #[test] fn negative_ninety_thousand_point_one() { let f : f32 = -90000.1; assert_eq!("-90,000.1", &f.separated_string()); } #[test] fn nine_thousand_point_one_two() { let f : f32 = 9000.12; assert_eq!("9,000.12", &f.separated_string()); } #[test] fn negative_nine_hundred_point_three_five_eight() { let f : f32 = -900.358; assert_eq!("-900.358", &f.separated_string()); } #[test] fn ninety_point_one_point_two_one_three_four() { let f : f32 = 90.2134; assert_eq!("90.2134", &f.separated_string()); } #[test] fn negative_nine_point_five_ish() { let f : f32 = -9.558914; assert_eq!("-9.558914", &f.separated_string()); } #[test] fn format_to_three_places() { let f : f32 = -9057.1234; assert_eq!("-9,057.123", &f.separated_string_with_fixed_place(3)); } separator-0.4.0/tests/float/f64/mod.rs010064400017500001750000000021501337630077600157410ustar0000000000000000use separator::{FixedPlaceSeparatable ,Separatable}; #[test] fn negative_ninety_million_point_two_two_two() { let f : f64 = -90000000.222; assert_eq!("-90,000,000.222", &f.separated_string()); } #[test] fn nine_million() { let f : f64 = 9000000.0; assert_eq!("9,000,000", &f.separated_string()); } #[test] fn negative_ninety_thousand_point_one() { let f : f64 = -90000.1; assert_eq!("-90,000.1", &f.separated_string()); } #[test] fn nine_thousand_point_one_two() { let f : f64 = 9000.12; assert_eq!("9,000.12", &f.separated_string()); } #[test] fn negative_nine_hundred_point_three_five_eight() { let f : f64 = -900.358; assert_eq!("-900.358", &f.separated_string()); } #[test] fn ninety_point_one_point_two_one_three_four() { let f : f64 = 90.2134; assert_eq!("90.2134", &f.separated_string()); } #[test] fn negative_nine_point_five_ish() { let f : f64 = -9.558914; assert_eq!("-9.558914", &f.separated_string()); } #[test] fn format_to_two_places() { let f : f64 = -9786057.95702; assert_eq!("-9,786,057.96", &f.separated_string_with_fixed_place(2)); } separator-0.4.0/tests/float/mod.rs010064400017500001750000000000221337630077600153360ustar0000000000000000mod f32; mod f64; separator-0.4.0/tests/isize/mod.rs010064400017500001750000000040271337630077600153650ustar0000000000000000use separator::Separatable; #[test] fn negative_nine_hundred_million() { let i : isize = -900000000; assert_eq!("-900,000,000", &i.separated_string()); } #[test] fn negative_ninety_million() { let i : isize = -90000000; assert_eq!("-90,000,000", &i.separated_string()); } #[test] fn negative_nine_million() { let i : isize = -9000000; assert_eq!("-9,000,000", &i.separated_string()); } #[test] fn negative_nine_hundred_thousand() { let i : isize = -900000; assert_eq!("-900,000", &i.separated_string()); } #[test] fn negative_ninety_thousand() { let i : isize = -90000; assert_eq!("-90,000", &i.separated_string()); } #[test] fn negative_nine_thousand() { let i : isize = -9000; assert_eq!("-9,000", &i.separated_string()); } #[test] fn negative_nine_hundred() { let i : isize = -900; assert_eq!("-900", &i.separated_string()); } #[test] fn negative_ninety() { let i : isize = -90; assert_eq!("-90", &i.separated_string()); } #[test] fn negative_nine() { let i : isize = -9; assert_eq!("-9", &i.separated_string()); } #[test] fn nine() { let i : isize = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : isize = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : isize = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : isize = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : isize = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : isize = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : isize = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : isize = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : isize = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/lib.rs010064400017500001750000000001211337630077600142200ustar0000000000000000extern crate separator; mod float; mod signed_int; mod unsigned_int; mod usize; separator-0.4.0/tests/signed_int/i128/mod.rs010064400017500001750000000040051337630077600170440ustar0000000000000000use separator::Separatable; #[test] fn negative_nine_hundred_million() { let i : i128 = -900000000; assert_eq!("-900,000,000", &i.separated_string()); } #[test] fn negative_ninety_million() { let i : i128 = -90000000; assert_eq!("-90,000,000", &i.separated_string()); } #[test] fn negative_nine_million() { let i : i128 = -9000000; assert_eq!("-9,000,000", &i.separated_string()); } #[test] fn negative_nine_hundred_thousand() { let i : i128 = -900000; assert_eq!("-900,000", &i.separated_string()); } #[test] fn negative_ninety_thousand() { let i : i128 = -90000; assert_eq!("-90,000", &i.separated_string()); } #[test] fn negative_nine_thousand() { let i : i128 = -9000; assert_eq!("-9,000", &i.separated_string()); } #[test] fn negative_nine_hundred() { let i : i128 = -900; assert_eq!("-900", &i.separated_string()); } #[test] fn negative_ninety() { let i : i128 = -90; assert_eq!("-90", &i.separated_string()); } #[test] fn negative_nine() { let i : i128 = -9; assert_eq!("-9", &i.separated_string()); } #[test] fn nine() { let i : i128 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : i128 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : i128 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : i128 = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : i128 = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : i128 = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : i128 = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : i128 = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : i128 = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/signed_int/i16/mod.rs010064400017500001750000000015101337630077600167560ustar0000000000000000use separator::Separatable; #[test] fn negative_nine_thousand() { let i : i16 = -9000; assert_eq!("-9,000", &i.separated_string()); } #[test] fn negative_nine_hundred() { let i : i16 = -900; assert_eq!("-900", &i.separated_string()); } #[test] fn negative_ninety() { let i : i16 = -90; assert_eq!("-90", &i.separated_string()); } #[test] fn negative_nine() { let i : i16 = -9; assert_eq!("-9", &i.separated_string()); } #[test] fn nine() { let i : i16 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : i16 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : i16 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : i16 = 9000; assert_eq!("9,000", &i.separated_string()); } separator-0.4.0/tests/signed_int/i32/mod.rs010064400017500001750000000037631337630077600167700ustar0000000000000000use separator::Separatable; #[test] fn negative_nine_hundred_million() { let i : i32 = -900000000; assert_eq!("-900,000,000", &i.separated_string()); } #[test] fn negative_ninety_million() { let i : i32 = -90000000; assert_eq!("-90,000,000", &i.separated_string()); } #[test] fn negative_nine_million() { let i : i32 = -9000000; assert_eq!("-9,000,000", &i.separated_string()); } #[test] fn negative_nine_hundred_thousand() { let i : i32 = -900000; assert_eq!("-900,000", &i.separated_string()); } #[test] fn negative_ninety_thousand() { let i : i32 = -90000; assert_eq!("-90,000", &i.separated_string()); } #[test] fn negative_nine_thousand() { let i : i32 = -9000; assert_eq!("-9,000", &i.separated_string()); } #[test] fn negative_nine_hundred() { let i : i32 = -900; assert_eq!("-900", &i.separated_string()); } #[test] fn negative_ninety() { let i : i32 = -90; assert_eq!("-90", &i.separated_string()); } #[test] fn negative_nine() { let i : i32 = -9; assert_eq!("-9", &i.separated_string()); } #[test] fn nine() { let i : i32 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : i32 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : i32 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : i32 = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : i32 = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : i32 = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : i32 = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : i32 = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : i32 = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/signed_int/i64/mod.rs010064400017500001750000000037631337630077600167750ustar0000000000000000use separator::Separatable; #[test] fn negative_nine_hundred_million() { let i : i64 = -900000000; assert_eq!("-900,000,000", &i.separated_string()); } #[test] fn negative_ninety_million() { let i : i64 = -90000000; assert_eq!("-90,000,000", &i.separated_string()); } #[test] fn negative_nine_million() { let i : i64 = -9000000; assert_eq!("-9,000,000", &i.separated_string()); } #[test] fn negative_nine_hundred_thousand() { let i : i64 = -900000; assert_eq!("-900,000", &i.separated_string()); } #[test] fn negative_ninety_thousand() { let i : i64 = -90000; assert_eq!("-90,000", &i.separated_string()); } #[test] fn negative_nine_thousand() { let i : i64 = -9000; assert_eq!("-9,000", &i.separated_string()); } #[test] fn negative_nine_hundred() { let i : i64 = -900; assert_eq!("-900", &i.separated_string()); } #[test] fn negative_ninety() { let i : i64 = -90; assert_eq!("-90", &i.separated_string()); } #[test] fn negative_nine() { let i : i64 = -9; assert_eq!("-9", &i.separated_string()); } #[test] fn nine() { let i : i64 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : i64 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : i64 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : i64 = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : i64 = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : i64 = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : i64 = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : i64 = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : i64 = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/signed_int/mod.rs010064400017500001750000000000451337630077600163610ustar0000000000000000mod i16; mod i32; mod i64; mod i128; separator-0.4.0/tests/unsigned_int/mod.rs010064400017500001750000000000451337630077600167240ustar0000000000000000mod u16; mod u32; mod u64; mod u128; separator-0.4.0/tests/unsigned_int/u128/mod.rs010064400017500001750000000017371337630077600174340ustar0000000000000000use separator::Separatable; #[test] fn nine() { let i : u128 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : u128 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : u128 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : u128 = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : u128 = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : u128 = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : u128 = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : u128 = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : u128 = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/unsigned_int/u16/mod.rs010064400017500001750000000006341337630077600173430ustar0000000000000000use separator::Separatable; #[test] fn nine() { let i : u16 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : u16 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : u16 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : u16 = 9000; assert_eq!("9,000", &i.separated_string()); } separator-0.4.0/tests/unsigned_int/u32/mod.rs010064400017500001750000000017261337630077600173440ustar0000000000000000use separator::Separatable; #[test] fn nine() { let i : u32 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : u32 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : u32 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : u32 = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : u32 = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : u32 = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : u32 = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : u32 = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : u32 = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/unsigned_int/u64/mod.rs010064400017500001750000000017261337630077600173510ustar0000000000000000use separator::Separatable; #[test] fn nine() { let i : u64 = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : u64 = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : u64 = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : u64 = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : u64 = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : u64 = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : u64 = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : u64 = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : u64 = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/tests/usize/mod.rs010064400017500001750000000017501337630077600154010ustar0000000000000000use separator::Separatable; #[test] fn nine() { let i : usize = 9; assert_eq!("9", &i.separated_string()); } #[test] fn ninety() { let i : usize = 90; assert_eq!("90", &i.separated_string()); } #[test] fn nine_hundred() { let i : usize = 900; assert_eq!("900", &i.separated_string()); } #[test] fn nine_thousand() { let i : usize = 9000; assert_eq!("9,000", &i.separated_string()); } #[test] fn ninety_thousand() { let i : usize = 90000; assert_eq!("90,000", &i.separated_string()); } #[test] fn nine_hundred_thousand() { let i : usize = 900000; assert_eq!("900,000", &i.separated_string()); } #[test] fn nine_million() { let i : usize = 9000000; assert_eq!("9,000,000", &i.separated_string()); } #[test] fn ninety_million() { let i : usize = 90000000; assert_eq!("90,000,000", &i.separated_string()); } #[test] fn nine_hundred_million() { let i : usize = 900000000; assert_eq!("900,000,000", &i.separated_string()); } separator-0.4.0/.cargo_vcs_info.json0000644000000001120000000000000130660ustar00{ "git": { "sha1": "be24256b5dd89745cbaef54ca1c20daabe1ded82" } }