Serge NOEL
366 lines
15 KiB
Java
366 lines
15 KiB
Java
package jmri.util;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.net.URI;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Paths;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.Scanner;
|
|
import java.util.UUID;
|
|
|
|
import org.junit.jupiter.api.*;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
|
import static org.junit.jupiter.api.Assertions.fail;
|
|
|
|
/**
|
|
* Tests for the jmri.util.FileUtilSupport class.
|
|
*
|
|
* Most tests use a deliberately non-existent filename since FileUtil appends a
|
|
* / to the end of a portable directory name, and tests could fail if they
|
|
* expect a file or non-existent filename and a directory exists at that path.
|
|
*
|
|
* @author Bob Jacobsen Copyright 2003, 2009
|
|
* @author Randall Wood Copyright 2016, 2017
|
|
*/
|
|
public class FileUtilSupportTest {
|
|
|
|
private File programTestFile;
|
|
private File preferencesTestFile;
|
|
private FileUtilSupport instance;
|
|
|
|
// tests of internal to external mapping
|
|
// relative file with no prefix: Leave relative in system-specific form
|
|
@Test
|
|
public void testGEFRel() {
|
|
String name = instance.getExternalFilename("resources/non-existant-file-foo");
|
|
assertEquals("resources" + File.separator + "non-existant-file-foo", name);
|
|
}
|
|
|
|
// relative file with no prefix: Leave relative in system-specific form
|
|
@Test
|
|
public void testGEFAbs() {
|
|
File f = new File("resources/non-existant-file-foo");
|
|
String name = instance.getExternalFilename(f.getAbsolutePath());
|
|
assertEquals(f.getAbsolutePath(), name);
|
|
}
|
|
|
|
// program: prefix with relative path, convert to relative in system-specific form
|
|
@Test
|
|
public void testGEFProgramRel() {
|
|
String name = instance.getExternalFilename("program:jython");
|
|
assertEquals(new File("jython").getAbsolutePath(), name);
|
|
}
|
|
|
|
// program: prefix with absolute path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGEFProgramAbs() {
|
|
File f = new File("resources/non-existant-file-foo");
|
|
String name = instance.getExternalFilename("program:" + f.getAbsolutePath());
|
|
assertEquals(f.getAbsolutePath(), name);
|
|
}
|
|
|
|
// preference: prefix with relative path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGEFPrefRel() {
|
|
String name = instance.getExternalFilename("preference:non-existant-file-foo");
|
|
assertEquals(instance.getUserFilesPath() + "non-existant-file-foo", name);
|
|
}
|
|
|
|
// preference: prefix with absolute path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGEFPrefAbs() {
|
|
File f = new File("resources/non-existant-file-foo");
|
|
String name = instance.getExternalFilename("preference:" + f.getAbsolutePath());
|
|
assertEquals(f.getAbsolutePath(), name);
|
|
}
|
|
|
|
// home: prefix with relative path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGEFHomeRel() {
|
|
String name = instance.getExternalFilename("home:non-existant-file-foo");
|
|
assertEquals(System.getProperty("user.home") + File.separator + "non-existant-file-foo", name);
|
|
}
|
|
|
|
// home: prefix with absolute path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGEFHomeAbs() {
|
|
File f = new File("resources/non-existant-file-foo");
|
|
String name = instance.getExternalFilename("home:" + f.getAbsolutePath());
|
|
assertEquals(f.getAbsolutePath(), name);
|
|
}
|
|
|
|
// tests of external to internal mapping
|
|
@Test
|
|
public void testGetpfPreferenceF() throws IOException {
|
|
File f = new File(instance.getUserFilesPath() + "non-existant-file-foo");
|
|
String name = instance.getPortableFilename(f);
|
|
assertEquals("preference:non-existant-file-foo", name);
|
|
}
|
|
|
|
@Test
|
|
public void testGetpfPreferenceS() {
|
|
String name = instance.getPortableFilename("preference:non-existant-file-foo");
|
|
assertEquals("preference:non-existant-file-foo", name);
|
|
}
|
|
|
|
@Test
|
|
public void testGetpfResourceF() throws IOException {
|
|
File f = new File(instance.getUserFilesPath() + "resources" + File.separator + "non-existant-file-foo");
|
|
String name = instance.getPortableFilename(f);
|
|
assertEquals("preference:resources/non-existant-file-foo", name);
|
|
}
|
|
|
|
@Test
|
|
public void testGetpfPrefF() throws IOException {
|
|
File f = new File(instance.getUserFilesPath() + "resources" + File.separator + "non-existant-file-foo");
|
|
String name = instance.getPortableFilename(f);
|
|
assertEquals("preference:resources/non-existant-file-foo", name);
|
|
}
|
|
|
|
@Test
|
|
public void testGetpfProgramF() throws IOException {
|
|
File f = new File("resources" + File.separator + "non-existant-file-foo");
|
|
String name = instance.getPortableFilename(f);
|
|
assertEquals("program:resources/non-existant-file-foo", name);
|
|
}
|
|
|
|
@Test
|
|
public void testGetpfProgramS() {
|
|
String name = instance.getPortableFilename("program:resources/non-existant-file-foo");
|
|
assertEquals("program:resources/non-existant-file-foo", name);
|
|
}
|
|
|
|
/*
|
|
* Test a real directory. It should end with a separator.
|
|
*/
|
|
@Test
|
|
public void testGetpfProgramDirS() {
|
|
String name = instance.getPortableFilename("program:resources/icons");
|
|
assertEquals("program:resources/icons/", name);
|
|
}
|
|
|
|
@Test
|
|
public void testGetpfHomeS() {
|
|
String name = instance.getPortableFilename("home:non-existant-file-foo");
|
|
assertEquals("home:non-existant-file-foo", name);
|
|
}
|
|
|
|
@Test
|
|
public void testGetpfHomeF() throws IOException {
|
|
File f = new File(System.getProperty("user.home") + File.separator + "resources" + File.separator + "non-existant-file-foo");
|
|
String name = instance.getPortableFilename(f);
|
|
assertEquals("home:resources/non-existant-file-foo", name);
|
|
}
|
|
|
|
/*
|
|
* test getAbsoluteFilename()
|
|
*/
|
|
// relative file with no prefix: Should become null
|
|
@Test
|
|
public void testGAFRel() {
|
|
String name = instance.getAbsoluteFilename("resources/non-existant-file-foo");
|
|
assertEquals(null, name);
|
|
}
|
|
|
|
// program: prefix with relative path, convert to relative in system-specific form
|
|
@Test
|
|
public void testGAFProgRel() throws IOException {
|
|
String name = instance.getAbsoluteFilename(FileUtil.PROGRAM + "jython");
|
|
assertEquals(new File("jython").getCanonicalPath(), name);
|
|
}
|
|
|
|
// program: prefix with absolute path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGAFProgAbs() throws IOException {
|
|
File f = new File("resources/non-existant-file-foo");
|
|
String name = instance.getAbsoluteFilename(FileUtil.PROGRAM + f.getAbsolutePath());
|
|
assertEquals(f.getCanonicalPath(), name);
|
|
}
|
|
|
|
// preference: prefix with relative path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGAFPrefRel() throws IOException {
|
|
String name = instance.getAbsoluteFilename(FileUtil.PREFERENCES + "non-existant-file-foo");
|
|
assertEquals(new File(instance.getUserFilesPath() + "non-existant-file-foo").getCanonicalPath(), name);
|
|
}
|
|
|
|
// preference: prefix with absolute path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGAFPrefAbs() throws IOException {
|
|
File f = new File("resources/non-existant-file-foo");
|
|
String name = instance.getAbsoluteFilename(FileUtil.PREFERENCES + f.getAbsolutePath());
|
|
assertEquals(f.getCanonicalPath(), name);
|
|
}
|
|
|
|
// home: prefix with relative path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGAFHomeRel() throws IOException {
|
|
String name = instance.getAbsoluteFilename(FileUtil.HOME + "non-existant-file-foo");
|
|
assertEquals(new File(System.getProperty("user.home") + File.separator + "non-existant-file-foo").getCanonicalPath(), name);
|
|
}
|
|
|
|
// home: prefix with absolute path, convert to absolute in system-specific form
|
|
@Test
|
|
public void testGAFHomeAbs() throws IOException {
|
|
File f = new File("resources/non-existant-file-foo");
|
|
String name = instance.getAbsoluteFilename(FileUtil.HOME + f.getAbsolutePath());
|
|
assertEquals(f.getCanonicalPath(), name);
|
|
}
|
|
|
|
@Test
|
|
public void testCopyFile() throws FileNotFoundException {
|
|
File src = instance.getFile(instance.getAbsoluteFilename("program:default_lcf.xml"));
|
|
File dest = new File(instance.getAbsoluteFilename("program:fileUtilTest_lcf.xml"));
|
|
ArrayList<String> sl = new ArrayList<>();
|
|
ArrayList<String> dl = new ArrayList<>();
|
|
try {
|
|
instance.copy(src, dest);
|
|
Scanner s = new Scanner(src);
|
|
while (s.hasNext()) {
|
|
sl.add(s.next());
|
|
}
|
|
s.close();
|
|
s = new Scanner(dest);
|
|
while (s.hasNext()) {
|
|
dl.add(s.next());
|
|
}
|
|
s.close();
|
|
} catch (IOException ex) {
|
|
instance.delete(dest);
|
|
fail("Unable to copy");
|
|
}
|
|
instance.delete(dest);
|
|
assertTrue(sl.equals(dl));
|
|
}
|
|
|
|
@Test
|
|
public void testCopyDirectoryToExistingDirectory() throws FileNotFoundException, IOException {
|
|
File src = instance.getFile(instance.getAbsoluteFilename("program:web/fonts"));
|
|
File dest = Files.createTempDirectory("FileUtilTest").toFile();
|
|
instance.copy(src, dest);
|
|
String[] destFiles = dest.list();
|
|
String[] srcFiles = src.list();
|
|
Assertions.assertNotNull(destFiles);
|
|
Assertions.assertNotNull(srcFiles);
|
|
Arrays.sort(destFiles);
|
|
Arrays.sort(srcFiles);
|
|
instance.delete(dest);
|
|
assertTrue(Arrays.equals(srcFiles, destFiles));
|
|
}
|
|
|
|
@Test
|
|
public void testDeleteFile() throws IOException {
|
|
File file = File.createTempFile("FileUtilTest", null);
|
|
instance.copy(instance.getFile(instance.getAbsoluteFilename("program:default_lcf.xml")), file);
|
|
instance.delete(file);
|
|
assertFalse(file.exists());
|
|
}
|
|
|
|
@Test
|
|
public void testAppendTextToFile() throws IOException {
|
|
File file = File.createTempFile("FileUtilTest", null);
|
|
String text = "jmri.util.FileUtil#appendTextToFile";
|
|
instance.appendTextToFile(file, text);
|
|
List<String> lines = Files.readAllLines(Paths.get(file.toURI()), StandardCharsets.UTF_8);
|
|
assertEquals(text, lines.get(0));
|
|
}
|
|
|
|
@Test
|
|
public void testFindURIPath() {
|
|
URI uri = this.programTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findURI(this.programTestFile.getName()));
|
|
assertEquals(uri, instance.findURI(FileUtil.PROGRAM + this.programTestFile.getName()));
|
|
assertNull(instance.findURI(FileUtil.PREFERENCES + this.programTestFile.getName()));
|
|
uri = this.preferencesTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findURI(this.preferencesTestFile.getName()));
|
|
assertEquals(uri, instance.findURI(FileUtil.PREFERENCES + this.preferencesTestFile.getName()));
|
|
assertNull(instance.findURI(FileUtil.PROGRAM + this.preferencesTestFile.getName()));
|
|
}
|
|
|
|
@Test
|
|
public void testFindURIPathLocation() {
|
|
URI uri = this.programTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findURI(this.programTestFile.getName(), FileUtil.Location.INSTALLED));
|
|
assertEquals(uri, instance.findURI(this.programTestFile.getName(), FileUtil.Location.ALL));
|
|
assertNull(instance.findURI(this.programTestFile.getName(), FileUtil.Location.USER));
|
|
uri = this.preferencesTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findURI(this.preferencesTestFile.getName(), FileUtil.Location.USER));
|
|
assertEquals(uri, instance.findURI(this.preferencesTestFile.getName(), FileUtil.Location.ALL));
|
|
assertNull(instance.findURI(this.preferencesTestFile.getName(), FileUtil.Location.INSTALLED));
|
|
}
|
|
|
|
@Test
|
|
public void testFindURIPathSearchPaths() {
|
|
URI uri = this.programTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findURI(this.programTestFile.getName(), new String[]{instance.getProgramPath()}));
|
|
assertEquals(uri, instance.findURI(this.programTestFile.getName(), new String[]{instance.getPreferencesPath(), instance.getProgramPath()}));
|
|
assertEquals(uri, instance.findURI(this.programTestFile.getName(), new String[]{instance.getPreferencesPath()}));
|
|
uri = this.preferencesTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findURI(this.preferencesTestFile.getName(), new String[]{instance.getPreferencesPath()}));
|
|
assertEquals(uri, instance.findURI(this.preferencesTestFile.getName(), new String[]{instance.getPreferencesPath(), instance.getProgramPath()}));
|
|
assertEquals(uri, instance.findURI(this.preferencesTestFile.getName(), new String[]{instance.getProgramPath()}));
|
|
}
|
|
|
|
@Test
|
|
public void testFindExternalFilename() {
|
|
URI uri = this.programTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findExternalFilename(this.programTestFile.getName()));
|
|
assertEquals(uri, instance.findExternalFilename(FileUtil.PROGRAM + this.programTestFile.getName()));
|
|
assertNull(instance.findExternalFilename(FileUtil.PREFERENCES + this.programTestFile.getName()));
|
|
uri = this.preferencesTestFile.toURI();
|
|
assertNotNull(uri);
|
|
assertEquals(uri, instance.findExternalFilename(this.preferencesTestFile.getName()));
|
|
assertEquals(uri, instance.findExternalFilename(FileUtil.PREFERENCES + this.preferencesTestFile.getName()));
|
|
assertNull(instance.findExternalFilename(FileUtil.PROGRAM + this.preferencesTestFile.getName()));
|
|
}
|
|
|
|
@BeforeEach
|
|
public void setUp() throws IOException {
|
|
JUnitUtil.setUp();
|
|
JUnitUtil.resetProfileManager();
|
|
this.instance = FileUtilSupport.getDefault();
|
|
this.programTestFile = new File(UUID.randomUUID().toString());
|
|
assertTrue(this.programTestFile.createNewFile());
|
|
JUnitUtil.waitFor(() -> {
|
|
return this.programTestFile.exists();
|
|
}, "Create program test file");
|
|
File profile = new File(instance.getProfilePath());
|
|
assertFalse(profile.mkdir(),"directory should exist");
|
|
this.preferencesTestFile = new File(profile, UUID.randomUUID().toString());
|
|
assertTrue(this.preferencesTestFile.createNewFile());
|
|
JUnitUtil.waitFor(() -> {
|
|
return this.preferencesTestFile.exists();
|
|
}, "Create program test file");
|
|
}
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
assertTrue(this.programTestFile.delete());
|
|
JUnitUtil.waitFor(() -> {
|
|
return !this.programTestFile.exists();
|
|
}, "Remove program test file");
|
|
assertTrue(this.preferencesTestFile.delete());
|
|
JUnitUtil.waitFor(() -> {
|
|
return !this.preferencesTestFile.exists();
|
|
}, "Remove program test file");
|
|
JUnitUtil.tearDown();
|
|
}
|
|
}
|