minxp 0.1.7

Partial reimplementation of std for no-std on unsupported Windows targets.
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376

use super::*;

fn same_path<A: AsRef<Path>, B: AsRef<Path>>(a: A, b: B) {
    assert_eq!(a.as_ref().as_os_str().as_str(), b.as_ref().as_os_str().as_str());
}

#[test]
fn remove_extraneous_suffixes() {
    same_path(Path::new("C:\\Users\\Something").remove_extraneous_suffixes(), "C:\\Users\\Something");
    same_path(Path::new("C:\\Users\\Something\\").remove_extraneous_suffixes(), "C:\\Users\\Something");
    same_path(Path::new("C:\\Users\\Something\\.\\.\\..\\.\\.\\./\\\\").remove_extraneous_suffixes(), "C:\\Users\\Something\\.\\.\\..");
}

#[test]
fn relative_to_root() {
    same_path(Path::new("C:\\Users\\Something\\").as_relative_to_root(), "Users\\Something\\");
    same_path(Path::new("\\\\Drive\\Something\\").as_relative_to_root(), "Something\\");
    same_path(Path::new("\\\\\\").as_relative_to_root(), "");
}

#[test]
fn as_path() {
    same_path(Path::new("C:\\Users\\Something\\").to_owned().as_path(), "C:\\Users\\Something\\");
}

#[test]
fn push() {
    same_path({
                  let mut a = Path::new("C:\\Users\\Something").to_owned();
                  a.push("OrRather");
                  a
              }, "C:\\Users\\Something\\OrRather");
    same_path({
                  let mut a = Path::new("C:\\Users\\Something\\").to_owned();
                  a.push("OrRather");
                  a
              }, "C:\\Users\\Something\\OrRather");
}

#[test]
fn pop() {
    same_path({
                  let mut a = Path::new("C:\\Users\\Something\\").to_owned();
                  a.pop();
                  a
              }, "C:\\Users");
    same_path({
                  let mut a = Path::new("C:\\").to_owned();
                  a.pop();
                  a
              }, "C:\\");
}

#[test]
fn set_file_name() {
    same_path({
                  let mut a = Path::new("C:\\Users\\Something").to_owned();
                  a.set_file_name("Red");
                  a
              }, "C:\\Users\\Red");
    same_path({
                  let mut a = Path::new("C:\\Users\\Blue.txt").to_owned();
                  a.set_file_name(".txt");
                  a
              }, "C:\\Users\\.txt");
    same_path({
                  let mut a = Path::new("C:\\").to_owned();
                  a.set_file_name("jxl.jxl");
                  a
              }, "C:\\jxl.jxl");
}

#[test]
fn set_extension() {
    same_path({
                  let mut a = Path::new("C:\\Users\\Something").to_owned();
                  a.set_extension("txt");
                  a
              }, "C:\\Users\\Something.txt");
    same_path({
                  let mut a = Path::new("C:\\Users\\Something").to_owned();
                  a.set_extension(".txt");
                  a
              }, "C:\\Users\\Something..txt");
    same_path({
                  let mut a = Path::new("C:\\Users\\Something.txt").to_owned();
                  a.set_extension("jxl");
                  a
              }, "C:\\Users\\Something.jxl");
}

#[test]
fn truncate_extraneous_suffixes() {
    same_path({
                  let mut a = Path::new("C:\\Users\\Something").to_owned();
                  a.truncate_extraneous_suffixes();
                  a
              }, "C:\\Users\\Something");
    same_path({
                  let mut a = Path::new("C:\\Users\\Something\\").to_owned();
                  a.truncate_extraneous_suffixes();
                  a
              }, "C:\\Users\\Something");
    same_path({
                  let mut a = Path::new("C:\\Users\\Something\\.\\.\\..\\.\\.\\.\\\\\\").to_owned();
                  a.truncate_extraneous_suffixes();
                  a
              }, "C:\\Users\\Something\\.\\.\\..");
}

