Merge pull request #591 from csmith/master

Add a JUnit rule for using JimFS.

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

@@ -22,14 +22,13 @@
 
 package com.dmdirc.commandparser.aliases;
 
-import com.google.common.jimfs.Configuration;
-import com.google.common.jimfs.Jimfs;
+import com.dmdirc.tests.JimFsRule;
 
 import java.io.IOException;
-import java.nio.file.FileSystem;
 import java.nio.file.Files;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -39,35 +38,38 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.verify;
 
+@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class ActionAliasMigratorTest {
 
+    @Rule public final JimFsRule jimFsRule = new JimFsRule();
+
     @Mock private AliasFactory aliasFactory;
     @Mock private AliasManager aliasManager;
 
-    private FileSystem fs;
     private ActionAliasMigrator migrator1;
     private ActionAliasMigrator migrator2;
     private ActionAliasMigrator migrator3;
 
     @Before
     public void setup() throws IOException {
-        fs = Jimfs.newFileSystem(Configuration.unix());
-
-        Files.createDirectories(fs.getPath("test1/aliases"));
-        Files.createDirectories(fs.getPath("test2/other-stuff/aliases"));
-        Files.createDirectories(fs.getPath("test3/aliases"));
+        Files.createDirectories(jimFsRule.getFileSystem().getPath("test1/aliases"));
+        Files.createDirectories(jimFsRule.getFileSystem().getPath("test2/other-stuff/aliases"));
+        Files.createDirectories(jimFsRule.getFileSystem().getPath("test3/aliases"));
 
         Files.copy(getClass().getResource("op-greater-0").openStream(),
-                fs.getPath("test1/aliases/op"));
+                jimFsRule.getFileSystem().getPath("test1/aliases/op"));
         Files.copy(getClass().getResource("unset-equals-2").openStream(),
-                fs.getPath("test1/aliases/unset"));
+                jimFsRule.getFileSystem().getPath("test1/aliases/unset"));
         Files.copy(getClass().getResource("no-trigger").openStream(),
-                fs.getPath("test3/aliases/bad"));
-
-        migrator1 = new ActionAliasMigrator(fs.getPath("test1"), aliasFactory, aliasManager);
-        migrator2 = new ActionAliasMigrator(fs.getPath("test2"), aliasFactory, aliasManager);
-        migrator3 = new ActionAliasMigrator(fs.getPath("test3"), aliasFactory, aliasManager);
+                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);
     }
 
     @Test
@@ -79,16 +81,16 @@ public class ActionAliasMigratorTest {
     @Test
     public void testDeletesFilesAfterMigration() {
         migrator1.migrate();
-        assertFalse(Files.exists(fs.getPath("test1/aliases/unset")));
-        assertFalse(Files.exists(fs.getPath("test1/aliases/op")));
-        assertFalse(Files.exists(fs.getPath("test1/aliases")));
-        assertTrue(Files.exists(fs.getPath("test1")));
+        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")));
     }
 
     @Test
     public void testLeavesOtherFilesDuringMigration() {
         migrator2.migrate();
-        assertTrue(Files.exists(fs.getPath("test2/other-stuff/aliases")));
+        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("test2/other-stuff/aliases")));
     }
 
     @Test
@@ -101,7 +103,7 @@ public class ActionAliasMigratorTest {
     @Test
     public void testBadActionsLeftOnDisk() {
         migrator3.migrate();
-        assertTrue(Files.exists(fs.getPath("test3/aliases/bad")));
+        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("test3/aliases/bad")));
     }
 
 }

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

@@ -22,16 +22,14 @@
 
 package com.dmdirc.commandparser.aliases;
 
-import com.google.common.jimfs.Configuration;
-import com.google.common.jimfs.Jimfs;
+import com.dmdirc.tests.JimFsRule;
 
 import java.io.IOException;
-import java.nio.file.FileSystem;
 import java.nio.file.Files;
 import java.nio.file.Path;
 
