package jmri.jmrit.operations.setup.backup;

import static org.junit.Assert.*;

import java.io.*;
import java.util.Calendar;

import org.junit.Assert;
import org.junit.jupiter.api.*;

import jmri.InstanceManager;
import jmri.jmrit.XmlFile;
import jmri.jmrit.operations.OperationsXml;
import jmri.jmrit.operations.locations.LocationManagerXml;
import jmri.jmrit.operations.rollingstock.cars.CarManagerXml;
import jmri.jmrit.operations.rollingstock.engines.EngineManagerXml;
import jmri.jmrit.operations.routes.RouteManagerXml;
import jmri.jmrit.operations.setup.OperationsSetupXml;
import jmri.jmrit.operations.trains.TrainManagerXml;
import jmri.util.FileUtil;

/**
 * Tests for the new Operations Setup Backup classes used for copying and
 * restoring file backup sets. These test the AutoBackup and DefaultBackup
 * classes that are derived from BackupBase.
 * <p>
 * These tests use dummy XML files for the copying to make testing the outcomes
 * easier. It is assumed that there are other tests to verify that the correct
 * format XML files get created. This only tests the copying parts of the Backup
 * and Restore operations.
 * <p>
 * Tests include: - copying to / from regular backup location - copying to /
 * from automatic backup location
 * <p>
 * Source files are in Operations / JUnitTests.
 * <p>
 * Backup dirs are in: Operations / JUnitTests / backups and
 * <p>
 * Operations / JUnitTests / autoBackups
 * <p>
 * <p>
 * Still to do: - Need file comparison method to verify exactly that the files
 * are the same.
 *
 *
 * @author Gregory Madsen Copyright (C) 2012
 *
 */
public class OperationsBackupTest {

    private String tempDirectoryName = "temp2";

    private File operationsRoot;

    public File getOperationsRoot() {
        return operationsRoot;
    }

    private File defaultBackupRoot;

    public File getDefaultBackupRoot() {
        return defaultBackupRoot;
    }

    private File autoBackupRoot;

    public File getAutoBackupRoot() {
        return autoBackupRoot;
    }

    private String[] regularBackupSetFileNames;

    public String[] getRegularBackupSetFileNames() {
        return java.util.Arrays.copyOf(regularBackupSetFileNames, regularBackupSetFileNames.length);
    }

    // private String[] testBackupSetFileNames;

    // public String[] getTestBackupSetFileNames() {
    //    return testBackupSetFileNames;
    // }

