Formatting, rename fields refactoring, add comments

pf4j/src/main/java/org/pf4j/DefaultPluginStatusProvider.java

 
 /**
  * The default implementation for {@link PluginStatusProvider}.
+ * The enabled plugins are read from {@code enabled.txt} file and
+ * the disabled plugins are read from {@code disabled.txt} file.
  *
  * @author Decebal Suiu
  * @author Mário Franco
     public DefaultPluginStatusProvider(Path pluginsRoot) {
         this.pluginsRoot = pluginsRoot;
 
-        initialize();
-    }
-
-    private void initialize() {
         try {
             // create a list with plugin identifiers that should be only accepted by this manager (whitelist from plugins/enabled.txt file)
             enabledPlugins = FileUtils.readLines(pluginsRoot.resolve("enabled.txt"), true);
 
     @Override
     public boolean enablePlugin(String pluginId) {
-        try {
-            if (disabledPlugins.remove(pluginId)) {
+        if (disabledPlugins.remove(pluginId)) {
+            try {
                 FileUtils.writeLines(disabledPlugins, pluginsRoot.resolve("disabled.txt").toFile());
+            } catch (IOException e) {
+                log.error("Failed to enable plugin {}", pluginId, e);
+                return false;
             }
-        } catch (IOException e) {
-            log.error("Failed to enable plugin {}", pluginId, e);
-            return false;
         }
 
         return true;

pf4j/src/test/java/org/pf4j/CompoundPluginDescriptorFinderTest.java

 import java.util.Arrays;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 
 /**
  * @author Decebal Suiu
 public class CompoundPluginDescriptorFinderTest {
 
     @Rule
-    public TemporaryFolder testFolder = new TemporaryFolder();
+    public TemporaryFolder pluginsFolder = new TemporaryFolder();
 
     @Test
     public void add() {
-        CompoundPluginDescriptorFinder instance = new CompoundPluginDescriptorFinder();
-        assertEquals(0, instance.size());
+        CompoundPluginDescriptorFinder descriptorFinder = new CompoundPluginDescriptorFinder();
+        assertEquals(0, descriptorFinder.size());
 
-        instance.add(new PropertiesPluginDescriptorFinder());
-        assertEquals(1, instance.size());
+        descriptorFinder.add(new PropertiesPluginDescriptorFinder());
+        assertEquals(1, descriptorFinder.size());
     }
 
     @Test
     public void find() throws Exception {
-        Path pluginPath = testFolder.newFolder("test-plugin-1").toPath();
+        Path pluginPath = pluginsFolder.newFolder("test-plugin-1").toPath();
         Files.write(pluginPath.resolve("plugin.properties"), getPlugin1Properties(), StandardCharsets.UTF_8);
 
-        PluginDescriptorFinder instance = new CompoundPluginDescriptorFinder()
+        PluginDescriptorFinder descriptorFinder = new CompoundPluginDescriptorFinder()
             .add(new PropertiesPluginDescriptorFinder());
 
-        PluginDescriptor pluginDescriptor = instance.find(pluginPath);
+        PluginDescriptor pluginDescriptor = descriptorFinder.find(pluginPath);
         assertNotNull(pluginDescriptor);
         assertEquals("test-plugin-1", pluginDescriptor.getPluginId());
         assertEquals("0.0.1", pluginDescriptor.getVersion());
 
     @Test
     public void findInJar() throws Exception {
-        PluginDescriptorFinder instance = new CompoundPluginDescriptorFinder()
+        PluginDescriptorFinder descriptorFinder = new CompoundPluginDescriptorFinder()
             .add(new PropertiesPluginDescriptorFinder());
 
-        PluginZip pluginJar = new PluginZip.Builder(testFolder.newFile("my-plugin-1.2.3.jar"), "myPlugin")
+        PluginZip pluginJar = new PluginZip.Builder(pluginsFolder.newFile("my-plugin-1.2.3.jar"), "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
-        PluginDescriptor pluginDescriptor = instance.find(pluginJar.path());
+        PluginDescriptor pluginDescriptor = descriptorFinder.find(pluginJar.path());
         assertNotNull(pluginDescriptor);
         assertEquals("myPlugin", pluginJar.pluginId());
         assertEquals("1.2.3", pluginJar.pluginVersion());
 
     @Test(expected = PluginException.class)
     public void testNotFound() throws Exception {
-        PluginDescriptorFinder instance = new CompoundPluginDescriptorFinder();
-        instance.find(getPluginsRoot().resolve("test-plugin-3"));
+        PluginDescriptorFinder descriptorFinder = new CompoundPluginDescriptorFinder();
+        Path pluginsPath = pluginsFolder.getRoot().toPath();
+        descriptorFinder.find(pluginsPath.resolve("test-plugin-3"));
     }
 
     @Test
     public void testSpaceCharacterInFileName() throws Exception {
-        PluginDescriptorFinder instance = new PropertiesPluginDescriptorFinder();
-        File jar = testFolder.newFile("my plugin-1.2.3.jar");
+        PluginDescriptorFinder descriptorFinder = new PropertiesPluginDescriptorFinder();
+        File jar = pluginsFolder.newFile("my plugin-1.2.3.jar");
 
         PluginZip pluginJar = new PluginZip.Builder(jar, "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
-        PluginDescriptor pluginDescriptor = instance.find(pluginJar.path());
+        PluginDescriptor pluginDescriptor = descriptorFinder.find(pluginJar.path());
         assertNotNull(pluginDescriptor);
     }
 
         return Arrays.asList(lines);
     }
 
-    private Path getPluginsRoot() {
-        return testFolder.getRoot().toPath();
-    }
-
 }

pf4j/src/test/java/org/pf4j/DefaultPluginFactoryTest.java

 package org.pf4j;
 
 import org.junit.Test;
+import org.pf4j.plugin.AnotherFailTestPlugin;
 import org.pf4j.plugin.FailTestPlugin;
 import org.pf4j.plugin.TestPlugin;
-import org.pf4j.plugin.AnotherFailTestPlugin;
 
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.junit.Assert.assertNotNull;
 import static org.mockito.Mockito.when;
 
 /**
- *
  * @author Mario Franco
  */
 public class DefaultPluginFactoryTest {
 
-    /**
-     * Test of create method, of class DefaultPluginFactory.
-     */
     @Test
     public void testCreate() {
         PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
         when(pluginWrapper.getDescriptor()).thenReturn(pluginDescriptor);
         when(pluginWrapper.getPluginClassLoader()).thenReturn(getClass().getClassLoader());
 
-        DefaultPluginFactory instance = new DefaultPluginFactory();
+        PluginFactory pluginFactory = new DefaultPluginFactory();
 
-        Plugin result = instance.create(pluginWrapper);
+        Plugin result = pluginFactory.create(pluginWrapper);
         assertNotNull(result);
         assertThat(result, instanceOf(TestPlugin.class));
     }
 
-    /**
-     * Test of create method, of class DefaultPluginFactory.
-     */
     @Test
     public void testCreateFail() {
         PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
         when(pluginWrapper.getDescriptor()).thenReturn(pluginDescriptor);
         when(pluginWrapper.getPluginClassLoader()).thenReturn(getClass().getClassLoader());
 
-        DefaultPluginFactory instance = new DefaultPluginFactory();
+        PluginFactory pluginFactory = new DefaultPluginFactory();
 
-        Plugin result = instance.create(pluginWrapper);
-        assertNull(result);
+        Plugin plugin = pluginFactory.create(pluginWrapper);
+        assertNull(plugin);
     }
 
-    /**
-     * Test of create method, of class DefaultPluginFactory.
-     */
     @Test
     public void testCreateFailNotFound() {
         PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
         when(pluginWrapper.getDescriptor()).thenReturn(pluginDescriptor);
         when(pluginWrapper.getPluginClassLoader()).thenReturn(getClass().getClassLoader());
 
-        DefaultPluginFactory instance = new DefaultPluginFactory();
+        PluginFactory pluginFactory = new DefaultPluginFactory();
 
-        Plugin result = instance.create(pluginWrapper);
-        assertNull(result);
+        Plugin plugin = pluginFactory.create(pluginWrapper);
+        assertNull(plugin);
     }
 
-    /**
-     * Test of create method, of class DefaultPluginFactory.
-     */
     @Test
     public void testCreateFailConstructor() {
         PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
         when(pluginWrapper.getDescriptor()).thenReturn(pluginDescriptor);
         when(pluginWrapper.getPluginClassLoader()).thenReturn(getClass().getClassLoader());
 
-        DefaultPluginFactory instance = new DefaultPluginFactory();
+        PluginFactory pluginFactory = new DefaultPluginFactory();
 
-        Plugin result = instance.create(pluginWrapper);
-        assertNull(result);
+        Plugin plugin = pluginFactory.create(pluginWrapper);
+        assertNull(plugin);
     }
 
 }

