qstr 0.2.0

Cache-efficient, stack-allocated string types
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

use core::mem;

use crate::{ExceedsCapacity, FStr8, FStr16, FStr24, FStr32, FStr64, FStr128};

#[test]
fn test_size() {
  assert_eq!(mem::size_of::<FStr8>(), 8);
  assert_eq!(mem::size_of::<FStr16>(), 16);
  assert_eq!(mem::size_of::<FStr24>(), 24);
  assert_eq!(mem::size_of::<FStr32>(), 32);
  assert_eq!(mem::size_of::<FStr64>(), 64);
  assert_eq!(mem::size_of::<FStr128>(), 128);
}

#[test]
fn test_alignment() {
  assert_eq!(mem::align_of::<FStr8>(), 8);
  assert_eq!(mem::align_of::<FStr16>(), 16);
  assert_eq!(mem::align_of::<FStr24>(), 8);
  assert_eq!(mem::align_of::<FStr32>(), 32);
  assert_eq!(mem::align_of::<FStr64>(), 64);
  assert_eq!(mem::align_of::<FStr128>(), 128);
}

#[test]
fn test_ord() {
  assert!(FStr8::from("a") < FStr8::from("b"));
  assert!(FStr16::from("a") < FStr16::from("b"));
  assert!(FStr32::from("a") < FStr32::from("b"));
  assert!(FStr64::from("a") < FStr64::from("b"));
  assert!(FStr128::from("a") < FStr128::from("b"));
}

const fn f() -> FStr24 {
  FStr24::const_try_from("abc").unwrap()
}

#[test]
fn test_const_try_from_zero_padded() {
  assert_eq!(f(), FStr24::try_from("abc").unwrap());
}

#[test]
fn test_as_str_zero_padded() {
  let str = FStr24::const_try_from("abc").unwrap();
  assert_eq!(str.as_str().len(), 24);
  assert_eq!(str.as_str_trimmed().len(), 3);
}

const fn g() -> FStr24 {
  FStr24::const_try_from("aaaaaaaaaaaaaaaaaaaaaaaa").unwrap()
}

#[test]
fn test_within_capacity() {
  // 24 bytes
  let result = g();
  let result2 = FStr24::try_from("aaaaaaaaaaaaaaaaaaaaaaaa").unwrap();

  assert_eq!(result.as_str(), "aaaaaaaaaaaaaaaaaaaaaaaa");
  assert_eq!(result2.as_str(), "aaaaaaaaaaaaaaaaaaaaaaaa");
  assert_eq!(result, result2);
}

const fn h() -> Option<FStr24> {
  FStr24::const_try_from("aaaaaaaaaaaaaaaaaaaaaaaaa")
}

#[test]
fn test_exceed_capacity() {
  // 25 bytes
  let result = h();
  let result2 = FStr24::try_from("aaaaaaaaaaaaaaaaaaaaaaaaa");

  assert_eq!(result, None);

  assert_eq!(
    result2,
    Err(ExceedsCapacity {
      length: 25,
      capacity: 24
    })
  );
}

#[cfg(feature = "std")]
mod std {
  use std::format;

  use crate::FStr32;

  #[test]
  fn test_debug() {
    let v = FStr32::try_from("abc").unwrap();
    assert_eq!(format!("{v:?}"), "abc");
  }
}

#[cfg(feature = "serde")]
mod serde_tests {
  use crate::FStr24;

  #[test]
  fn test_serialise() {
    let s = FStr24::try_from("aaaaaaaaaaaaaaaaaaaaaaaa").unwrap();
    let json = serde_json::to_string(&s).unwrap();
    assert_eq!(json, r#""aaaaaaaaaaaaaaaaaaaaaaaa""#);
  }

  #[test]
  fn test_deserialise() {
    let json = r#""aaaaaaaaaaaaaaaaaaaaaaaa""#;
    let result = serde_json::from_str::<FStr24>(json).unwrap();
    assert_eq!(
      result,
      FStr24::try_from("aaaaaaaaaaaaaaaaaaaaaaaa").unwrap()
    );
  }
}