Clover icon

Coverage Report

  1. Project Clover database Thu Nov 27 2025 17:07:57 GMT
  2. Package jalview.bin.argparser

File ArgParserTest.java

 

Code metrics

40
163
25
2
884
695
48
0.29
6.52
12.5
1.92

Classes

Class Line # Actions
ArgParserTest 43 155 45
0.925925992.6%
ArgParserTest.ArgAndValues 839 8 3
0.916666791.7%
 

Contributing tests

This file is covered by 65 tests. .

Source view

1    /*
2    * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3    * Copyright (C) $$Year-Rel$$ The Jalview Authors
4    *
5    * This file is part of Jalview.
6    *
7    * Jalview is free software: you can redistribute it and/or
8    * modify it under the terms of the GNU General Public License
9    * as published by the Free Software Foundation, either version 3
10    * of the License, or (at your option) any later version.
11    *
12    * Jalview is distributed in the hope that it will be useful, but
13    * WITHOUT ANY WARRANTY; without even the implied warranty
14    * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15    * PURPOSE. See the GNU General Public License for more details.
16    *
17    * You should have received a copy of the GNU General Public License
18    * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19    * The Jalview Authors are detailed in the 'AUTHORS' file.
20    */
21    package jalview.bin.argparser;
22   
23    import java.io.File;
24    import java.io.IOException;
25    import java.util.ArrayList;
26    import java.util.Arrays;
27    import java.util.HashSet;
28    import java.util.List;
29    import java.util.Properties;
30   
31    import org.apache.logging.log4j.util.Strings;
32    import org.testng.Assert;
33    import org.testng.annotations.AfterClass;
34    import org.testng.annotations.AfterMethod;
35    import org.testng.annotations.DataProvider;
36    import org.testng.annotations.Test;
37   
38    import jalview.bin.Cache;
39    import jalview.bin.Console;
40    import jalview.gui.Desktop;
41   
42    @Test(singleThreaded = true)
 