    /**
     * Test-by test initialization.
     * @throws IOException if thrown by {@link #createTestFiles()}
     */
    @BeforeEach
    public void setUp() throws IOException {
        jmri.util.JUnitUtil.setUp();

        // set the file location to temp (in the root of the build directory).
        OperationsSetupXml.setFileLocation(tempDirectoryName + File.separator);

        // Set the static Operations root directory used for tests
        OperationsXml.setOperationsDirectoryName("operations" + File.separator
                + "JUnitTest");

        // Initialize our root directories as they should be so that we can
        // verify the Backup classes use the correct locations.
        //
        // Correct structure is:
        // <user>/JMRI/Operations / JUnitTest / backups
        // <user>/JMRI/Operations / JUnitTest / autoBackups
        operationsRoot = new File(OperationsXml.getFileLocation(),
                OperationsXml.getOperationsDirectoryName());

        autoBackupRoot = new File(operationsRoot, "autoBackups");

        defaultBackupRoot = new File(operationsRoot, "backups");

        // Build the list of test file names from the regular list.
        // We assume this works, as there is a specific test for it later.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        regularBackupSetFileNames = backup.getBackupSetFileNames();

        // testBackupSetFileNames = new
        // String[regularBackupSetFileNames.length];
        //
        // for (int i = 0; i < regularBackupSetFileNames.length; i++) {
        // testBackupSetFileNames[i] = "NEW_TEST_"
        // + regularBackupSetFileNames[i];
        // }
        // set the file location to temp (in the root of the build directory).
        OperationsSetupXml.setFileLocation(tempDirectoryName + File.separator);

        // Repoint OperationsSetupXml to JUnitTest subdirectory
        String tempstring = OperationsSetupXml.getOperationsDirectoryName();
        if (!tempstring.contains(File.separator + "JUnitTest")) {
            OperationsSetupXml.setOperationsDirectoryName("operations" + File.separator + "JUnitTest");
        }
        // Change file names to ...Test.xml
        InstanceManager.getDefault(OperationsSetupXml.class).setOperationsFileName("OperationsJUnitTest.xml");
        InstanceManager.getDefault(RouteManagerXml.class).setOperationsFileName("OperationsJUnitTestRouteRoster.xml");
        InstanceManager.getDefault(EngineManagerXml.class).setOperationsFileName("OperationsJUnitTestEngineRoster.xml");
        InstanceManager.getDefault(CarManagerXml.class).setOperationsFileName("OperationsJUnitTestCarRoster.xml");
        InstanceManager.getDefault(LocationManagerXml.class).setOperationsFileName("OperationsJUnitTestLocationRoster.xml");
        InstanceManager.getDefault(TrainManagerXml.class).setOperationsFileName("OperationsJUnitTestTrainRoster.xml");

        FileUtil.createDirectory(tempDirectoryName + File.separator + OperationsSetupXml.getOperationsDirectoryName());

        // Delete any existing auto or default backup sets
        deleteBackupSets();

        // Make sure we have a fresh set of file before each test.
        // Clean up our test files, just to be safe.
        deleteTestFiles();
        createTestFiles();
    }

    @AfterEach
    public void tearDown() {
        deleteTestFiles();
        deleteBackupSets();
        deleteDirectoryAndFiles(operationsRoot);
        // delete temp directory
        deleteDirectoryAndFiles(new File(OperationsXml.getFileLocation()));
        jmri.util.JUnitUtil.tearDown();
    }

    // Some private helper methods......
    public void createTestFiles() throws IOException {
        // Here we create the source files and the directory they are in.
        // Called before each test as part of setup()
        // Could roll up into setup() if not used elsewhere.

        if (!operationsRoot.exists()) {
            assertTrue(operationsRoot.mkdirs());
        }

        if (!autoBackupRoot.exists()) {
            assertTrue(autoBackupRoot.mkdirs());
        }

        if (!defaultBackupRoot.exists()) {
            assertTrue(defaultBackupRoot.mkdirs());
        }

        for (String name : regularBackupSetFileNames) {
            createDummyXmlFile(operationsRoot, name);
        }
    }

    private void createDummyXmlFile(File dir, String name) throws IOException {
        // Creates a single dummy XML file in the given directory
        File file = new File(dir, name);
        try (FileWriter out = new FileWriter(file)) {
            out.write("This is a dummy version of the " + name + " file...");
        }
    }

    private Boolean existsFile(File dir, String name) {
        // Helper to check if a file in the given directory exists.
        // Could roll up into verifyBackupSetFiles if not used elsewhere.
        File file = new File(dir, name);
        return file.exists();
    }

    public void deleteTestFiles() {
        // Delete all files in the test source directory
        // Called before each test as part of setup()
        // Could roll up into setup() if not used elsewhere.
        if (operationsRoot.exists()) {
            for (File f : operationsRoot.listFiles()) {
                if (f.isFile() && f.exists()) {
                    assertTrue(f.delete());
                }
            }
        }
    }

    private void deleteBackupSets() {
        if (autoBackupRoot.exists()) {
            for (File f : autoBackupRoot.listFiles()) {
                // Delete directories assuming they are backup sets
                if (f.isDirectory()) {
                    deleteDirectoryAndFiles(f);
                }
            }
        }

        if (defaultBackupRoot.exists()) {
            for (File f : defaultBackupRoot.listFiles()) {
                // Delete directories assuming they are backup sets
                if (f.isDirectory()) {
                    deleteDirectoryAndFiles(f);
                }
            }
        }
    }

