newer-type-std 0.3.0

Support defining newtype wrapper with inheriting trait implementations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use newer_type::implement;
use std::fmt::Write;

#[implement(
    newer_type_std::fmt::Display,
    newer_type_std::fmt::Debug,
    newer_type_std::fmt::Binary,
    newer_type_std::fmt::Octal,
    newer_type_std::fmt::LowerHex,
    newer_type_std::fmt::UpperHex,
    newer_type_std::fmt::LowerExp,
    newer_type_std::fmt::UpperExp,
    // newer_type_std::fmt::Pointer,
    // newer_type_std::fmt::Write
)]
pub struct MyFmtStruct {
    inner: u32,
}

#[implement(newer_type_std::fmt::Display, newer_type_std::fmt::Debug)]
pub struct MyGenericFmtStruct<T> {
    inner: T,
}

#[implement(newer_type_std::fmt::Display, newer_type_std::fmt::Debug)]
pub enum MyFmtEnum {
    Text(String),
    Number(i32),
}

#[implement(newer_type_std::fmt::Debug)]
pub enum MyGenericFmtEnum<T> {
    One(T),
    Many(Vec<T>),
}

#[implement(newer_type_std::fmt::Write)]
pub struct MyWriteStruct {
    inner: String,
}

#[implement(newer_type_std::fmt::Write)]
pub enum MyWriteEnum {
    A(String),
    B(std::ffi::OsString),
}

#[test]
fn test_display_debug() {
    let value = MyFmtStruct { inner: 42 };
    assert_eq!(format!("{}", value), "42");
    assert_eq!(format!("{:?}", value), "42");
}

#[test]
fn test_binary_octal_hex() {
    let value = MyFmtStruct { inner: 42 };
    assert_eq!(format!("{:b}", value), "101010");
    assert_eq!(format!("{:o}", value), "52");
    assert_eq!(format!("{:x}", value), "2a");
    assert_eq!(format!("{:X}", value), "2A");
}

#[test]
fn test_exponential_and_pointer() {
    let value = MyFmtStruct { inner: 1_000_000 };
    let lower = format!("{:e}", value);
    let upper = format!("{:E}", value);
    assert!(lower.starts_with("1e") || lower.starts_with("1.0e"));
    assert!(upper.starts_with("1E") || upper.starts_with("1.0E"));

    // Just ensure it runs without panic
    let _ = format!("{:p}", &value);
}

#[test]
fn test_fmt_write_trait() {
    let value = MyFmtStruct { inner: 123 };
    let mut output = String::new();
    write!(&mut output, "value: {}", value).unwrap();
    assert_eq!(output, "value: 123");
}

#[test]
fn test_generic_fmt_struct() {
    let value = MyGenericFmtStruct { inner: 3.14f64 };
    assert_eq!(format!("{}", value), "3.14");
    assert_eq!(format!("{:?}", value), "3.14");
}

#[test]
fn test_fmt_enum() {
    let a = MyFmtEnum::Text("hello".to_string());
    let b = MyFmtEnum::Number(123);
    assert_eq!(format!("{}", a), "hello");
    assert_eq!(format!("{}", b), "123");
    assert_eq!(format!("{:?}", a), "\"hello\"");
    assert_eq!(format!("{:?}", b), "123");
}

#[test]
fn test_generic_fmt_enum() {
    let e1 = MyGenericFmtEnum::One(3.14);
    let e2 = MyGenericFmtEnum::Many(vec![1, 2, 3]);
    assert_eq!(format!("{:?}", e1), "3.14");
    assert_eq!(format!("{:?}", e2), "[1, 2, 3]");
}

#[test]
fn test_write_struct_trait() {
    let mut wrapper = MyWriteStruct {
        inner: String::new(),
    };
    write!(&mut wrapper, "abc{}", 123).unwrap();
    assert_eq!(wrapper.inner, "abc123");
}

#[test]
fn test_write_enum_trait() {
    let mut wrapper = MyWriteEnum::A(String::new());
    write!(&mut wrapper, "hello {}", "world").unwrap();
    match wrapper {
        MyWriteEnum::A(ref s) => assert_eq!(s, "hello world"),
        _ => panic!("unexpected variant"),
    }

    let mut wrapper = MyWriteEnum::B(std::ffi::OsString::new());
    write!(&mut wrapper, "abc{}", 123).unwrap();
    match wrapper {
        MyWriteEnum::B(ref v) => assert_eq!(&v.clone().into_string().unwrap(), &"abc123"),
        _ => panic!("unexpected variant"),
    }
}