43    public class ArgParserTest
44    {
 
45  1 toggle @AfterClass(alwaysRun = true)
46    public static void resetProps()
47    {
48  1 Cache.loadProperties("test/jalview/testProps.jvprops");
49    }
50   
 
51  73 toggle @AfterMethod(alwaysRun = true)
52    public void tearDown()
53    {
54  73 if (Desktop.instance != null)
55  73 Desktop.instance.closeAll_actionPerformed(null);
56    }
57   
 
58  10 toggle @Test(groups = "Functional", dataProvider = "argLines")
59    public void parseArgsTest(String commandLineArgs, Arg a, String other)
60    {
61  10 String[] args = commandLineArgs.split("\\s+");
62  10 ArgParser argparser = new ArgParser(args);
63    }
64   
 
65  7 toggle @Test(groups = "Functional", dataProvider = "argSubValsAndLinkedIds")
66    public void parseSubValsAndLinkedIdsTest(String commandLineArgs,
67    String linkedId, Arg a, String subvalKey, String value,
68    boolean trueOrFalse)
69    {
70  7 String[] args = commandLineArgs.split("\\s+");
71  7 ArgParser argparser = new ArgParser(args);
72  7 ArgValuesMap avm = argparser.getLinkedArgs(linkedId);
73  7 ArgValue av = avm.getArgValue(a);
74  7 SubVals sv = av.getSubVals();
75  7 String testString = null;
76  7 if (subvalKey.equals("GETINDEX"))
77    {
78  2 testString = String.valueOf(sv.getIndex());
79    }
80    else
81    {
82  5 testString = sv.get(subvalKey);
83    }
84  7 if (trueOrFalse)
85    {
86  4 Assert.assertEquals(testString, value);
87    }
88    else
89    {
90  3 Assert.assertNotEquals(testString, value);
91    }
92    }
93   
 
94  24 toggle @Test(
95    groups = "Functional",
96    dataProvider = "argAutoIndexAndSubstitutions")
97    public void parseAutoIndexAndSubstitutionsTest(String commandLineArgs,
98    String linkedId, Arg a, String filename)
99    {
100    // { "--append=filename0 --new --append=filename1", "JALVIEW:1",
101    // Arg.OPEN, "filename1" },
102  24 String[] args = commandLineArgs.split("\\s+");
103  24 ArgParser argparser = new ArgParser(args);
104  24 ArgValuesMap avm = argparser.getLinkedArgs(linkedId);
105  24 ArgValue av = avm.getArgValue(a);
106  24 Assert.assertEquals(av.getValue(), filename);
107    }
108   
 
109  10 toggle @Test(groups = "Functional", dataProvider = "argLines")
110    public void bootstrapArgsTest(String commandLineArgs, Arg a, String other)
111    {
112  10 String[] args = commandLineArgs.split("\\s+");
113  10 BootstrapArgs b = BootstrapArgs.getBootstrapArgs(args);
114   
115  10 Assert.assertTrue(b.contains(a));
116  10 if (a == Arg.PROPS)
117    {
118  1 Properties bP = Cache.bootstrapProperties(b.getValue(Arg.PROPS));
119  1 Assert.assertNotNull(bP);
120  1 Assert.assertTrue(other.equals(bP.get(Cache.BOOTSTRAP_TEST)));
121  1 Assert.assertFalse(bP.contains("NOT" + Cache.BOOTSTRAP_TEST));
122    }
123  9 else if (a == Arg.ARGFILE)
124    {
125  7 List<String> filenames = b.getValueList(a);
126  7 boolean found = false;
127  7 for (String s : filenames)
128    {
129  13 File f = new File(s);
130  13 File fo = new File(other);
131  13 try
132    {
133  13 if (fo.getCanonicalPath().equals(f.getCanonicalPath()))
134    {
135  7 found = true;
136  7 break;
137    }
138    } catch (IOException e)
139    {
140    }
141    }
142  7 Assert.assertTrue(found,
143    "File '" + other + "' not found in shell expanded glob '"
144    + commandLineArgs + "'");
145    }
146    }
147   
 
148  1 toggle @Test(groups = "Functional", dataProvider = "argFiles")
149    public void argFilesTest(String commandLineArgs, Arg a, String other)
150    {
151  1 String[] args = commandLineArgs.split("\\s+");
152  1 BootstrapArgs b = BootstrapArgs.getBootstrapArgs(args);
153   
154  1 Assert.assertTrue(b.contains(a));
155  1 Assert.assertFalse(b.contains(Arg.APPEND));
156  1 if (a == Arg.PROPS)
157    {
158  0 Properties bP = Cache.bootstrapProperties(b.getValue(Arg.PROPS));
159  0 Assert.assertTrue("true".equals(bP.get(Cache.BOOTSTRAP_TEST)));
160    }
161    }
162   
 
163  0 toggle @DataProvider(name = "argLinesNotworking")
164    public Object[][] argLinesTest()
165    {
166  0 return new Object[][] {
167    // can't use this one yet as it doesn't get shell glob expanded by the
168    // test
169    { "--argfile test/jalview/bin/argparser/testfiles/argfile*.txt",
170    Arg.ARGFILE,
171    "test/jalview/bin/argparser/testfiles/argfile0.txt" }, };
172    }
173   
 
174  2 toggle @DataProvider(name = "argLines")
175    public Object[][] argLines()
176    {
177  2 return new Object[][] { {
178    "--append=test/jalview/bin/argparser/testfiles/test1.fa --props=test/jalview/bin/argparser/testfiles/testProps.jvprops",
179    Arg.PROPS, "true" },
180    { "--debug --append=test/jalview/bin/argparser/testfiles/test1.fa",
181    Arg.DEBUG, null },
182    { "--append=test/jalview/bin/argparser/testfiles/test1.fa --headless",
183    Arg.HEADLESS, null },
184   
185    { "--argfile test/jalview/bin/argparser/testfiles/argfile0.txt",
186    Arg.ARGFILE,
187    "test/jalview/bin/argparser/testfiles/argfile0.txt" },
188    // these next three are what a shell glob expansion would look like
189    { "--argfile test/jalview/bin/argparser/testfiles/argfile0.txt test/jalview/bin/argparser/testfiles/argfile1.txt test/jalview/bin/argparser/testfiles/argfile2.txt",
190    Arg.ARGFILE,
191    "test/jalview/bin/argparser/testfiles/argfile0.txt" },
192    { "--argfile test/jalview/bin/argparser/testfiles/argfile0.txt test/jalview/bin/argparser/testfiles/argfile1.txt test/jalview/bin/argparser/testfiles/argfile2.txt",
193    Arg.ARGFILE,
194    "test/jalview/bin/argparser/testfiles/argfile1.txt" },
195    { "--argfile test/jalview/bin/argparser/testfiles/argfile0.txt test/jalview/bin/argparser/testfiles/argfile1.txt test/jalview/bin/argparser/testfiles/argfile2.txt",
196    Arg.ARGFILE,
197    "test/jalview/bin/argparser/testfiles/argfile2.txt" },
198    { "--argfile=test/jalview/bin/argparser/testfiles/argfile*.txt",
199    Arg.ARGFILE,
200    "test/jalview/bin/argparser/testfiles/argfile0.txt" },
201    { "--argfile=test/jalview/bin/argparser/testfiles/argfile*.txt",
202    Arg.ARGFILE,
203    "test/jalview/bin/argparser/testfiles/argfile1.txt" },
204    { "--argfile=test/jalview/bin/argparser/testfiles/argfile*.txt",
205    Arg.ARGFILE,
206    "test/jalview/bin/argparser/testfiles/argfile2.txt" } };
207    }
208   
 
209  1 toggle @DataProvider(name = "argSubValsAndLinkedIds")
210    public Object[][] argSubValsAndLinkedIds()
211    {
212  1 return new Object[][] {
213    //
214    /*
215    */
216    { "--debug --append=[hi]test/jalview/bin/argparser/testfiles/test1.fa",
217    "JALVIEW:0", Arg.APPEND, "hi", "true", true },
218    { "--append[linkedId1]=[new,hello=world,1]test/jalview/bin/argparser/testfiles/test1.fa --headless",
219    "linkedId1", Arg.APPEND, "new", "true", true },
220    { "--append[linkedId2]=[new,hello=world,1]test/jalview/bin/argparser/testfiles/test1.fa --headless",
221    "linkedId2", Arg.APPEND, "hello", "world", true },
222    { "--append[linkedId3]=[new,hello=world,1]test/jalview/bin/argparser/testfiles/test1.fa --headless",
223    "linkedId3", Arg.APPEND, "GETINDEX", "1", true },
224    { "--append[linkedId4]=[new,hello=world,1]test/jalview/bin/argparser/testfiles/test1.fa --append[linkedId5]=[notnew;hello=world;1]test/jalview/bin/argparser/testfiles/test1.fa --headless",
225    "linkedId5", Arg.APPEND, "new", "true", false },
226    { "--append[linkedId5]=[new,hello=worlddomination,1]test/jalview/bin/argparser/testfiles/test1.fa --append[linkedId2]=[new;hello=world;1]test/jalview/bin/argparser/testfiles/test1.fa --headless",
227    "linkedId5", Arg.APPEND, "hello", "world", false },
228    { "--append[linkedId6]=[new,hello=world,0]test/jalview/bin/argparser/testfiles/test1.fa --append[linkedId7]=[new;hello=world;1]test/jalview/bin/argparser/testfiles/test1.fa --headless",
229    "linkedId7", Arg.APPEND, "GETINDEX", "0", false },
230    /*
231    */
232    //
233    };
234    }
235   
 
236  1 toggle @DataProvider(name = "argAutoIndexAndSubstitutions")
237    public Object[][] argAutoIndexAndSubstitutions()
238    {
239  1 return new Object[][] {
240    //
241    /*
242    */
243    { "--append=filename0 --append=filename1", "JALVIEW:0", Arg.APPEND,
244    "filename0" },
245    { "--append=filename0 --new --append=filename1", "JALVIEW:1",
246    Arg.APPEND, "filename1" },
247    { "--append=filename0 --new --new --append=filename2", "JALVIEW:0",
248    Arg.APPEND, "filename0" },
249    { "--append=filename0 --new --new --append=filename2", "JALVIEW:2",
250    Arg.APPEND, "filename2" },
251    { "--append[linkA-{n}]=filenameA0 --append[linkA-{++n}]=filenameA1",
252    "linkA-0", Arg.APPEND, "filenameA0" },
253    { "--append[linkB-{n}]=filenameB0 --append[linkB-{++n}]=filenameB1",
254    "linkB-1", Arg.APPEND, "filenameB1" },
255    { "--append[linkC-{n}]=filenameC0 --image[linkC-{n}]=outputC{n}.txt",
256    "linkC-0", Arg.IMAGE, "outputC{n}.txt" },
257    { "--append[linkD-{n}]=filenameD0 --substitutions --image[linkD-{n}]=outputD{n}.txt",
258    "linkD-0", Arg.IMAGE, "outputD0.txt" },
259    { "--append[linkE-{n}]=filenameE0 --substitutions --image[linkE-{n}]=output-E{n}.txt --nil[{++n}] --image[linkE-{n}]=outputE{n}.txt",
260    "linkE-0", Arg.IMAGE, "output-E0.txt" },
261    { "--append[linkF-{n}]=filenameF0 --substitutions --image[linkF-{n}]=output-F{n}.txt --nil[{++n}] --image[linkF-{n}]=outputF{n}.txt",
262    "linkF-1", Arg.IMAGE, "outputF1.txt" },
263    { "--append[linkG-{n}]=filenameG0 --substitutions --image[linkG-{n}]=output-G{n}.txt --nil[{++n}] --nosubstitutions --image[linkG-{n}]=outputG{n}.txt",
264    "linkG-1", Arg.IMAGE, "outputG{n}.txt" },
265    { "--append[linkH-{n}]=filenameH0 --substitutions --image[linkH-{n}]=output-H{n}.txt --nil[{++n}] --nosubstitutions --image[linkH-{n}]=outputH{n}.txt",
266    "linkH-0", Arg.IMAGE, "output-H0.txt" },
267    { "--open=filename0 --append=filename1", "JALVIEW:0", Arg.OPEN,
268    "filename0" },
269    { "--open=filename0 --new --append=filename1", "JALVIEW:1",
270    Arg.APPEND, "filename1" },
271    { "--open=filename0 --new --new --append=filename2", "JALVIEW:0",
272    Arg.OPEN, "filename0" },
273    { "--open=filename0 --new --new --append=filename2", "JALVIEW:2",
274    Arg.APPEND, "filename2" },
275    { "--open[linkA-{n}]=filenameA0 --append[linkA-{++n}]=filenameA1",
276    "linkA-0", Arg.OPEN, "filenameA0" },
277    { "--open[linkB-{n}]=filenameB0 --append[linkB-{++n}]=filenameB1",
278    "linkB-1", Arg.APPEND, "filenameB1" },
279    { "--open[linkC-{n}]=filenameC0 --image[linkC-{n}]=outputC{n}.txt",
280    "linkC-0", Arg.IMAGE, "outputC{n}.txt" },
281    { "--open[linkD-{n}]=filenameD0 --substitutions --image[linkD-{n}]=outputD{n}.txt",
282    "linkD-0", Arg.IMAGE, "outputD0.txt" },
283    { "--open[linkE-{n}]=filenameE0 --substitutions --image[linkE-{n}]=output-E{n}.txt --nil[{++n}] --image[linkE-{n}]=outputE{n}.txt",
284    "linkE-0", Arg.IMAGE, "output-E0.txt" },
285    { "--open[linkF-{n}]=filenameF0 --substitutions --image[linkF-{n}]=output-F{n}.txt --nil[{++n}] --image[linkF-{n}]=outputF{n}.txt",
286    "linkF-1", Arg.IMAGE, "outputF1.txt" },
287    { "--open[linkG-{n}]=filenameG0 --substitutions --image[linkG-{n}]=output-G{n}.txt --nil[{++n}] --nosubstitutions --image[linkG-{n}]=outputG{n}.txt",
288    "linkG-1", Arg.IMAGE, "outputG{n}.txt" },
289    { "--open[linkH-{n}]=filenameH0 --substitutions --image[linkH-{n}]=output-H{n}.txt --nil[{++n}] --nosubstitutions --image[linkH-{n}]=outputH{n}.txt",
290    "linkH-0", Arg.IMAGE, "output-H0.txt" },
291    /*
292    */
293   
294    //
295    };
296    }
297   
 
298  1 toggle @DataProvider(name = "argFiles")
299    public Object[][] argFiles()
300    {
301  1 return new Object[][] { {
302    "--argfile=test/jalview/bin/argparser/testfiles/argfile0.txt --open=shouldntbeabootstrap",
303    Arg.ARGFILE, "test/jalview/bin/argfiles/testfiles/test1.fa" } };
304    }
305   
 
306  3 toggle @Test(groups = "Functional", dataProvider = "allLinkedIdsData")
307    public void allLinkedIdsTest(String pwd, String commandLineArgs, Arg a,
308    String[] values, String[] nonvalues)
309    {
310  3 String userDir = System.getProperty("user.dir");
311  3 if (pwd != null)
312    {
313  0 File pwdFile = new File(pwd);
314  0 System.setProperty("user.dir", pwdFile.getAbsolutePath());
315    }
316  3 String[] args = commandLineArgs.split("\\s+");
317  3 ArgParser argparser = new ArgParser(args);
318   
319  3 int num = values.length;
320  3 List<String> linkedIds = argparser.getLinkedIds();
321  3 Assert.assertEquals(linkedIds.size(), num,
322    "Wrong number of linkedIds: " + linkedIds.toString());
323  12 for (int i = 0; i < num; i++)
324    {
325  9 String value = values[i];
326  9 String linkedId = linkedIds.get(i);
327  9 ArgValuesMap avm = argparser.getLinkedArgs(linkedId);
328  9 if (value == null)
329    {
330  3 Assert.assertTrue(avm.containsArg(a),
331    "Arg value for " + a.argString()
332    + " not applied correctly to linkedId '" + linkedId
333    + "'");
334    }
335    else
336    {
337  6 ArgValues avs = avm.getArgValues(a);
338  6 ArgValue av = avs.getArgValue();
339  6 String v = av.getValue();
340  6 value = new File(value).getPath();
341  6 Assert.assertEquals(v, value, "Arg value for " + a.argString()
342    + " not applied correctly to linkedId '" + linkedId + "'");
343    }
344    }
345   
346  3 System.setProperty("user.dir", userDir);
347    }
348   
 
349  1 toggle @DataProvider(name = "allLinkedIdsData")
350    public Object[][] allLinkedIdsData()
351    {
352  1 return new Object[][] {
353    //
354    /*
355    */
356    { null,
357    "--open=test/jalview/bin/argparser/testfiles/*.fa --substitutions --all --image={dirname}/{basename}.png --close",
358    Arg.CLOSE, new String[]
359    { null, null, null },
360    null },
361    { null,
362    "--open=test/jalview/bin/argparser/testfiles/*.fa --substitutions --all --output={dirname}/{basename}.stk --close",
363    Arg.OUTPUT, new String[]
364    { "test/jalview/bin/argparser/testfiles/test1.stk",
365    "test/jalview/bin/argparser/testfiles/test2.stk",
366    "test/jalview/bin/argparser/testfiles/test3.stk", },
367    null },
368    { null,
369    "--open=test/jalview/bin/argparser/testfiles/*.fa --substitutions --all --image={dirname}/{basename}.png --close",
370    Arg.IMAGE, new String[]
371    { "test/jalview/bin/argparser/testfiles/test1.png",
372    "test/jalview/bin/argparser/testfiles/test2.png",
373    "test/jalview/bin/argparser/testfiles/test3.png", },
374    null },
375    /*
376    * Find a way to change pwd reliably -- need to match "*.fa" against some files!
377    { "test/jalview/bin/argparser/testfiles",
378   
379    "--open=*.fa --image={dirname}/{basename}.png --close",
380    Arg.IMAGE, new String[]
381    { "./test1.png", "./test2.png", "./test3.png", }, null },
382    */
383    //
384    };
385    }
386   
 
387  14 toggle @Test(groups = "Functional", dataProvider = "bootstrapArgsData")
388    public void bootstrapArgsValuesAndHeadlessModeTest(String commandLineArgs,
389    Arg a, String valS, boolean valB, boolean headlessValue)
390    {
391  14 String[] args = commandLineArgs.split("\\s+");
392  14 BootstrapArgs bsa = BootstrapArgs.getBootstrapArgs(args);
393  14 if (a != null)
394    {
395  6 if (valS != null)
396    {
397  1 Assert.assertEquals(bsa.getValue(a), valS,
398    "BootstrapArg " + a.argString()
399    + " value does not match expected '" + valS + "'");
400    }
401    else
402    {
403  5 Assert.assertEquals(bsa.getBoolean(a), valB,
404    "Boolean/Unary value of BootstrapArg " + a.argString()
405    + "' is not the expected '" + valB + "'");
406    }
407    }
408   
409  14 boolean isHeadless = bsa.isHeadless();
410  14 Assert.assertEquals(isHeadless, headlessValue,
411    "Assumed headless setting '" + isHeadless + "' is wrong.");
412    }
413   
 
414  1 toggle @DataProvider(name = "bootstrapArgsData")
415    public Object[][] bootstrapArgsData()
416    {
417  1 return new Object[][] {
418    /*
419    * cmdline args
420    * Arg (null if only testing headless)
421    * String value if there is one (null otherwise)
422    * boolean value if String value is null
423    * expected value of isHeadless()
424    */
425    /*
426    */
427    { "--open thisway.fa --output thatway.fa --jabaws https://forwardsandbackwards.com/",
428    Arg.JABAWS, "https://forwardsandbackwards.com/", false, true },
429    { "--help-all --open thisway.fa --output thatway.fa --jabaws https://forwardsandbackwards.com/",
430    Arg.HELP, null, true, true },
431    { "--help-all --nonews --open thisway.fa --output thatway.fa --jabaws https://forwardsandbackwards.com/",
432    Arg.NEWS, null, false, true },
433    { "--help --nonews --open thisway.fa --output thatway.fa --jabaws https://forwardsandbackwards.com/",
434    Arg.NEWS, null, false, true },
435    { "--help-opening --nonews --open thisway.fa --output thatway.fa --jabaws https://forwardsandbackwards.com/",
436    Arg.NEWS, null, false, true },
437    { "--nonews --open thisway.fa --output thatway.fa --jabaws https://forwardsandbackwards.com/",
438    Arg.NEWS, null, false, true },
439    { "--open thisway.fa --image thatway.png", null, null, false,
440    true },
441    { "--open thisway.fa --output thatway.png", null, null, false,
442    true },
443    { "--open thisway.fa --image thatway.png --noheadless", null, null,
444    false, false },
445    { "--open thisway.fa --output thatway.png --noheadless", null, null,
446    false, false },
447    { "--open thisway.fa --image thatway.png --gui", null, null, false,
448    false },
449    { "--open thisway.fa --output thatway.png --gui", null, null, false,
450    false },
451    // --gui takes precedence
452    { "--open thisway.fa --image thatway.png --gui --headless", null,
453    null, false, false },
454    { "--open thisway.fa --output thatway.png --gui --headless", null,
455    null, false, false },
456    //
457    };
458    }
459   
 
460  2 toggle @Test(groups = "Functional", dataProvider = "argValuesData")
461    public void checkArgValues(String commandLineArgs, ArgAndValues[] avals)
462    {
463  2 String linkedId = "JALVIEW:0";
464  2 String[] args = commandLineArgs.split("\\s+");
465  2 ArgParser argparser = new ArgParser(args);
466  2 ArgValuesMap avm = argparser.getLinkedArgs(linkedId);
467   
468    // Now look at the argparser
469  2 for (ArgAndValues aval : avals)
470    {
471  4 Arg primaryArg = aval.arg;
472   
473  4 List<ArgValue> parsed_ArgValues = avm.getArgValueList(primaryArg);
474   
475  4 Assert.assertTrue(
476    areEqualSets(aval.values,
477    ArgValuesMap.toValues(parsed_ArgValues)),
478    "Primary arg (" + primaryArg.toString()
479    + ") does not have the expected values. Expected "
480    + aval.values + " and got "
481    + ArgValuesMap.toValues(parsed_ArgValues));
482   
483  8 for (int i = 0; i < parsed_ArgValues.size(); i++)
484    {
485  4 ArgValue parsed_ArgValue = parsed_ArgValues.get(i);
486  4 String value = aval.values.get(i);
487   
488  4 Console.debug(
489    "- primary arg '" + primaryArg + "' = '" + value + "'");
490   
491  4 Assert.assertEquals(parsed_ArgValue.getValue(), value,
492    "Primary arg value not as expected");
493    }
494    }
495    }
496   
 
497  1 toggle @DataProvider(name = "argValuesData")
498    public Object[][] argValuesData()
499    {
500  1 return new Object[][] {
501    /*
502    * { cmdline args },
503    * {
504    * { Primary Arg, Secondary Args },
505    * },
506    */
507    /*
508    */
509    { "--open=https://a.location/alignment.fa --structure=https://a.location/structure/file.cif",
510    new ArgAndValues[]
511    { av(Arg.OPEN, "https://a.location/alignment.fa"),
512    av(Arg.STRUCTURE,
513    "https://a.location/structure/file.cif") } },
514    { "--open=alignment.fa --structure=https://a.location/structure/file.cif",
515    new ArgAndValues[]
516    { av(Arg.OPEN, "alignment.fa"), av(Arg.STRUCTURE,
517    "https://a.location/structure/file.cif") } } };
518   
519    }
520   
 
521  2 toggle @Test(groups = "Functional", dataProvider = "argsWithinTypesData")
522    public void checkArgsWithinTypesTest(String commandLineArgs,
523    Object[] stuff)
524    {
525  2 String linkedId = "JALVIEW:0";
526  2 String[] args = commandLineArgs.split("\\s+");
527  2 ArgParser argparser = new ArgParser(args);
528  2 ArgValuesMap avm = argparser.getLinkedArgs(linkedId);
529   
530  2 ArgAndValues avals = (ArgAndValues) stuff[0];
531   
532  2 Object[] moreStuff = (Object[]) stuff[1];
533   
534  2 ArgAndValues[] subAv = (ArgAndValues[]) moreStuff[0];
535   
536  2 Object[] secondaryArgAndAuxStuff = (Object[]) stuff[2];
537   
538    // Now look at the argparser
539   
540  2 Arg primaryArg = avals.arg;
541   
542  2 List<ArgValue> parsed_ArgValues = avm.getArgValueList(primaryArg);
543   
544  2 Assert.assertTrue(
545    areEqualSets(avals.values,
546    ArgValuesMap.toValues(parsed_ArgValues)),
547    "Primary arg (" + primaryArg.toString()
548    + ") does not have the expected values. Expected "
549    + avals.values + " and got "
550    + ArgValuesMap.toValues(parsed_ArgValues));
551   
552  7 for (int i = 0; i < parsed_ArgValues.size(); i++)
553    {
554  5 ArgValue parsed_ArgValue = parsed_ArgValues.get(i);
555  5 String value = avals.values.get(i);
556   
557  5 Console.debug("- primary arg '" + primaryArg + "' = '" + value + "'");
558   
559  5 Assert.assertEquals(parsed_ArgValue.getValue(), value,
560    "Primary arg value not as expected");
561   
562  5 ArgAndValues[] aux_avals = (ArgAndValues[]) moreStuff[i];
563   
564  5 for (ArgAndValues aux_aval : aux_avals)
565    {
566  10 Arg auxArg = aux_aval.arg;
567  10 List<String> auxValues = aux_aval.values;
568   
569  10 String parsed_auxValue = avm.getFromSubValArgOrPref(auxArg,
570    ArgValuesMap.Position.AFTER, parsed_ArgValue, null, null,
571    null, null);
572   
573  10 if (auxValues.isEmpty())
574    {
575  2 Assert.assertTrue(parsed_auxValue == null,
576    "Not expecting to parse a value for '" + auxArg
577    + "' but found '" + parsed_auxValue + "'");
578    }
579   
580  10 for (String auxValue : auxValues)
581    {
582   
583  8 Console.debug("- + primary aux arg '" + auxArg + "' = '"
584    + auxValue + "'");
585   
586  8 Assert.assertEquals(parsed_auxValue, auxValue,
587    "Primary auxiliary arg (" + auxArg.toString()
588    + ") values do not match");
589   
590    }
591    }
592   
593    // Now for the secondary args
594  5 Object[] secondaryStuff = (Object[]) secondaryArgAndAuxStuff[i];
595  5 ArgAndValues secondaryArgAndValues = (ArgAndValues) secondaryStuff[0];
596  5 Arg secondaryArg = secondaryArgAndValues.arg;
597  5 List<String> secondaryValues = secondaryArgAndValues.values;
598   
599  5 List<ArgValue> parsed_secondaryArgValues = avm
600    .getArgValueListFromSubValOrArg(parsed_ArgValue, secondaryArg,
601    null);
602   
603  5 Assert.assertTrue(
604    areEqualSets(secondaryValues,
605    ArgValuesMap.toValues(parsed_secondaryArgValues)),
606    "Secondary arg (" + secondaryArg.toString()
607    + ") does not have the expected values");
608   
609  5 Object[] secondaryMoreStuff = (Object[]) secondaryStuff[1];
610   
611  18 for (int j = 0; j < parsed_secondaryArgValues.size(); j++)
612    {
613  13 ArgValue parsed_secondaryArgValue = parsed_secondaryArgValues
614    .get(j);
615  13 String secondary_value = secondaryValues.get(j);
616   
617  13 Console.debug("-- secondary arg '" + secondaryArg + "' = '"
618    + secondary_value + "'");
619   
620  13 Assert.assertEquals(parsed_secondaryArgValue.getValue(),
621    secondary_value, "Secondary arg value not as expected");
622   
623  13 ArgAndValues[] secondary_aux_avals = (ArgAndValues[]) secondaryMoreStuff[j];
624   
625  13 for (ArgAndValues secondary_aux_aval : secondary_aux_avals)
626    {
627  35 Arg secondary_auxArg = secondary_aux_aval.arg;
628  35 List<String> secondary_auxValues = secondary_aux_aval.values;
629   
630  35 String parsed_secondary_auxValue = avm.getValueFromSubValOrArg(
631    parsed_secondaryArgValue, secondary_auxArg, null);
632   
633  35 if (secondary_auxValues.isEmpty())
634    {
635  1 Assert.assertTrue(parsed_secondary_auxValue == null,
636    "Not expecting to parse a value for '"
637    + secondary_auxArg + "' but found '"
638    + parsed_secondary_auxValue + "'");
639    }
640   
641  35 for (String secondary_auxValue : secondary_auxValues)
642    {
643  34 Console.debug("-- + secondary aux arg '" + secondary_auxArg
644    + "' for value '" + secondary_auxValue + "'");
645   
646  34 Assert.assertEquals(parsed_secondary_auxValue,
647    secondary_auxValue,
648    "Secondary auxiliary arg ("
649    + secondary_auxArg.toString()
650    + ") values do not match");
651    }
652    }
653    }
654    }
655    }
656   
 
657  1 toggle @DataProvider(name = "argsWithinTypesData")
658    public Object[][] argsWithinTypesData()
659    {
660  1 return new Object[][] {
661    /*
662    * { cmdline args },
663    * {
664    * { Primary Arg, Secondary Args },
665    * { { Secondary Arg => { Values } } }
666    * },
667    */
668    /*
669    */
670   
671    { //
672    // commandLineArgs
673    "--open=alignment.fa --structure=structure0.pdb"
674    // structureimage0a and structureimage args
675    + " --structureimage=image0a.png --bgcolour=bg0a --imagecolour=col0a"
676    // structureimage0b and structureimage args
677    + " --structureimage=image0b.png --bgcolour=bg0b --imagecolour=col0b"
678    // more structure args
679    + " --structureviewer=sv0 --paematrix=pae0" //
680    // structure1
681    + " --structure=structure1.pdb"
682    // structure args
683    + " --structureviewer=sv1 --paematrix=pae1"
684    // structureimage1a with NO structureimage args
685    // (see `--all --bgcolour=pineapple` later)
686    + " --structureimage=image1a.png"
687    // structureimage1b and structureimage args
688    + " --structureimage=image1b.png --bgcolour=bg1b --imagecolour=col1b"
689    // --all args, should apply to structureimage1a only
690    + " --all --bgcolour=pineapple" //
691    ,
692    // stuff
693    new Object[]
694    {
695    // avals (0) and (1)
696    av(Arg.STRUCTURE, "structure0.pdb", "structure1.pdb"),
697    // moreStuff (0) and (1)
698    new ArgAndValues[][]
699    { //
700    { av(Arg.STRUCTUREVIEWER, "sv0"),
701    av(Arg.PAEMATRIX, "pae0") },
702    { av(Arg.STRUCTUREVIEWER, "sv1"),
703    av(Arg.PAEMATRIX, "pae1") } //
704    },
705    // secondaryArgAndAuxStuff
706    // (same size as values of avals)
707    new Object[][]
708    {
709    // secondaryStuff (0)
710    {
711    // secondaryArgAndValues (a) and (b)
712    av(Arg.STRUCTUREIMAGE, "image0a.png",
713    "image0b.png"),
714    // secondaryMoreStuff
715    // (same size as values of secondaryArgAndValues)
716    new ArgAndValues[][]
717    {
718    // secondary_aux_avals (a)
719    { av(Arg.BGCOLOUR, "bg0a"),
720    av(Arg.IMAGECOLOUR, "col0a") },
721    // secondary_aux_avals (b)
722    { av(Arg.BGCOLOUR, "bg0b"),
723    av(Arg.IMAGECOLOUR, "col0b") }, //
724    }, //
725    },
726    // secondaryStuff (1)
727    {
728    // secondaryArgAndValues (a) and (b)
729    av(Arg.STRUCTUREIMAGE, "image1a.png",
730    "image1b.png"),
731    // secondaryMoreStuff
732    new ArgAndValues[][]
733    {
734    // secondary_aux_avals (a)
735    { av(Arg.BGCOLOUR, "pineapple"),
736    av(Arg.IMAGECOLOUR) },
737    // secondary_aux_avals (b)
738    { av(Arg.BGCOLOUR, "bg1b"),
739    av(Arg.IMAGECOLOUR, "col1b") }, //
740    }, //
741    }, //
742    } //
743    } //
744    }, //
745    { //
746    "--open=alignment.fa --wrap --colour=gecose-flower"
747    // structure0
748    + " --structure=structure0.pdb"
749    + " --structureimage=image0a.png --bgcolour=bg0a --scale=3"
750    + " --structureimage=image0b.png --imagecolour=col0b --scale=4"
751    + " --structureviewer=sv0 --paematrix=pae0" //
752    + " --structureimage=image0c.png"
753    // structure1
754    + " --structure=structure1.pdb"
755    + " --structureviewer=sv1 --paematrix=pae1"
756    + " --structureimage=image1a.png"
757    + " --structureimage=image1b.png --bgcolour=bg1b --imagecolour=col1b"
758    + " --structureimage=image1c.png --bgcolour=bg1c --imagecolour=col1c --scale=5"
759    + " --structureimage=image1d.png --imagecolour=col1d --scale=6"
760    + " --structureimage=image1e.png --bgcolour=bg1e"
761    // structure2
762    + " --structure=structure2.pdb"
763    + " --structureimage=image2a.png --bgcolour=bg2a --scale=23"
764    + " --all --bgcolour=pineapple --imagecolour=banana --scale=2" //
765    ,
766    // stuff
767    new Object[]
768    { av(Arg.STRUCTURE, "structure0.pdb", "structure1.pdb",
769    "structure2.pdb"),
770    new ArgAndValues[][]
771    { //
772    { av(Arg.STRUCTUREVIEWER, "sv0"),
773    av(Arg.PAEMATRIX, "pae0") },
774    { av(Arg.STRUCTUREVIEWER, "sv1"),
775    av(Arg.PAEMATRIX, "pae1") },
776    { av(Arg.STRUCTUREVIEWER), av(Arg.PAEMATRIX) } //
777    }, //
778    new Object[][]
779    { //
780    { //
781    av(Arg.STRUCTUREIMAGE, "image0a.png", "image0b.png",
782    "image0c.png"), //
783    new ArgAndValues[][]
784    { //
785    { av(Arg.BGCOLOUR, "bg0a"),
786    av(Arg.IMAGECOLOUR, "banana"),
787    av(Arg.SCALE, "3") },
788    { av(Arg.BGCOLOUR, "pineapple"),
789    av(Arg.IMAGECOLOUR, "col0b"),
790    av(Arg.SCALE, "4") },
791    { av(Arg.BGCOLOUR, "pineapple"),
792    av(Arg.IMAGECOLOUR, "banana"),
793    av(Arg.SCALE, "2") }, //
794    }, //
795    }, //
796    { //
797    av(Arg.STRUCTUREIMAGE, "image1a.png", "image1b.png",
798    "image1c.png", "image1d.png",
799    "image1e.png"),
800    new ArgAndValues[][]
801    { //
802    { av(Arg.BGCOLOUR, "pineapple"),
803    av(Arg.IMAGECOLOUR, "banana"),
804    av(Arg.SCALE, "2") },
805    { av(Arg.BGCOLOUR, "bg1b"),
806    av(Arg.IMAGECOLOUR, "col1b"),
807    av(Arg.SCALE, "2") },
808    { av(Arg.BGCOLOUR, "bg1c"),
809    av(Arg.IMAGECOLOUR, "col1c"),
810    av(Arg.SCALE, "5") },
811    { av(Arg.BGCOLOUR, "pineapple"),
812    av(Arg.IMAGECOLOUR, "col1d"),
813    av(Arg.SCALE, "6") },
814    { av(Arg.BGCOLOUR, "bg1e"),
815    av(Arg.IMAGECOLOUR, "banana"),
816    av(Arg.SCALE, "2") } //
817    }, //
818    }, //
819    { //
820    av(Arg.STRUCTUREIMAGE, "image2a.png"),
821    new ArgAndValues[][]
822    { //
823    { av(Arg.BGCOLOUR, "bg2a"),
824    av(Arg.IMAGECOLOUR, "banana"),
825    av(Arg.SCALE, "23") }, //
826    }, //
827    }, //
828    } //
829    } //
830    } //
831    };
832    }
833   
 
834  56 toggle protected ArgAndValues av(Arg a, String... vals)
835    {
836  56 return new ArgAndValues(a, vals);
837    }
838   
 
839    protected class ArgAndValues
840    {
841    protected Arg arg;
842   
843    protected List<String> values;
844   
 
845  56 toggle ArgAndValues(Arg a, String... vals)
846    {
847  56 arg = a;
848  56 values = vals == null ? new ArrayList<String>() : Arrays.asList(vals);
849    }
850   
 
851  336 toggle @Override
852    public String toString()
853    {
854  336 StringBuilder sb = new StringBuilder();
855  336 sb.append(arg.argString());
856  336 sb.append("\n");
857  336 sb.append(Strings.join(values, ','));
858  336 sb.append("\n");
859  336 return sb.toString();
860    }
861    }
862   
 
863  0 toggle private static boolean areEqualSets(String[] strArray,
864    List<String> strList)
865    {
866  0 return areEqualSets(Arrays.asList(strArray), strList);
867    }
868   
 
869  11 toggle private static boolean areEqualSets(List<String> l1, List<String> l2)
870    {
871  11 if (l1 == null && l2 == null)
872    {
873  0 Console.info(
874    "Comparing null lists, should be okay but you might want to know");
875  0 return true;
876    }
877  11 if (l1 == null || l2 == null)
878    {
879  0 return false;
880    }
881  11 return new HashSet<String>(l1).equals(new HashSet<String>(l2));
882    }
883   
884    }
  • Report generated by OpenClover v 4.4.1 on Thu Nov 27 2025 17:17:47 GMT using coverage data from Thu Nov 27 2025 17:17:32 GMT.
  • OpenClover is free and open-source software.