    private void deleteDirectoryAndFiles(File dir) {
        // Deletes all of the files in a directory, and then the directory
        // itself.
        // This is NOT a general purpose method, as it only handles directories
        // with only files and no sub directories.
        for (File f : dir.listFiles()) {
            // Delete files first
            if (f.isFile()) {
                assertTrue(f.delete());
            }
        }
        // now delete directories
        for (File d : dir.listFiles()) {
            for (File f : d.listFiles()) {
                assertTrue(f.delete());
            }
            assertTrue(d.delete());
        }
        assertTrue(dir.delete());
    }

    public void verifyBackupSetAgainst(File srcDir, String srcSet, File dstDir,
            String dstSet) {
        // Defaults to the test file names
        verifyBackupSetAgainst(srcDir, srcSet, dstDir, dstSet,
                regularBackupSetFileNames);
    }

    public void verifyBackupSetAgainst(File srcDir, String srcSet, File dstDir,
            String dstSet, String[] fileNames) {
        // Does a number of tests on the files in a backup set directory and
        // compares them to the source directory.
        // Both source and destination can have a setName as we have to test
        // both copies and restores.

        // If the src or dst Set Name is the empty string, "", new File() will
        // simply ignore it and use just the directory.
        srcDir = new File(srcDir, srcSet);
        dstDir = new File(dstDir, dstSet);

        // Verify each file in turn.
        for (String fileName : fileNames) {
            verifyDstFileEqualsScrFile(fileName, srcDir, dstDir);
        }
    }

    private void verifyBackupFileCount(File dir, String setName,
            int expectedCount) {
        // Verifies if the actual number of files in the destination directory
        // equals
        // the expected count.
        dir = new File(dir, setName);
        int actualCount = dir.list().length;

        assertEquals(expectedCount, actualCount);
    }

    private void verifyDstFileEqualsScrFile(String fileName, File srcDir,
            File dstDir) {
        // Verifies if the named file in the destination directory is the same
        // as the same named file in the source directory.
        // A variety of tests are done to determine equality.
        File src = new File(srcDir, fileName);
        File dst = new File(dstDir, fileName);

        Assert.assertTrue(fileName + " file must exist", dst.exists());

        Assert.assertTrue(fileName + " file must have length > 0",
                dst.length() > 0);

        Assert.assertEquals(fileName + " file size must be the same",
                src.length(), dst.length());

        // Enable after Backup updates modified date
        Assert.assertEquals(fileName + " file modifed date must be the same",
                src.lastModified(), dst.lastModified());

        // We could extend this to compare the file contents, but I don't think
        // this is necessary if the file sizes and dates match.
    }

    // And now the actual tests themselves.....
    // First some common tests of BackupBase
    // Need to instantiate DefaultBackup as BackupBase is abstract.
    // Make sure that we are working with the exact set of file names that we
    // expect.
    @Test
    public void testGetBackupSetFileNames() {
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        String[] names = backup.getBackupSetFileNames();

        Assert.assertEquals("Backup set file name count", 6, names.length);

        Assert.assertEquals("Operations.xml", names[0]);
        Assert.assertEquals("OperationsCarRoster.xml", names[1]);
        Assert.assertEquals("OperationsEngineRoster.xml", names[2]);
        Assert.assertEquals("OperationsLocationRoster.xml", names[3]);
        Assert.assertEquals("OperationsRouteRoster.xml", names[4]);
        Assert.assertEquals("OperationsTrainRoster.xml", names[5]);
    }