pf4j/src/test/java/org/pf4j/DefaultPluginRepositoryTest.java

  */
 public class DefaultPluginRepositoryTest {
 
+    private Path pluginsPath;
+
     @Rule
-    public TemporaryFolder testFolder = new TemporaryFolder();
+    public TemporaryFolder pluginsFolder = new TemporaryFolder();
 
     @Before
     public void setUp() throws IOException {
-        testFolder.newFolder("plugin-1");
+        pluginsPath = pluginsFolder.getRoot().toPath();
+
+        pluginsFolder.newFolder("plugin-1");
         // Prove that we can delete a folder with a file inside
-        Files.createFile(Paths.get(testFolder.getRoot().getAbsolutePath()).resolve("plugin-1").resolve("myfile"));
+        Files.createFile(Paths.get(pluginsFolder.getRoot().getAbsolutePath()).resolve("plugin-1").resolve("myfile"));
         // Create a zip file for plugin-1 to test that it is deleted when plugin is deleted
-        Files.createFile(Paths.get(testFolder.getRoot().getAbsolutePath()).resolve("plugin-1.zip"));
-        testFolder.newFolder("plugin-2");
-        testFolder.newFolder("plugin-3");
+        Files.createFile(Paths.get(pluginsFolder.getRoot().getAbsolutePath()).resolve("plugin-1.zip"));
+        pluginsFolder.newFolder("plugin-2");
+        pluginsFolder.newFolder("plugin-3");
         // standard maven/gradle bin folder - these should be skipped in development mode because the cause errors
-        testFolder.newFolder("target");
-        testFolder.newFolder("build");
+        pluginsFolder.newFolder("target");
+        pluginsFolder.newFolder("build");
     }
 
     /**
      */
     @Test
     public void testGetPluginArchives() {
-        Path pluginsRoot = getPluginsRoot();
+        PluginRepository repository = new DefaultPluginRepository(pluginsPath, false);
 
-        PluginRepository instance = new DefaultPluginRepository(pluginsRoot, false);
+        List<Path> pluginPaths = repository.getPluginPaths();
 
-        List<Path> result = instance.getPluginPaths();
-
-        assertEquals(5, result.size());
-        assertPathExists(result, pluginsRoot.resolve("plugin-1"));
-        assertPathExists(result, pluginsRoot.resolve("plugin-2"));
-        assertPathExists(result, pluginsRoot.resolve("plugin-3"));
+        assertEquals(5, pluginPaths.size());
+        assertPathExists(pluginPaths, pluginsPath.resolve("plugin-1"));
+        assertPathExists(pluginPaths, pluginsPath.resolve("plugin-2"));
+        assertPathExists(pluginPaths, pluginsPath.resolve("plugin-3"));
         // when not in development mode we will honor these folders
-        assertPathExists(result, pluginsRoot.resolve("target"));
-        assertPathExists(result, pluginsRoot.resolve("build"));
+        assertPathExists(pluginPaths, pluginsPath.resolve("target"));
+        assertPathExists(pluginPaths, pluginsPath.resolve("build"));
     }
 
     @Test
     public void testGetPluginArchivesInDevelopmentMode() {
-        Path pluginsRoot = getPluginsRoot();
-
-        PluginRepository instance = new DefaultPluginRepository(pluginsRoot, true);
+        PluginRepository repository = new DefaultPluginRepository(pluginsPath, true);
 
-        List<Path> result = instance.getPluginPaths();
+        List<Path> pluginPaths = repository.getPluginPaths();
 
         // target and build should be ignored
-        assertEquals(3, result.size());
-        assertPathDoesNotExists(result, pluginsRoot.resolve("target"));
-        assertPathDoesNotExists(result, pluginsRoot.resolve("build"));
+        assertEquals(3, pluginPaths.size());
+        assertPathDoesNotExists(pluginPaths, pluginsPath.resolve("target"));
+        assertPathDoesNotExists(pluginPaths, pluginsPath.resolve("build"));
     }
 
     /**
      */
     @Test
     public void testDeletePluginPath() {
-        Path pluginsRoot = getPluginsRoot();
+        PluginRepository repository = new DefaultPluginRepository(pluginsPath, false);
 
-        PluginRepository instance = new DefaultPluginRepository(pluginsRoot, false);
+        assertTrue(Files.exists(pluginsPath.resolve("plugin-1.zip")));
+        assertTrue(repository.deletePluginPath(pluginsPath.resolve("plugin-1")));
+        assertFalse(Files.exists(pluginsPath.resolve("plugin-1.zip")));
+        assertTrue(repository.deletePluginPath(pluginsPath.resolve("plugin-3")));
+        assertFalse(repository.deletePluginPath(pluginsPath.resolve("plugin-4")));
+        assertTrue(repository.deletePluginPath(pluginsPath.resolve("target")));
+        assertTrue(repository.deletePluginPath(pluginsPath.resolve("build")));
 
-        assertTrue(Files.exists(pluginsRoot.resolve("plugin-1.zip")));
-        assertTrue(instance.deletePluginPath(pluginsRoot.resolve("plugin-1")));
-        assertFalse(Files.exists(pluginsRoot.resolve("plugin-1.zip")));
-        assertTrue(instance.deletePluginPath(pluginsRoot.resolve("plugin-3")));
-        assertFalse(instance.deletePluginPath(pluginsRoot.resolve("plugin-4")));
-        assertTrue(instance.deletePluginPath(pluginsRoot.resolve("target")));
-        assertTrue(instance.deletePluginPath(pluginsRoot.resolve("build")));
+        List<Path> pluginPaths = repository.getPluginPaths();
 
-        List<Path> result = instance.getPluginPaths();
-
-        assertEquals(1, result.size());
-        assertEquals(pluginsRoot.relativize(result.get(0)).toString(), "plugin-2");
+        assertEquals(1, pluginPaths.size());
+        assertEquals(pluginsPath.relativize(pluginPaths.get(0)).toString(), "plugin-2");
     }
 
     private void assertPathExists(List<Path> paths, Path path) {
         assertFalse("The directory must not contain the file " + path, paths.contains(path));
     }
 
-    private Path getPluginsRoot() {
-        return testFolder.getRoot().toPath();
-    }
-
 }

