1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.io.file;
18
19 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertFalse;
22 import static org.junit.jupiter.api.Assertions.assertNotNull;
23 import static org.junit.jupiter.api.Assertions.assertThrows;
24 import static org.junit.jupiter.api.Assertions.assertTrue;
25 import static org.junit.jupiter.api.Assumptions.assumeTrue;
26
27 import java.io.BufferedReader;
28 import java.io.BufferedWriter;
29 import java.io.IOException;
30 import java.io.InputStream;
31 import java.io.OutputStream;
32 import java.io.UncheckedIOException;
33 import java.nio.channels.SeekableByteChannel;
34 import java.nio.charset.StandardCharsets;
35 import java.nio.file.DirectoryStream;
36 import java.nio.file.FileVisitOption;
37 import java.nio.file.Files;
38 import java.nio.file.LinkOption;
39 import java.nio.file.OpenOption;
40 import java.nio.file.Path;
41 import java.nio.file.Paths;
42 import java.nio.file.StandardCopyOption;
43 import java.nio.file.StandardOpenOption;
44 import java.nio.file.attribute.BasicFileAttributes;
45 import java.nio.file.attribute.FileAttribute;
46 import java.nio.file.attribute.FileTime;
47 import java.nio.file.attribute.PosixFilePermission;
48 import java.nio.file.attribute.UserPrincipal;
49 import java.util.Arrays;
50 import java.util.Collections;
51 import java.util.HashSet;
52 import java.util.Set;
53 import java.util.stream.Stream;
54
55 import org.apache.commons.io.IOUtils;
56 import org.apache.commons.io.function.Uncheck;
57 import org.apache.commons.io.input.NullInputStream;
58 import org.apache.commons.io.output.NullOutputStream;
59 import org.apache.commons.lang3.ArrayUtils;
60 import org.junit.jupiter.api.AfterEach;
61 import org.junit.jupiter.api.BeforeEach;
62 import org.junit.jupiter.api.Test;
63
64
65
66
67
68
69 public class FilesUncheckTest {
70
71 private static final FileAttribute<?>[] EMPTY_FILE_ATTRIBUTES_ARRAY = {};
72
73 private static final Path FILE_PATH_A = Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-1/file-size-1.bin");
74
75 private static final Path FILE_PATH_EMPTY = Paths.get("src/test/resources/org/apache/commons/io/test-file-empty.bin");
76
77 private static final Path NEW_DIR_PATH = Paths.get("target/newdir");
78
79 private static final Path NEW_FILE_PATH = Paths.get("target/file.txt");
80
81 private static final Path NEW_FILE_PATH_LINK = Paths.get("target/to_another_file.txt");
82
83 private static final String PREFIX = "prefix";
84
85 private static final String SUFFIX = "suffix";
86
87 private static final Path TARGET_PATH = Paths.get("target");
88
89 @BeforeEach
90 @AfterEach
91 public void deleteFixtures() throws IOException {
92 Files.deleteIfExists(NEW_FILE_PATH);
93 Files.deleteIfExists(NEW_DIR_PATH);
94 Files.deleteIfExists(NEW_FILE_PATH_LINK);
95 }
96
97 @Test
98 public void testCopyInputStreamPathCopyOptionArray() {
99 assertEquals(0, FilesUncheck.copy(NullInputStream.INSTANCE, NEW_FILE_PATH, PathUtils.EMPTY_COPY_OPTIONS));
100 }
101
102 @Test
103 public void testCopyPathOutputStream() {
104 assertEquals(0, FilesUncheck.copy(FILE_PATH_EMPTY, NullOutputStream.INSTANCE));
105 }
106
107 @Test
108 public void testCopyPathPathCopyOptionArray() {
109 assertEquals(NEW_FILE_PATH, FilesUncheck.copy(FILE_PATH_EMPTY, NEW_FILE_PATH, PathUtils.EMPTY_COPY_OPTIONS));
110 }
111
112 @Test
113 public void testCreateDirectories() {
114 assertEquals(TARGET_PATH, FilesUncheck.createDirectories(TARGET_PATH, EMPTY_FILE_ATTRIBUTES_ARRAY));
115 }
116
117 @Test
118 public void testCreateDirectory() {
119 assertEquals(NEW_DIR_PATH, FilesUncheck.createDirectory(NEW_DIR_PATH, EMPTY_FILE_ATTRIBUTES_ARRAY));
120 }
121
122 @Test
123 public void testCreateFile() {
124 assertEquals(NEW_FILE_PATH, FilesUncheck.createFile(NEW_FILE_PATH, EMPTY_FILE_ATTRIBUTES_ARRAY));
125 }
126
127 @Test
128 public void testCreateLink() {
129 assertEquals(NEW_FILE_PATH_LINK, FilesUncheck.createLink(NEW_FILE_PATH_LINK, FILE_PATH_EMPTY));
130 }
131
132 @Test
133 public void testCreateSymbolicLink() {
134
135 assertEquals(NEW_FILE_PATH_LINK, FilesUncheck.createSymbolicLink(NEW_FILE_PATH_LINK, FILE_PATH_EMPTY));
136 }
137
138 @Test
139 public void testCreateTempDirectoryPathStringFileAttributeOfQArray() {
140 assertEquals(TARGET_PATH, FilesUncheck.createTempDirectory(TARGET_PATH, PREFIX, EMPTY_FILE_ATTRIBUTES_ARRAY).getParent());
141 }
142
143 @Test
144 public void testCreateTempDirectoryStringFileAttributeOfQArray() {
145 assertEquals(PathUtils.getTempDirectory(), FilesUncheck.createTempDirectory(PREFIX, EMPTY_FILE_ATTRIBUTES_ARRAY).getParent());
146 }
147
148 @Test
149 public void testCreateTempFilePathStringStringFileAttributeOfQArray() {
150 assertEquals(TARGET_PATH, FilesUncheck.createTempFile(TARGET_PATH, PREFIX, SUFFIX, EMPTY_FILE_ATTRIBUTES_ARRAY).getParent());
151 }
152
153 @Test
154 public void testCreateTempFileStringStringFileAttributeOfQArray() {
155 assertEquals(PathUtils.getTempDirectory(), FilesUncheck.createTempFile(PREFIX, SUFFIX, EMPTY_FILE_ATTRIBUTES_ARRAY).getParent());
156 }
157
158 @Test
159 public void testDelete() {
160 assertThrows(UncheckedIOException.class, () -> FilesUncheck.delete(NEW_FILE_PATH));
161 }
162
163 @Test
164 public void testDeleteIfExists() {
165 assertFalse(FilesUncheck.deleteIfExists(NEW_FILE_PATH));
166 }
167
168 @Test
169 public void testFind() {
170 try (Stream<Path> find = FilesUncheck.find(FILE_PATH_EMPTY, 0, (t, u) -> false)) {
171 assertNotNull(find);
172 }
173 }
174
175 @Test
176 public void testGetAttribute() {
177 assertEquals(0L, FilesUncheck.getAttribute(FILE_PATH_EMPTY, "basic:size", LinkOption.NOFOLLOW_LINKS));
178 }
179
180 @Test
181 public void testGetFileStore() {
182 assertNotNull(FilesUncheck.getFileStore(FILE_PATH_EMPTY));
183 }
184
185 @Test
186 public void testGetLastModifiedTime() {
187 assertTrue(0 < FilesUncheck.getLastModifiedTime(FILE_PATH_EMPTY, LinkOption.NOFOLLOW_LINKS).toMillis());
188 }
189
190 @Test
191 public void testGetOwner() {
192 assertNotNull(FilesUncheck.getOwner(FILE_PATH_EMPTY, LinkOption.NOFOLLOW_LINKS));
193 }
194
195 @Test
196 public void testGetPosixFilePermissions() {
197 assumeTrue(PathUtils.isPosix(FILE_PATH_EMPTY, LinkOption.NOFOLLOW_LINKS));
198 assertNotNull(FilesUncheck.getPosixFilePermissions(FILE_PATH_EMPTY, LinkOption.NOFOLLOW_LINKS));
199 }
200
201 @Test
202 public void testIsHidden() {
203 assertFalse(FilesUncheck.isHidden(FILE_PATH_EMPTY));
204 }
205
206 @Test
207 public void testIsSameFile() {
208 assertTrue(FilesUncheck.isSameFile(FILE_PATH_EMPTY, FILE_PATH_EMPTY));
209 }
210
211 @Test
212 public void testLinesPath() {
213 try (Stream<String> stream = FilesUncheck.lines(FILE_PATH_EMPTY)) {
214 assertEquals(0, stream.count());
215 }
216 }
217
218 @Test
219 public void testLinesPathCharset() {
220 try (Stream<String> stream = FilesUncheck.lines(FILE_PATH_EMPTY, StandardCharsets.UTF_8)) {
221 assertEquals(0, stream.count());
222 }
223 }
224
225 @Test
226 public void testList() {
227 try (Stream<Path> stream = FilesUncheck.list(Paths.get("src/test/resources/org/apache/commons/io/dirs-1-file-size-0"))) {
228 assertEquals(1, stream.count());
229 }
230 }
231
232 @Test
233 public void testMove() {
234 final Path tempFile1 = FilesUncheck.createTempFile(PREFIX, SUFFIX);
235 final Path tempFile2 = FilesUncheck.createTempFile(PREFIX, SUFFIX);
236 assertEquals(tempFile2, FilesUncheck.move(tempFile1, tempFile2, StandardCopyOption.REPLACE_EXISTING));
237 FilesUncheck.delete(tempFile2);
238 }
239
240 @Test
241 public void testNewBufferedReaderPath() {
242 Uncheck.run(() -> {
243 try (BufferedReader reader = FilesUncheck.newBufferedReader(FILE_PATH_EMPTY)) {
244 IOUtils.consume(reader);
245 }
246 });
247 }
248
249 @Test
250 public void testNewBufferedReaderPathCharset() {
251 Uncheck.run(() -> {
252 try (BufferedReader reader = FilesUncheck.newBufferedReader(FILE_PATH_EMPTY, StandardCharsets.UTF_8)) {
253 IOUtils.consume(reader);
254 }
255 });
256 }
257
258 @Test
259 public void testNewBufferedWriterPathCharsetOpenOptionArray() {
260 final Path tempPath = FilesUncheck.createTempFile(PREFIX, SUFFIX);
261 Uncheck.run(() -> {
262 try (BufferedWriter writer = FilesUncheck.newBufferedWriter(tempPath, StandardCharsets.UTF_8, StandardOpenOption.TRUNCATE_EXISTING)) {
263 writer.append("test");
264 }
265 });
266 assertEquals("test", FilesUncheck.readAllLines(tempPath, StandardCharsets.UTF_8).get(0));
267 }
268
269 @Test
270 public void testNewBufferedWriterPathOpenOptionArray() {
271 final Path tempPath = FilesUncheck.createTempFile(PREFIX, SUFFIX);
272 Uncheck.run(() -> {
273 try (BufferedWriter writer = FilesUncheck.newBufferedWriter(tempPath, StandardOpenOption.TRUNCATE_EXISTING)) {
274 writer.append("test");
275 }
276 });
277 assertEquals("test", FilesUncheck.readAllLines(tempPath).get(0));
278 }
279
280 @Test
281 public void testNewByteChannelPathOpenOptionArray() {
282 assertEquals(0, Uncheck.get(() -> {
283 try (SeekableByteChannel c = FilesUncheck.newByteChannel(FILE_PATH_EMPTY, StandardOpenOption.READ)) {
284 return c.size();
285 }
286 }));
287 }
288
289 @Test
290 public void testNewByteChannelPathSetOfQextendsOpenOptionFileAttributeOfQArray() {
291 final Set<OpenOption> options = new HashSet<>();
292 options.add(StandardOpenOption.READ);
293 assertEquals(0, Uncheck.get(() -> {
294 try (SeekableByteChannel c = FilesUncheck.newByteChannel(FILE_PATH_EMPTY, options, EMPTY_FILE_ATTRIBUTES_ARRAY)) {
295 return c.size();
296 }
297 }));
298 }
299
300 @Test
301 public void testNewDirectoryStreamPath() {
302 Uncheck.run(() -> {
303 try (final DirectoryStream<Path> directoryStream = FilesUncheck.newDirectoryStream(TARGET_PATH)) {
304 directoryStream.forEach(e -> assertEquals(TARGET_PATH, e.getParent()));
305 }
306 });
307 }
308
309 @Test
310 public void testNewDirectoryStreamPathFilterOfQsuperPath() {
311 Uncheck.run(() -> {
312 try (final DirectoryStream<Path> directoryStream = FilesUncheck.newDirectoryStream(TARGET_PATH, e -> true)) {
313 directoryStream.forEach(e -> assertEquals(TARGET_PATH, e.getParent()));
314 }
315 });
316 }
317
318 @Test
319 public void testNewDirectoryStreamPathString() {
320 Uncheck.run(() -> {
321 try (final DirectoryStream<Path> directoryStream = FilesUncheck.newDirectoryStream(TARGET_PATH, "*.xml")) {
322 directoryStream.forEach(e -> assertEquals(TARGET_PATH, e.getParent()));
323 }
324 });
325 }
326
327 @Test
328 public void testNewInputStream() {
329 assertEquals(0, Uncheck.get(() -> {
330 try (InputStream in = FilesUncheck.newInputStream(FILE_PATH_EMPTY, StandardOpenOption.READ)) {
331 return in.available();
332 }
333 }));
334 }
335
336 @Test
337 public void testNewOutputStream() {
338 final Path tempPath = FilesUncheck.createTempFile(PREFIX, SUFFIX);
339 Uncheck.run(() -> {
340 try (OutputStream stream = FilesUncheck.newOutputStream(tempPath, StandardOpenOption.TRUNCATE_EXISTING)) {
341 stream.write("test".getBytes());
342 }
343 });
344 assertEquals("test", FilesUncheck.readAllLines(tempPath).get(0));
345 }
346
347 @Test
348 public void testProbeContentType() {
349
350 String probeContentType = FilesUncheck.probeContentType(FILE_PATH_EMPTY);
351
352
353
354
355
356 probeContentType = FilesUncheck.probeContentType(Paths.get("src/test/resources/org/apache/commons/io/testfileBOM.xml"));
357
358
359
360 }
361
362 @Test
363 public void testReadAllBytes() {
364 assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, FilesUncheck.readAllBytes(FILE_PATH_EMPTY));
365 assertArrayEquals(new byte[] {'a'}, FilesUncheck.readAllBytes(FILE_PATH_A));
366 }
367
368 @Test
369 public void testReadAllLinesPath() {
370 assertEquals(Collections.emptyList(), FilesUncheck.readAllLines(FILE_PATH_EMPTY));
371 assertEquals(Arrays.asList("a"), FilesUncheck.readAllLines(FILE_PATH_A));
372 }
373
374 @Test
375 public void testReadAllLinesPathCharset() {
376 assertEquals(Collections.emptyList(), FilesUncheck.readAllLines(FILE_PATH_EMPTY, StandardCharsets.UTF_8));
377 assertEquals(Arrays.asList("a"), FilesUncheck.readAllLines(FILE_PATH_A, StandardCharsets.UTF_8));
378 }
379
380 @Test
381 public void testReadAttributesPathClassOfALinkOptionArray() {
382 assertNotNull(FilesUncheck.readAttributes(FILE_PATH_EMPTY, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS));
383 }
384
385 @Test
386 public void testReadAttributesPathStringLinkOptionArray() {
387 assertNotNull(FilesUncheck.readAttributes(FILE_PATH_EMPTY, "basic:lastModifiedTime", LinkOption.NOFOLLOW_LINKS));
388 }
389
390 @Test
391 public void testReadSymbolicLink() {
392 assertThrows(UncheckedIOException.class, () -> FilesUncheck.readSymbolicLink(NEW_FILE_PATH_LINK));
393 }
394
395 @Test
396 public void testSetAttribute() {
397 final FileTime ft = FilesUncheck.getLastModifiedTime(FILE_PATH_EMPTY);
398 assertEquals(FILE_PATH_EMPTY, FilesUncheck.setAttribute(FILE_PATH_EMPTY, "basic:lastModifiedTime", ft, LinkOption.NOFOLLOW_LINKS));
399 }
400
401 @Test
402 public void testSetLastModifiedTime() {
403 final FileTime ft = FilesUncheck.getLastModifiedTime(FILE_PATH_EMPTY);
404 assertEquals(FILE_PATH_EMPTY, FilesUncheck.setLastModifiedTime(FILE_PATH_EMPTY, ft));
405 }
406
407 @Test
408 public void testSetOwner() {
409 final UserPrincipal owner = FilesUncheck.getOwner(FILE_PATH_EMPTY, LinkOption.NOFOLLOW_LINKS);
410 assertEquals(FILE_PATH_EMPTY, FilesUncheck.setOwner(FILE_PATH_EMPTY, owner));
411 }
412
413 @Test
414 public void testSetPosixFilePermissions() {
415 assumeTrue(PathUtils.isPosix(FILE_PATH_EMPTY, LinkOption.NOFOLLOW_LINKS));
416 final Set<PosixFilePermission> posixFilePermissions = FilesUncheck.getPosixFilePermissions(FILE_PATH_EMPTY, LinkOption.NOFOLLOW_LINKS);
417 assertEquals(FILE_PATH_EMPTY, FilesUncheck.setPosixFilePermissions(FILE_PATH_EMPTY, posixFilePermissions));
418 }
419
420 @Test
421 public void testSize() {
422 assertEquals(0, FilesUncheck.size(FILE_PATH_EMPTY));
423 assertEquals(1, FilesUncheck.size(FILE_PATH_A));
424 }
425
426 @Test
427 public void testWalkFileTreePathFileVisitorOfQsuperPath() {
428 assertEquals(TARGET_PATH, FilesUncheck.walkFileTree(TARGET_PATH, NoopPathVisitor.INSTANCE));
429 }
430
431 @Test
432 public void testWalkFileTreePathSetOfFileVisitOptionIntFileVisitorOfQsuperPath() {
433 assertEquals(TARGET_PATH, FilesUncheck.walkFileTree(TARGET_PATH, new HashSet<>(), 1, NoopPathVisitor.INSTANCE));
434 }
435
436 @Test
437 public void testWalkPathFileVisitOptionArray() {
438 try (Stream<Path> stream = FilesUncheck.walk(TARGET_PATH, FileVisitOption.FOLLOW_LINKS)) {
439 assertTrue(0 < stream.count());
440 }
441 }
442
443 @Test
444 public void testWalkPathIntFileVisitOptionArray() {
445 try (Stream<Path> stream = FilesUncheck.walk(TARGET_PATH, 0, FileVisitOption.FOLLOW_LINKS)) {
446 assertEquals(1, stream.count());
447 }
448 }
449
450 @Test
451 public void testWritePathByteArrayOpenOptionArray() {
452 final Path tempFile = FilesUncheck.createTempFile(PREFIX, SUFFIX);
453 assertEquals(tempFile, FilesUncheck.write(tempFile, "test".getBytes(), StandardOpenOption.TRUNCATE_EXISTING));
454 FilesUncheck.delete(tempFile);
455 }
456
457 @Test
458 public void testWritePathIterableOfQextendsCharSequenceCharsetOpenOptionArray() {
459 final Path tempFile = FilesUncheck.createTempFile(PREFIX, SUFFIX);
460 assertEquals(tempFile, FilesUncheck.write(tempFile, Arrays.asList("test"), StandardCharsets.UTF_8, StandardOpenOption.TRUNCATE_EXISTING));
461 FilesUncheck.delete(tempFile);
462 }
463
464 @Test
465 public void testWritePathIterableOfQextendsCharSequenceOpenOptionArray() {
466 final Path tempFile = FilesUncheck.createTempFile(PREFIX, SUFFIX);
467 assertEquals(tempFile, FilesUncheck.write(tempFile, Arrays.asList("test"), StandardOpenOption.TRUNCATE_EXISTING));
468 FilesUncheck.delete(tempFile);
469 }
470
471 }