    @Test
    @Disabled("Disabled in JUnit 3")
    public void testTestBackupSetFileNames() {
        // String[] names = testBackupSetFileNames;
        String[] names = new String[]{"Disabled","in","junit","3","",""};
        Assert.assertEquals("Test Backup set file name count", 6, names.length);

        Assert.assertEquals("NEW_TEST_Operations.xml", names[0]);
        Assert.assertEquals("NEW_TEST_OperationsCarRoster.xml", names[1]);
        Assert.assertEquals("NEW_TEST_OperationsEngineRoster.xml", names[2]);
        Assert.assertEquals("NEW_TEST_OperationsLocationRoster.xml", names[3]);
        Assert.assertEquals("NEW_TEST_OperationsRouteRoster.xml", names[4]);
        Assert.assertEquals("NEW_TEST_OperationsTrainRoster.xml", names[5]);
    }
    
    @Test
    public void testTestFilesCreated() {
        // Make sure we can create our test files correctly

        // Make sure the directories exist
        Assert.assertTrue("Test directory must exist", operationsRoot.exists());
        Assert.assertTrue("Auto backup directory must exist",
                autoBackupRoot.exists());
        Assert.assertTrue("Default backup directory must exist",
                defaultBackupRoot.exists());

        // and the test files
        verifyBackupSetAgainst(operationsRoot, "", operationsRoot, "");

        // and the getSourceFileCount method as well
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        int count = backup.getSourceFileCount(operationsRoot);
        assertEquals("Test source file count", 6, count);

    }

    @Test
    public void testBasicCopyBackupSet() throws IOException {
        // Test that we can actually copy the files of a backup set to a
        // different directory. This is the heart of the Backup class.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        String setName = "NEW Test Backup Set 01";
        File setDir = new File(defaultBackupRoot, setName);

        // Enable this only after we decide how to handle extra files.
        // // Throw in an extra file in the source to test of we only copy the
        // files we want.
        // createDummyXmlFile(testRoot, "This is an EXTRA file.xml");
        // createDummyXmlFile(testRoot, "This is NOT an xml file.txt");
        backup.copyBackupSet(operationsRoot, setDir);

        // Check that they got there
        verifyBackupSetAgainst(operationsRoot, "", defaultBackupRoot, setName);

        // And that we have the right count of files
        verifyBackupFileCount(defaultBackupRoot, setName,
                backup.getBackupSetFileNames().length);
    }

    @Test
    public void testBasicCopyBackupSetWithNoFiles() throws IOException {
        // Test copying with none of the files in the source, representing the
        // state after a Reset() operation.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        String setName = "NEW Test Backup Set 02";
        File setDir = new File(defaultBackupRoot, setName);

        deleteTestFiles();
        int count = backup.getSourceFileCount(operationsRoot);
        assertEquals("SHould be zero files after delete()", 0, count);

        backup.copyBackupSet(operationsRoot, setDir);

        // Should just return without creating the dest dir or throwing an
        // exception.
        Boolean exists = existsFile(defaultBackupRoot, setName);
        assertFalse(exists);

    }

    @Test
    public void testBasicCopyBackupSetWithMissingFiles() throws IOException {
        // Test copying with only some of the files in the source. This MAY be
        // a valid state, so no exception should be thrown.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        String setName = "NEW Test Backup Set 03";
        File setDir = new File(defaultBackupRoot, setName);

        // Clear out any files, and create just one
        deleteTestFiles();
        createDummyXmlFile(operationsRoot, regularBackupSetFileNames[0]);

        backup.copyBackupSet(operationsRoot, setDir);
        jmri.util.JUnitAppender.assertWarnMessage("Only 1 file(s) found in directory " + operationsRoot.getAbsolutePath());

        // Should NOT throw an exception, and the destination dir should exist.
        Boolean exists = existsFile(defaultBackupRoot, setName);
        assertTrue(exists);
    }