#[test]
fn as_mut_os_string() {
    same_path(Path::new("C:\\Users\\Something").to_owned().as_mut_os_string(), "C:\\Users\\Something");
}

#[test]
fn into_os_string() {
    same_path(Path::new("C:\\Users\\Something").to_owned().into_os_string(), "C:\\Users\\Something");
}

#[test]
fn into_boxed_path() {
    same_path(Path::new("C:\\Users\\Something").to_owned().into_boxed_path(), "C:\\Users\\Something");
}

#[test]
fn as_os_str() {
    assert_eq!(Path::new("some sort of string").as_os_str().as_str(), "some sort of string");
}

#[test]
fn to_str() {
    assert_eq!(Path::new("some sort of string").to_str().unwrap(), "some sort of string");
}

#[test]
fn to_string_lossy() {
    assert_eq!(Path::new("some sort of string").to_string_lossy(), "some sort of string");
}

#[test]
fn to_path_buf() {
    assert_eq!(Path::new("some sort of string").to_path_buf().as_os_str().as_str(), "some sort of string");
}

#[test]
fn is_absolute() {
    assert!(!Path::new("C:something").is_absolute());
    assert!(!Path::new("c:something").is_absolute());
    assert!(Path::new("C:\\something").is_absolute());
    assert!(Path::new("c:\\something").is_absolute());
    assert!(Path::new("C:/something").is_absolute());
    assert!(Path::new("c:/something").is_absolute());
    assert!(!Path::new("\\something").is_absolute());
    assert!(!Path::new("\\\\something").is_absolute());
    assert!(Path::new("\\\\something\\").is_absolute());
    assert!(!Path::new("CCCCC:\\something").is_absolute());
}

#[test]
fn has_drive_letter() {
    assert!(Path::new("C:something").has_drive_letter());
    assert!(Path::new("c:something").has_drive_letter());
    assert!(Path::new("C:\\something").has_drive_letter());
    assert!(Path::new("c:\\something").has_drive_letter());
    assert!(Path::new("C:/something").has_drive_letter());
    assert!(Path::new("c:/something").has_drive_letter());
    assert!(!Path::new("\\something").has_drive_letter());
    assert!(!Path::new("\\\\something").has_drive_letter());
    assert!(!Path::new("CCCCC:\\something").has_drive_letter());
}

#[test]
fn is_relative() {
    assert!(Path::new("C:something").is_relative());
    assert!(Path::new("c:something").is_relative());
    assert!(!Path::new("C:\\something").is_relative());
    assert!(!Path::new("c:\\something").is_relative());
    assert!(!Path::new("C:/something").is_relative());
    assert!(!Path::new("c:/something").is_relative());
    assert!(Path::new("\\something").is_relative());
    assert!(Path::new("\\\\something").is_relative());
    assert!(!Path::new("\\\\something\\").is_relative());
    assert!(Path::new("CCCCC:\\something").is_relative());
}

#[test]
fn has_root() {
    assert!(!Path::new("C:something").has_root());
    assert!(!Path::new("c:something").has_root());
    assert!(Path::new("C:\\something").has_root());
    assert!(Path::new("c:\\something").has_root());
    assert!(Path::new("C:/something").has_root());
    assert!(Path::new("c:/something").has_root());
    assert!(Path::new("\\something").has_root());
    assert!(Path::new("\\\\something").has_root());
    assert!(Path::new("\\\\something\\").has_root());
    assert!(!Path::new("CCCCC:\\something").has_root());
}

#[test]
fn utf16() {
    // null bytes are stripped from OsStr::from_str
    assert_eq!(String::from_utf16(&Path::new("C:\\Users\\Something").encode_for_win32()).unwrap(), "C:\\Users\\Something\x00");
    same_path(String::from_utf16(&Path::new("C:\\Users\\Something").encode_for_win32()).unwrap(), "C:\\Users\\Something");
    same_path(String::from_utf16(&Path::new("C:\\Users////\\Something").encode_for_win32()).unwrap(), "C:\\Users\\Something");
}