-import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.runners.MockitoJUnitRunner;
@@ -39,28 +37,22 @@ import org.mockito.runners.MockitoJUnitRunner;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
+@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class DefaultAliasInstallerTest {
 
-    private FileSystem fs;
+    @Rule public final JimFsRule jimFsRule = new JimFsRule();
+
     private Path path;
 
     private DefaultAliasInstaller installer;
 
     @Before
     public void setup() {
-        fs = Jimfs.newFileSystem(Configuration.unix().toBuilder()
-                .setAttributeViews("posix").build());
-        path = fs.getPath("aliases.yml");
-
+        path = jimFsRule.getFileSystem().getPath("aliases.yml");
         installer = new DefaultAliasInstaller(path);
     }
 
-    @After
-    public void tearDown() throws IOException {
-        fs.close();
-    }
-
     @Test
     public void testNeedsMigrationIfFileDoesntExist() {
         assertTrue(installer.needsMigration());

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

@@ -22,26 +22,28 @@
 
 package com.dmdirc.commandparser.auto;
 
+import com.dmdirc.tests.JimFsRule;
+
 import com.google.common.collect.Sets;
-import com.google.common.jimfs.Configuration;
-import com.google.common.jimfs.Jimfs;
 
 import java.io.IOException;
-import java.nio.file.FileSystem;
 import java.nio.file.Files;
 import java.util.Optional;
 import java.util.Set;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 
 import static junit.framework.TestCase.assertFalse;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
+@SuppressWarnings("resource")
 public class YamlAutoCommandStoreTest {
 
-    private FileSystem fs;
+    @Rule public final JimFsRule jimFsRule = new JimFsRule();
+
     private YamlAutoCommandStore ycs;
     private AutoCommand command;
     private AutoCommand command1;
@@ -51,9 +53,8 @@ public class YamlAutoCommandStoreTest {
 
     @Before
     public void setup() throws IOException {
-        fs = Jimfs.newFileSystem(Configuration.unix());
         Files.copy(getClass().getResource("readtest.yml").openStream(),
-                fs.getPath("readtest.yml"));
+                jimFsRule.getFileSystem().getPath("readtest.yml"));
         command = AutoCommand.create(Optional.ofNullable("server"),
                 Optional.ofNullable("network"),
                 Optional.ofNullable("profile"),
@@ -76,7 +77,7 @@ public class YamlAutoCommandStoreTest {
 
     @Test
     public void testReadAutoCommands() {
-        ycs = new YamlAutoCommandStore(fs.getPath("readtest.yml"));
+        ycs = new YamlAutoCommandStore(jimFsRule.getFileSystem().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));
@@ -86,13 +87,13 @@ public class YamlAutoCommandStoreTest {
 
     @Test
     public void testWriteAutoCommands() throws IOException {
-        ycs = new YamlAutoCommandStore(fs.getPath("store.yml"));
+        ycs = new YamlAutoCommandStore(jimFsRule.getFileSystem().getPath("store.yml"));
         assertEquals(0, ycs.readAutoCommands().size());
-        assertFalse(Files.exists(fs.getPath("store.yml")));
+        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("store.yml")));
         ycs.writeAutoCommands(Sets.newHashSet(command));
         final Set<AutoCommand> commands = ycs.readAutoCommands();
         assertTrue("Command not present", commands.contains(command));
-        assertTrue(Files.exists(fs.getPath("store.yml")));
+        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("store.yml")));
     }
 
 }

test/com/dmdirc/config/ConfigFileBackedConfigProviderTest.java

@@ -24,20 +24,19 @@ package com.dmdirc.config;
 
 import com.dmdirc.interfaces.config.ConfigChangeListener;
 import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.tests.JimFsRule;
 import com.dmdirc.util.io.InvalidConfigFileException;
 import com.dmdirc.util.validators.NumericalValidator;
 import com.dmdirc.util.validators.PermissiveValidator;
 
 import com.google.common.collect.Lists;
-import com.google.common.jimfs.Configuration;
-import com.google.common.jimfs.Jimfs;
 
 import java.io.IOException;
-import java.nio.file.FileSystem;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -51,6 +50,7 @@ import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 
+@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class ConfigFileBackedConfigProviderTest {
 
@@ -62,33 +62,35 @@ public class ConfigFileBackedConfigProviderTest {
     public static final PermissiveValidator<String> PERMISSIVE_VALIDATOR =
             new PermissiveValidator<>();
 
+    @Rule public final JimFsRule jimFsRule = new JimFsRule();
+
     @Mock private IdentityManager identityManager;
     @Mock private ConfigChangeListener changeListener;
 
-    private FileSystem fs;
-
     @Before
     public void setUp() throws Exception {
-        fs = Jimfs.newFileSystem(Configuration.unix());
-
         for (String file: FILES) {
-            Files.copy(getClass().getResourceAsStream(file), fs.getPath(file));
+            Files.copy(getClass().getResourceAsStream(file),
+                    jimFsRule.getFileSystem().getPath(file));
         }
     }
 
     @Test(expected = InvalidIdentityFileException.class)
     public void testNoName() throws IOException, InvalidIdentityFileException {
-        new ConfigFileBackedConfigProvider(identityManager, fs.getPath("no-name"), false);
+        new ConfigFileBackedConfigProvider(identityManager,
+                jimFsRule.getFileSystem().getPath("no-name"), false);
     }
 
     @Test(expected = InvalidIdentityFileException.class)
     public void testNoTarget() throws IOException, InvalidIdentityFileException {
-        new ConfigFileBackedConfigProvider(identityManager, fs.getPath("no-target"), false);
+        new ConfigFileBackedConfigProvider(identityManager,
+                jimFsRule.getFileSystem().getPath("no-target"), false);
     }
 
     @Test(expected = InvalidIdentityFileException.class)
     public void testInvalidConfigFile() throws IOException, InvalidIdentityFileException {
-        new ConfigFileBackedConfigProvider(identityManager, fs.getPath("invalid-config-file"), false);
+        new ConfigFileBackedConfigProvider(identityManager,
+                jimFsRule.getFileSystem().getPath("invalid-config-file"), false);
     }
 
     @Test
@@ -311,14 +313,16 @@ public class ConfigFileBackedConfigProviderTest {
 
     private void copyFileAndReload(final ConfigProvider provider)
             throws IOException, InvalidConfigFileException {
-        Files.copy(fs.getPath("simple-ircd-extra"), fs.getPath("simple-ircd"),
+        Files.copy(jimFsRule.getFileSystem().getPath("simple-ircd-extra"),
+                jimFsRule.getFileSystem().getPath("simple-ircd"),
                 StandardCopyOption.REPLACE_EXISTING);
         provider.reload();
     }
 
     private ConfigFileBackedConfigProvider getProvider(final String file)
             throws IOException, InvalidIdentityFileException {
-        return new ConfigFileBackedConfigProvider(identityManager, fs.getPath(file), false);
+        return new ConfigFileBackedConfigProvider(identityManager,
+                jimFsRule.getFileSystem().getPath(file), false);
     }
 
 }

test/com/dmdirc/config/IdentityManagerTest.java

@@ -24,18 +24,16 @@ package com.dmdirc.config;
 
 import com.dmdirc.DMDircMBassador;
 import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.tests.JimFsRule;
 import com.dmdirc.util.ClientInfo;
 
-import com.google.common.jimfs.Configuration;
-import com.google.common.jimfs.Jimfs;
-
 import java.io.IOException;
-import java.nio.file.FileSystem;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Collection;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -47,6 +45,8 @@ import static org.junit.Assert.assertNotNull;
 @RunWith(MockitoJUnitRunner.class)
 public class IdentityManagerTest {
 
+    @Rule public final JimFsRule jimFsRule = new JimFsRule();
+
     @Mock private DMDircMBassador eventBus;
     @Mock private ClientInfo clientInfo;
 
@@ -56,8 +56,7 @@ public class IdentityManagerTest {
     @Before
     @SuppressWarnings("resource")
     public void setUp() throws Exception {
-        final FileSystem fs = Jimfs.newFileSystem(Configuration.unix());
-        baseDirectory = fs.getPath("config");
+        baseDirectory = jimFsRule.getFileSystem().getPath("config");
         identitiesDirectory = baseDirectory.resolve("identities");
     }
 

test/com/dmdirc/logger/DiskLoggingErrorManagerTest.java

@@ -26,15 +26,13 @@ import com.dmdirc.DMDircMBassador;
 import com.dmdirc.config.ConfigBinder;
 import com.dmdirc.events.UserErrorEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.tests.JimFsRule;
 
-import com.google.common.jimfs.Configuration;
-import com.google.common.jimfs.Jimfs;
-
-import java.nio.file.FileSystem;
 import java.nio.file.Files;
 import java.nio.file.Path;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -45,29 +43,31 @@ import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+@SuppressWarnings("resource")
 @RunWith(MockitoJUnitRunner.class)
 public class DiskLoggingErrorManagerTest {
 
+    @Rule public final JimFsRule jimFsRule = new JimFsRule();
+
     @Mock private DMDircMBassador eventBus;
     @Mock private AggregateConfigProvider config;
     @Mock private ConfigBinder configBinder;
 
-    private FileSystem fileSystem;
     private DiskLoggingErrorManager instance;
 
     @Before
     public void setUp() throws Exception {
         when(config.getBinder()).thenReturn(configBinder);
-        fileSystem = Jimfs.newFileSystem(Configuration.unix());
-        instance = new DiskLoggingErrorManager(fileSystem.getPath("/errors"), eventBus);
+        instance = new DiskLoggingErrorManager(jimFsRule.getFileSystem().getPath("/errors"),
+                eventBus);
     }
 
     @Test
     public void testInitialise() throws Exception {
-        assertFalse(Files.exists(fileSystem.getPath("/errors")));
+        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors")));
         instance.initialise(config);
         verify(configBinder).bind(instance, DiskLoggingErrorManager.class);
-        assertTrue(Files.exists(fileSystem.getPath("/errors")));
+        assertTrue(Files.exists(jimFsRule.getFileSystem().getPath("/errors")));
         assertFalse(instance.isDirectoryError());
     }
 
@@ -83,9 +83,9 @@ public class DiskLoggingErrorManagerTest {
         instance.initialise(config);
         instance.handleLoggingSetting(true);
         final String logName = error.getTimestamp() + "-" + error.getLevel() + ".log";;
-        assertFalse(Files.exists(fileSystem.getPath("/errors", logName)));
+        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
         instance.handleErrorEvent(error);
-        final Path errorPath = fileSystem.getPath("/errors", logName);
+        final Path errorPath = jimFsRule.getFileSystem().getPath("/errors", logName);
         assertTrue(Files.exists(errorPath));
         assertTrue(Files.readAllLines(errorPath).contains("Level: Medium"));
     }
@@ -98,9 +98,9 @@ public class DiskLoggingErrorManagerTest {
         instance.initialise(config);
         instance.handleLoggingSetting(false);
         final String logName = error.getTimestamp() + "-" + error.getLevel() + ".log";;
-        assertFalse(Files.exists(fileSystem.getPath("/errors", logName)));
+        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
         instance.handleErrorEvent(error);
-        assertFalse(Files.exists(fileSystem.getPath("/errors", logName)));
+        assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
     }
 
     @Test

test/com/dmdirc/tests/JimFsRule.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.tests;
+
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+
+import java.nio.file.FileSystem;
+
+import javax.annotation.WillCloseWhenClosed;
+
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * JUnit rule to create a JimFS file system and automatically close it on completion.
+ */
+public class JimFsRule implements TestRule {
+
+    private FileSystem fileSystem;
+
+    @Override
+    public Statement apply(final Statement base, final Description description) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                fileSystem = Jimfs.newFileSystem(Configuration.unix());
+                try {
+                    base.evaluate();
+                } finally {
+                    fileSystem.close();
+                }
+            }
+        };
+    }
+
+    @WillCloseWhenClosed
+    public FileSystem getFileSystem() {
+        return fileSystem;
+    }
+
+}

test/com/dmdirc/util/URLBuilderTest.java

@@ -26,19 +26,17 @@ import com.dmdirc.DMDircMBassador;
 import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.plugins.PluginMetaData;
+import com.dmdirc.tests.JimFsRule;
 import com.dmdirc.ui.themes.ThemeManager;
 
-import com.google.common.jimfs.Configuration;
-import com.google.common.jimfs.Jimfs;
-
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.nio.file.FileSystem;
 
 import javax.inject.Provider;
 
 import org.junit.Assert;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Matchers;
@@ -50,6 +48,8 @@ import static org.mockito.Mockito.when;
 @RunWith(MockitoJUnitRunner.class)
 public class URLBuilderTest {
 
+    @Rule public final JimFsRule jimFsRule = new JimFsRule();
+
     @Mock private Provider<PluginManager> pluginManagerProvider;
     @Mock private Provider<ThemeManager> themeManagerProvider;
     @Mock private PluginManager pluginManager;
@@ -59,14 +59,15 @@ public class URLBuilderTest {
     @Mock private DMDircMBassador eventBus;
 
     @Before
+    @SuppressWarnings("resource")
     public void setup() throws MalformedURLException {
-        final FileSystem fs = Jimfs.newFileSystem(Configuration.unix());
         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(fs.getPath("file://testPlugin"));
+        when(pluginMetaData.getPluginPath()).thenReturn(
+                jimFsRule.getFileSystem().getPath("file://testPlugin"));
     }
 
     @Test
@@ -94,7 +95,8 @@ public class URLBuilderTest {
     public void testGetUrlForJarFile() throws MalformedURLException {
         final URLBuilder urlBuilder
                 = new URLBuilder(pluginManagerProvider, themeManagerProvider);
-        Assert.assertEquals(new URL("jar:file:/jarFile!/test"), urlBuilder.getUrlForJarFile("jarFile", "test"));
+        Assert.assertEquals(new URL("jar:file:/jarFile!/test"),
+                urlBuilder.getUrlForJarFile("jarFile", "test"));
     }
 
     @Test
@@ -124,14 +126,16 @@ public class URLBuilderTest {
     public void testGetUrlForThemeResource() throws MalformedURLException {
         final URLBuilder urlBuilder
                 = new URLBuilder(pluginManagerProvider, themeManagerProvider);
-        Assert.assertEquals(new URL("jar:file:/themes/testTheme.zip!/testFile"), urlBuilder.getUrlForThemeResource("testTheme", "testFile"));
+        Assert.assertEquals(new URL("jar:file:/themes/testTheme.zip!/testFile"),
+                urlBuilder.getUrlForThemeResource("testTheme", "testFile"));
     }
 
     @Test
     public void testGetUrlForPluginResource() throws MalformedURLException {
         final URLBuilder urlBuilder
                 = new URLBuilder(pluginManagerProvider, themeManagerProvider);
-        Assert.assertEquals(new URL("jar:file:/testPlugin!/testFile"), urlBuilder.getUrlForPluginResource("testPlugin", "testFile"));
+        Assert.assertEquals(new URL("jar:file:/testPlugin!/testFile"),
+                urlBuilder.getUrlForPluginResource("testPlugin", "testFile"));
     }
 
     @Test
@@ -147,7 +151,8 @@ public class URLBuilderTest {
     public void testGetUrlJar() throws MalformedURLException {
         final URLBuilder urlBuilder
                 = new URLBuilder(pluginManagerProvider, themeManagerProvider);
-        Assert.assertEquals(new URL("jar:file:/jarFile!/testFile"), urlBuilder.getUrl("jar://jarFile:testFile"));
+        Assert.assertEquals(new URL("jar:file:/jarFile!/testFile"),
+                urlBuilder.getUrl("jar://jarFile:testFile"));
     }
 
     @Test
@@ -161,7 +166,8 @@ public class URLBuilderTest {
     public void testGetUrlZip() throws MalformedURLException {
         final URLBuilder urlBuilder
                 = new URLBuilder(pluginManagerProvider, themeManagerProvider);
-        Assert.assertEquals(new URL("jar:file:/zipFile!/testFile"), urlBuilder.getUrl("zip://zipFile:testFile"));
+        Assert.assertEquals(new URL("jar:file:/zipFile!/testFile"),
+                urlBuilder.getUrl("zip://zipFile:testFile"));
     }
 
     @Test
@@ -175,7 +181,8 @@ public class URLBuilderTest {
     public void testGetUrlPlugin() throws MalformedURLException {
         final URLBuilder urlBuilder
                 = new URLBuilder(pluginManagerProvider, themeManagerProvider);
-        Assert.assertEquals(new URL("jar:file:/testPlugin!/testFile"), urlBuilder.getUrl("plugin://pluginFile:testFile"));
+        Assert.assertEquals(new URL("jar:file:/testPlugin!/testFile"),
+                urlBuilder.getUrl("plugin://pluginFile:testFile"));
     }
 
     @Test
@@ -189,7 +196,8 @@ public class URLBuilderTest {
     public void testGetUrlTheme() throws MalformedURLException {
         final URLBuilder urlBuilder
                 = new URLBuilder(pluginManagerProvider, themeManagerProvider);
-        Assert.assertEquals(new URL("jar:file:/themes/themeFile.zip!/testFile"), urlBuilder.getUrl("theme://themeFile:testFile"));
+        Assert.assertEquals(new URL("jar:file:/themes/themeFile.zip!/testFile"),
+                urlBuilder.getUrl("theme://themeFile:testFile"));
     }
 
     @Test