pf4j/src/test/java/org/pf4j/DefaultPluginStatusProviderTest.java

  */
 package org.pf4j;
 
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
  */
 public class DefaultPluginStatusProviderTest {
 
+    private Path pluginsPath;
+
     @Rule
-    public TemporaryFolder testFolder = new TemporaryFolder();
+    public TemporaryFolder pluginsFolder = new TemporaryFolder();
+
+    @Before
+    public void setUp() {
+        pluginsPath = pluginsFolder.getRoot().toPath();
+    }
 
-    /**
-     * Test of isPluginDisabled method, of class DefaultPluginStatusProvider.
-     */
     @Test
     public void testIsPluginDisabled() throws IOException {
         createEnabledFile();
         createDisabledFile();
 
-        PluginStatusProvider instance = new DefaultPluginStatusProvider(getPluginsRoot());
+        PluginStatusProvider statusProvider = new DefaultPluginStatusProvider(pluginsPath);
 
-        assertFalse(instance.isPluginDisabled("plugin-1"));
-        assertTrue(instance.isPluginDisabled("plugin-2"));
-        assertTrue(instance.isPluginDisabled("plugin-3"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-1"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-2"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-3"));
     }
 
-    /**
-     * Test of isPluginDisabled method, of class DefaultPluginStatusProvider.
-     */
     @Test
     public void testIsPluginDisabledWithEnableEmpty() throws IOException {
         createDisabledFile();
 
-        PluginStatusProvider instance = new DefaultPluginStatusProvider(getPluginsRoot());
+        PluginStatusProvider statusProvider = new DefaultPluginStatusProvider(pluginsPath);
 
-        assertFalse(instance.isPluginDisabled("plugin-1"));
-        assertTrue(instance.isPluginDisabled("plugin-2"));
-        assertFalse(instance.isPluginDisabled("plugin-3"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-1"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-2"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-3"));
     }
 
-    /**
-     * Test of disablePlugin method, of class DefaultPluginStatusProvider.
-     */
     @Test
     public void testDisablePlugin() throws IOException {
         createEnabledFile();
         createDisabledFile();
 
-        PluginStatusProvider instance = new DefaultPluginStatusProvider(getPluginsRoot());
+        PluginStatusProvider statusProvider = new DefaultPluginStatusProvider(pluginsPath);
 
-        assertTrue(instance.disablePlugin("plugin-1"));
-        assertTrue(instance.isPluginDisabled("plugin-1"));
-        assertTrue(instance.isPluginDisabled("plugin-2"));
-        assertTrue(instance.isPluginDisabled("plugin-3"));
+        assertTrue(statusProvider.disablePlugin("plugin-1"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-1"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-2"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-3"));
     }
 
-    /**
-     * Test of disablePlugin method, of class DefaultPluginStatusProvider.
-     */
     @Test
     public void testDisablePluginWithEnableEmpty() throws IOException {
         createDisabledFile();
 
-        PluginStatusProvider instance = new DefaultPluginStatusProvider(getPluginsRoot());
+        PluginStatusProvider statusProvider = new DefaultPluginStatusProvider(pluginsPath);
 
-        assertTrue(instance.disablePlugin("plugin-1"));
-        assertTrue(instance.isPluginDisabled("plugin-1"));
-        assertTrue(instance.isPluginDisabled("plugin-2"));
-        assertFalse(instance.isPluginDisabled("plugin-3"));
+        assertTrue(statusProvider.disablePlugin("plugin-1"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-1"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-2"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-3"));
     }
 
-    /**
-     * Test of enablePlugin method, of class DefaultPluginStatusProvider.
-     */
     @Test
     public void testEnablePlugin() throws IOException {
         createEnabledFile();
 
-        PluginStatusProvider instance = new DefaultPluginStatusProvider(getPluginsRoot());
+        PluginStatusProvider statusProvider = new DefaultPluginStatusProvider(pluginsPath);
 
-        assertTrue(instance.enablePlugin("plugin-2"));
-        assertFalse(instance.isPluginDisabled("plugin-1"));
-        assertFalse(instance.isPluginDisabled("plugin-2"));
-        assertTrue(instance.isPluginDisabled("plugin-3"));
+        assertTrue(statusProvider.enablePlugin("plugin-2"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-1"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-2"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-3"));
     }
 
-    /**
-     * Test of enablePlugin method, of class DefaultPluginStatusProvider.
-     */
     @Test
     public void testEnablePluginWithEnableEmpty() {
-        PluginStatusProvider instance = new DefaultPluginStatusProvider(getPluginsRoot());
+        PluginStatusProvider statusProvider = new DefaultPluginStatusProvider(pluginsPath);
 
-        assertTrue(instance.enablePlugin("plugin-2"));
-        assertFalse(instance.isPluginDisabled("plugin-1"));
-        assertFalse(instance.isPluginDisabled("plugin-2"));
-        assertFalse(instance.isPluginDisabled("plugin-3"));
+        assertTrue(statusProvider.enablePlugin("plugin-2"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-1"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-2"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-3"));
     }
 
-    /**
-     * Test of disablePlugin method without a disabled.txt file.
-     */
     @Test
-    public void testDisablePluginWithoutDisabledFile() throws IOException {
-        PluginStatusProvider instance = new DefaultPluginStatusProvider(getPluginsRoot());
+    public void testDisablePluginWithoutDisabledFile() {
+        PluginStatusProvider statusProvider = new DefaultPluginStatusProvider(pluginsPath);
 
-        assertFalse(instance.isPluginDisabled("plugin-1"));
-        assertTrue(instance.disablePlugin("plugin-1"));
-        assertTrue(instance.isPluginDisabled("plugin-1"));
+        assertFalse(statusProvider.isPluginDisabled("plugin-1"));
+        assertTrue(statusProvider.disablePlugin("plugin-1"));
+        assertTrue(statusProvider.isPluginDisabled("plugin-1"));
     }
 
     private void createDisabledFile() throws IOException {
-        List<String> plugins = new ArrayList<>();
-        plugins.add("plugin-2");
+        List<String> disabledPlugins = new ArrayList<>();
+        disabledPlugins.add("plugin-2");
 
-        writeLines(plugins, "disabled.txt");
+        File disabledFile = pluginsFolder.newFile("disabled.txt");
+        FileUtils.writeLines(disabledPlugins, disabledFile);
     }
 
     private void createEnabledFile() throws IOException {
-        List<String> plugins = new ArrayList<>();
-        plugins.add("plugin-1");
-        plugins.add("plugin-2");
-
-        writeLines(plugins, "enabled.txt");
-    }
-
-    private void writeLines(List<String> lines, String fileName) throws IOException {
-        File file = testFolder.newFile(fileName);
-        FileUtils.writeLines(lines, file);
-    }
+        List<String> enabledPlugins = new ArrayList<>();
+        enabledPlugins.add("plugin-1");
+        enabledPlugins.add("plugin-2");
 
-    private Path getPluginsRoot() {
-        return testFolder.getRoot().toPath();
+        File enabledFile = pluginsFolder.newFile("enabled.txt");
+        FileUtils.writeLines(enabledPlugins, enabledFile);
     }
 
 }

pf4j/src/test/java/org/pf4j/LoadPluginsTest.java

 import org.junit.rules.TemporaryFolder;
 import org.pf4j.plugin.PluginZip;
 
-import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 public class LoadPluginsTest {
 
-    @Rule
-    public TemporaryFolder testFolder = new TemporaryFolder();
-
     private DefaultPluginManager pluginManager;
 
+    @Rule
+    public TemporaryFolder pluginsFolder = new TemporaryFolder();
+
     @Before
-    public void setup() {
-        pluginManager = new DefaultPluginManager(testFolder.getRoot().toPath());
+    public void setUp() {
+        pluginManager = new DefaultPluginManager(pluginsFolder.getRoot().toPath());
     }
 
     @Test
     public void load() throws Exception {
-        PluginZip pluginZip = new PluginZip.Builder(testFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
+        PluginZip pluginZip = new PluginZip.Builder(pluginsFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
         assertTrue(Files.exists(pluginZip.path()));
         assertEquals(0, pluginManager.getPlugins().size());
         pluginManager.loadPlugins();
+
         assertTrue(Files.exists(pluginZip.path()));
         assertTrue(Files.exists(pluginZip.unzippedPath()));
         assertEquals(1, pluginManager.getPlugins().size());
 
     @Test(expected = PluginAlreadyLoadedException.class)
     public void loadTwiceFails() throws Exception {
-        PluginZip pluginZip = new PluginZip.Builder(testFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
+        PluginZip pluginZip = new PluginZip.Builder(pluginsFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
 
     @Test
     public void loadUnloadLoad() throws Exception {
-        PluginZip pluginZip = new PluginZip.Builder(testFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
+        PluginZip pluginZip = new PluginZip.Builder(pluginsFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
 
     @Test
     public void upgrade() throws Exception {
-        new PluginZip.Builder(testFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
+        new PluginZip.Builder(pluginsFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
         assertEquals(1, pluginManager.getPlugins().size());
         assertEquals(1, pluginManager.getStartedPlugins().size());
 
-        PluginZip pluginZip2 = new PluginZip.Builder(testFolder.newFile("my-plugin-2.0.0.ZIP"), "myPlugin")
+        PluginZip pluginZip2 = new PluginZip.Builder(pluginsFolder.newFile("my-plugin-2.0.0.ZIP"), "myPlugin")
             .pluginVersion("2.0.0")
             .build();
 
 
     @Test
     public void getRoot() {
-        assertEquals(testFolder.getRoot().toPath(), pluginManager.getPluginsRoot());
+        assertEquals(pluginsFolder.getRoot().toPath(), pluginManager.getPluginsRoot());
     }
 
     @Test
     public void notAPlugin() throws Exception {
-        testFolder.newFile("not-a-zip");
+        pluginsFolder.newFile("not-a-zip");
 
         pluginManager.loadPlugins();
 
 
     @Test
     public void deletePlugin() throws Exception {
-        PluginZip pluginZip1 = new PluginZip.Builder(testFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
+        PluginZip pluginZip1 = new PluginZip.Builder(pluginsFolder.newFile("my-plugin-1.2.3.zip"), "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
-        PluginZip pluginZip3 = new PluginZip.Builder(testFolder.newFile("other-3.0.0.Zip"), "other")
+        PluginZip pluginZip3 = new PluginZip.Builder(pluginsFolder.newFile("other-3.0.0.Zip"), "other")
             .pluginVersion("3.0.0")
             .build();
 

pf4j/src/test/java/org/pf4j/ManifestPluginDescriptorFinderTest.java

 public class ManifestPluginDescriptorFinderTest {
 
     private VersionManager versionManager;
+    private Path pluginsPath;
 
     @Rule
-    public TemporaryFolder testFolder = new TemporaryFolder();
+    public TemporaryFolder pluginsFolder = new TemporaryFolder();
 
     @Before
     public void setUp() throws IOException {
+        pluginsPath = pluginsFolder.getRoot().toPath();
+
         Charset charset = Charset.forName("UTF-8");
 
-        Path pluginPath = testFolder.newFolder("test-plugin-1", "classes", "META-INF").toPath();
+        Path pluginPath = pluginsFolder.newFolder("test-plugin-1", "classes", "META-INF").toPath();
         Files.write(pluginPath.resolve("extensions.idx"), "org.pf4j.demo.hello.HelloPlugin$HelloGreeting".getBytes());
         Files.write(pluginPath.resolve("MANIFEST.MF"), getPlugin1Manifest(), charset);
 
-        pluginPath = testFolder.newFolder("test-plugin-2", "classes", "META-INF").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-2", "classes", "META-INF").toPath();
         Files.write(pluginPath.resolve("extensions.idx"), "org.pf4j.demo.hello.HelloPlugin$HelloGreeting".getBytes());
         Files.write(pluginPath.resolve("MANIFEST.MF"), getPlugin2Manifest(), charset);
 
         // empty plugin
-        testFolder.newFolder("test-plugin-3");
+        pluginsFolder.newFolder("test-plugin-3");
 
         // no plugin class
-        pluginPath = testFolder.newFolder("test-plugin-4", "classes", "META-INF").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-4", "classes", "META-INF").toPath();
         Files.write(pluginPath.resolve("extensions.idx"), "org.pf4j.demo.hello.HelloPlugin$HelloGreeting".getBytes());
         Files.write(pluginPath.resolve("MANIFEST.MF"), getPlugin4Manifest(), charset);
 
         // no plugin version
-        pluginPath = testFolder.newFolder("test-plugin-5", "classes", "META-INF").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-5", "classes", "META-INF").toPath();
         Files.write(pluginPath.resolve("extensions.idx"), "org.pf4j.demo.hello.HelloPlugin$HelloGreeting".getBytes());
         Files.write(pluginPath.resolve("MANIFEST.MF"), getPlugin5Manifest(), charset);
 
         // no plugin id
-        pluginPath = testFolder.newFolder("test-plugin-6", "classes", "META-INF").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-6", "classes", "META-INF").toPath();
         Files.write(pluginPath.resolve("extensions.idx"), "org.pf4j.demo.hello.HelloPlugin$HelloGreeting".getBytes());
         Files.write(pluginPath.resolve("MANIFEST.MF"), getPlugin6Manifest(), charset);
 
      */
     @Test
     public void testFind() throws Exception {
-        PluginDescriptorFinder instance = new ManifestPluginDescriptorFinder();
+        PluginDescriptorFinder descriptorFinder = new ManifestPluginDescriptorFinder();
 
-        PluginDescriptor plugin1 = instance.find(getPluginsRoot().resolve("test-plugin-1"));
-        PluginDescriptor plugin2 = instance.find(getPluginsRoot().resolve("test-plugin-2"));
+        PluginDescriptor plugin1 = descriptorFinder.find(pluginsPath.resolve("test-plugin-1"));
+        PluginDescriptor plugin2 = descriptorFinder.find(pluginsPath.resolve("test-plugin-2"));
 
         assertEquals("test-plugin-1", plugin1.getPluginId());
         assertEquals("Test Plugin 1", plugin1.getPluginDescription());
      */
     @Test(expected = PluginException.class)
     public void testFindNotFound() throws Exception {
-        PluginDescriptorFinder instance = new ManifestPluginDescriptorFinder();
-        instance.find(getPluginsRoot().resolve("test-plugin-3"));
+        PluginDescriptorFinder descriptorFinder = new ManifestPluginDescriptorFinder();
+        descriptorFinder.find(pluginsPath.resolve("test-plugin-3"));
     }
 
     private List<String> getPlugin1Manifest() {
         return Arrays.asList(lines);
     }
 
-    private Path getPluginsRoot() {
-        return testFolder.getRoot().toPath();
-    }
-
 }

pf4j/src/test/java/org/pf4j/PropertiesPluginDescriptorFinderTest.java

 public class PropertiesPluginDescriptorFinderTest {
 
     private VersionManager versionManager;
+    private Path pluginsPath;
 
     @Rule
-    public TemporaryFolder testFolder = new TemporaryFolder();
+    public TemporaryFolder pluginsFolder = new TemporaryFolder();
 
     @Before
     public void setUp() throws IOException {
+        pluginsPath = pluginsFolder.getRoot().toPath();
+
         Charset charset = Charset.forName("UTF-8");
 
-        Path pluginPath = testFolder.newFolder("test-plugin-1").toPath();
+        Path pluginPath = pluginsFolder.newFolder("test-plugin-1").toPath();
         Files.write(pluginPath.resolve("plugin.properties"), getPlugin1Properties(), charset);
 
-        pluginPath = testFolder.newFolder("test-plugin-2").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-2").toPath();
         Files.write(pluginPath.resolve("plugin.properties"), getPlugin2Properties(), charset);
 
         // empty plugin
-        testFolder.newFolder("test-plugin-3");
+        pluginsFolder.newFolder("test-plugin-3");
 
         // no plugin class
-        pluginPath = testFolder.newFolder("test-plugin-4").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-4").toPath();
         Files.write(pluginPath.resolve("plugin.properties"), getPlugin4Properties(), charset);
 
         // no plugin version
-        pluginPath = testFolder.newFolder("test-plugin-5").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-5").toPath();
         Files.write(pluginPath.resolve("plugin.properties"), getPlugin5Properties(), charset);
 
         // no plugin id
-        pluginPath = testFolder.newFolder("test-plugin-6").toPath();
+        pluginPath = pluginsFolder.newFolder("test-plugin-6").toPath();
         Files.write(pluginPath.resolve("plugin.properties"), getPlugin6Properties(), charset);
 
         versionManager = new DefaultVersionManager();
 
     @Test
     public void testFind() throws Exception {
-        PluginDescriptorFinder instance = new PropertiesPluginDescriptorFinder();
+        PluginDescriptorFinder descriptorFinder = new PropertiesPluginDescriptorFinder();
 
-        PluginDescriptor plugin1 = instance.find(getPluginsRoot().resolve("test-plugin-1"));
-        PluginDescriptor plugin2 = instance.find(getPluginsRoot().resolve("test-plugin-2"));
+        PluginDescriptor plugin1 = descriptorFinder.find(pluginsPath.resolve("test-plugin-1"));
+        PluginDescriptor plugin2 = descriptorFinder.find(pluginsPath.resolve("test-plugin-2"));
 
         assertEquals("test-plugin-1", plugin1.getPluginId());
         assertEquals("Test Plugin 1", plugin1.getPluginDescription());
 
     @Test(expected = PluginException.class)
     public void testNotFound() throws Exception {
-        PluginDescriptorFinder instance = new PropertiesPluginDescriptorFinder();
-        instance.find(getPluginsRoot().resolve("test-plugin-3"));
+        PluginDescriptorFinder descriptorFinder = new PropertiesPluginDescriptorFinder();
+        descriptorFinder.find(pluginsPath.resolve("test-plugin-3"));
     }
 
     @Test
     public void findInJar() throws Exception {
-        PluginZip pluginJar = new PluginZip.Builder(testFolder.newFile("my-plugin-1.2.3.jar"), "myPlugin")
+        PluginZip pluginJar = new PluginZip.Builder(pluginsFolder.newFile("my-plugin-1.2.3.jar"), "myPlugin")
             .pluginVersion("1.2.3")
             .build();
 
         assertTrue(Files.exists(pluginJar.path()));
 
-        PluginDescriptorFinder instance = new PropertiesPluginDescriptorFinder();
-        PluginDescriptor pluginDescriptor = instance.find(pluginJar.path());
+        PluginDescriptorFinder descriptorFinder = new PropertiesPluginDescriptorFinder();
+        PluginDescriptor pluginDescriptor = descriptorFinder.find(pluginJar.path());
         assertNotNull(pluginDescriptor);
         assertEquals("myPlugin", pluginJar.pluginId());
         assertEquals("1.2.3", pluginJar.pluginVersion());
         return Arrays.asList(lines);
     }
 
-    private Path getPluginsRoot() {
-        return testFolder.getRoot().toPath();
-    }
-
 }