#[test]
fn parent() {
    same_path(Path::new("C:\\Users\\Something\\").parent().unwrap(), "C:\\Users");
    same_path(Path::new("C:\\Users").parent().unwrap(), "C:\\");
}

#[test]
fn ancestors() {
    let mut ancestors = Path::new("C:\\Users\\Something\\Or/.\\Rather\\\\//////\\././././././././\\.\\Thing/").ancestors();
    same_path(ancestors.next().unwrap(), "C:\\Users\\Something\\Or/.\\Rather");
    same_path(ancestors.next().unwrap(), "C:\\Users\\Something\\Or");
    same_path(ancestors.next().unwrap(), "C:\\Users\\Something");
    same_path(ancestors.next().unwrap(), "C:\\Users");
    same_path(ancestors.next().unwrap(), "C:\\");
    assert!(ancestors.next().is_none());
}

#[test]
fn file_name() {
    assert_eq!(Path::new("C:\\Users\\Something\\Or/.\\Rather\\\\//////\\././././././././\\.\\Thing/").file_name().unwrap(), "Thing");
    assert_eq!(Path::new("C:\\Users\\Something.txt").file_name().unwrap(), "Something.txt");
    assert!(Path::new("C:\\").file_name().is_none());
}

#[test]
fn strip_prefix() {
    assert_eq!(
        Path::new("C:\\Users\\Something\\or").strip_prefix("C:\\Users\\\\Something").unwrap(),
        Path::new("or")
    );
    assert_eq!(
        Path::new("C:\\Users\\\\\\Something\\or\\rather").strip_prefix("C:\\Users\\\\Something\\or").unwrap(),
        Path::new("rather")
    );
    assert!(
        Path::new("C:\\Users\\\\\\Something").strip_prefix("C:\\Users\\\\Somet").is_err()
    );
    assert!(
        Path::new("C:\\Users\\\\\\Something").strip_prefix("D:\\Users\\\\").is_err()
    );
}

#[test]
fn ends_with() {
    assert!(Path::new("C:\\Users\\Something").ends_with(Path::new("C:\\Users\\\\Something")));
    assert!(Path::new("C:\\Users\\Something").ends_with(Path::new("Users/Something")));
    assert!(Path::new("C:\\Users\\Something").ends_with(Path::new("Something")));
    assert!(Path::new("C:\\Users\\Something").ends_with(Path::new("Something///////./")));
    assert!(!Path::new("C:\\Users\\Something").ends_with(Path::new("thing")));
}

#[test]
fn starts_with() {
    assert!(Path::new("C:\\Users\\Something").starts_with(Path::new("C:\\Users\\\\Something")));
    assert!(!Path::new("C:\\Users\\Something").starts_with(Path::new("C:\\Users\\\\Something\\or")));
    assert!(Path::new("C:\\Users\\Something\\or\\").starts_with(Path::new("C:\\Users\\\\Something\\or")));
    assert!(Path::new("C:\\Users\\Something\\or").starts_with(Path::new("C:\\Users\\\\Something\\or\\")));
    assert!(Path::new("C:\\Users\\Something\\or").starts_with(Path::new("C:\\Users\\\\Something\\")));
    assert!(Path::new("C:\\Users\\Something\\or").starts_with(Path::new("C:\\Users\\\\Something")));
    assert!(Path::new("C:\\Users\\Something\\or").starts_with(Path::new("C:\\Users\\\\Something/")));
    assert!(Path::new("C:\\Users\\Something\\or").starts_with(Path::new("C:\\Users\\\\Something/.")));
}

#[test]
fn file_stem() {
    assert_eq!(Path::new("C:\\Users\\Something\\Or/.\\Rather\\\\//////\\././././././././\\.\\Thing/").file_stem().unwrap(), "Thing");
    assert_eq!(Path::new("C:\\Users\\Something.txt").file_stem().unwrap(), "Something");
    assert!(Path::new("C:\\").file_stem().is_none());
}

