Merge pull request #594 from csmith/master

Add getPath utility method to JimFsRule.

test/com/dmdirc/commandparser/aliases/ActionAliasMigratorTest.java

 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.verify;
 
-@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class ActionAliasMigratorTest {
 
 
     @Before
     public void setup() throws IOException {
-        Files.createDirectories(jimFsRule.getFileSystem().getPath("test1/aliases"));
-        Files.createDirectories(jimFsRule.getFileSystem().getPath("test2/other-stuff/aliases"));
-        Files.createDirectories(jimFsRule.getFileSystem().getPath("test3/aliases"));
+        Files.createDirectories(jimFsRule.getPath("test1/aliases"));
+        Files.createDirectories(jimFsRule.getPath("test2/other-stuff/aliases"));
+        Files.createDirectories(jimFsRule.getPath("test3/aliases"));
 
         Files.copy(getClass().getResource("op-greater-0").openStream(),
-                jimFsRule.getFileSystem().getPath("test1/aliases/op"));
+                jimFsRule.getPath("test1/aliases/op"));
         Files.copy(getClass().getResource("unset-equals-2").openStream(),
-                jimFsRule.getFileSystem().getPath("test1/aliases/unset"));
+                jimFsRule.getPath("test1/aliases/unset"));
         Files.copy(getClass().getResource("no-trigger").openStream(),
-                jimFsRule.getFileSystem().getPath("test3/aliases/bad"));
-
-        migrator1 = new ActionAliasMigrator(jimFsRule.getFileSystem().getPath("test1"),
-                aliasFactory, aliasManager);
-        migrator2 = new ActionAliasMigrator(jimFsRule.getFileSystem().getPath("test2"),
-                aliasFactory, aliasManager);
-        migrator3 = new ActionAliasMigrator(jimFsRule.getFileSystem().getPath("test3"),
-                aliasFactory, aliasManager);
+                jimFsRule.getPath("test3/aliases/bad"));
+
+        migrator1 = new ActionAliasMigrator(jimFsRule.getPath("test1"), aliasFactory, aliasManager);
+        migrator2 = new ActionAliasMigrator(jimFsRule.getPath("test2"), aliasFactory, aliasManager);
+        migrator3 = new ActionAliasMigrator(jimFsRule.getPath("test3"), aliasFactory, aliasManager);
     }
 
     @Test
     @Test
     public void testDeletesFilesAfterMigration() {
         migrator1.migrate();
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("test1/aliases/unset")));
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("test1/aliases/op")));
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("test1/aliases")));
-        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("test1")));
+        assertFalse(Files.exists(jimFsRule.getPath("test1/aliases/unset")));
+        assertFalse(Files.exists(jimFsRule.getPath("test1/aliases/op")));
+        assertFalse(Files.exists(jimFsRule.getPath("test1/aliases")));
+        assertTrue(Files.exists(jimFsRule.getPath("test1")));
     }
 
     @Test
     public void testLeavesOtherFilesDuringMigration() {
         migrator2.migrate();
-        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("test2/other-stuff/aliases")));
+        assertTrue(Files.exists(jimFsRule.getPath("test2/other-stuff/aliases")));
     }
 
     @Test
     @Test
     public void testBadActionsLeftOnDisk() {
         migrator3.migrate();
-        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("test3/aliases/bad")));
+        assertTrue(Files.exists(jimFsRule.getPath("test3/aliases/bad")));
     }
 
 }

