flexstr 0.11.7

A flexible, simple to use, clone-efficient string type for Rust
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

#![allow(dead_code)]

use core::fmt;
use core::str::FromStr;
use flexstr::{FlexStr, RefCounted};
use flexstr_support::StringToFromBytes;

/// Test FromStr success for FlexStr
pub fn test_from_str_flex_str_success<S, R>(s: &str)
where
    FlexStr<'static, S, R>: FromStr<Err = core::convert::Infallible>,
    S: ?Sized + StringToFromBytes + fmt::Debug + PartialEq,
    R: RefCounted<S>,
    S::Owned: AsRef<S>,
{
    let flex_str = FlexStr::from_str(s).unwrap();
    assert_eq!(flex_str.as_ref_type(), flex_str.as_ref_type()); // Basic sanity check
}

/// Test FromStr for FlexStr<[u8], R>
#[cfg(feature = "bytes")]
pub fn test_from_str_bytes_success<R>()
where
    R: RefCounted<[u8]>,
{
    let flex_str = FlexStr::<'static, [u8], R>::from_str("test").unwrap();
    assert_eq!(flex_str.as_ref_type(), b"test");
}

/// Test FromStr for FlexStr<OsStr, R>
#[cfg(all(feature = "std", feature = "osstr"))]
pub fn test_from_str_osstr_success<R>()
where
    R: RefCounted<std::ffi::OsStr>,
{
    use std::ffi::OsStr;

    let flex_str = FlexStr::<'static, OsStr, R>::from_str("test").unwrap();
    assert_eq!(flex_str.as_ref_type(), OsStr::new("test"));
}

/// Test FromStr for FlexStr<Path, R>
#[cfg(all(feature = "std", feature = "path"))]
pub fn test_from_str_path_success<R>()
where
    R: RefCounted<std::path::Path>,
{
    use std::path::Path;

    let flex_str = FlexStr::<'static, Path, R>::from_str("test").unwrap();
    assert_eq!(flex_str.as_ref_type(), Path::new("test"));
}

/// Test FromStr for FlexStr<CStr, R> success
#[cfg(feature = "cstr")]
pub fn test_from_str_cstr_success<R>()
where
    R: RefCounted<core::ffi::CStr> + fmt::Debug,
{
    use flexstr::FlexStr;

    let flex_str = FlexStr::<'static, core::ffi::CStr, R>::from_str("test").unwrap();
    assert_eq!(flex_str.as_ref_type().to_bytes(), b"test");
}

/// Test FromStr for FlexStr<CStr, R> error (interior NUL)
#[cfg(feature = "cstr")]
pub fn test_from_str_cstr_error<R>()
where
    R: RefCounted<core::ffi::CStr> + fmt::Debug,
{
    use flexstr::{FlexStr, InteriorNulError};

    // String with interior NUL should fail
    let result: Result<FlexStr<'static, core::ffi::CStr, R>, InteriorNulError> =
        FlexStr::from_str("test\0middle");
    result.unwrap_err();
}