Clover icon

Coverage Report

  1. Project Clover database Thu Aug 13 2020 12:04:21 BST
  2. Package jalview.io

File BackupFilesTest.java

 

Code metrics

48
150
17
1
424
314
43
0.29
8.82
17
2.53

Classes

Class Line # Actions
BackupFilesTest 27 150 43
0.8232558482.3%
 

Contributing tests

This file is covered by 4 tests. .

Source view

1    package jalview.io;
2   
3    import jalview.bin.Cache;
4    import jalview.datamodel.AlignmentI;
5    import jalview.datamodel.Sequence;
6    import jalview.datamodel.SequenceI;
7    import jalview.gui.AlignFrame;
8    import jalview.gui.JvOptionPane;
9   
10    import java.io.File;
11    import java.io.IOException;
12    import java.nio.file.Files;
13    import java.nio.file.Path;
14    import java.nio.file.Paths;
15    import java.util.Arrays;
16    import java.util.Collections;
17    import java.util.Enumeration;
18    import java.util.HashMap;
19    import java.util.List;
20    import java.util.TreeMap;
21   
22    import org.testng.Assert;
23    import org.testng.annotations.AfterClass;
24    import org.testng.annotations.BeforeClass;
25    import org.testng.annotations.Test;
26   
 
27    public class BackupFilesTest
28    {
 
29  1 toggle @BeforeClass(alwaysRun = true)
30    public void setUpJvOptionPane()
31    {
32  1 JvOptionPane.setInteractiveMode(false);
33  1 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
34    }
35   
36    private static boolean actuallyDeleteTmpFiles = true;
37   
38    private static String testDir = "test/jalview/io";
39   
40    private static String testBasename = "backupfilestest";
41   
42    private static String testExt = ".fa";
43   
44    private static String testFilename = testBasename + testExt;
45   
46   
47    private static String testFile = testDir + File.separatorChar
48    + testFilename;
49   
50    private static String newBasename = testBasename + "Temp";
51   
52    private static String newFilename = newBasename + testExt;
53   
54    private static String newFile = testDir + File.separatorChar
55    + newFilename;
56   
57    private static String sequenceName = "BACKUP_FILES";
58   
59    private static String sequenceDescription = "backupfiles";
60   
61    private static String sequenceData = "AAAARG";
62   
63    private static String suffix = "_BACKUPTEST-%n";
64   
65    private static int digits = 6;
66   
67    private static int rollMax = 2;
68   
69    private AlignFrame af;
70   
71    // read and save with backupfiles disabled
 
72  1 toggle @Test(groups = { "Functional" })
73    public void noBackupsEnabledTest() throws Exception
74    {
75    // set BACKUPFILES_ENABLED to false (i.e. turn off BackupFiles feature -- no
76    // backup files to be made when saving)
77  1 setBackupFilesOptions(false, true, true);
78   
79    // init the newFile and backups (i.e. make sure newFile exists on its own
80    // and has no backups
81  1 initNewFileForTesting();
82   
83    // now save again
84  1 save();
85   
86    // check no backup files
87  1 File[] backupFiles = getBackupFiles();
88  1 Assert.assertTrue(backupFiles.length == 0);
89    }
90   
91    // save keeping all backup files
 
92  1 toggle @Test(groups = { "Functional" })
93    public void backupsEnabledNoRollMaxTest() throws Exception
94    {
95    // Enable BackupFiles and set noMax so all backupfiles get kept
96  1 setBackupFilesOptions(true, false, true);
97   
98    // init the newFile and backups (i.e. make sure newFile exists on its own
99    // and has no backups)
100  1 initNewFileForTesting();
101   
102    // now save a few times again. No rollMax so should have more than two
103    // backup files
104  1 int numSaves = 10;
105  11 for (int i = 0; i < numSaves; i++)
106    {
107  10 save();
108    }
109   
110    // check 10 backup files
111  1 HashMap<Integer, String> correctindexmap = new HashMap<>();
112  1 correctindexmap.put(1, "backupfilestestTemp.fa_BACKUPTEST-000001");
113  1 correctindexmap.put(2, "backupfilestestTemp.fa_BACKUPTEST-000002");
114  1 correctindexmap.put(3, "backupfilestestTemp.fa_BACKUPTEST-000003");
115  1 correctindexmap.put(4, "backupfilestestTemp.fa_BACKUPTEST-000004");
116  1 correctindexmap.put(5, "backupfilestestTemp.fa_BACKUPTEST-000005");
117  1 correctindexmap.put(6, "backupfilestestTemp.fa_BACKUPTEST-000006");
118  1 correctindexmap.put(7, "backupfilestestTemp.fa_BACKUPTEST-000007");
119  1 correctindexmap.put(8, "backupfilestestTemp.fa_BACKUPTEST-000008");
120  1 correctindexmap.put(9, "backupfilestestTemp.fa_BACKUPTEST-000009");
121  1 correctindexmap.put(10, "backupfilestestTemp.fa_BACKUPTEST-000010");
122  1 HashMap<Integer, String> wrongindexmap = new HashMap<>();
123  1 wrongindexmap.put(1, "backupfilestestTemp.fa_BACKUPTEST-1");
124  1 wrongindexmap.put(2, "backupfilestestTemp.fa_BACKUPTEST-000002");
125  1 wrongindexmap.put(3, "backupfilestestTemp.fa_BACKUPTEST-000003");
126  1 wrongindexmap.put(4, "backupfilestestTemp.fa_BACKUPTEST-000004");
127  1 wrongindexmap.put(5, "backupfilestestTemp.fa_BACKUPTEST-000005");
128  1 wrongindexmap.put(6, "backupfilestestTemp.fa_BACKUPTEST-000006");
129  1 wrongindexmap.put(7, "backupfilestestTemp.fa_BACKUPTEST-000007");
130  1 wrongindexmap.put(8, "backupfilestestTemp.fa_BACKUPTEST-000008");
131  1 wrongindexmap.put(9, "backupfilestestTemp.fa_BACKUPTEST-000009");
132  1 wrongindexmap.put(10, "backupfilestestTemp.fa_BACKUPTEST-000010");
133  1 int[] indexes2 = { 3, 4, 5, 6, 7, 8, 9, 10 };
134  1 int[] indexes3 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
135  1 Assert.assertTrue(checkBackupFiles(correctindexmap));
136  1 Assert.assertFalse(checkBackupFiles(wrongindexmap));
137  1 Assert.assertFalse(checkBackupFiles(indexes2));
138  1 Assert.assertFalse(checkBackupFiles(indexes3));
139    }
140   
141    // save keeping only the last rollMax (2) backup files
 
142  1 toggle @Test(groups = { "Functional" })
143    public void backupsEnabledRollMaxTest() throws Exception
144    {
145    // Enable BackupFiles and set noMax so all backupfiles get kept
146  1 setBackupFilesOptions(true, false, false);
147   
148    // init the newFile and backups (i.e. make sure newFile exists on its own
149    // and has no backups)
150  1 initNewFileForTesting();
151   
152    // now save a few times again. No rollMax so should have more than two
153    // backup files
154  1 int numSaves = 10;
155  11 for (int i = 0; i < numSaves; i++)
156    {
157  10 save();
158    }
159   
160    // check there are "rollMax" backup files and they are all saved correctly
161    // check 10 backup files
162  1 HashMap<Integer, String> correctindexmap = new HashMap<>();
163  1 correctindexmap.put(9, "backupfilestestTemp.fa_BACKUPTEST-000009");
164  1 correctindexmap.put(10, "backupfilestestTemp.fa_BACKUPTEST-000010");
165  1 int[] indexes2 = { 10 };
166  1 int[] indexes3 = { 8, 9, 10 };
167  1 Assert.assertTrue(checkBackupFiles(correctindexmap));
168  1 Assert.assertFalse(checkBackupFiles(indexes2));
169  1 Assert.assertFalse(checkBackupFiles(indexes3));
170    }
171   
172    // save keeping only the last rollMax (2) backup files
 
173  1 toggle @Test(groups = { "Functional" })
174    public void backupsEnabledReverseRollMaxTest() throws Exception
175    {
176    // Enable BackupFiles and set noMax so all backupfiles get kept
177  1 setBackupFilesOptions(true, true, false);
178   
179    // init the newFile and backups (i.e. make sure newFile exists on its own
180    // and has no backups)
181  1 initNewFileForTesting();
182   
183    // now save a few times again. No rollMax so should have more than two
184    // backup files
185  1 int numSaves = 10;
186  11 for (int i = 0; i < numSaves; i++)
187    {
188  10 save();
189    }
190   
191    // check there are "rollMax" backup files and they are all saved correctly
192    // check 10 backup files
193  1 HashMap<Integer, String> correctindexmap = new HashMap<>();
194  1 correctindexmap.put(1, "backupfilestestTemp.fa_BACKUPTEST-000001");
195  1 correctindexmap.put(2, "backupfilestestTemp.fa_BACKUPTEST-000002");
196  1 int[] indexes2 = { 1 };
197  1 int[] indexes3 = { 1, 2, 3 };
198  1 Assert.assertTrue(checkBackupFiles(correctindexmap));
199  1 Assert.assertFalse(checkBackupFiles(indexes2));
200  1 Assert.assertFalse(checkBackupFiles(indexes3));
201    }
202   
 
203  0 toggle private void setBackupFilesOptions()
204    {
205  0 setBackupFilesOptions(true, false, false);
206    }
207   
 
208  4 toggle private void setBackupFilesOptions(boolean enabled, boolean reverse,
209    boolean noMax)
210    {
211  4 Cache.loadProperties("test/jalview/io/testProps.jvprops");
212   
213  4 BackupFilesPresetEntry bfpe = new BackupFilesPresetEntry(suffix, digits,
214    reverse, noMax, rollMax, false);
215   
216  4 Cache.applicationProperties.setProperty(BackupFiles.ENABLED,
217    Boolean.toString(enabled));
218  4 Cache.applicationProperties.setProperty(
219    BackupFilesPresetEntry.SAVEDCONFIG, bfpe.toString());
220    /*
221    Cache.applicationProperties.setProperty(BackupFiles.ENABLED,
222    Boolean.toString(enabled));
223    Cache.applicationProperties.setProperty(BackupFiles.SUFFIX, suffix);
224    Cache.applicationProperties.setProperty(BackupFiles.SUFFIX_DIGITS,
225    Integer.toString(digits));
226    Cache.applicationProperties.setProperty(BackupFiles.REVERSE_ORDER,
227    Boolean.toString(reverse));
228    Cache.applicationProperties.setProperty(BackupFiles.NO_MAX,
229    Boolean.toString(noMax));
230    Cache.applicationProperties.setProperty(BackupFiles.ROLL_MAX,
231    Integer.toString(rollMax));
232    Cache.applicationProperties.setProperty(BackupFiles.CONFIRM_DELETE_OLD,
233    "false");
234    */
235    }
236   
 
237  31 toggle private void save()
238    {
239  31 if (af != null)
240    {
241  31 af.saveAlignment(newFile, jalview.io.FileFormat.Fasta);
242    }
243    }
244   
245    // this runs cleanTmpFiles and then writes the newFile once as a starting
246    // point for all tests
 
247  4 toggle private void initNewFileForTesting() throws Exception
248    {
249  4 cleanupTmpFiles();
250   
251  4 AppletFormatAdapter afa = new AppletFormatAdapter();
252  4 AlignmentI al = afa.readFile(testFile, DataSourceType.FILE,
253    jalview.io.FileFormat.Fasta);
254  4 List<SequenceI> l = al.getSequences();
255   
256    // check this is right
257  4 if (l.size() != 1)
258    {
259  0 throw new Exception("single sequence from '" + testFile
260    + "' not read in correctly (should be a single short sequence). List<SequenceI> size is wrong.");
261    }
262  4 SequenceI s = l.get(0);
263  4 Sequence ref = new Sequence(sequenceName, sequenceData);
264  4 ref.setDescription(sequenceDescription);
265  4 if (!sequencesEqual(s, ref))
266    {
267  0 throw new Exception("single sequence from '" + testFile
268    + "' not read in correctly (should be a single short sequence). SequenceI name, description or data is wrong.");
269    }
270    // save alignment file to new filename -- this doesn't test backups disabled
271    // yet as this file shouldn't already exist
272  4 af = new AlignFrame(al, 0, 0);
273  4 af.saveAlignment(newFile, jalview.io.FileFormat.Fasta);
274    }
275   
276    // this deletes the newFile (if it exists) and any saved backup file for it
 
277  5 toggle @AfterClass(alwaysRun = true)
278    private void cleanupTmpFiles()
279    {
280  5 File newfile = new File(newFile);
281  5 if (newfile.exists())
282    {
283  4 newfile.delete();
284    }
285  5 File[] tmpFiles = getBackupFiles(newFile, suffix, digits);
286  19 for (int i = 0; i < tmpFiles.length; i++)
287    {
288  14 if (actuallyDeleteTmpFiles)
289    {
290  14 tmpFiles[i].delete();
291    }
292    else
293    {
294  0 System.out.println("Pretending to delete " + tmpFiles[i].getPath());
295    }
296    }
297    }
298   
 
299  6 toggle private static File[] getBackupFiles(String f, String s, int i)
300    {
301  6 TreeMap<Integer, File> bfTreeMap = BackupFiles.getBackupFilesAsTreeMap(f,
302    s, i);
303  6 File[] backupFiles = new File[bfTreeMap.size()];
304  6 bfTreeMap.values().toArray(backupFiles);
305  6 return backupFiles;
306    }
307   
 
308  1 toggle private static File[] getBackupFiles()
309    {
310  1 return getBackupFiles(newFile, suffix, digits);
311    }
312   
 
313  4 toggle private static boolean checkBackupFiles(HashMap<Integer, String> indexmap)
314    throws IOException
315    {
316  4 TreeMap<Integer, File> map = BackupFiles.getBackupFilesAsTreeMap(newFile,
317    suffix, digits);
318  4 Enumeration<Integer> indexesenum = Collections
319    .enumeration(indexmap.keySet());
320  18 while (indexesenum.hasMoreElements())
321    {
322  15 int i = indexesenum.nextElement();
323  15 String indexfilename = indexmap.get(i);
324  15 if (!map.containsKey(i))
325    {
326  0 return false;
327    }
328  15 File f = map.get(i);
329  15 if (!filesContentEqual(newFile, f.getPath()))
330    {
331  0 return false;
332    }
333  15 map.remove(i);
334  15 if (f == null)
335    {
336  0 return false;
337    }
338  15 if (!f.getName().equals(indexfilename))
339    {
340  1 return false;
341    }
342    }
343    // should be nothing left in map
344  3 if (map.size() > 0)
345    {
346  0 return false;
347    }
348   
349  3 return true;
350    }
351   
 
352  6 toggle private static boolean checkBackupFiles(int[] indexes) throws IOException
353    {
354  6 TreeMap<Integer, File> map = BackupFiles.getBackupFilesAsTreeMap(newFile,
355    suffix, digits);
356  28 for (int m = 0; m < indexes.length; m++)
357    {
358  25 int i = indexes[m];
359  25 if (!map.containsKey(i))
360    {
361  3 return false;
362    }
363  22 File f = map.get(i);
364  22 if (!filesContentEqual(newFile, f.getPath()))
365    {
366  0 return false;
367    }
368  22 map.remove(i);
369  22 if (f == null)
370    {
371  0 return false;
372    }
373    // check the filename -- although this uses the same code to forumulate the filename so not much of a test!
374  22 String filename = BackupFilenameParts.getBackupFilename(i,
375    newBasename + testExt, suffix, digits);
376  22 if (!filename.equals(f.getName()))
377    {
378  0 System.out.println("Supposed filename '" + filename
379    + "' not equal to actual filename '" + f.getName() + "'");
380  0 return false;
381    }
382    }
383    // should be nothing left in map
384  3 if (map.size() > 0)
385    {
386  3 return false;
387    }
388   
389  0 return true;
390    }
391   
 
392  0 toggle private static String[] getBackupFilesAsStrings()
393    {
394  0 File[] files = getBackupFiles(newFile, suffix, digits);
395  0 String[] filenames = new String[files.length];
396  0 for (int i = 0; i < files.length; i++)
397    {
398  0 filenames[i] = files[i].getPath();
399    }
400  0 return filenames;
401    }
402   
 
403  4 toggle public static boolean sequencesEqual(SequenceI s1, SequenceI s2) {
404  4 if (s1 == null && s2 == null) {
405  0 return true;
406  4 } else if (s1 == null || s2 == null) {
407  0 return false;
408    }
409  4 return (s1.getName().equals(s2.getName())
410    && s1.getDescription().equals(s2.getDescription())
411    && Arrays.equals(s1.getSequence(), s2.getSequence()));
412    }
413   
 
414  37 toggle public static boolean filesContentEqual(String fileName1,
415    String fileName2) throws IOException
416    {
417  37 Path file1 = Paths.get(fileName1);
418  37 Path file2 = Paths.get(fileName2);
419  37 byte[] bytes1 = Files.readAllBytes(file1);
420  37 byte[] bytes2 = Files.readAllBytes(file2);
421  37 return Arrays.equals(bytes1, bytes2);
422    }
423   
424    }
  • Report generated by OpenClover v 4.4.1 on Thu Aug 13 2020 12:06:48 BST using coverage data from Thu Aug 13 2020 12:06:40 BST.
  • OpenClover is free and open-source software.