test/com/dmdirc/commandparser/aliases/DefaultAliasInstallerTest.java

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class DefaultAliasInstallerTest {
 
 
     @Before
     public void setup() {
-        path = jimFsRule.getFileSystem().getPath("aliases.yml");
+        path = jimFsRule.getPath("aliases.yml");
         installer = new DefaultAliasInstaller(path);
     }
 

test/com/dmdirc/commandparser/auto/YamlAutoCommandStoreTest.java

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-@SuppressWarnings("resource")
 public class YamlAutoCommandStoreTest {
 
     @Rule public final JimFsRule jimFsRule = new JimFsRule();
     @Before
     public void setup() throws IOException {
         Files.copy(getClass().getResource("readtest.yml").openStream(),
-                jimFsRule.getFileSystem().getPath("readtest.yml"));
+                jimFsRule.getPath("readtest.yml"));
         command = AutoCommand.create(Optional.ofNullable("server"),
                 Optional.ofNullable("network"),
                 Optional.ofNullable("profile"),
 
     @Test
     public void testReadAutoCommands() {
-        ycs = new YamlAutoCommandStore(jimFsRule.getFileSystem().getPath("readtest.yml"));
+        ycs = new YamlAutoCommandStore(jimFsRule.getPath("readtest.yml"));
         final Set<AutoCommand> commands = ycs.readAutoCommands();
         assertTrue("Command 1 not present", commands.contains(command1));
         assertTrue("Command 2 not present", commands.contains(command2));
 
     @Test
     public void testWriteAutoCommands() throws IOException {
-        ycs = new YamlAutoCommandStore(jimFsRule.getFileSystem().getPath("store.yml"));
+        ycs = new YamlAutoCommandStore(jimFsRule.getPath("store.yml"));
         assertEquals(0, ycs.readAutoCommands().size());
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("store.yml")));
+        assertFalse(Files.exists(jimFsRule.getPath("store.yml")));
         ycs.writeAutoCommands(Sets.newHashSet(command));
         final Set<AutoCommand> commands = ycs.readAutoCommands();
         assertTrue("Command not present", commands.contains(command));
-        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("store.yml")));
+        assertTrue(Files.exists(jimFsRule.getPath("store.yml")));
     }
 
 }

test/com/dmdirc/config/ConfigFileBackedConfigProviderTest.java

 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 
-@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class ConfigFileBackedConfigProviderTest {
 
     @Before
     public void setUp() throws Exception {
         for (String file: FILES) {
-            Files.copy(getClass().getResourceAsStream(file),
-                    jimFsRule.getFileSystem().getPath(file));
+            Files.copy(getClass().getResourceAsStream(file), jimFsRule.getPath(file));
         }
     }
 
     @Test(expected = InvalidIdentityFileException.class)
     public void testNoName() throws IOException, InvalidIdentityFileException {
         new ConfigFileBackedConfigProvider(identityManager,
-                jimFsRule.getFileSystem().getPath("no-name"), false);
+                jimFsRule.getPath("no-name"), false);
     }
 
     @Test(expected = InvalidIdentityFileException.class)
     public void testNoTarget() throws IOException, InvalidIdentityFileException {
         new ConfigFileBackedConfigProvider(identityManager,
-                jimFsRule.getFileSystem().getPath("no-target"), false);
+                jimFsRule.getPath("no-target"), false);
     }
 
     @Test(expected = InvalidIdentityFileException.class)
     public void testInvalidConfigFile() throws IOException, InvalidIdentityFileException {
         new ConfigFileBackedConfigProvider(identityManager,
-                jimFsRule.getFileSystem().getPath("invalid-config-file"), false);
+                jimFsRule.getPath("invalid-config-file"), false);
     }
 
     @Test
 
     private void copyFileAndReload(final ConfigProvider provider)
             throws IOException, InvalidConfigFileException {
-        Files.copy(jimFsRule.getFileSystem().getPath("simple-ircd-extra"),
-                jimFsRule.getFileSystem().getPath("simple-ircd"),
+        Files.copy(jimFsRule.getPath("simple-ircd-extra"), jimFsRule.getPath("simple-ircd"),
                 StandardCopyOption.REPLACE_EXISTING);
         provider.reload();
     }
 
     private ConfigFileBackedConfigProvider getProvider(final String file)
             throws IOException, InvalidIdentityFileException {
-        return new ConfigFileBackedConfigProvider(identityManager,
-                jimFsRule.getFileSystem().getPath(file), false);
+        return new ConfigFileBackedConfigProvider(identityManager, jimFsRule.getPath(file), false);
     }
 
 }

test/com/dmdirc/config/IdentityManagerTest.java

     private Path identitiesDirectory;
 
     @Before
