StratoSDK is a framework with a declarative approach similar to Flutter/React, written and designed entirely for Rust.
| 1 | use super::{number_to_alphabet, number_to_roman, ListNumbering}; |
| 2 | use crate::elements::OrderedListLabel; |
| 3 | |
| 4 | #[test] |
| 5 | fn test_entirely_automatic() { |
| 6 | let mut numbering = ListNumbering::new(); |
| 7 | // Start at level 0. |
| 8 | assert_eq!( |
| 9 | numbering.advance(0, None), |
| 10 | OrderedListLabel { |
| 11 | label_index: 1, |
| 12 | display_label: "1".to_owned() |
| 13 | } |
| 14 | ); |
| 15 | assert_eq!( |
| 16 | numbering.advance(0, None), |
| 17 | OrderedListLabel { |
| 18 | label_index: 2, |
| 19 | display_label: "2".to_owned() |
| 20 | } |
| 21 | ); |
| 22 | // Indent, which should start over again at 1. |
| 23 | assert_eq!( |
| 24 | numbering.advance(1, None), |
| 25 | OrderedListLabel { |
| 26 | label_index: 1, |
| 27 | display_label: "a".to_owned() |
| 28 | } |
| 29 | ); |
| 30 | assert_eq!( |
| 31 | numbering.advance(1, None), |
| 32 | OrderedListLabel { |
| 33 | label_index: 2, |
| 34 | display_label: "b".to_owned() |
| 35 | } |
| 36 | ); |
| 37 | // Un-indent, which should resume at 3. |
| 38 | assert_eq!( |
| 39 | numbering.advance(0, None), |
| 40 | OrderedListLabel { |
| 41 | label_index: 3, |
| 42 | display_label: "3".to_owned() |
| 43 | } |
| 44 | ); |
| 45 | // Re-indent, which should restart at 1. |
| 46 | assert_eq!( |
| 47 | numbering.advance(1, None), |
| 48 | OrderedListLabel { |
| 49 | label_index: 1, |
| 50 | display_label: "a".to_owned() |
| 51 | } |
| 52 | ); |
| 53 | } |
| 54 | |
| 55 | #[test] |
| 56 | fn test_indent_jump() { |
| 57 | // Ensure that we can skip indent levels. |
| 58 | let mut numbering = ListNumbering::new(); |
| 59 | assert_eq!( |
| 60 | numbering.advance(0, None), |
| 61 | OrderedListLabel { |
| 62 | label_index: 1, |
| 63 | display_label: "1".to_owned() |
| 64 | } |
| 65 | ); |
| 66 | // Skip multiple levels of indentation. |
| 67 | assert_eq!( |
| 68 | numbering.advance(4, None), |
| 69 | OrderedListLabel { |
| 70 | label_index: 1, |
| 71 | display_label: "a".to_owned() |
| 72 | } |
| 73 | ); |
| 74 | assert_eq!( |
| 75 | numbering.advance(4, None), |
| 76 | OrderedListLabel { |
| 77 | label_index: 2, |
| 78 | display_label: "b".to_owned() |
| 79 | } |
| 80 | ); |
| 81 | // Skip multiple levels un-indenting. |
| 82 | assert_eq!( |
| 83 | numbering.advance(2, None), |
| 84 | OrderedListLabel { |
| 85 | label_index: 1, |
| 86 | display_label: "i".to_owned() |
| 87 | } |
| 88 | ); |
| 89 | assert_eq!( |
| 90 | numbering.advance(1, None), |
| 91 | OrderedListLabel { |
| 92 | label_index: 1, |
| 93 | display_label: "a".to_owned() |
| 94 | } |
| 95 | ); |
| 96 | assert_eq!( |
| 97 | numbering.advance(0, None), |
| 98 | OrderedListLabel { |
| 99 | label_index: 2, |
| 100 | display_label: "2".to_owned() |
| 101 | } |
| 102 | ); |
| 103 | } |
| 104 | |
| 105 | #[test] |
| 106 | fn test_assigned_numbers() { |
| 107 | let mut numbering = ListNumbering::new(); |
| 108 | assert_eq!( |
| 109 | numbering.advance(0, Some(4)), |
| 110 | OrderedListLabel { |
| 111 | label_index: 4, |
| 112 | display_label: "4".to_owned() |
| 113 | } |
| 114 | ); |
| 115 | assert_eq!( |
| 116 | numbering.advance(0, None), |
| 117 | OrderedListLabel { |
| 118 | label_index: 5, |
| 119 | display_label: "5".to_owned() |
| 120 | } |
| 121 | ); |
| 122 | assert_eq!( |
| 123 | numbering.advance(0, None), |
| 124 | OrderedListLabel { |
| 125 | label_index: 6, |
| 126 | display_label: "6".to_owned() |
| 127 | } |
| 128 | ); |
| 129 | // Assigned numbers not at the start should be ignored. |
| 130 | assert_eq!( |
| 131 | numbering.advance(0, Some(1)), |
| 132 | OrderedListLabel { |
| 133 | label_index: 7, |
| 134 | display_label: "7".to_owned() |
| 135 | } |
| 136 | ); |
| 137 | // Assigned numbers at a new indent level are respected. |
| 138 | assert_eq!( |
| 139 | numbering.advance(1, Some(3)), |
| 140 | OrderedListLabel { |
| 141 | label_index: 3, |
| 142 | display_label: "c".to_owned() |
| 143 | } |
| 144 | ); |
| 145 | assert_eq!( |
| 146 | numbering.advance(1, None), |
| 147 | OrderedListLabel { |
| 148 | label_index: 4, |
| 149 | display_label: "d".to_owned() |
| 150 | } |
| 151 | ); |
| 152 | // The custom start number shouldn't be lost when un-indenting. |
| 153 | assert_eq!( |
| 154 | numbering.advance(0, Some(2)), |
| 155 | OrderedListLabel { |
| 156 | label_index: 8, |
| 157 | display_label: "8".to_owned() |
| 158 | } |
| 159 | ); |
| 160 | } |
| 161 | |
| 162 | #[test] |
| 163 | fn test_reset() { |
| 164 | let mut numbering = ListNumbering::new(); |
| 165 | assert_eq!( |
| 166 | numbering.advance(0, None), |
| 167 | OrderedListLabel { |
| 168 | label_index: 1, |
| 169 | display_label: "1".to_owned() |
| 170 | } |
| 171 | ); |
| 172 | assert_eq!( |
| 173 | numbering.advance(1, None), |
| 174 | OrderedListLabel { |
| 175 | label_index: 1, |
| 176 | display_label: "a".to_owned() |
| 177 | } |
| 178 | ); |
| 179 | numbering.reset(); |
| 180 | // After a reset, all levels should be 1. |
| 181 | assert_eq!( |
| 182 | numbering.advance(1, None), |
| 183 | OrderedListLabel { |
| 184 | label_index: 1, |
| 185 | display_label: "a".to_owned() |
| 186 | } |
| 187 | ); |
| 188 | assert_eq!( |
| 189 | numbering.advance(0, None), |
| 190 | OrderedListLabel { |
| 191 | label_index: 1, |
| 192 | display_label: "1".to_owned() |
| 193 | } |
| 194 | ); |
| 195 | |
| 196 | // This assigned number is ignored, since it's not at the start of a list. |
| 197 | assert_eq!( |
| 198 | numbering.advance(0, Some(5)), |
| 199 | OrderedListLabel { |
| 200 | label_index: 2, |
| 201 | display_label: "2".to_owned() |
| 202 | } |
| 203 | ); |
| 204 | |
| 205 | numbering.reset(); |
| 206 | // This assigned number is kept because of the reset. |
| 207 | assert_eq!( |
| 208 | numbering.advance(0, Some(5)), |
| 209 | OrderedListLabel { |
| 210 | label_index: 5, |
| 211 | display_label: "5".to_owned() |
| 212 | } |
| 213 | ); |
| 214 | } |
| 215 | |
| 216 | #[test] |
| 217 | fn test_number_to_roman() { |
| 218 | assert_eq!(number_to_roman(0), "i"); |
| 219 | assert_eq!(number_to_roman(5), "vi"); |
| 220 | assert_eq!(number_to_roman(29), "xxx"); |
| 221 | assert_eq!(number_to_roman(30), "i"); |
| 222 | assert_eq!(number_to_roman(61), "ii"); |
| 223 | } |
| 224 | |
| 225 | #[test] |
| 226 | fn test_number_to_alphabet() { |
| 227 | assert_eq!(number_to_alphabet(0), "a"); |
| 228 | assert_eq!(number_to_alphabet(25), "z"); |
| 229 | assert_eq!(number_to_alphabet(26), "aa"); |
| 230 | assert_eq!(number_to_alphabet(27), "bb"); |
| 231 | assert_eq!(number_to_alphabet(77), "zzz"); |
| 232 | assert_eq!(number_to_alphabet(78), "a"); |
| 233 | } |
| 234 |