    @Test
    public void testBasicCopyBackupSetWithExtraFiles() throws IOException {
        // Test copying with all of the Operations files, plus some extra files.
        // SHould only copy the Operations files.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        String setName = "NEW Test Backup Set 04";
        File setDir = new File(defaultBackupRoot, setName);

        // Enable this only after we decide how to handle extra files.
        // Throw in an extra file in the source to test of we only copy the
        // files we want.
        createDummyXmlFile(operationsRoot, "This is an EXTRA file.xml");
        createDummyXmlFile(operationsRoot, "This is NOT an xml file.txt");

        backup.copyBackupSet(operationsRoot, setDir);

        // Check that they got there
        verifyBackupSetAgainst(operationsRoot, "", defaultBackupRoot, setName);

        // And that we have the right count of files, skipping the extra Xml
        // file
        verifyBackupFileCount(defaultBackupRoot, setName,
                backup.getBackupSetFileNames().length);
    }

    @Test
    public void testBackupToSpecificDirectory() throws IOException {
        // Does a backup to a specific directory.
        // The backup set directory is given as a File object.
        // This simulates using a FIleChooser to select the destination
        // directory.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        File dir = new File(operationsRoot, "Specific Backup Dir");

        backup.backupFilesToDirectory(dir);

        // Check that they got there
        verifyBackupSetAgainst(operationsRoot, "", dir, "");

        deleteDirectoryAndFiles(dir);
    }

    // Comment out for now until I can learn what constitutes an invalid
    // filename on the CI build server....
    // Having "<<" in a file name fails under Windows, but maybe not under
    // Linux???
    @Test
    @Disabled("Disabled in JUnit 3")
    public void testBackupToInvalidDirectory() {
        // Does a backup to a specific directory that has an invalid name.
        // The backup set directory is given as a File object.
        // This simulates using a FIleChooser to select the destination
        // directory.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        File dir = new File(operationsRoot, "Invalid Name<<>>");

        try {
            backup.backupFilesToDirectory(dir);
            fail("Expected exception to be thrown.");
        } catch (IOException ex) {
            assertEquals("Test Currently Disabled", ex.getMessage());
        }
    }
    
    @Test
    public void testRestoreFilesFromSpecificDirectory() throws IOException {
        // Simulates using a FileChooser to select a directory to restore from.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        File dir = new File(operationsRoot, "Specific Backup Dir");

        backup.backupFilesToDirectory(dir);

        deleteTestFiles();

        backup.restoreFilesFromDirectory(dir);

        verifyBackupSetAgainst(dir, "", operationsRoot, "");
    }

    @Test
    public void testResetFiles() {

        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        // Now you see them...
        for (String name : regularBackupSetFileNames) {
            // Make sure each file does exist
            Assert.assertTrue(name + " file should exist",
                    existsFile(operationsRoot, name));
        }

        backup.deleteOperationsFiles();

        // and now you don't....
        for (String name : regularBackupSetFileNames) {
            // Make sure each file does NOT exist
            Assert.assertFalse(name + " file should not exist",
                    existsFile(operationsRoot, name));
        }
    }

    @Test
    public void testLoadDemoFiles() throws IOException {
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        backup.deleteOperationsFiles();

        backup.loadDemoFiles();

        // check that we have 6 or more files...
        assertTrue("File count", operationsRoot.listFiles().length >= 6);

        verifyBackupSetAgainst(new File(XmlFile.xmlDir(), "demoOperations"),
                "", operationsRoot, "", regularBackupSetFileNames);

        // Also need to make sure we copied over the demo panel file
        verifyBackupSetAgainst(new File(XmlFile.xmlDir(), "demoOperations"),
                "", operationsRoot, "",
                new String[]{"Operations Demo Panel.xml"});
    }