-    @SuppressWarnings("resource")
     public void setUp() throws Exception {
-        baseDirectory = jimFsRule.getFileSystem().getPath("config");
+        baseDirectory = jimFsRule.getPath("config");
         identitiesDirectory = baseDirectory.resolve("identities");
     }
 

test/com/dmdirc/logger/DiskLoggingErrorManagerTest.java

 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class DiskLoggingErrorManagerTest {
 
         when(programError.getThrowableAsString()).thenReturn(Optional.of("test"));
         when(programError.getLevel()).thenReturn(ErrorLevel.MEDIUM);
         when(config.getBinder()).thenReturn(configBinder);
-        instance = new DiskLoggingErrorManager(jimFsRule.getFileSystem().getPath("/errors"),
+        instance = new DiskLoggingErrorManager(jimFsRule.getPath("/errors"),
                 eventBus);
     }
 
     @Test
     public void testInitialise() throws Exception {
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors")));
+        assertFalse(Files.exists(jimFsRule.getPath("/errors")));
         instance.initialise(config);
         verify(configBinder).bind(instance, DiskLoggingErrorManager.class);
-        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("/errors")));
+        assertTrue(Files.exists(jimFsRule.getPath("/errors")));
         assertFalse(instance.isDirectoryError());
     }
 
         instance.initialise(config);
         instance.handleLoggingSetting(true);
         final String logName = error.getTimestamp() + "-" + error.getError().getLevel() + ".log";;
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
+        assertFalse(Files.exists(jimFsRule.getPath("/errors", logName)));
         instance.handleErrorEvent(error);
-        final Path errorPath = jimFsRule.getFileSystem().getPath("/errors", logName);
+        final Path errorPath = jimFsRule.getPath("/errors", logName);
         assertTrue(Files.exists(errorPath));
         assertTrue(Files.readAllLines(errorPath).contains("Level: Medium"));
     }
         instance.initialise(config);
         instance.handleLoggingSetting(false);
         final String logName = error.getTimestamp() + "-" + error.getError().getLevel() + ".log";;
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
+        assertFalse(Files.exists(jimFsRule.getPath("/errors", logName)));
         instance.handleErrorEvent(error);
-        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
+        assertFalse(Files.exists(jimFsRule.getPath("/errors", logName)));
     }
 
     @Test

test/com/dmdirc/tests/JimFsRule.java

 import com.google.common.jimfs.Jimfs;
 
 import java.nio.file.FileSystem;
-
-import javax.annotation.WillCloseWhenClosed;
+import java.nio.file.Path;
 
 import org.junit.rules.TestRule;
 import org.junit.runner.Description;
         };
     }
 
-    @WillCloseWhenClosed
+    /**
+     * Gets the file system for use in the test.
+     *
+     * @return The JimFS filesystem.
+     */
     public FileSystem getFileSystem() {
         return fileSystem;
     }
 
+    /**
+     * Utility method to get a path from the file system.
+     *
+     * @param first The first component of the path
+     * @param more Any additional path components
+     * @return A corresponding {@link Path} object from the JimFS file system.
+     */
+    public Path getPath(final String first, final String ... more) {
+        return fileSystem.getPath(first, more);
+    }
+
 }

test/com/dmdirc/util/URLBuilderTest.java

     @Mock private DMDircMBassador eventBus;
 
     @Before
-    @SuppressWarnings("resource")
     public void setup() throws MalformedURLException {
         when(pluginManagerProvider.get()).thenReturn(pluginManager);
         when(themeManagerProvider.get()).thenReturn(themeManager);
         when(pluginManager.getPluginInfoByName(Matchers.anyString())).thenReturn(pluginInfo);
         when(themeManager.getDirectory()).thenReturn("/themes/");
         when(pluginInfo.getMetaData()).thenReturn(pluginMetaData);
-        when(pluginMetaData.getPluginPath()).thenReturn(
-                jimFsRule.getFileSystem().getPath("file://testPlugin"));
+        when(pluginMetaData.getPluginPath()).thenReturn(jimFsRule.getPath("file://testPlugin"));
     }
 
     @Test