#[test]
fn extension() {
    assert_eq!(Path::new("C:\\Users\\Something\\Or/.\\Rather\\\\//////\\././././././././\\.\\Thing/").extension(), None);
    assert_eq!(Path::new("C:\\Users\\Something.txt").extension().unwrap().as_str(), "txt");
}

#[test]
fn join() {
    same_path(Path::new("C:\\Users\\Something.txt\\").join("test"), "C:\\Users\\Something.txt\\test");
    same_path(Path::new("C:\\Users\\Something.txt/").join("test"), "C:\\Users\\Something.txt/test");
    same_path(Path::new("C:\\Users\\Something.txt").join("test"), "C:\\Users\\Something.txt\\test");
    same_path(Path::new("C:\\").join("test"), "C:\\test");
}

#[test]
fn with_file_name() {
    same_path(Path::new("C:\\Users\\Something.txt\\").with_file_name("test"), "C:\\Users\\test");
    same_path(Path::new("C:\\Users\\Something.txt/").with_file_name("test"), "C:\\Users\\test");
    same_path(Path::new("C:\\Users\\Something.txt").with_file_name("test"), "C:\\Users\\test");
    same_path(Path::new("C:\\").with_file_name("test"), "C:\\test");
}

#[test]
fn with_extension() {
    same_path(Path::new("C:\\Users\\Something.txt\\").with_extension("test"), "C:\\Users\\Something.test");
    same_path(Path::new("C:\\Users\\Something.txt/").with_extension("test"), "C:\\Users\\Something.test");
    same_path(Path::new("C:\\Users\\Something.txt").with_extension("test"), "C:\\Users\\Something.test");
    same_path(Path::new("C:\\Users\\Something").with_extension("test"), "C:\\Users\\Something.test");
    same_path(Path::new("C:\\").with_extension("test"), "C:\\");
}

#[test]
fn components() {
    let mut c = Path::new("C:\\Users\\Something\\/////./././././/.//\\\\\\\\..").components();
    assert_eq!(c.next().unwrap(), "C:");
    assert_eq!(c.next().unwrap(), "Users");
    assert_eq!(c.next().unwrap(), "Something");
    assert_eq!(c.next().unwrap(), "..");
    assert_eq!(c.next(), None);

    let mut c = Path::new("C:\\Users\\Something\\/////./././././/.//\\\\\\\\..").components();
    assert_eq!(c.next_back().unwrap(), "..");
    assert_eq!(c.next_back().unwrap(), "Something");
    assert_eq!(c.next_back().unwrap(), "Users");
    assert_eq!(c.next_back().unwrap(), "C:");
    assert_eq!(c.next_back(), None);
}

#[test]
fn iter() {
    let mut c = Path::new("C:\\Users\\Something\\/////./././././/.//\\\\\\\\..").iter();
    assert_eq!(c.next().unwrap(), "C:");
    assert_eq!(c.next().unwrap(), "Users");
    assert_eq!(c.next().unwrap(), "Something");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), ".");
    assert_eq!(c.next().unwrap(), ".");
    assert_eq!(c.next().unwrap(), ".");
    assert_eq!(c.next().unwrap(), ".");
    assert_eq!(c.next().unwrap(), ".");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), ".");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "");
    assert_eq!(c.next().unwrap(), "..");
    assert_eq!(c.next(), None);

    let mut c = Path::new("C:\\Users\\Something\\/////./././././/.//\\\\\\\\..").iter();
    assert_eq!(c.next_back().unwrap(), "..");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), ".");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), ".");
    assert_eq!(c.next_back().unwrap(), ".");
    assert_eq!(c.next_back().unwrap(), ".");
    assert_eq!(c.next_back().unwrap(), ".");
    assert_eq!(c.next_back().unwrap(), ".");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "");
    assert_eq!(c.next_back().unwrap(), "Something");
    assert_eq!(c.next_back().unwrap(), "Users");
    assert_eq!(c.next_back().unwrap(), "C:");
    assert_eq!(c.next_back(), None);
}