    // Now tests of the DefaultBackup class.....
    @Test
    public void testCreateDefaultBackupInstance() {
        // Basic test to make sure we can instantiate the DefaultBackup class
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        Assert.assertNotNull("Default constructor", backup);

        // Make sure default roots got setup OK
        File root = backup.getBackupRoot();
        Assert.assertNotNull("DEfault root must be set", root);
        Assert.assertTrue("Default root dir must exist", root.exists());

        //String usersDir = FileUtil.getUserFilesPath();
        // we're resetting the root directory used to temp
        String usersDir = tempDirectoryName + File.separator;
        String opsDirName = OperationsXml.getOperationsDirectoryName();
        File opsRoot = new File(usersDir, opsDirName);

        File expectedRoot = new File(opsRoot, "backups");
        Assert.assertEquals("Default root", expectedRoot, root);
    }

    @Test
    public void testDefaultBackupWithName() throws IOException, IllegalArgumentException {
        // Does a backup to the backups directory
        // The name of the backup set is given.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        String setName = backup.suggestBackupSetName();
        backup.backupFilesToSetName(setName);

        // Check that they got there
        verifyBackupSetAgainst(operationsRoot, "", defaultBackupRoot, setName);
    }

    @Test
    public void testDefaultBackupWithName2() throws IOException, IllegalArgumentException {
        // Does a backup to the backups directory
        // The name of the backup set is given.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        String setName = backup.suggestBackupSetName();
        backup.backupFilesToSetName(setName);

        // Check that they got there
        verifyBackupSetAgainst(operationsRoot, "", defaultBackupRoot, setName);
    }

    @Test
    public void testDefaultBackupWithNullName() {
        // Tries a backup to the backups directory
        // The name of the backup set is null.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        try {
            backup.backupFilesToSetName( null);
            fail("Expected exception to be thrown.");
        } catch (IOException | IllegalArgumentException ex) {
            assertTrue( ex instanceof IllegalArgumentException);
        }
    }

    @Test
    public void testDefaultBackupWithEmptyName() {
        // Tries a backup to the backups directory
        // The name of the backup set is empty ("")
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        // String setName = backup.suggestBackupSetName();
        try {
            backup.backupFilesToSetName("");
            fail("Expected exception to be thrown.");
        } catch (IOException | IllegalArgumentException ex) {
            assertTrue( ex instanceof IllegalArgumentException);
        }
    }

    @Test
    public void testSuggestedDefaultBackupName() throws IOException, IllegalArgumentException {
        // Tests creating the suggested backup set names that account for
        // existing backup sets.
        // This probably should test for what happens after 99, but I'll leave
        // that for later.
        String suggestedName;

        // Get the suggested name with no backups in place
        Calendar now = Calendar.getInstance();

        int year = now.get(Calendar.YEAR);
        int month = now.get(Calendar.MONTH) + 1;
        int day = now.get(Calendar.DATE);

        String date2 = String.format("%d_%02d_%02d", year, month, day);

        String expected = date2 + "_00";

        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        suggestedName = backup.suggestBackupSetName();
        Assert.assertEquals("Suggested default backup set name", expected,
                suggestedName);

        // Again with one backup
        backup.backupFilesToSetName(suggestedName);

        expected = date2 + "_01";
        suggestedName = backup.suggestBackupSetName();
        Assert.assertEquals("Suggested default backup set name", expected,
                suggestedName);

        // and again with two backups
        backup.backupFilesToSetName(suggestedName);

        expected = date2 + "_02";
        suggestedName = backup.suggestBackupSetName();
        Assert.assertEquals("Suggested default backup set name", expected,
                suggestedName);

    }

    // Test restores by doing a backup, deleting the source files, doing a
    // restore and verifying the new source files.
    @Test
    public void testRestoreFilesFromDefault() throws IOException, IllegalArgumentException {
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        String setName = backup.suggestBackupSetName();
        backup.backupFilesToSetName(setName);

        deleteTestFiles();

        backup.restoreFilesFromSetName(setName);

        verifyBackupSetAgainst(defaultBackupRoot, setName, operationsRoot, "");
    }

    @Test
    public void testDefaultBackupSetList() throws IOException, IllegalArgumentException {

        // confirm that all directories have been deleted
        Assert.assertTrue("Default directory exists", defaultBackupRoot.exists());
        assertEquals("Confirm directory is empty", 0, defaultBackupRoot.list().length);
        assertEquals("Confirm auto back up directory is empty", 0, autoBackupRoot.list().length );

        // Make three backups and then get the list of set names
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);
        assertEquals("Confirm directory is empty", 0, backup.getBackupSetList().length );

        String[] expectedList = new String[3];

        String setName;
        for (int i = 0; i < 3; i++) {
            setName = backup.suggestBackupSetName();
            expectedList[i] = setName;
            backup.backupFilesToSetName(setName);
        }

        assertEquals("Confirm default directory has the right number of files", 3, defaultBackupRoot.list().length );
        assertEquals("Confirm default directory has the right number of files", 3, backup.getBackupSetList().length );
        assertEquals("Confirm auto back up directory is empty", 0, autoBackupRoot.list().length );

        String[] actualList = backup.getBackupSetList();

        for (int i = 0; i < 3; i++) {
            Assert.assertEquals("Default set list", expectedList[i],
                    actualList[i]);
        }
    }

    @Test
    public void testIfDefaultBackupSetExists() throws IOException, IllegalArgumentException {
        // Create a default backup set then see if it exists.
        BackupBase backup = InstanceManager.getDefault(DefaultBackup.class);

        String defName = backup.suggestBackupSetName();

        // Make sure it does not already exist
        Assert.assertFalse("Set should not exist yet",
                backup.checkIfBackupSetExists(defName));

        backup.backupFilesToSetName(defName);

        Assert.assertTrue("Set should exist now",
                backup.checkIfBackupSetExists(defName));
    }

    // And now the tests for the AutoBackup class...
    @Test
    public void testCreateAutoBackupInstance() {
        // Basic test to make sure we can instantiate the DefaultBackup class
        BackupBase backup = InstanceManager.getDefault(AutoBackup.class);
        Assert.assertNotNull("Default constructor", backup);

        // Make sure default roots got setup OK
        File root = backup.getBackupRoot();
        Assert.assertNotNull("Auto root must be set", root);
        Assert.assertTrue("Auto root dir must exist", root.exists());

        // String usersDir = FileUtil.getUserFilesPath();
        // we're resetting the root directory used to temp
        String usersDir = tempDirectoryName + File.separator;
        String opsDirName = OperationsXml.getOperationsDirectoryName();
        File opsRoot = new File(usersDir, opsDirName);

        File expectedRoot = new File(opsRoot, "autoBackups");
        Assert.assertEquals("Automatic root", expectedRoot, root);
    }

    @Test
    public void testAutoBackupWithName() throws IOException, IllegalArgumentException {
        // Does a backup to the autoBackups directory
        // The name of the backup set is given.
        BackupBase backup = InstanceManager.getDefault(AutoBackup.class);

        String setName = backup.suggestBackupSetName();
        backup.backupFilesToSetName(setName);

        // Check that they got there
        verifyBackupSetAgainst(operationsRoot, "", autoBackupRoot, setName);
    }

    @Test
    public void testAutoBackupAfterResetWithNoFiles() throws IOException {
        // Should not cause a problem if there are no files to autobackup.
        AutoBackup backup = InstanceManager.getDefault(AutoBackup.class);

        backup.deleteOperationsFiles();

        // Now try to back up nothing.
        backup.autoBackup();
    }

    @Test
    public void testSuggestedAutoBackupName() throws IOException {
        // Tests creating the suggested backup set names that account for
        // existing backup sets.
        // This probably should test for what happens after 99, but I'll leave
        // that for later.
        String suggestedName;

        // Get the suggested name with no backups in place
        Calendar now = Calendar.getInstance();

        int year = now.get(Calendar.YEAR);
        int month = now.get(Calendar.MONTH) + 1;
        int day = now.get(Calendar.DATE);

        String date2 = String.format("%d_%02d_%02d", year, month, day);

        String expected = date2 + "_00";

        BackupBase backup = InstanceManager.getDefault(AutoBackup.class);

        suggestedName = backup.suggestBackupSetName();
        Assert.assertEquals("Suggested auto backup set name 00", expected,
                suggestedName);

        // Again with one backup
        backup.backupFilesToSetName(suggestedName);

        expected = date2 + "_01";
        suggestedName = backup.suggestBackupSetName();
        Assert.assertEquals("Suggested auto backup set name 01", expected,
                suggestedName);

        // and again with two backups
        backup.backupFilesToSetName(suggestedName);

        expected = date2 + "_02";
        suggestedName = backup.suggestBackupSetName();
        Assert.assertEquals("Suggested auto backup set name 02", expected,
                suggestedName);

    }

    // Test restores by doing a backup, deleting the source files, doing a
    // restore and verifying the new source files.
    @Test
    public void testRestoreFilesFromAuto() throws IOException, IllegalArgumentException {
        BackupBase backup = InstanceManager.getDefault(AutoBackup.class);
        String setName = backup.suggestBackupSetName();
        backup.backupFilesToSetName(setName);

        deleteTestFiles();

        backup.restoreFilesFromSetName(setName);

        verifyBackupSetAgainst(autoBackupRoot, setName, operationsRoot, "");
    }

    @Test
    public void testAutoBackupSetList() throws IOException, IllegalArgumentException {

        // confirm that all directories have been deleted
        assertTrue("Auto backup directory exists", autoBackupRoot.exists());
        assertEquals("Confirm directory is empty", 0, autoBackupRoot.list().length );
        assertEquals("Confirm default backup directory is empty", 0, defaultBackupRoot.list().length );

        // Make three backups and then get the list of set names
        BackupBase backup = InstanceManager.getDefault(AutoBackup.class);
        assertEquals("Confirm directory is empty", 0, backup.getBackupSetList().length );

        String[] expectedList = new String[3];

        String setName;
        for (int i = 0; i < 3; i++) {
            setName = backup.suggestBackupSetName();
            expectedList[i] = setName;
            backup.backupFilesToSetName(setName);
        }

        assertEquals("Auto backup directory has the right number of files", 3, autoBackupRoot.list().length );
        assertEquals("Auto backup directory has the right number of files", 3, backup.getBackupSetList().length );
        assertEquals("Confirm default backup directory is empty", 0, defaultBackupRoot.list().length );

        String[] actualList = backup.getBackupSetList();

        assertEquals("Confirm actual list length", 3, actualList.length );

        for (int i = 0; i < 3; i++) {
            Assert.assertEquals("Default set list", expectedList[i],
                    actualList[i]);
        }
    }

    @Test
    public void testIfAutoBackupSetExists() throws IOException, IllegalArgumentException {
        // Create a auto backup set then see if it exists.
        BackupBase backup = InstanceManager.getDefault(AutoBackup.class);

        String defName = backup.suggestBackupSetName();

        // Make sure it does not already exist
        Assert.assertFalse("Set should not exist yet",
                backup.checkIfBackupSetExists(defName));

        backup.backupFilesToSetName(defName);

        Assert.assertTrue("Set should exist now",
                backup.checkIfBackupSetExists(defName));
    }

    @Test
    public void testAutoBackup() throws IOException {
        // Does a backup to the autoBackups directory.
        // The name of the backup set is generated internally.
        AutoBackup backup = InstanceManager.getDefault(AutoBackup.class);

        String setName = backup.suggestBackupSetName();
        backup.autoBackup();

        // Check that they got there
        verifyBackupSetAgainst(operationsRoot, "", autoBackupRoot, setName);
    }
}