xan/awips2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Issue #2208 move remainder of unit-tests to tests project, disable building ones dependent on eclipse/swt, ignore ones that are failing

Browse source 
Change-Id: I49467fe6e9425a73985f729bc1ea4b10eb139c16

Former-commit-id: cf656dddc6 [formerly a53ff5142d15461a595adb8a6e8d6b96aee3a878]
Former-commit-id: d364cfe32e
This commit is contained in:
Nate Jensen 2013-07-25 14:59:01 -05:00
parent 8f168b281b
commit dc7c2fd063
160 changed files with 14229 additions and 11182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
RadarServer/com.raytheon.rcm.server/.classpath
View file

@ -1,7 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" output="test-bin" path="test"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="output" path="bin"/>

3
RadarServer/com.raytheon.rcm.server/META-INF/MANIFEST.MF
View file

@ -18,5 +18,4 @@ Require-Bundle: com.raytheon.rcm.lib;bundle-version="1.0.0",
org.quartz;bundle-version="1.8.6"
Import-Package: com.raytheon.uf.common.util,
org.apache.commons.logging,
org.apache.log4j,
org.junit
org.apache.log4j

1
cave/com.raytheon.viz.core.gl/.classpath
View file

@ -1,7 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" output="testbin" path="test"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="output" path="bin"/>

4
cave/com.raytheon.viz.core.gl/META-INF/MANIFEST.MF
View file

@ -35,7 +35,5 @@ Import-Package: com.raytheon.uf.common.status,
com.raytheon.uf.viz.core.preferences,
com.raytheon.uf.viz.core.rsc,
com.raytheon.uf.viz.core.rsc.hdf5,
com.raytheon.uf.viz.core.status,
junit.framework,
org.junit
com.raytheon.uf.viz.core.status
Bundle-RequiredExecutionEnvironment: JavaSE-1.6

1
cave/com.raytheon.viz.gfe/.classpath
View file

@ -1,7 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="tests"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="output" path="bin"/>

3
cave/com.raytheon.viz.gfe/META-INF/MANIFEST.MF
View file

@ -70,6 +70,5 @@ Import-Package: com.raytheon.edex.meteoLib,
org.eclipse.jdt.ui;resolution:=optional,
org.eclipse.jface.text;resolution:=optional,
org.eclipse.jface.text.contentassist;resolution:=optional,
org.eclipse.ui.texteditor.spelling;resolution:=optional,
org.junit
org.eclipse.ui.texteditor.spelling;resolution:=optional
Bundle-RequiredExecutionEnvironment: JavaSE-1.6

1
ncep/gov.noaa.nws.ncep.gempak.parameterConversionLibrary/.classpath
View file

@ -3,6 +3,5 @@
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="unit-test"/>
<classpathentry kind="output" path="bin"/>
</classpath>

3
ncep/gov.noaa.nws.ncep.gempak.parameterConversionLibrary/META-INF/MANIFEST.MF
View file

@ -6,5 +6,4 @@ Bundle-Version: 1.0.0.qualifier
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Export-Package: gov.noaa.nws.ncep.gempak.parameterconversionlibrary
Import-Package: gov.noaa.nws.ncep.edex.common.sounding,
org.junit
Import-Package: gov.noaa.nws.ncep.edex.common.sounding

4022
ncep/gov.noaa.nws.ncep.gempak.parameterConversionLibrary/unit-test/gov/noaa/nws/ncep/gempak/parameterConversionLibrary/PRLibraryTest.java
View file

File diff suppressed because it is too large Load diff

1
ncep/gov.noaa.nws.ncep.gempak.parameters.core/.classpath
View file

@ -3,6 +3,5 @@
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="unit_test"/>
<classpathentry kind="output" path="bin"/>
</classpath>

1
ncep/gov.noaa.nws.ncep.gempak.parameters.core/META-INF/MANIFEST.MF
View file

@ -4,7 +4,6 @@ Bundle-Name: Core
Bundle-SymbolicName: gov.noaa.nws.ncep.gempak.parameters.core
Bundle-Version: 1.0.0.qualifier
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: org.junit
Export-Package: gov.noaa.nws.ncep.gempak.parameters.core.categorymap,
gov.noaa.nws.ncep.gempak.parameters.core.contourinterval,
gov.noaa.nws.ncep.gempak.parameters.core.marshaller.garea,

376
ncep/gov.noaa.nws.ncep.gempak.parameters.core/unit_test/gov/noaa/nws/ncep/gempak/parameters/core/categorymap/CATMAPTest.java
View file

@ -1,376 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.core.categorymap;
import org.junit.Assert;
import org.junit.Test;
/**
* <pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 16-Nov-2009 194 Archana.S Initial Creation
* 20-Nov-2009 194 Archana.S Updated per review comments:
* Added a test-case to retrieve the label
* given a value
* Updated method names per design changes in the class
* CATMAP
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
*
* </pre>
*
* @author Archana.S
* @version 1
* <p>
* {@link gov.noaa.nws.ncep.gempak.parameters.core.categorymap.CatMap}.
*/
public class CATMAPTest {
private static int testCaseNumber;
private static final double ALLOWABLE_DOUBLE_DELTA = 0.0001;
/**
*Test for valid label/value pair
*/
@Test
public void testGetValueForLabel() {
testCaseNumber=1;
CatMap catmap = new CatMap("ABC=4;acd=2;lmn=0.5");
assertEquals(catmap.getMatchingValueForLabel("abc"),4.0);
assertEquals(catmap.getMatchingValueForLabel("ABC"),4.0);
assertEquals(catmap.getMatchingValueForLabel("LmN"),0.5);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for valid label/value pairs without wild-card");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label abc = "+ catmap.getMatchingValueForLabel("abc"));
System.out.println("The value for label LmN = "+ catmap.getMatchingValueForLabel("LmN"));
testCaseNumber++;
}
/**
* @param val1
* @param expected
*/
private void assertEquals(Float val1, double expected) {
Assert.assertEquals(expected, val1.doubleValue(),
ALLOWABLE_DOUBLE_DELTA);
}
/**
* Test to retrieve matching label given a floating point value
*/
@Test
public void testGetLabelForValue() {
CatMap catmap = new CatMap("ABC=4;acd=2;lmn=0.5;efg=2;hij=2");
Assert.assertEquals(catmap.getMatchingLabelForValue(0.5f), "lmn");
Assert.assertEquals(catmap.getMatchingLabelForValue(4f), "ABC");
Assert.assertEquals(catmap.getMatchingLabelForValue(2f), "acd");
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for getting the matching label, given a floating point value");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The label for the value 4 = "+ catmap.getMatchingLabelForValue(4f));
System.out.println("The label for the value 0.5 = "+ catmap.getMatchingLabelForValue(0.5f));
System.out.println("The label for the value 2 = "+ catmap.getMatchingLabelForValue(2f));
testCaseNumber++;
}
/**
*Test to retrieve the label for a floating point value not in the list
*/
@Test
public void testGetLabelForNonExistentValue() {
CatMap catmap = new CatMap("ABC=4;acd=2;lmn=0.5;efg=2;hij=2");
Assert.assertNull(catmap.getMatchingLabelForValue(0.00005f));
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for getting the matching label, given a floating point value not in the list");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The label for the value 0.00005 = "+ catmap.getMatchingLabelForValue(0.00005f));
testCaseNumber++;
}
/**
*Test for valid label with a wild-card character
*/
@Test
public void testGetValueForWildcardLabel() {
CatMap catmap = new CatMap("Abc=4;a*=0.5;acd=2");
assertEquals(catmap.getMatchingValueForLabel("abc"),4.0);
assertEquals(catmap.getMatchingValueForLabel("ACD"),0.5);
assertEquals(catmap.getMatchingValueForLabel("A*"),0.5);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for valid label/value pairs with a wild-card label included");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label aCD = "+ catmap.getMatchingValueForLabel("aCD"));
System.out.println("The value for label a = "+ catmap.getMatchingValueForLabel("a"));
testCaseNumber++;
}
/**
*Test CATMAP String with invalid delimiters
*/
@Test
public void testInvalidDelimiter() {
CatMap catmap = new CatMap("Abc=4:a*=0.5:acd=2");
assertEquals(catmap.getMatchingValueForLabel("abc"),Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("ACD"),Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("A*"),Float.NaN);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for invalid delimiters");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label aCD = "+ catmap.getMatchingValueForLabel("aCD"));
System.out.println("The value for label a = "+ catmap.getMatchingValueForLabel("a"));
testCaseNumber++;
}
/**
* Test CATMAP String without '=' character between label/value pairs
*/
@Test
public void testCATMAPStringWithoutEqualToSign() {
CatMap catmap = new CatMap("Abc-4;a*-0.5;acd+2");
assertEquals(catmap.getMatchingValueForLabel("abc"),Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("ACD"),Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("A*"),Float.NaN);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for missing '=' character");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label aCD = "+ catmap.getMatchingValueForLabel("aCD"));
System.out.println("The value for label a = "+ catmap.getMatchingValueForLabel("a"));
testCaseNumber++;
}
/**
* Test empty CATMAP String
*/
@Test
public void testEmptyCATMAPString(){
CatMap catmap = new CatMap("");
System.out.println("\n=====================Test-Case "+testCaseNumber+"a ========================");
System.out.println("Test for empty input string");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label \"\" = "+ catmap.getMatchingValueForLabel(""));
CatMap catmap3 = new CatMap(null);
System.out.println("\n=====================Test-Case "+testCaseNumber+"b ========================");
System.out.println("Test for null string");
System.out.println("The input string = "+catmap3.getCategoricalMappingString());
System.out.println("The value for null string = "+ catmap3.getMatchingValueForLabel(null));
CatMap catmap4 = new CatMap(" ");
System.out.println("\n=====================Test-Case "+testCaseNumber+"c ========================");
System.out.println("Test for string with only blanks");
System.out.println("The input string = "+catmap4.getCategoricalMappingString());
System.out.println("The value for string with only blanks= "+ catmap4.getMatchingValueForLabel(" "));
testCaseNumber++;
}
/**
* Test CATMAP String with a missing label
*/
@Test
public void testMissingLabel(){
CatMap catmap = new CatMap("Abc=4;bingo=-0.5; =2");
assertEquals(catmap.getMatchingValueForLabel("abc"),4.0);
assertEquals(catmap.getMatchingValueForLabel("bINgO"),-0.5);
assertEquals(catmap.getMatchingValueForLabel(" "),Float.NaN);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for missing Label");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "+ catmap.getMatchingValueForLabel("bINgO"));
System.out.println("The value for the missing label= "+ catmap.getMatchingValueForLabel(" "));
testCaseNumber++;
}
/**
* Test CATMAP String with a missing value
*/
@Test
public void testMissingValue(){
CatMap catmap = new CatMap("Abc= ;bingo=-.5;label3=2");
assertEquals(catmap.getMatchingValueForLabel("abc"),Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("bINgO"),-0.5);
assertEquals(catmap.getMatchingValueForLabel("label3"),2);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for missing value");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "+ catmap.getMatchingValueForLabel("bINgO"));
System.out.println("The value for the label3= "+ catmap.getMatchingValueForLabel("label3"));
testCaseNumber++;
}
/**
* Test CATMAP string with a missing label and a missing value
*/
@Test
public void testMissingValueAndLabel(){
CatMap catmap = new CatMap("Abc=99.99999; = ;bingo=-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"),99.99999);
assertEquals(catmap.getMatchingValueForLabel("bINgO"),-0.5);
assertEquals(catmap.getMatchingValueForLabel(" "),Float.NaN);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for missing label and value");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "+ catmap.getMatchingValueForLabel("bINgO"));
System.out.println("The value for the missing label= "+ catmap.getMatchingValueForLabel(" "));
testCaseNumber++;
}
/**
* Test CATMAP string with missing label/value pairs
*/
@Test
public void testMissingLabelValuePairs(){
CatMap catmap = new CatMap("Abc=99.99999;;;;bingo=-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"),99.99999);
assertEquals(catmap.getMatchingValueForLabel("bINgO"),-0.5);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test with missing label/value pairs");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "+ catmap.getMatchingValueForLabel("bINgO"));
testCaseNumber++;
}
/**
* Test CATMAP string with non-numeric data for value
*/
@Test
public void testNonNumericDataForValue(){
CatMap catmap = new CatMap("Abc=99acd.99999;bingo=-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"),Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("bINgO"),Float.NaN);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for non-numeric characters in the value");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "+ catmap.getMatchingValueForLabel("bINgO"));
testCaseNumber++;
}
/**
* Test CATMAP string with multiple '=' characters
*/
@Test
public void testMultipleEqualToCharaters(){
CatMap catmap = new CatMap("Abc=99;bingo==-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"),99);
assertEquals(catmap.getMatchingValueForLabel("bINgO"),Float.NaN);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for multiple '=' characters");
System.out.println("The input string = "+catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bingo = "+ catmap.getMatchingValueForLabel("bingo"));
testCaseNumber++;
}
/**
* Test CATMAP string with labels containing punctuation symbols
*/
@Test
public void testLabelWithPunctuationSymbols(){
CatMap catmap = new CatMap("@!'Ab#c=99;@#$%^=19.08");
assertEquals(catmap.getMatchingValueForLabel("@!'Ab#c"),99);
assertEquals(catmap.getMatchingValueForLabel("@#$%^"),19.08);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for labels containing punctuation symbols");
System.out.println("The input string = "+catmap.getCategoricalMappingString()+"\n");
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("@!'Ab#c"));
System.out.println("The value for label bINgO = "+ catmap.getMatchingValueForLabel("@#$%^"));
testCaseNumber++;
}
/**
* Test valid CATMAP string with blanks between labels and values
*/
@Test
public void testCATMAPStringWithBlanksBetweenLabelsAndValues(){
CatMap catmap = new CatMap(" @!'Ab#c = 99 ; @#$%^ = 19.08 ");
assertEquals(catmap.getMatchingValueForLabel("@!'Ab#c"),99);
assertEquals(catmap.getMatchingValueForLabel("@#$%^"),19.08);
System.out.println("\n=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Test for string containing blanks between labels and values");
System.out.println("The input string = "+catmap.getCategoricalMappingString()+"\n");
System.out.println("The value for label ABC = "+ catmap.getMatchingValueForLabel("@!'Ab#c"));
System.out.println("The value for label bINgO = "+ catmap.getMatchingValueForLabel("@#$%^"));
testCaseNumber++;
}
}

713
ncep/gov.noaa.nws.ncep.gempak.parameters.core/unit_test/gov/noaa/nws/ncep/gempak/parameters/core/contourinterval/CINTTest.java
View file

@ -1,713 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.core.contourinterval;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
/**
*<pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 12-Nov-2009 174 Archana.S Initial Creation
* 10-Jun-2010 174 Archana.S Added assertion to check that
* the list of String equivalents for the contour
* values is generated correctly.
* 15-Jun-2010 174 Archana.S Updated test-cases per changes in the code design
* 02-Aug-2010 174 Archana.S Updated test-cases per changes in the code design
* </pre>
* @author Archana.S
* @version 1
*/
public class CINTTest {
private static final double ALLOWABLE_DOUBLE_DELTA = 0.0001;
private static int testCaseNumber;
private List<Double> testList;
private List<Double> testList2;
private List<Double> keySetList;
List<String> contourValuesList;
@Test
/* Test for valid fill contour string of the form contourInterval/minContourValue/maxContourValue */
public void testPositiveContourIntervalWithMinMaxValues(){
testCaseNumber = 1;
CINT cint = new CINT("10/0.5/9");
assertEquals(cint.isCINTStringParsed(),true);
testList = new ArrayList<Double>(Arrays.asList(0.5, 9.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 0.5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 9, ALLOWABLE_DOUBLE_DELTA);
assertEquals(
cint.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL).intValue(), 0);
System.out.println("=====================Test-Case "+testCaseNumber+"a ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
System.out.println("The contour interval: " + cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The minimum contour value: " + cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The maximum contour value: " + cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
CINT cint2 = new CINT(" 10 / -57 / 86 / 4 ");
assertEquals(cint2.isCINTStringParsed(),true);
testList2 = new ArrayList<Double>(Arrays.asList(-50.0, -40.0, -30.0, -20.0, -10.0, 0.0, 10.0,
20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0));
keySetList = cint2.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(testList2,keySetList);
assertEquals(cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -57, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 86, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL)
.intValue(), 4);
System.out.println("=====================Test-Case "+testCaseNumber+"b ========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint2.isCINTStringParsed());
contourValuesList = cint2.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
System.out.println("The contour interval: " + cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The minimum contour value: " + cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The maximum contour value: " + cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for valid contour data string of the form contourInterval/minContourValue/maxContourValue
* with a negative contourInterval
* */
public void testNegativeContourIntervalWithMinMaxValues(){
CINT cint = new CINT("-5/-11/23");
assertEquals(cint.isCINTStringParsed(),true);
testList = new ArrayList<Double>(Arrays.asList(-10.0, -5.0, 0.0, 5.0, 10.0, 15.0, 20.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/*Test for valid contour value string of the form val1;val2;val3;val4..... */
public void testValidContourLevelValuesString(){
CINT cint = new CINT("66.1;0.1;5000;76;-.999;12233459390;0.00009988;1234.567890");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0, 76.0, -0.999,
1.223345939E10, 9.988E-5, 1234.56789));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/*Test for valid contour value string of the form val1 ; val2 ; val3 */
public void testValidContourLevelValuesStringWithBlanks(){
CINT cint = new CINT(" 66.1 ; 0.1 ; 5000 ");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/*Test for valid contour string of the form contourInterval/minContourValue/ */
public void testContourIntervalWithMinValueOnly(){
CINT cint = new CINT("-0.345/0/");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -0.345, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 0, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid contour data string of the form contourInterval//maxContourValue */
public void testContourIntervalWithMaxValueOnly(){
CINT cint = new CINT("15//30");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 15, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 30, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
public void testCINTWithOnlyContourIntervalSpecified(){
CINT cint = new CINT("-0.5/");
assertEquals(cint.isCINTStringParsed(),true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -0.5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case "+testCaseNumber+"a ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
CINT cint2 = new CINT("-.89//");
assertEquals(cint2.isCINTStringParsed(),true);
assertEquals(cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -0.89, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case "+testCaseNumber+"b ========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint2.isCINTStringParsed());
System.out.println("Contour Interval = "+cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid contour data string of the form /minContourValue/maxContourValue */
public void testContourIntervalWithNoContourIntervalAndWithMinMaxValueOnly(){
CINT cint = new CINT("/10/30");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 30, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid contour data string of the form /minContourValue/maxContourValue */
public void testContourIntervalWithMinValSameAsMaxValAndNoContourIntervalSpecified(){
CINT cint = new CINT("/10/10");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(10.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/*Test input string containing a single contour value */
public void testLessNumArgsContourIntervalString(){
CINT cint = new CINT("-0.6");
assertEquals(cint.isCINTStringParsed(),true);
testList = new ArrayList<Double>(Arrays.asList(-0.6));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
// assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"a ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("The contour interval is: " + cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = " + contourValuesList);
CINT cint2 = new CINT("0.7;");
assertEquals(cint2.isCINTStringParsed(),true);
testList2 = new ArrayList<Double>(Arrays.asList(0.7));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
// assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"b ========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint2.isCINTStringParsed());
System.out.println("The contour interval is: " + cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint2.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = " + contourValuesList);
testCaseNumber++;
}
@Test
/*Test for contour data string of the form contourInterval/minContourValue/maxContourValue/extraNumbers/extraNumbers/extraNumbers*/
public void testExtraNumArgsContourIntervalString(){
CINT cint = new CINT("20/10/70/30/40/500");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 20, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 70, ALLOWABLE_DOUBLE_DELTA);
//
testList = new ArrayList<Double>(Arrays.asList(10.0, 30.0, 50.0, 60.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/*Test for non-numeric values in contour interval string*/
public void testNonNumericContourIntervalString(){
CINT cint = new CINT("-def/abc/%^&/30/40");
assertEquals(cint.isCINTStringParsed(), false);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test contour interval string with invalid delimiters*/
public void testInvalidDelimitersInContourIntervalString(){
CINT cint = new CINT("5.10.60.9");
assertEquals(cint.isCINTStringParsed(), false);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = "+cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test contour interval string by interchanging minContourValue and maxContourValue */
public void testMinMaxValuesInterchangedContourIntervalString(){
CINT cint = new CINT("-5/20/5");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 20, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"a========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = " + cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = " + cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = " + cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = " + contourValuesList);
CINT cint2 = new CINT("5/20/5");
assertEquals(cint2.isCINTStringParsed(), true);
assertEquals(cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 20, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
// assertEquals(cint2.getContourValuesList(),testList);
System.out.println("=====================Test-Case "+testCaseNumber+"b========================");
System.out.println("The input string = "+cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint2.isCINTStringParsed());
System.out.println("Contour Interval = "+cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "+cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "+cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Contour Values List = "+cint2.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for non-numeric vales in contour values' string*/
public void testInvalidContourLevelValuesString(){
CINT cint = new CINT("66.1;abc;5000;76;;@#$%;12233459390");
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
testCaseNumber++;
}
@Test
/*Test for invalid delimiters in contour values' string */
public void testInvalidDelimiterContourValuesString(){
CINT cint = new CINT("66.1,0,1,5000,76,-.999,12233459390");
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
testCaseNumber++;
}
@Test
/*Test for empty contour data string*/
public void testEmptyString(){
CINT cint = new CINT();
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"a========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
CINT cint2 = new CINT("");
assertEquals(cint2.isCINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"b========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint2.isCINTStringParsed());
CINT cint3 = new CINT(null);
assertEquals(cint3.isCINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"c========================");
System.out.println("The input string = " + cint3.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint3.isCINTStringParsed());
testCaseNumber++;
}
@Test
/*Test for contour data string with blank-spaces*/
public void testContourDataStringWithBlankSpaces(){
CINT cint = new CINT(" ");
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
testCaseNumber++;
}
@Test
/*Test contour interval string by interchanging minContourValue and maxContourValue */
public void testSingleLabelledContourIntervalString(){
CINT cint = new CINT("5=good/5/5");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 0, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(5.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("Contour Interval = " + cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = " + cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = " + cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = " + contourValuesList);
testCaseNumber++;
}
@Test
/*Test contour interval string by interchanging minContourValue and maxContourValue */
public void testLabelledContourIntervalStrings(){
CINT cint = new CINT("10=ab;35=sdnf");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(10.0,35.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("HashMap for labeled contour string = " + cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test contour interval string of the form:
*contourInterval/minimumContourValue/maximumContourValue/numPaddingDigits*/
public void testCINTStringWithNumPaddingDigits(){
// CINT cint = new CINT("1/2/10/3");
CINT cint = new CINT("1/2/10/3 > 4/2/18");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 1, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 2, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 3, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("The input string = "+ cint. getUserInputString());
System.out.println("The parsed input string at first zoom level = "+ cint. getCINTString(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Contour Interval = " + cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = " + cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = " + cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum number of digits in label = " + cint.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL));
List<Double>contourList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
System.out.println("Contour values list as double= " + contourList);
System.out.println("Set of contour values with padding digits = " + cint.getContourLabelsForZoomLevel(CINT.FIRST_ZOOM_LEVEL));
System.out.println("HashMap at first zoom level = " + cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The parsed input string at second zoom level = "+ cint. getCINTString(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Contour Interval = " + cint.getContourInterval(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = " + cint.getMinContourValue(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = " + cint.getMaxContourValue(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Minimum number of digits in label = " + cint.getNumPaddingDigits(CINT.SECOND_ZOOM_LEVEL));
System.out.println("HashMap at second zoom level = " + cint.getCintHashMap(CINT.SECOND_ZOOM_LEVEL));
contourList = new ArrayList<Double> (cint.getContourValuesListAsDouble(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Contour values list as double= " + contourList);
testCaseNumber++;
}
/*
* Test contour interval string with multiple zoom levels
*/
@Test
public void testCINTMultipleZoomLevels(){
CINT cint = new CINT("2/-6/6/3 > 30;50;80 > 60=abc; 80=def > 0.00009999 > 0.0000001;");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0,-2.0, 0.0, 2.0, 4.0, 6.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(testList,keySetList);
testList = new ArrayList<Double>(Arrays.asList(30.0,50.0,80.0));
keySetList = cint.getContourValuesListAsDouble(CINT.SECOND_ZOOM_LEVEL);
assertEquals(testList,keySetList);
testList = new ArrayList<Double>(Arrays.asList(60.0,80.0));
keySetList = cint.getContourValuesListAsDouble(CINT.THIRD_ZOOM_LEVEL);
assertEquals(testList,keySetList);
assertEquals(0.00009999, cint
.getContourInterval(CINT.FOURTH_ZOOM_LEVEL).doubleValue(),
ALLOWABLE_DOUBLE_DELTA);
assertEquals(0.0000001, cint.getContourInterval(CINT.FIFTH_ZOOM_LEVEL)
.doubleValue(), ALLOWABLE_DOUBLE_DELTA);
// testList = new ArrayList<Double>(Arrays.asList(0.00009999));
// keySetList = cint.getContourValuesListAsDouble(CINT.FOURTH_ZOOM_LEVEL);
// assertEquals(testList,keySetList);
// testList = new ArrayList<Double>(Arrays.asList(0.0000001));
// keySetList = cint.getContourValuesListAsDouble(CINT.FIFTH_ZOOM_LEVEL);
assertEquals(testList,keySetList);
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 30.0, 50.0, 60.0, 80.0));
keySetList = cint.getUniqueSortedContourValuesFromAllZoomLevels();
assertEquals(testList,keySetList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("The HashMap at 1st zoom level"+ cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The HashMap at 2nd zoom level"+ cint.getCintHashMap(CINT.SECOND_ZOOM_LEVEL));
System.out.println("The HashMap at 3rd zoom level"+ cint.getCintHashMap(CINT.THIRD_ZOOM_LEVEL));
System.out.println("The HashMap at 4th zoom level"+ cint.getCintHashMap(CINT.FOURTH_ZOOM_LEVEL));
System.out.println("The HashMap at 5th zoom level"+ cint.getCintHashMap(CINT.FIFTH_ZOOM_LEVEL));
System.out.println("The unique contour values sorted in ascending order: "+ cint.getUniqueSortedContourValuesFromAllZoomLevelsAsString());
}
/*
* Test contour interval string with more than 5 zoom levels (currently 5 is the maximum)
*/
@Test
public void testCINTWithMoreThanFiveZoomLevels(){
CINT cint = new CINT("2/-6/6/3 > 30;50;80 > 60=abc; 80=def > 0.00009999 > 0.0000001;1.2 > 90=GoodLuck > 100;200;300;400");
testList = new ArrayList<Double>(Arrays.asList(0.0000001,1.2));
keySetList = cint.getContourValuesListAsDouble(CINT.MAX_ZOOM_LEVEL);
assertEquals(testList,keySetList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? " + cint.isCINTStringParsed());
System.out.println("The HashMap at 1st zoom level"+ cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The HashMap at 2nd zoom level"+ cint.getCintHashMap(CINT.SECOND_ZOOM_LEVEL));
System.out.println("The HashMap at 3rd zoom level"+ cint.getCintHashMap(CINT.THIRD_ZOOM_LEVEL));
System.out.println("The HashMap at 4th zoom level"+ cint.getCintHashMap(CINT.FOURTH_ZOOM_LEVEL));
System.out.println("The HashMap at 5th zoom level"+ cint.getCintHashMap(CINT.FIFTH_ZOOM_LEVEL));
}
/*
* Test contour interval string with multiple zoom levels, some of which are invalid
*/
@Test
public void testCINTWithInvalidZoomLevels() throws IndexOutOfBoundsException{
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+"2/-6/6/3 > > 60=abc; 80=def > > ");
CINT cint = new CINT("2/-6/6/3 > > 60=abc; 80=def > > ");
System.out.println( "Is CINT String parsed correctly? " + cint.isCINTStringParsed());
}
}

504
ncep/gov.noaa.nws.ncep.gempak.parameters.core/unit_test/gov/noaa/nws/ncep/gempak/parameters/core/marshaller/garea/GraphicsAreaCoordinatesTest.java
View file

@ -1,504 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.core.marshaller.garea;
import static org.junit.Assert.*;
import gov.noaa.nws.ncep.gempak.parameters.core.marshaller.garea.GraphicsAreaCoordinates;
import org.junit.Test;
/**
* <pre>
*
* SOFTWARE HISTORY
*
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 29-Sep-2009 171 Archana Initial Version
*
* </pre>
* @author Archana
* @version 1
*/
/**
* This junit test file tests the methods in the class GraphicsAreaCoordinates.
*/
public class GraphicsAreaCoordinatesTest {
private boolean flag;
private String error_msg;
@Test
//Test that all Latitude/Longitude values can be set to 0
public void testAllZeroLatLon(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("0;0;0;0");
flag = gac.isGraphicsAreaStringValid();
if(flag == true){
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0],0.0f);
assertEquals(lat_lon[1],0.0f);
assertEquals(lat_lon[2],0.0f);
assertEquals(lat_lon[3],0.0f);
assertEquals(lat_lon[4],0.0f);
assertEquals(lat_lon[5],0.0f);
}
}
@Test
// Test that Lower Left Latitude is not <-91 or > 90
public void testLowerLeftLatOutOfBounds(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("-90.1;0;20;40");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Lower Left Latitude can only take values between -90.00 and 90.00", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Lower Left Latitude can only take values between -90.00 and 90.00");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("90.1;0;90.0;40");
flag = gac2.isGraphicsAreaStringValid();
assertFalse("Lower Left Latitude can only take values between -90.00 and 90.00", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Lower Left Latitude can only take values between -90.00 and 90.00");
// }
}
@Test
// Test that Upper Right Latitude is not <-91 or > 90
public void testUpperRightLatOutOfBounds(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("-60;50;-90.1;0");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Upper Right Latitude can only take values between -90.00 and 90.00", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Upper Right Latitude can only take values between -90.00 and 90.00");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("0;0;90.1;50");
flag = gac2.isGraphicsAreaStringValid();
assertFalse("Upper Right Latitude can only take values between -90.00 and 90.00", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Upper Right Latitude can only take values between -90.00 and 90.00");
// }
}
@Test
// Test that Lower Left Longitude is not > 360 or < -181
public void testLowerLeftLonOutOfBounds(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("-89;-180.1;60;0");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
GraphicsAreaCoordinates gac2= new GraphicsAreaCoordinates("0;360.1;50;0");
flag = gac2.isGraphicsAreaStringValid();
assertFalse("Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
}
@Test
// Test that Upper Right Longitude is not > 360 or < -181
public void testUpperRightLonOutOfBounds(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("-89;59;50;-180.1");
flag = gac.isGraphicsAreaStringValid();
assertTrue("After adding convertLongitudeValue(...) logic, Upper Right Longitude -180.1 is valid now", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Upper Right Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("0;0;0;360.1");
flag = gac2.isGraphicsAreaStringValid();
assertTrue("After adding convertLongitudeValue(...) logic, Upper Right Longitude 360.1 is valid now", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Upper Right Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
}
@Test
//Test for valid values of Lower Left and Upper Right Latitude/Longitude values
public void testValidLatLonDataRange(){
String gAreaString = "-90;-180;90;180";
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(gAreaString);
// flag = gac.parseGraphicsAreaString(gAreaString);
flag = gac.isGraphicsAreaStringValid();
assertTrue("The input Graphics Area Coordinates should be valid", flag);
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0],-90.0f);
assertEquals(lat_lon[1],-180.0f);
assertEquals(lat_lon[2],90.0f);
assertEquals(lat_lon[3],180.0f);
assertEquals(lat_lon[4],0.0f);
assertEquals(lat_lon[5],0.0f);
gAreaString = "-89;-179;89;179";
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(gAreaString);
flag = gac2.isGraphicsAreaStringValid();
// flag = gac2.parseGraphicsAreaString(gAreaString);
assertTrue("The input Graphics Area Coordinates should be valid", flag);
lat_lon = gac2.getGAREACoordinates();
assertEquals(lat_lon[0],-89f);
assertEquals(lat_lon[1],-179.0f);
assertEquals(lat_lon[2],89.0f);
assertEquals(lat_lon[3],179.0f);
assertEquals(lat_lon[4],0.0f);
assertEquals(lat_lon[5],0.0f);
}
@Test
//Test if Latitude/Longitude values can be entered without any digit preceding the '.' character.
public void testValiLatLonNoLeadingDigit(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("-.55;.66;30.45678;170");
flag = gac.isGraphicsAreaStringValid();
assertTrue("The input Graphics Area Coordinates should be valid", flag);
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0],-0.55f);
assertEquals(lat_lon[1],0.66f);
assertEquals(lat_lon[2],30.45678f);
assertEquals(lat_lon[3],170.0f);
assertEquals(lat_lon[4],14.95339f);
assertEquals(lat_lon[5],85.33f);
}
@Test
// Test for less than 4 Latitude/Longitude values
public void testLessThanFourLatLonValues(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("10;20;30");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Too few arguments entered", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Too few arguments entered");
// }
}
@Test
//Test for more than 4 Latitude/Longitude values
public void testMoreThanFourLatLonValues(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("10;20;30;40;50");
flag = gac.isGraphicsAreaStringValid();
assertTrue("For the number of arguments more than 4, it should be considered a valid string, the extra arguments is simply ignored", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// }
}
@Test
//Test that Lower Left Latitude value cannot exceed the Upper Right Latitude
public void testLowerLeftLatLessThanUpperRightLat(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("70.55;40.45;30.02;80.44");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Lower left latitude must be less than or equal to upper right latitude", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Lower left latitude must be less than or equal to upper right latitude");
// }
GraphicsAreaCoordinates gac_1 = new GraphicsAreaCoordinates("90;180;-90;-180");
flag = gac_1.isGraphicsAreaStringValid();
assertFalse("Lower left latitude must be less than or equal to upper right latitude", flag);
// if(!flag){
// error_msg = gac_1.getErrorCode();
// assertEquals(error_msg,"Lower left latitude must be less than or equal to upper right latitude");
// }
}
@Test
//Test that Lower Left Longitude value cannot exceed the Upper Right Longitude
public void testLowerLeftLonLessThanUpperRightLon(){
GraphicsAreaCoordinates gac19 = new GraphicsAreaCoordinates("20.55;140.45;30.02;80.44");
flag = gac19.isGraphicsAreaStringValid();
assertFalse("Lower left longitude must be less than or equal to upper right longitude", flag);
// if(!flag){
// error_msg = gac19.getErrorCode();
// assertEquals(error_msg,"Lower left longitude must be less than or equal to upper right longitude");
// }
GraphicsAreaCoordinates gac_1 = new GraphicsAreaCoordinates("90;180;90;-180");
flag = gac_1.isGraphicsAreaStringValid();
assertFalse("The two coordinate points are the same point, thus it is invalid", flag);
// if(!flag){
// error_msg = gac_1.getErrorCode();
// assertEquals(error_msg,"Lower left longitude must be less than or equal to upper right longitude");
// }
}
@Test
//Test for invalid separator like a ',' character or a '.' character instead of ';'
public void testInvalidDelimiter(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("0.0.0.0");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Invalid String Format", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Invalid String Format");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("#0,0,0,0");
flag = gac2.isGraphicsAreaStringValid();
assertFalse("String Format '#0,0,0,0' should be invalid", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Invalid String Format");
// }
}
@Test
//Test for the presence of an extra '.' character
public void testExtraDemialPoint(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("-.55;90..77;30.45678;170");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Invalid lat/lon String Format", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Invalid lat/lon values entered");
// }
}
@Test
//Test for non-numeric characters in the input Latitude/Longitude string
public void testInvalidNonNumericLatLonInput(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("0;$0;0-;0");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Invalid lat/lon values entered", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Invalid lat/lon values entered");
// }
}
@Test
//Test that the Upper Right and Lower Left Latitude Values computed from the Center/Delta Lat/Lon Values
// lie in the correct range from -90.0 to 90.0
public void testInvalidCenterDeltaLatValues(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("#-90.0;10.4;0.1;0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse("center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("#90.0;10.4;0.1;0.45");
flag = gac2.isGraphicsAreaStringValid();
assertFalse("center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0");
// }
}
@Test
//Test that the Upper Right and Lower Left Longitude Values computed from the Center/Delta Latitude/Longitude Values
// lie in the correct range from -180.0 to 360.0
public void testInvalidCenterDeltaLonValues(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("#89.0;-180;0.1;0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse("center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("#89.0;180;0.1;0.45");
flag = gac2.isGraphicsAreaStringValid();
assertTrue("A valid string pattern meets the logic of center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0");
// }
GraphicsAreaCoordinates gac3 = new GraphicsAreaCoordinates("#89.0;360;0.1;0.45");
flag = gac3.isGraphicsAreaStringValid();
/*
* After convertLongitudeValue(..) logic, the center Lon=360 is converted to Lon=0, thus,
* (center_lon + delta_lon=0.45) <=360.0
*/
assertTrue("After convertLongitudeValue(..) logic,, this string should be valid", flag);
// if(!flag){
// error_msg = gac3.getErrorCode();
// assertEquals(error_msg,"center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0");
// }
}
@Test
//Test for negative delta latitude value
public void testNegativeDeltaLat(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("#30.0;160.00;-0.761;0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Delta Latitude values cannot be negative", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Delta Latitude values cannot be negative");
// }
}
@Test
//Test for negative delta longitude value
public void testNegativeDeltaLon(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("#30.0;160.00;0.761;-0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Delta Longitude values cannot be negative", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Delta Longitude values cannot be negative");
// }
}
@Test
//Test if the Latitude/Longitude and Projection String Data can be retrieved from the Geog Table (geog.xml)
// When the input string is a Geographical Area Code.
public void testValidInputGeogTable(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("MAAR");
flag = gac.isGraphicsAreaStringValid();
assertTrue("MAAR is a valid name in geog.xml table", flag);
assertEquals(gac.getGeogAreaCode(),"MAAR");
assertEquals(gac.getMapProjectionString(),"MER");
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0],17.00f);
assertEquals(lat_lon[1],-63.90f);
assertEquals(lat_lon[2],18.60f);
assertEquals(lat_lon[3],-62.30f);
assertEquals(lat_lon[4],17.80f);
assertEquals(lat_lon[5],-63.10f);
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("105");
flag = gac2.isGraphicsAreaStringValid();
assertTrue("105 is a valid name in geog.xml table", flag);
assertEquals(gac2.getMapProjectionString(),"STR/90;-105;0");
lat_lon = gac2.getGAREACoordinates();
assertEquals(lat_lon[0],17.52f);
assertEquals(lat_lon[1],-129.30f);
assertEquals(lat_lon[2],53.78f);
assertEquals(lat_lon[3],-22.37f);
assertEquals(lat_lon[4],35.65f);
assertEquals(lat_lon[5],-105.00f);
GraphicsAreaCoordinates gac3 = new GraphicsAreaCoordinates("105**");
flag = gac3.isGraphicsAreaStringValid();
assertTrue("105** is a valid name in geog.xml table", flag);
assertEquals(gac3.getMapProjectionString(),"STR/90;-105;0");
lat_lon = gac3.getGAREACoordinates();
assertEquals(lat_lon[0],26.585f);
assertEquals(lat_lon[1],-102.567f);
assertEquals(lat_lon[2],46.981f);
assertEquals(lat_lon[3],-42.419f);
assertEquals(lat_lon[4],35.65f);
assertEquals(lat_lon[5],-105.00f);
GraphicsAreaCoordinates gac4 = new GraphicsAreaCoordinates("105---");
flag = gac4.isGraphicsAreaStringValid();
assertTrue("105--- is a valid name in geog.xml table", flag);
assertEquals(gac4.getMapProjectionString(),"STR/90;-105;0");
lat_lon = gac4.getGAREACoordinates();
assertEquals(lat_lon[0],-0.609f);
assertEquals(lat_lon[1],-182.765f);
assertEquals(lat_lon[2],80.975f);
assertEquals(lat_lon[3],57.827f);
assertEquals(lat_lon[4],35.65f);
assertEquals(lat_lon[5],-105.00f);
}
@Test
public void testInvalidInputGeogTable(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("105$%&");
flag = gac.isGraphicsAreaStringValid();
assertFalse("105$%& is NOT a valid name in geog.xml table", flag);
// if(!flag){
// assertEquals(gac.getGeogAreaCode(),"Invalid String Format");
// }
}
@Test
public void testValidInputStationTable(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("LFK");
flag = gac.isGraphicsAreaStringValid();
assertTrue("LFK is a valid name in sfstas.xml station table", flag);
assertEquals(gac.getStationCode(),"LFK");
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[4],31.00f);
assertEquals(lat_lon[5],-94.00f);
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("BLI++");
flag = gac2.isGraphicsAreaStringValid();
assertTrue("BLI++ is a valid name in sfstas.xml station table", flag);
assertEquals(gac2.getStationCode(),"BLI");
lat_lon = gac2.getGAREACoordinates();
assertEquals(lat_lon[0],46.00f);
assertEquals(lat_lon[1],-125.50f);
assertEquals(lat_lon[2],51.50f);
assertEquals(lat_lon[3],-118.50f);
assertEquals(lat_lon[4],48.00f);
assertEquals(lat_lon[5],-122.00f);
GraphicsAreaCoordinates gac3 = new GraphicsAreaCoordinates("BLI-");
flag = gac3.isGraphicsAreaStringValid();
assertTrue("BLI- is a valid name in sfstas.xml station table", flag);
assertEquals(gac3.getStationCode(),"BLI");
lat_lon = gac3.getGAREACoordinates();
assertEquals(lat_lon[0],40.00f);
assertEquals(lat_lon[1],-136.00f);
assertEquals(lat_lon[2],62.00f);
assertEquals(lat_lon[3],-108.00f);
assertEquals(lat_lon[4],48.00f);
assertEquals(lat_lon[5],-122.00f);
}
@Test
public void testInvalidInputStationTable(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("#BLI!@#$%&");
flag = gac.isGraphicsAreaStringValid();
assertFalse("invalid station table name is entered", flag);
// if(!flag){
// assertEquals(gac.getGeogAreaCode(),"Invalid String Format");
// }
}
@Test
public void testEmptyString(){
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Empty String is not a valid Graphic Area Coordinate string", flag);
// if(!flag){
// assertEquals(gac.getGeogAreaCode(),"Empty String");
// }
}
}

1
ncep/gov.noaa.nws.ncep.gempak.parameters/.classpath
View file

@ -3,6 +3,5 @@
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="unit_test"/>
<classpathentry kind="output" path="bin"/>
</classpath>

3
ncep/gov.noaa.nws.ncep.gempak.parameters/META-INF/MANIFEST.MF
View file

@ -16,8 +16,7 @@ Import-Package: gov.noaa.nws.ncep.gempak.parameters.core.contourinterval,
gov.noaa.nws.ncep.gempak.parameters.core.util,
gov.noaa.nws.ncep.viz.common.ui,
gov.noaa.nws.ncep.viz.common.ui.color,
gov.noaa.nws.ncep.viz.localization,
org.junit
gov.noaa.nws.ncep.viz.localization
Export-Package: gov.noaa.nws.ncep.gempak.parameters,
gov.noaa.nws.ncep.gempak.parameters.colors,
gov.noaa.nws.ncep.gempak.parameters.colorbar,

932
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/discrete/DiscreteTest.java
View file

@ -1,932 +0,0 @@
/**
*
*/
package gov.noaa.nws.ncep.gempak.parameters.discrete;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
/**
* <pre>
*
* Junit test for {@link gov.noaa.nws.ncep.gempak.parameters.discrete.Discrete}.
*
*
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 10-Dec-2009 205 Archana.S Initial Creation
* 18-Dec-2009 205 Archana.S Updated per review comments:
* ----------------------------
* 1. Removed all references to hard-coded tolerance value
* (0.000001) and replaced it with the method
* getTolerance(). Accordingly updated Javadoc for the corresponding
* tests.
* 2. Updated all test-cases, to replace the '-' delimiter in the
* input string with '~'
* 3. Added the following test-cases:
* a. To parse negative numbers in the Discrete string.
* b. Test for extra arguments.
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
* </pre>
*
* @author Archana.S
* @version 1
*/
public class DiscreteTest {
private static final double ALLOWABLE_DOUBLE_DELTA = 0.1;
private static int testCaseNumber;
private List<Float> testList;
/**
* Test valid input string with multiple start/end/discrete value strings.
*/
@Test
public void testGetDiscreteDataList() {
testCaseNumber=1;
Discrete discreteObj = new Discrete("0.1~.5 = 0.444 ; 0.6 ~ 0.9 = 0.75 ; 0.99 ~ 1.15 = 1.105");
testList = new ArrayList<Float>(Arrays.asList(0.1f,0.5f,0.444f,0.6f,0.9f,0.75f,0.99f,1.15f,1.05f));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test valid input string with multiple start/end/discrete value pair strings");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+ (i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
System.out.println("==========================================");
testCaseNumber++;
}
/**
* Test valid input string with multiple start/end/discrete value strings, all of which are negative numbers
*/
@Test
public void testGetDiscreteDataListForNegativeNumbers() {
Discrete discreteObj = new Discrete("-0.1~ -.5 = -0.444 ; -0.6 ~ -0.9 = -0.75 ; -0.99 ~ -1.15 = -1.105");
testList = new ArrayList<Float>(Arrays.asList(-0.1f,-0.5f,-0.444f,-0.6f,-0.9f,-0.75f,-0.99f,-1.15f,-1.05f));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test valid input string with multiple start/end/discrete value pair strings, all of which are negative numbers");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+ (i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
System.out.println("==========================================");
testCaseNumber++;
}
/**
* Test valid input string with a missing start value in the first string.
*/
@Test
public void testDiscreteDataListWithMissingStartValueInFirstString() {
Discrete discreteObj = new Discrete("~.5=0.444;0.6~0.9=0.75;0.99~1.15=1.105");
testList = new ArrayList<Float>(Arrays.asList(-Float.MAX_VALUE,0.5f,0.444f,0.6f,0.9f,
0.75f,0.99f,1.15f,1.05f));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test valid input string with a missing start value in the first string");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+ (i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test input string with a missing start value in the second string.
*/
@Test
public void testDiscreteDataListWithMissingStartValueInSecondString() {
Discrete discreteObj = new Discrete("0.1~.5=0.444;~0.9=0.75;0.99~1.15=1.105");
testList = new ArrayList<Float>(Arrays.asList(0.1f,0.5f,0.444f,Float.NaN ,0.9f,
0.75f,0.99f,1.15f,1.05f));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test input string with a missing start value in the second string.");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+(i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test valid input string with a missing end value in the last string.
*/
@Test
public void testDiscreteDataListWithMissingEndValueInLastString() {
Discrete discreteObj = new Discrete("0.1~.5=0.444;0.6~0.9=0.75;0.99~=1.105");
testList = new ArrayList<Float>(Arrays.asList(0.1f,0.5f,0.444f,0.6f ,0.9f,
0.75f,0.99f,Float.MAX_VALUE,1.05f));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test valid input string with a missing end value in the last string\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+(i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test input string with a missing end value in the second string.
*/
@Test
public void testDiscreteDataListWithMissingEndValueInSecondString() {
Discrete discreteObj = new Discrete("0.1~.5=0.444;0.6~=0.75;0.99~1.15=1.105");
testList = new ArrayList<Float>(Arrays.asList(0.1f,0.5f,0.444f,0.6f ,Float.NaN,
0.75f,0.99f,1.15f,1.05f));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test input string with a missing end value in the second string\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+(i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test input string with missing discrete values in all strings.
*/
@Test
public void testDiscreteDataListWithMissingDiscreteValuesInAllStrings() {
Discrete discreteObj = new Discrete("0.1~.5=;0.6~0.9=;0.99~1.15=");
testList = new ArrayList<Float>(Arrays.asList(0.1f,0.5f,Float.NaN,0.6f ,0.9f,
0.75f,Float.NaN,1.15f,Float.NaN));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test input string with missing discrete values in all strings\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+(i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test input string with invalid delimiters
*/
@Test
public void testDiscreteDataListWithInvalidDelimiters() {
Discrete discreteObj = new Discrete("0.1-.5=0.3,0.6-0.9=0.75,0.99-1.15=1.05");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test input string with invalid delimiters\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Size of discrete data list = "+discreteObj.getDiscreteDataList().size());
assertEquals(discreteObj.getDiscreteDataList().size(), 0);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test input string with all numbers missing
*/
@Test
public void testDiscreteDataListWithAllNumbersMissing() {
Discrete discreteObj = new Discrete(" ~ = ; ~ = ; ~ =");
testList = new ArrayList<Float>(Arrays.asList(-Float.MAX_VALUE,Float.NaN,Float.NaN,Float.NaN,Float.NaN,
Float.NaN,Float.NaN,Float.MAX_VALUE,Float.NaN));
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test input string with all numbers missing\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Size of discrete data list = "+discreteObj.getDiscreteDataList().size());
for(int i=0;i < discreteObj.getDiscreteDataList().size(); i++){
System.out.println("-----------------");
System.out.println("Element number:"+(i+1));
System.out.println("Start value = "+discreteObj
.getDiscreteDataList().get(i).getStartValue());
System.out.println("End value = "+discreteObj
.getDiscreteDataList().get(i).getEndValue());
System.out.println("Discrete value = "+discreteObj
.getDiscreteDataList().get(i).getDiscreteValue());
if(i==0){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(0));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(1));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(2));
}
else if(i==1){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(3));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(4));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(5));
}
else if(i==2){
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getStartValue(),testList.get(6));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getEndValue(),testList.get(7));
assertFloatComparison(discreteObj.getDiscreteDataList()
.get(i).getDiscreteValue(),testList.get(8));
}
}
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test Discrete with extra arguments
*/
@Test
public void testGetDiscreteDataListForExtraArguments() {
Discrete discreteObj = new Discrete("-0.1 ~ -.5 ~ -0.5999 = -0.444 ; -0.6 ~ -0.9 ~ -0.9111 = -0.75 ; -0.99 ~ -1.15 = -1.105");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test Discrete with extra arguments");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println( "Size of the discrete data list is " + discreteObj.getDiscreteDataList().size());
System.out.println("==========================================");
testCaseNumber++;
}
/**
* Test empty string
*/
@Test
public void testDiscreteDataListWithEmptyString() {
Discrete discreteObj = new Discrete("");
System.out.println("Test-case: "+testCaseNumber+" a");
System.out.println("Test empty string\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Size of discrete data list = "+discreteObj.getDiscreteDataList().size());
assertEquals(discreteObj.getDiscreteDataList().size(), 0);
Discrete discreteObj2 = new Discrete(null);
System.out.println("Test-case: "+testCaseNumber+" b");
System.out.println("Test empty string\n");
System.out.println("The input string is "+discreteObj2.getStrDiscrete());
System.out.println("Size of discrete data list = "+discreteObj2.getDiscreteDataList().size());
assertEquals(discreteObj2.getDiscreteDataList().size(), 0);
Discrete discreteObj3 = new Discrete(" ");
System.out.println("Test-case: "+testCaseNumber+" c");
System.out.println("Test empty string\n");
System.out.println("The input string is "+discreteObj3.getStrDiscrete());
System.out.println("Size of discrete data list = "+discreteObj3.getDiscreteDataList().size());
assertEquals(discreteObj3.getDiscreteDataList().size(), 0);
System.out.println("==========================================");
testCaseNumber++;
}
/**
* Test input string with non numeric inputs
*/
@Test
public void testDiscreteDataListWithNonNumericInputs() {
Discrete discreteObj = new Discrete("0.1l~.S5=0.O3;0.O6~0.90=0.S75;0.J99~1Q.1$5=1.^05");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test input string with non numeric inputs\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Size of discrete data list = "+discreteObj.getDiscreteDataList().size());
assertEquals(discreteObj.getDiscreteDataList().size(), 0);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test the method getDiscreteValueLeftOfCurrentDiscreteValue()
*/
@Test
public void testGetDiscreteValueLeftOfCurrentDiscreteValue(){
Discrete discreteObj = new Discrete("0.1~.5=0.444;0.6~0.9=0.75;0.99~1.15=1.105;1.25~4.5=3.6");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test the method getDiscreteValueLeftOfCurrentDiscreteValue()\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Discrete Value to the left of 3.6 = "+discreteObj.getPrecedingDiscreteValue(3.6f));
System.out.println("Discrete Value to the left of 0.444 = "+discreteObj.getPrecedingDiscreteValue(0.444f));
assertFloatComparison(discreteObj.getPrecedingDiscreteValue(3.6f),
1.105f);
assertFloatComparison(discreteObj.getPrecedingDiscreteValue(0.444f),
0.444f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* @param precedingDiscreteValue
* @param f
*/
private void assertFloatComparison(Float precedingDiscreteValue, float f) {
assertEquals(precedingDiscreteValue.floatValue(), f,
ALLOWABLE_DOUBLE_DELTA);
}
/**
* Test the method getDiscreteValueClosestToTwoContourLines() when the
* following conditions are satisfied: The absolute difference between the
* current start value and the first parameter in the function is less than
* the tolerance value and The absolute difference between the current end
* value and the second parameter in the function is less than the tolerance
* value
*/
@Test
public void testGetDiscreteValueClosestToTwoContourLines1(){
Discrete discreteObj = new Discrete("0.1~.5=0.444;0.6~0.9=0.75;0.99~1.15=1.105;1.25~3.5=3.6");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:\n"+
"The absolute difference between the current start value and the first parameter in the function is\n"+
"less than " + discreteObj.getTOLERANCE() +"and \n" +
"The absolute difference between the current end value and the second parameter in the function\nis "+
"less than " + discreteObj.getTOLERANCE() +"\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Discrete Value between 0.99 and 1.15 = "+discreteObj.getDiscreteValueClosestToTwoContourLines(0.99f,1.15f));
assertFloatComparison(
discreteObj.getDiscreteValueClosestToTwoContourLines(0.99f,
1.15f), 1.105f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:
* The absolute difference between the current start value and the first parameter in the function is
* exactly the tolerance value and
* The absolute difference between the current end value and the second parameter in the function is
* less than the tolerance value
*/
@Test
public void testGetDiscreteValueClosestToTwoContourLines2(){
Discrete discreteObj = new Discrete("0.1~.5=0.444;0.6~0.9=0.75;0.99~1.15=1.105;1.25~2.5=3.6");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:\n"+
"The absolute difference between the current start value and the first parameter in the function is\n"+
"exactly " + discreteObj.getTOLERANCE() +" and\n" +
"The absolute difference between the current end value and the second parameter in the function\nis "+
"less than " + discreteObj.getTOLERANCE() +"\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Discrete Value between 0.990001 and 1.15 = "+discreteObj.getDiscreteValueClosestToTwoContourLines(0.990001f,1.15f));
assertFloatComparison(
discreteObj.getDiscreteValueClosestToTwoContourLines(0.990001f,
1.15f), Float.NaN);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:
* The absolute difference between the current start value and the first parameter in the function is
* less than the tolerance value and
* The absolute difference between the current end value and the second parameter in the function is
* exactly the tolerance value
*/
@Test
public void testGetDiscreteValueClosestToTwoContourLines3(){
Discrete discreteObj = new Discrete("0.1~.5=0.444;0.6~0.9=0.75;0.99~1.15=1.105;1.25~2.5=3.6");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:\n"+
"The absolute difference between the current start value and the first parameter in the function is\n"+
"less than " + discreteObj.getTOLERANCE() +"\n" +
"The absolute difference between the current end value and the second parameter in the function\nis "+
"exactly " + discreteObj.getTOLERANCE() +"\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Discrete Value between 0.99 and 1.150001 = "+discreteObj.getDiscreteValueClosestToTwoContourLines(0.99f,1.150001f));
assertFloatComparison(
discreteObj.getDiscreteValueClosestToTwoContourLines(0.99f,
1.150001f), Float.NaN);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:
* The absolute difference between the negative of current start value and the Float MAX
* is less than the tolerance value
* The first parameter in the function is >= the current starting value
* The absolute difference between the current end value and the second parameter in the function is
* less than the tolerance value
*/
@Test
public void testGetDiscreteValueClosestToTwoContourLines4(){
Discrete discreteObj = new Discrete("~.5=0.444;0.6~0.9=0.75;0.99~1.15=1.105;1.25~2.5=3.6");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:\n"+
"The absolute difference between the negative of the current start value and the Float MAX is\n"+
"less than " + discreteObj.getTOLERANCE() +"\n" +
"The first parameter in the function is >= the current starting value and \n"+
"The absolute difference between the current end value and the second parameter in the function\nis "+
"less than " + discreteObj.getTOLERANCE() +"\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Discrete Value between Float.MAX-VALUE and 1.15 = "+discreteObj.getDiscreteValueClosestToTwoContourLines(Float.MAX_VALUE, 0.5f));
assertFloatComparison(
discreteObj.getDiscreteValueClosestToTwoContourLines(
Float.MAX_VALUE, 0.5f), 0.444f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:
* The absolute difference between the negative of current start value and the Float MAX
* is less than the tolerance value
* The first parameter in the function is >= the current starting value
* The absolute difference between the current end value and the second parameter in the function is
* less than the tolerance value
*/
@Test
public void testGetDiscreteValueClosestToTwoContourLines5(){
Discrete discreteObj = new Discrete("0.1~.5=0.444;0.6~0.9=0.75;0.99~1.15=1.105;1.25~=3.6");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test the method getDiscreteValueClosestToTwoContourLines() when the following conditions are satisfied:\n"+
"The absolute difference between the current end value and the Float MAX is\n"+
"less than" + discreteObj.getTOLERANCE() +"\n" +
"The second parameter in the function is <= the current ending value and \n"+
"The absolute difference between the current start value and the first parameter in the function\nis "+
"less than" + discreteObj.getTOLERANCE() +"\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("Discrete Value between 1.25 and Float.MAX-VALUE = "+discreteObj.getDiscreteValueClosestToTwoContourLines(1.25f,Float.MAX_VALUE));
assertFloatComparison(
discreteObj.getDiscreteValueClosestToTwoContourLines(1.25f,
Float.MAX_VALUE), 3.6f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test Discrete class when only a single value1-value2=value3; pair is given
*/
@Test
public void testSingleString(){
Discrete discreteObj = new Discrete("0.1~.5=0.444;");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test Discrete class when only a single value1-value2=value3; pair is given\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("The size of the list"+discreteObj.getDiscreteDataList().size());
System.out.println("The starting value="+discreteObj.getDiscreteDataList().get(0).getStartValue());
System.out.println("The ending value="+discreteObj.getDiscreteDataList().get(0).getEndValue());
System.out.println("The discrete value="+discreteObj.getDiscreteDataList().get(0).getDiscreteValue());
assertEquals(discreteObj.getDiscreteDataList().size(), 1);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getStartValue(), 0.1f);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getEndValue(), 0.5f);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getDiscreteValue(), 0.444f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test Discrete class when only a single value1-value2=value3 pair is given
*/
@Test
public void testSingleString2(){
Discrete discreteObj = new Discrete("0.1~.5=0.444");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test Discrete class when only a single value1-value2=value3; pair is given\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("The size of the list"+discreteObj.getDiscreteDataList().size());
System.out.println("The starting value="+discreteObj.getDiscreteDataList().get(0).getStartValue());
System.out.println("The ending value="+discreteObj.getDiscreteDataList().get(0).getEndValue());
System.out.println("The discrete value="+discreteObj.getDiscreteDataList().get(0).getDiscreteValue());
assertEquals(discreteObj.getDiscreteDataList().size(), 1);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getStartValue(), 0.1f);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getEndValue(), 0.5f);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getDiscreteValue(), 0.444f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test Discrete class when only a single value1-value2=value3 pair is given, but with value1 missing
*/
@Test
public void testSingleString3(){
Discrete discreteObj = new Discrete("~.5=0.444");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test Discrete class when only a single value1-value2=value3; pair is given, but with value1 missing\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("The size of the list"+discreteObj.getDiscreteDataList().size());
System.out.println("The starting value="+discreteObj.getDiscreteDataList().get(0).getStartValue());
System.out.println("The ending value="+discreteObj.getDiscreteDataList().get(0).getEndValue());
System.out.println("The discrete value="+discreteObj.getDiscreteDataList().get(0).getDiscreteValue());
assertEquals(discreteObj.getDiscreteDataList().size(), 1);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getStartValue(), -Float.MAX_VALUE);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getEndValue(), 0.5f);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getDiscreteValue(), 0.444f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test Discrete class when only a single value1-value2=value3 pair is given, but with value2 missing
*/
@Test
public void testSingleString4(){
Discrete discreteObj = new Discrete(".5~=0.444");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test Discrete class when only a single value1-value2=value3; pair is given, but with value1 missing\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("The size of the list"+discreteObj.getDiscreteDataList().size());
System.out.println("The starting value="+discreteObj.getDiscreteDataList().get(0).getStartValue());
System.out.println("The ending value="+discreteObj.getDiscreteDataList().get(0).getEndValue());
System.out.println("The discrete value="+discreteObj.getDiscreteDataList().get(0).getDiscreteValue());
assertEquals(discreteObj.getDiscreteDataList().size(), 1);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getStartValue(), 0.5f);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getEndValue(), Float.MAX_VALUE);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getDiscreteValue(), 0.444f);
testCaseNumber++;
System.out.println("==========================================");
}
/**
* Test Discrete class when only a single value1-value2=value3 pair is given, but with
* both value1 and value2 missing
*/
@Test
public void testSingleString5(){
Discrete discreteObj = new Discrete(" ~ =0.444");
System.out.println("Test-case: "+testCaseNumber);
System.out.println("Test Discrete class when only a single value1-value2=value3; pair is given, but " +
"with both value1 and value 2 missing\n");
System.out.println("The input string is "+discreteObj.getStrDiscrete());
System.out.println("The size of the list"+discreteObj.getDiscreteDataList().size());
System.out.println("The starting value="+discreteObj.getDiscreteDataList().get(0).getStartValue());
System.out.println("The ending value="+discreteObj.getDiscreteDataList().get(0).getEndValue());
System.out.println("The discrete value="+discreteObj.getDiscreteDataList().get(0).getDiscreteValue());
assertEquals(discreteObj.getDiscreteDataList().size(), 1);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getStartValue(), -Float.MAX_VALUE);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getEndValue(), Float.MAX_VALUE);
assertFloatComparison(discreteObj.getDiscreteDataList().get(0)
.getDiscreteValue(), 0.444f);
testCaseNumber++;
System.out.println("==========================================");
}
}

204
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/dlines/DLINESTest.java
View file

@ -1,204 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.dlines;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
/**
* <pre>
* Junit test-case for DLINES and DLINEData
*
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 29-Dec-2009 211 Archana.S Initial Creation
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
* </pre>
*
* @author Archana.S
* @version 1
*/
public class DLINESTest {
/**
* Test method for {@link gov.noaa.nws.ncep.gempak.parameters.dlines.DLines#getDlineData()}.
*/
@Test
public void testGetDlineData() {
String[] testCaseDescription = {"Test DLINES with both right and left states set to true and epsilon set to 0.25",
"Test DLINES with both right and left states set to true and epsilon undefined",
"Test DLINES with only right state (set to true)",
"Test DLINES with both right and left states set to false and epsilon set to 1.3",
"Test DLINES with both right and left states set to false and epsilon undefined",
"Test DLINES with only right state (set to false)",
"Test DLINES with right state set to false and left state set to true",
"Test DLINES with right state set to true and left state set to false",
"Test DLINES for case-insensitive comparisons",
"Test DLINES with an invalid delimiter - using , instead of ;",
"Test DLINES with an invalid delimiter - using / instead of |",
"Test DLINES with a malformed input",
"Test DLINES with an empty string",
"Test DLINES with a null string",
"Test DLINES with a string containing only blanks",
"Test DLINES with extra arguments",
"Test DLINES with input parameters in reverse order"
};
String[] inputString = {"yes;yes|0.25",
"yes;yes",
"yes",
"no;no|1.3",
"no;no",
"no",
"no ; yes",
"yes ; no",
"YES ; YeS",
"Yes , yes ",
"Yes ; yes / 0.9",
" ; |",
"",
null,
" ",
"yes;yes;yes;yes | 0.9 | 0.8",
"0.9 | yes ; yes"};
for(int i = 0; i < inputString.length; i++){
DLines dlines = new DLines(inputString[i]);
System.out.println("Test-case number: "+ (i+1));
System.out.println(testCaseDescription[i]);
System.out.println("\nThe input string is: "+ dlines.getDString());
if(dlines.getDlineData() != null){
System.out.println("Contour values to the right of the current contour line are greater = "+ dlines.getDlineData().isRightOfContourLineGreater());
System.out.println("Contour values to the left of the current contour line are greater = "+ dlines.getDlineData().isLeftOfContourLineGreater());
System.out.println("Epsilon value = "+ dlines.getDlineData().getEpsilon());
}
else{
System.out.println("\nEmpty DLINES string");
}
System.out.println("==================================================");
switch(i){
case 0:
assertEquals("Contour values to the right of the current contour line should be greater",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),true);
assertEquals("Contour values to the left of the current contour line should be greater",dlines.getDlineData()
.isLeftOfContourLineGreater(),true);
assertEquals("Epsilon should be set to 0.25", dlines
.getDlineData().getEpsilon(), 0.25, 0.01);
break;
case 1:
assertEquals("Contour values to the right of the current contour line should be greater",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),true);
assertEquals("Contour values to the left of the current contour line should be greater",dlines.getDlineData()
.isLeftOfContourLineGreater(),true);
assertEquals("Epsilon should be undefined",dlines.getDlineData()
.getEpsilon(), Double.NaN, 0.01);
break;
case 2:
assertEquals("Contour values to the right of the current contour line should be greater",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),true);
assertEquals("Contour values to the left of the current contour line should be lesser",dlines.getDlineData()
.isLeftOfContourLineGreater(),false);
assertEquals("Epsilon should be undefined",dlines.getDlineData()
.getEpsilon(), Double.NaN, 0.01);
break;
case 3:
assertEquals("Contour values to the right of the current contour line should be lesser",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),false);
assertEquals("Contour values to the left of the current contour line should be lesser",dlines.getDlineData()
.isLeftOfContourLineGreater(),false);
assertEquals("Epsilon should be set to 1.3", dlines
.getDlineData().getEpsilon(), 1.3, 0.01);
break;
case 6:
assertEquals("Contour values to the right of the current contour line should be lesser",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),false);
assertEquals("Contour values to the left of the current contour line should be greater",dlines.getDlineData()
.isLeftOfContourLineGreater(),true);
assertEquals("Epsilon should be undefined",dlines.getDlineData()
.getEpsilon(), Double.NaN, 0.01);
break;
case 7:
assertEquals("Contour values to the right of the current contour line should be greater",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),true);
assertEquals("Contour values to the left of the current contour line should be lesser",dlines.getDlineData()
.isLeftOfContourLineGreater(),false);
assertEquals("Epsilon should be undefined",dlines.getDlineData()
.getEpsilon(), Double.NaN, 0.01);
break;
case 8:
assertEquals("Contour values to the right of the current contour line should be greater",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),true);
assertEquals("Contour values to the left of the current contour line should be greater",dlines.getDlineData()
.isLeftOfContourLineGreater(),true);
assertEquals("Epsilon should be undefined",dlines.getDlineData()
.getEpsilon(), Double.NaN, 0.01);
break;
case 10:
assertEquals("Contour values to the right of the current contour line should be greater",dlines.getDlineData()
.isRightOfContourLineGreater().booleanValue(),true);
assertEquals("Contour values to the left of the current contour line should be lesser",dlines.getDlineData()
.isLeftOfContourLineGreater(),false);
assertEquals("Epsilon should be undefined",dlines.getDlineData()
.getEpsilon(), Double.NaN, 0.01);
break;
default:
if (dlines.getDlineData() != null) {
assertEquals(
"Contour values to the right of the current contour line should be lesser",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), false);
assertEquals("Contour values to the left of the current contour line should be lesser",
dlines.getDlineData().isLeftOfContourLineGreater(),
false);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
}else{
assertEquals("DLINES should be null", dlines.getDlineData(), null);
}
break;
}
}
}
}

1062
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/gridlimits/GGLIMSTest.java
View file

File diff suppressed because it is too large Load diff

583
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/infill/FINTTest.java
View file

@ -1,583 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.infill;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
/**
* <pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 10-Nov-2009 184 Archana.S Initial Creation
* 17-Jun-2010 184 Archana.S Updated test-cases to test
* updated code in FINT
* 03-Aug-2010 184 Archana.S Updated test-cases to test
* updated code in FINT
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
* </pre>
*
* @author Archana.S
* @version 1
*/
public class FINTTest {
private static int testCaseNumber;
private List<Double> testList;
private List<Double> testList2;
private List<Double> keySetList;
@Test
/* Test for valid FINT string of the form fillInterval/minFillValue/maxFillValue */
public void testPositiveFillFillIntervalWithMinMaxValues(){
testCaseNumber = 1;
FINT fint = new FINT("10/0.5/9");
assertEquals(fint.isFINTStringParsed(),true);
testList = new ArrayList<Double>(Arrays.asList(0.5,9.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
assertEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue(), 10);
assertEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(), 0.5);
assertEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(), 9);
System.out.println("=====================Test-Case "+testCaseNumber+"a ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Values List = " + fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Interval in First Zoom Level" + fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Min Fill Value in First Zoom Level" + fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Max Fill Value in First Zoom Level" + fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
FINT fint2 = new FINT(" 10 / -57 / 86 ");
assertEquals(fint2.isFINTStringParsed(),true);
testList2 = new ArrayList<Double>(Arrays.asList(-50.0, -40.0, -30.0, -20.0, -10.0, 0.0, 10.0,
20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0));
keySetList = fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList2);
assertEquals(fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue(), 10);
assertEquals(fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(), -57.0);
assertEquals(fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(), 86);
System.out.println("=====================Test-Case "+testCaseNumber+"b ========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the fill data string parsed correctly? " + fint2.isFINTStringParsed());
System.out.println("Fill Values List = "+fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Interval in First Zoom Level" + fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Min Fill Value in First Zoom Level" + fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Max Fill Value in First Zoom Level" + fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
testCaseNumber++;
}
/**
* @param doubleValue
* @param i
*/
// private static void assertEquals(double doubleValue, int i) {
// Assert.assertEquals(doubleValue, i, 0.001);
// }
@Test
/* Test for valid FINT string of the form fillInterval/minFillValue/maxFillValue
* with a negative contourInterval
* */
public void testNegativeFillIntervalWithMinMaxValues(){
FINT fint = new FINT("-5/-11/23");
assertEquals(fint.isFINTStringParsed(),true);
testList = new ArrayList<Double>(Arrays.asList(-10.0, -5.0, 0.0, 5.0, 10.0, 15.0, 20.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid FINT string of the form val1;val2;val3;val4..... */
public void testValidFillLevelValuesString(){
FINT fint = new FINT("66.1;0.1;5000;76;-.999;12233459390;0.00009988;1234.567890");
Assert.assertTrue(fint.isFINTStringParsed());
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0, 76.0, -0.999,
1.223345939E10, 9.988E-5, 1234.56789));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid FINT string of the form val1 ; val2 ; val3 */
public void testValidFillLevelValuesStringWithBlanks(){
FINT fint = new FINT(" 66.1 ; 0.1 ; 5000 ");
Assert.assertTrue(fint.isFINTStringParsed());
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid FINT string of the form fillInterval/minFillValue/ */
public void testFillIntervalWithMinValueOnly(){
FINT fint = new FINT("-0.345/0/");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -0.345);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 0);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
/**
* @param fillInterval
* @param d
*/
private void assertDoubleEquals(Double fillInterval, double d) {
Assert.assertEquals(d, fillInterval.doubleValue(), 0.01);
}
@Test
/*Test for valid FINT string of the form fillInterval//maxFillValue */
public void testFillIntervalWithMaxValueOnly(){
FINT fint = new FINT("15//30");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), 15);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 30);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid FINT string containing only the fill interval*/
public void testFINTWithOnlyFillIntervalSpecified(){
FINT fint = new FINT("-0.5/");
assertEquals(fint.isFINTStringParsed(),true);
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -0.5);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case "+testCaseNumber+"a ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
FINT fint2 = new FINT("-.89//");
assertEquals(fint2.isFINTStringParsed(),true);
assertDoubleEquals(fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -0.89);
assertDoubleEquals(fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case "+testCaseNumber+"b ========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint2.isFINTStringParsed());
System.out.println("Fill Interval = "+fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid FINT string of the form /minFillValue/maxFillValue */
public void testFillIntervalWithNoFillIntervalAndWithMinMaxValueOnly(){
FINT fint = new FINT("/10/30");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 30);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for valid FINT string of the form /minFillValue/maxFillValue,where both minFillValue
*and maxFillValue are the same*/
public void testFillIntervalWithMinValSameAsMaxValAndNoFillIntervalSpecified(){
FINT fint = new FINT("/10/10");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
testList = new ArrayList<Double>(Arrays.asList(10.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+" ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test input string containing a single fill contour value */
public void testLessNumArgsFillIntervalString(){
FINT fint = new FINT("-0.6");
assertEquals(fint.isFINTStringParsed(),true);
System.out.println("=====================Test-Case "+testCaseNumber+"a ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
FINT fint2 = new FINT("0.7;");
assertEquals(fint2.isFINTStringParsed(),true);
System.out.println("=====================Test-Case "+testCaseNumber+"b ========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint2.isFINTStringParsed());
System.out.println("Fill Interval = "+fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "+fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for FINT string of the form fillInterval/minFillValue/maxFillValue/extraNumbers/extraNumbers/extraNumbers*/
public void testExtraNumArgsFillIntervalString(){
FINT fint = new FINT("20/10/70/30/40/500");
Assert.assertTrue(fint.isFINTStringParsed());
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), 20);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 70);
testList = new ArrayList<Double>(Arrays.asList(10.0,30.0,50.0,60.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for non-numeric values in FINT string*/
public void testNonNumericFillIntervalString(){
FINT fint = new FINT("-def/abc/%^&/30/40");
assertEquals(fint.isFINTStringParsed(), false);
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test FINT string with invalid delimiters*/
public void testInvalidDelimitersInFillIntervalString(){
FINT fint = new FINT("5.10.60.9");
assertEquals(fint.isFINTStringParsed(), false);
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = "+fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test FINT string by interchanging minFillValue and maxFillValue */
public void testMinMaxValuesInterchangedFillIntervalString(){
FINT fint = new FINT("-5/20/5");
Assert.assertTrue(fint.isFINTStringParsed());
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -5);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 5);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 20);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList,testList);
System.out.println("=====================Test-Case "+testCaseNumber+"a========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval = " + fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = " + fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = " + fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
FINT fint2 = new FINT("5/20/5");
assertEquals(fint2.isFINTStringParsed(), true);
assertDoubleEquals(fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL), 5);
assertDoubleEquals(fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 5);
assertDoubleEquals(fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 20);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
keySetList = fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(testList,keySetList);
System.out.println("=====================Test-Case "+testCaseNumber+"b========================");
System.out.println("The input string = "+fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint2.isFINTStringParsed());
System.out.println("Fill Interval = "+fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "+fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "+fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for non-numeric vales in fill values' string*/
public void testInvalidFillLevelValuesString(){
FINT fint = new FINT("66.1;abc;5000;76;;@#$%;12233459390");
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Values List = "+fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*Test for invalid delimiters in fill values' string */
public void testInvalidDelimiterFillValuesString(){
FINT fint = new FINT("66.1,0,1,5000,76,-.999,12233459390");
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
testCaseNumber++;
}
@Test
/*Test for empty FINT string*/
public void testEmptyString(){
FINT fint = new FINT();
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"a========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
FINT fint2 = new FINT("");
assertEquals(fint2.isFINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"b========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint2.isFINTStringParsed());
FINT fint3 = new FINT(null);
assertEquals(fint3.isFINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"c========================");
System.out.println("The input string = " + fint3.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint3.isFINTStringParsed());
testCaseNumber++;
}
@Test
/*Test for FINT string with blank-spaces*/
public void testFillDataStringWithBlankSpaces(){
FINT fint = new FINT(" ");
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
testCaseNumber++;
}
/*
* Test contour interval string with multiple zoom levels
*/
@Test
public void testFINTMultipleZoomLevels(){
FINT fint = new FINT("2/-6/6/3 > 30;50;80 > 60 ; 80 > 0.00009999 > 0.0000001;");
Assert.assertTrue(fint.isFINTStringParsed());
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0,-2.0, 0.0, 2.0, 4.0, 6.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(testList,keySetList);
testList = new ArrayList<Double>(Arrays.asList(30.0,50.0,80.0));
keySetList = fint.getFillValuesListAsDouble(FINT.SECOND_ZOOM_LEVEL);
assertEquals(testList,keySetList);
testList = new ArrayList<Double>(Arrays.asList(60.0,80.0));
keySetList = fint.getFillValuesListAsDouble(FINT.THIRD_ZOOM_LEVEL);
assertEquals(testList,keySetList);
keySetList = fint.getFillValuesListAsDouble(FINT.FOURTH_ZOOM_LEVEL);
assertEquals(Collections.EMPTY_LIST,keySetList);
keySetList = fint.getFillValuesListAsDouble(FINT.FIFTH_ZOOM_LEVEL);
assertEquals(Collections.EMPTY_LIST,keySetList);
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0, 30.0, 50.0, 60.0, 80.0));
keySetList = fint.getUniqueSortedFillValuesFromAllZoomLevels();
assertEquals(testList,keySetList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Interval at the 4th zoom level " + fint.getFillInterval(FINT.FOURTH_ZOOM_LEVEL) );
System.out.println("Fill Interval at the 5th zoom level " + fint.getFillInterval(FINT.FIFTH_ZOOM_LEVEL) );
System.out.println("The unique fill values sorted in ascending order: "+ fint.getUniqueSortedFillValuesFromAllZoomLevelsAsString());
}
/*
* Test contour interval string with more than 5 zoom levels (currently 5 is the maximum)
*/
@Test
public void testFINTWithMoreThanFiveZoomLevels(){
FINT fint = new FINT("2/-6/6/3 > 30;50;80 > 60;80 > 0.00009999 > 0.0000001;0.2 > 90 > 100;200;300;400");
testList = new ArrayList<Double>(Arrays.asList(0.0000001,0.2));
keySetList = fint.getFillValuesListAsDouble(FINT.MAX_ZOOM_LEVEL);
assertEquals(testList,keySetList);
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
System.out.println("The input string = "+fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? " + fint.isFINTStringParsed());
System.out.println("Fill Values at the maximum zoom level " + fint.getFillValuesListAsDouble(FINT.MAX_ZOOM_LEVEL) );
}
/*
* Test contour interval string with multiple zoom levels, some of which are invalid
*/
@Test
public void testFINTWithInvalidZoomLevels() throws IndexOutOfBoundsException{
System.out.println("=====================Test-Case "+testCaseNumber+"========================");
FINT fint = new FINT("2/-6/6/3 > > 60; 80 > > ");
System.out.println("The input string = "+"2/-6/6/3 > > 60; 80 > > ");
System.out.println("Is the FINT string parsed correctly? " + fint.isFINTStringParsed());
}
}

497
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/infill/FLineTest.java
View file

@ -1,497 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.infill;
import gov.noaa.nws.ncep.gempak.parameters.infill.FLine;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import static org.junit.Assert.*;
/**
*<pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 04-Nov-2009 185 Archana.S Initial Creation
* </pre>
* @author Archana.S
* @version 1
*/
public class FLineTest {
private static Integer testCaseNumber=1;
private List<Integer>testColorList;
private List<Integer>testPatternList;
private List<Integer>testColorList2;
private List<Integer>testPatternList2;
private List<Integer>testColorList3;
private List<Integer>testPatternList3;
@Test
public void testValidListOfColorsWithRepeatingPatterns(){
System.out.println("------------------Test-case "+ testCaseNumber +"a----------------");
FLine fline = new FLine("1;2;3;4/4;5");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(1,2,3,4));
testPatternList = new ArrayList<Integer>(Arrays.asList(4,5,4,5));
assertEquals(fline.getFillColorList(), testColorList);
assertEquals(fline.getFillTypeList(), testPatternList);
System.out.println("------------------Test-case "+ testCaseNumber +"b----------------");
FLine fline2 = new FLine("6;5;4;3;2;1/1;2;3;4;5;6");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+fline2.isFLineStringParsed());
System.out.println("The input string : " +fline2.getFLineString());
System.out.println("The list of colors: "+fline2.getFillColorList());
System.out.println("The list of patterns: "+fline2.getFillTypeList());
assertEquals(fline2.isFLineStringParsed(),true);
testColorList2 = new ArrayList<Integer>(Arrays.asList(6,5,4,3,2,1));
testPatternList2 = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6));
assertEquals(fline2.getFillColorList(), testColorList2);
assertEquals(fline2.getFillTypeList(), testPatternList2);
System.out.println("--------------------------------------------------------");
testCaseNumber++;
}
@Test
public void testValidListOfColors(){
System.out.println("------------------Test-case "+ testCaseNumber +"a----------------");
FLine fline = new FLine("1;2;3;4");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(1,2,3,4));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1,1,1));
assertEquals(fline.getFillTypeList(), testPatternList);
System.out.println("------------------Test-case "+ testCaseNumber +"b----------------");
FLine fline2 = new FLine("6;5;4;3;2;1/");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+fline2.isFLineStringParsed());
System.out.println("The input string : " +fline2.getFLineString());
System.out.println("The list of colors: "+fline2.getFillColorList());
System.out.println("The list of patterns: "+fline2.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline2.isFLineStringParsed(),true);
testColorList2 = new ArrayList<Integer>(Arrays.asList(6,5,4,3,2,1));
assertEquals(fline2.getFillColorList(), testColorList2);
testPatternList2 = new ArrayList<Integer>(Arrays.asList(1,1,1,1,1,1));
assertEquals(fline2.getFillTypeList(), testPatternList2);
testCaseNumber++;
}
@Test
public void testListOfColorsWithSomeMissingNumbers(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine(";5;;15;;25");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(0,5,0,15,0,25));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1,1,1,1,1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testListOfColorsWithBlanksAndMissingNumbers(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine("5; 4 ;6 ;; ; 8");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(5, 4, 6, 0, 0, 8));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1,1,1,1,1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testLisOfColorsWithAllNumbersMissing(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline2 = new FLine(";;;;;");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline2.isFLineStringParsed());
System.out.println("The input string : " +fline2.getFLineString());
System.out.println("The list of colors: "+fline2.getFillColorList());
System.out.println("--------------------------------------------------------");
assertEquals(fline2.isFLineStringParsed(),false);
testCaseNumber++;
}
@Test
public void testValidSingleColorInputs(){
System.out.println("------------------Test-case "+ testCaseNumber +"a----------------");
FLine fline = new FLine("10;");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("------------------Test-case "+ testCaseNumber +"b----------------");
FLine fline2 = new FLine("11/");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+fline2.isFLineStringParsed());
System.out.println("The input string : " +fline2.getFLineString());
System.out.println("The list of colors: "+fline2.getFillColorList());
System.out.println("The list of patterns: "+fline2.getFillTypeList());
System.out.println("------------------Test-case "+ testCaseNumber +"c----------------");
FLine fline3 = new FLine("13");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"c? "+fline3.isFLineStringParsed());
System.out.println("The input string : " +fline3.getFLineString());
System.out.println("The list of colors: "+fline3.getFillColorList());
System.out.println("The list of patterns: "+fline3.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(10));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1));
assertEquals(fline.getFillTypeList(), testPatternList);
assertEquals(fline2.isFLineStringParsed(),true);
testColorList2 = new ArrayList<Integer>(Arrays.asList(11));
assertEquals(fline2.getFillColorList(), testColorList2);
testPatternList2 = new ArrayList<Integer>(Arrays.asList(1));
assertEquals(fline2.getFillTypeList(), testPatternList2);
assertEquals(fline3.isFLineStringParsed(),true);
testColorList3 = new ArrayList<Integer>(Arrays.asList(13));
assertEquals(fline3.getFillColorList(), testColorList3);
testPatternList3 = new ArrayList<Integer>(Arrays.asList(1));
assertEquals(fline3.getFillTypeList(), testPatternList3);
testCaseNumber++;
}
@Test
public void testValidColorInputRange(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine("30-45");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithMinMaxValuesAltered(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine("30-4");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithMissingMinValue(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine("-20");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithMissingMaxValue(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine("10-");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(10, 9, 8, 7, 6, 5, 4, 3, 2, 1));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithExcessParameters(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine("30-45-70-80");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testFLineWithEmptyStringInput(){
System.out.println("------------------Test-case "+ testCaseNumber +"a----------------");
FLine fline = new FLine("");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("------------------Test-case "+ testCaseNumber +"b----------------");
FLine fline2 = new FLine();
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+fline2.isFLineStringParsed());
System.out.println("The input string : " +fline2.getFLineString());
System.out.println("The list of colors: "+fline2.getFillColorList());
System.out.println("------------------Test-case "+ testCaseNumber +"c----------------");
FLine fline3 = new FLine(" ");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"c? "+fline3.isFLineStringParsed());
System.out.println("The input string : " +fline3.getFLineString());
System.out.println("The list of colors: "+fline3.getFillColorList());
System.out.println("------------------Test-case "+ testCaseNumber +"d----------------");
FLine fline4 = new FLine(null);
System.out.println("Is line data parsed in test-case "+testCaseNumber+"d? "+fline4.isFLineStringParsed());
System.out.println("The input string : " +fline4.getFLineString());
System.out.println("The list of colors: "+fline4.getFillColorList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),false);
assertEquals(fline2.isFLineStringParsed(),false);
assertEquals(fline3.isFLineStringParsed(),false);
assertEquals(fline4.isFLineStringParsed(),false);
testCaseNumber++;
}
@Test
public void testFLineWithInvalidDelimiters(){
System.out.println("------------------Test-case "+ testCaseNumber +"a----------------");
FLine fline = new FLine("10,20,30,");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
assertEquals(fline.isFLineStringParsed(),false);
System.out.println("------------------Test-case "+ testCaseNumber +"b----------------");
FLine fline2 = new FLine("40;50//60");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+fline2.isFLineStringParsed());
System.out.println("The input string : " +fline2.getFLineString());
System.out.println("The list of colors: "+fline2.getFillColorList());
assertEquals(fline2.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(40, 50));
assertEquals(fline2.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1,1));
assertEquals(fline2.getFillTypeList(), testPatternList);
System.out.println("------------------Test-case "+ testCaseNumber +"c----------------");
FLine fline3 = new FLine("10=40");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"c? "+fline3.isFLineStringParsed());
System.out.println("The input string : " +fline3.getFLineString());
System.out.println("The list of colors: "+fline3.getFillColorList());
assertEquals(fline3.isFLineStringParsed(),false);
System.out.println("--------------------------------------------------------");
testCaseNumber++;
}
@Test
public void testFLineWithNonNumericInputs(){
System.out.println("------------------Test-case "+ testCaseNumber +"a----------------");
FLine fline = new FLine("10a;gp##$%;*jsao/");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("------------------Test-case "+ testCaseNumber +"b----------------");
FLine fline2 = new FLine("10a;bcd");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+fline2.isFLineStringParsed());
System.out.println("The input string : " +fline2.getFLineString());
System.out.println("The list of colors: "+fline2.getFillColorList());
System.out.println("------------------Test-case "+ testCaseNumber +"c----------------");
FLine fline3 = new FLine("abc-def");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"c? "+fline3.isFLineStringParsed());
System.out.println("The input string : " +fline3.getFLineString());
System.out.println("The list of colors: "+fline3.getFillColorList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),false);
assertEquals(fline2.isFLineStringParsed(),false);
assertEquals(fline3.isFLineStringParsed(),false);
testCaseNumber++;
}
@Test
public void testColorRange(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
FLine fline = new FLine("0;30-20");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+fline.isFLineStringParsed());
System.out.println("The input string : " +fline.getFLineString());
System.out.println("The list of colors: "+fline.getFillColorList());
System.out.println("The list of patterns: "+fline.getFillTypeList());
System.out.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(),true);
testColorList = new ArrayList<Integer>(Arrays.asList(0, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20));
assertEquals(fline.getFillColorList(), testColorList);
testCaseNumber++;
}
}

958
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/inline/LineDataStringParserTest.java
View file

@ -1,958 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.inline;
import static org.junit.Assert.assertEquals;
import org.junit.Assert;
import org.junit.Test;
/**
* *
*
* <pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 30-Oct-2009 186 Archana.S Initial Creation
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
* </pre>
*
* @author Archana.S
* @version 1
*/
public class LineDataStringParserTest {
private static Integer testCaseNumber=1;
@Test
public void testValidLineDataStringWithAllInputsAndBlanksWithinInputString(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("5 ; 6 ; 12 /3 ; 4/5;6/1/2/0.5/T");
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertDoubleComparison(ldsp1.getInstanceOfLineBuilder()
.getPointsFilter().doubleValue(), 0.5);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 2);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
/**
* @param pointsFilter
* @param d
*/
private static void assertDoubleComparison(Double pointsFilter, double d) {
Assert.assertEquals(d, pointsFilter.doubleValue(), 0.01);
}
@Test
public void testValidLineDataStringWithOnlyLineColorInput(){
System.out.println("------------------Test-case "+ testCaseNumber +"a----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("7;");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertDoubleComparison(ldsp1.getInstanceOfLineBuilder()
.getPointsFilter().doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
System.out.println("------------------Test-case "+ testCaseNumber +"b----------------");
LineDataStringParser ldsp2 = new LineDataStringParser("6/");
if(ldsp2.isLineDataParsed()){
assertEquals(ldsp2.getInstanceOfLineBuilder().isSmallContourFlagSuppressed(),false);
assertEquals(ldsp2.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp2.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp2.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp2.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp2.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp2.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp2.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp2.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp2.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp2.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
System.out.println("------------------Test-case "+ testCaseNumber +"c----------------");
LineDataStringParser ldsp3 = new LineDataStringParser("5");
if(ldsp3.isLineDataParsed()){
assertEquals(ldsp3.getInstanceOfLineBuilder().isSmallContourFlagSuppressed(),false);
assertEquals(ldsp3.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp3.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp3.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"c? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp3.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp3.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp3.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp3.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp3.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp3.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp3.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithMultipleColorsAndFilterDataOnly(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("3;2;16/0.67654");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.67654);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithSingleColorAndFilterDataOnly(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("3/0.67654");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.67654);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithLineColorPointsFilterDataAndSmallContourFlag(){
LineDataStringParser ldsp1 = new LineDataStringParser("7/0.5/true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.5);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithPointsFilterDataOnly(){
LineDataStringParser ldsp1 = new LineDataStringParser(".7");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.7);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithPointsFilterDataAndSmallContourFlag(){
LineDataStringParser ldsp1 = new LineDataStringParser("1.0/TRUE");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 1.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithLineColorAndPatternOnly(){
LineDataStringParser ldsp1 = new LineDataStringParser("7/7");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithIntegerLineAttributesOnly(){
LineDataStringParser ldsp1 = new LineDataStringParser("8;9;10/2;4/3/2/2");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 2);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataStringWithSmallContourFlagOnly(){
LineDataStringParser ldsp1 = new LineDataStringParser("true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testEmptyStringFunction1(){
LineDataStringParser ldsp1 = new LineDataStringParser();
if(!ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testEmptyStringFunction2(){
LineDataStringParser ldsp1 = new LineDataStringParser("");
if(!ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testInputStringWithBlanks(){
LineDataStringParser ldsp1 = new LineDataStringParser(" ");
if(!ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithoutSmoothFactorInInputString(){
LineDataStringParser ldsp1 = new LineDataStringParser("132;240;255/4;4;4/5;5;5/3");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMissingInputLineColor(){
LineDataStringParser ldsp1 = new LineDataStringParser("/4;10/6/1/1/0.65789/true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.65789);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 1);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMissingInputLinePattern(){
LineDataStringParser ldsp1 = new LineDataStringParser("144;110//6/1/1/0.65789/true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.65789);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 1);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMissingInputLineWidth(){
LineDataStringParser ldsp1 = new LineDataStringParser("4;10/8;9//1/1/0.9999/true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.9999);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 1);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMissingInputLineLabel(){
LineDataStringParser ldsp1 = new LineDataStringParser("4;10/8;9/6;7//1/0.65789/true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.65789);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 1);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMissingInputLineSmoothingLevel(){
LineDataStringParser ldsp1 = new LineDataStringParser("4;10/8;9/6;7/2//0.65789/true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.65789);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMissingInputPointsFilter(){
LineDataStringParser ldsp1 = new LineDataStringParser("4;10/8;9/6;7/2/2//true");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 2);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMissingInputSmallContourFlag(){
LineDataStringParser ldsp1 = new LineDataStringParser("4;10/8;9/6;7/2/1/0.65789/");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.65789);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 1);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testValidLineDataParserWithMultipleMissingInputs(){
LineDataStringParser ldsp1 = new LineDataStringParser("4;10//6;7///0.65789/");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.65789);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testLineDataParserWithPatternOutOfRange(){
LineDataStringParser ldsp1 = new LineDataStringParser("240;234/28;36/6/1/1/0.4477");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.4477);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 1);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testLineDataParserWithPointsDataFilterOutOfRange(){
LineDataStringParser ldsp1 = new LineDataStringParser("2/4/6/1/1/3.65789");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 1);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
System.out.println("--------------------------------------------------------");
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithNegativeValuesForLineColor(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("5;-6;-12");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithNegativeValuesForIntegerAttributes(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("5;-6;-12/5;-10/-4/-2/2/0.7");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.7);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 2);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithNegativeValueForPointsFilter(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("-0.7");
if(!ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithInvalidDelimiters(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("5,6,12");
if(!ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithNonNumericInputs(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("lmn;abc;def/2;4/5/1/2/0.6/t");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.6);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 2);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
@Test
public void testLineDataStringOutOffOrderInputs(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("0.6667/2/true/4/5");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), false);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.0);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithExcessInputs(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("5;6;12/3;4/5;6/1/3/4/5/2/0.5/T");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isSmallContourFlagSuppressed(), true);
assertEquals(ldsp1.getInstanceOfLineBuilder().getPointsFilter()
.doubleValue(), 0.5);
assertEquals(ldsp1.getInstanceOfLineBuilder()
.getLineSmoothingLevel().intValue(), 0);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("List of line colors: " +ldsp1.getInstanceOfLineBuilder().getLineColorsList());
System.out.println("List of line patterns: " +ldsp1.getInstanceOfLineBuilder().getLinePatternsList());
System.out.println("List of line widths: " +ldsp1.getInstanceOfLineBuilder().getLineWidthList());
System.out.println("List of lines to be labelled: "+ldsp1.getInstanceOfLineBuilder().getLineLabelPresentList());
System.out.println("Smoothing Level: " +ldsp1.getInstanceOfLineBuilder().getLineSmoothingLevel());
System.out.println("Points filter data: " +ldsp1.getInstanceOfLineBuilder().getPointsFilter());
System.out.println("Small Contour Flag: " +ldsp1.getInstanceOfLineBuilder().isSmallContourFlagSuppressed());
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithNegativeLabel(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("5;6;12/3;4/5;6/-2/0.5/T");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isBreakInLineForLabel(), false);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"? "+ldsp1.isLineDataParsed());
System.out.println("Is there a break in the line for the label: " +ldsp1.getInstanceOfLineBuilder().isBreakInLineForLabel());
}
testCaseNumber++;
}
@Test
public void testLineDataStringWithPositiveLabel(){
System.out.println("------------------Test-case "+ testCaseNumber +"----------------");
LineDataStringParser ldsp1 = new LineDataStringParser("5;6;12/3;4/5;6/2/0.5/T");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isBreakInLineForLabel(), true);
System.out.println("The input string : " +ldsp1.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"a? "+ldsp1.isLineDataParsed());
System.out.println("Is there a break in the line for the label: " +ldsp1.getInstanceOfLineBuilder().isBreakInLineForLabel());
}
LineDataStringParser ldsp2= new LineDataStringParser("5;6;12/3;4/5;6/1;2/0.5/T");
if(ldsp1.isLineDataParsed()){
assertEquals(ldsp1.getInstanceOfLineBuilder()
.isBreakInLineForLabel(), true);
System.out.println("The input string : " +ldsp2.getLineDataString());
System.out.println("Is line data parsed in test-case "+testCaseNumber+"b? "+ldsp1.isLineDataParsed());
System.out.println("Is there a break in the line for the label: " +ldsp2.getInstanceOfLineBuilder().isBreakInLineForLabel());
}
testCaseNumber++;
}
}

226
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/intext/TextStringParserTest.java
View file

@ -1,226 +0,0 @@
package gov.noaa.nws.ncep.gempak.parameters.intext;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
/**
* TEXT format: size/font/width/hwflgs
*
*/
public class TextStringParserTest {
private static int testCaseNumber=1;
@Test
public void testTextInputStringParse1 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with blank string----------------");
TextStringParser txt = new TextStringParser("");
if ( ! txt.isTextParsed()) {
assertEquals (txt.isTextParsed(),false);
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
}
testCaseNumber ++;
}
@Test
public void testHLSYMInputStringParse2 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with sizes----------------");
TextStringParser txt = new TextStringParser("1.286");
if ( txt.isTextParsed() ) {
assertEquals (txt.isTextParsed(),true);
assertEquals (txt.getSymbolMarkerSize(), 1.286f);
assertEquals (txt.getTextSize(), 18);
assertEquals (txt.getTextFont(), 1);
assertEquals (txt.getTextWidth(), 2);
assertEquals (txt.getTextHWFlag(), "HW");
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
System.out.println ( " Symbol/Marker size : " + txt.getSymbolMarkerSize() );
System.out.println ( " Text size : " + txt.getTextSize() );
System.out.println ( " Text font : " + txt.getTextFont() );
System.out.println ( " Text width : " + txt.getTextWidth() );
System.out.println ( " Text hwflg : " + txt.getTextHWFlag() );
}
testCaseNumber ++;
}
@Test
public void testHLSYMInputStringParse3 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with size name ----------------");
TextStringParser txt = new TextStringParser("tin");
if ( txt.isTextParsed() ) {
assertEquals (txt.isTextParsed(),true);
assertEquals (txt.getSymbolMarkerSize(), 0.714f);
assertEquals (txt.getTextSize(), 10);
assertEquals (txt.getTextFont(), 1);
assertEquals (txt.getTextWidth(), 2);
assertEquals (txt.getTextHWFlag(), "HW");
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
System.out.println ( " Symbol/Marker size : " + txt.getSymbolMarkerSize() );
System.out.println ( " Text size : " + txt.getTextSize() );
System.out.println ( " Text font : " + txt.getTextFont() );
System.out.println ( " Text width : " + txt.getTextWidth() );
System.out.println ( " Text hwflg : " + txt.getTextHWFlag() );
}
testCaseNumber ++;
}
@Test
public void testHLSYMInputStringParse4 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with size/font ----------------");
TextStringParser txt = new TextStringParser("1.286/2");
if ( txt.isTextParsed() ) {
assertEquals (txt.isTextParsed(),true);
assertEquals (txt.getSymbolMarkerSize(), 1.286f);
assertEquals (txt.getTextSize(), 18);
assertEquals (txt.getTextFont(), 2);
assertEquals (txt.getTextWidth(), 2);
assertEquals (txt.getTextHWFlag(), "HW");
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
System.out.println ( " Symbol/Marker size : " + txt.getSymbolMarkerSize() );
System.out.println ( " Text size : " + txt.getTextSize() );
System.out.println ( " Text font : " + txt.getTextFont() );
System.out.println ( " Text width : " + txt.getTextWidth() );
System.out.println ( " Text hwflg : " + txt.getTextHWFlag() );
}
testCaseNumber ++;
}
@Test
public void testHLSYMInputStringParse5 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with size/invalid font ----------------");
TextStringParser txt = new TextStringParser("1.286/5");
if ( txt.isTextParsed() ) {
assertEquals (txt.isTextParsed(),true);
assertEquals (txt.getSymbolMarkerSize(), 1.286f);
assertEquals (txt.getTextSize(), 18);
assertEquals (txt.getTextFont(), 1);
assertEquals (txt.getTextWidth(), 2);
assertEquals (txt.getTextHWFlag(), "HW");
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
System.out.println ( " Symbol/Marker size : " + txt.getSymbolMarkerSize() );
System.out.println ( " Text size : " + txt.getTextSize() );
System.out.println ( " Text font : " + txt.getTextFont() );
System.out.println ( " Text width : " + txt.getTextWidth() );
System.out.println ( " Text hwflg : " + txt.getTextHWFlag() );
}
testCaseNumber ++;
}
@Test
public void testHLSYMInputStringParse6 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with size/ font / width ----------------");
TextStringParser txt = new TextStringParser("1.714/3/8");
if ( txt.isTextParsed() ) {
assertEquals (txt.isTextParsed(),true);
assertEquals (txt.getSymbolMarkerSize(), 1.714f);
assertEquals (txt.getTextSize(), 24);
assertEquals (txt.getTextFont(), 3);
assertEquals (txt.getTextWidth(), 8);
assertEquals (txt.getTextHWFlag(), "HW");
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
System.out.println ( " Symbol/Marker size : " + txt.getSymbolMarkerSize() );
System.out.println ( " Text size : " + txt.getTextSize() );
System.out.println ( " Text font : " + txt.getTextFont() );
System.out.println ( " Text width : " + txt.getTextWidth() );
System.out.println ( " Text hwflg : " + txt.getTextHWFlag() );
}
testCaseNumber ++;
}
@Test
public void testHLSYMInputStringParse7 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with size/ font / width /hw flag ----------------");
TextStringParser txt = new TextStringParser("2.429/2/8/HW");
if ( txt.isTextParsed() ) {
assertEquals (txt.isTextParsed(),true);
assertEquals (txt.getSymbolMarkerSize(), 2.429f);
assertEquals (txt.getTextSize(), 34);
assertEquals (txt.getTextFont(), 2);
assertEquals (txt.getTextWidth(), 8);
assertEquals (txt.getTextHWFlag(), "HW");
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
System.out.println ( " Symbol/Marker size : " + txt.getSymbolMarkerSize() );
System.out.println ( " Text size : " + txt.getTextSize() );
System.out.println ( " Text font : " + txt.getTextFont() );
System.out.println ( " Text width : " + txt.getTextWidth() );
System.out.println ( " Text hwflg : " + txt.getTextHWFlag() );
}
testCaseNumber ++;
}
@Test
public void testHLSYMInputStringParse8 () {
System.out.println("------------------Test-case "+ testCaseNumber +" with size/ font / width /hw flag ----------------");
TextStringParser txt = new TextStringParser("2.429/2/8/SW");
if ( txt.isTextParsed() ) {
assertEquals (txt.isTextParsed(),true);
assertEquals (txt.getSymbolMarkerSize(), 2.429f);
assertEquals (txt.getTextSize(), 34);
assertEquals (txt.getTextFont(), 2);
assertEquals (txt.getTextWidth(), 8);
assertEquals (txt.getTextHWFlag(), "SW");
System.out.println ( "--User Input Text parameter:" + txt.getInputTextString() );
System.out.println ( "-----------------------------" );
System.out.println ( " Symbol/Marker size : " + txt.getSymbolMarkerSize() );
System.out.println ( " Text size : " + txt.getTextSize() );
System.out.println ( " Text font : " + txt.getTextFont() );
System.out.println ( " Text width : " + txt.getTextWidth() );
System.out.println ( " Text hwflg : " + txt.getTextHWFlag() );
}
testCaseNumber ++;
}
}

1
ncep/gov.noaa.nws.ncep.ui.pgen/.classpath
View file

@ -1,7 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="unit-test"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="output" path="bin"/>

5
ncep/gov.noaa.nws.ncep.ui.pgen/META-INF/MANIFEST.MF
View file

@ -43,8 +43,5 @@ Import-Package: com.raytheon.edex.meteoLib,
com.raytheon.viz.core.gl,
com.raytheon.viz.core.gl.images,
gov.noaa.nws.ncep.common.staticdata,
javax.measure.unit,
org.junit,
org.junit.runner,
org.junit.runners
javax.measure.unit
Bundle-ClassPath: .

198
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/GfaFormatTest.java
View file

@ -1,198 +0,0 @@
package gov.noaa.nws.ncep.ui.pgen.gfa;
import static org.junit.Assert.*;
import gov.noaa.nws.ncep.ui.pgen.elements.AbstractDrawableComponent;
import gov.noaa.nws.ncep.ui.pgen.elements.Layer;
import gov.noaa.nws.ncep.ui.pgen.elements.Product;
import gov.noaa.nws.ncep.ui.pgen.file.ProductConverter;
import gov.noaa.nws.ncep.ui.pgen.file.Products;
import gov.noaa.nws.ncep.ui.pgen.tools.PgenCycleTool;
import java.io.FileNotFoundException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
//import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import com.raytheon.uf.common.serialization.SerializationException;
import com.raytheon.uf.viz.core.localization.LocalizationManager;
public class GfaFormatTest {
/** Logger */
// private final static Logger log = Logger.getLogger(GfaFormatTest.class);
public static final String BASE_DIR = "../../eclipse/";
public static final int CYCLE_DAY = 20;
public static final int CYCLE_HOUR = 14;
public static final String HTTP_SERVER = "http://localhost:9581/services";
public static final String PACKAGE = "unit-test/"
+ GfaFormatTest.class.getPackage().getName().replace(".", "/") + "/xml/";
public static String rulesXml = "rules.xml";
private static Document doc;
@Before
public void setUp() throws Exception {
configure();
getDocument();
}
@After
public void tearDown() throws Exception {
}
@Ignore
public void getDocumentTest() {
// reads the rules file
assertNotNull(doc);
}
private void createSmearsTest(String fileName, GfaWording expectedWording, int adj) throws FileNotFoundException, SerializationException {
List<AbstractDrawableComponent> drawables = read(PACKAGE + fileName);
// test if all gfa and size
ArrayList<Gfa> gfaList = new ArrayList<Gfa>();
for (AbstractDrawableComponent adc : drawables) {
if (adc instanceof Gfa)
gfaList.add((Gfa) adc);
}
assertFalse(gfaList.isEmpty());
int sizeBefore = gfaList.size();
GfaFormat gf = new GfaFormat();
// actual test
gf.createSmears(drawables);
int sizeAfter = drawables.size();
assertTrue(sizeAfter > sizeBefore);
Gfa gfa = (Gfa) drawables.get(sizeBefore + adj);
GfaWording e = expectedWording; // expected
GfaWording r = gfa.getAttribute("WORDING", GfaWording.class); // result
assertEquals("failed fromCondsDvlpg in " + fileName, e.fromCondsDvlpg, r.fromCondsDvlpg);
assertEquals("failed fromCondsEndg in " + fileName, e.fromCondsEndg, r.fromCondsEndg);
assertEquals("failed genOlk in " + fileName, e.genOlk, r.genOlk);
assertEquals("failed condsContg in " + fileName, e.condsContg, r.condsContg);
assertEquals("failed otlkCondsDvlpg in " + fileName, e.otlkCondsDvlpg, r.otlkCondsDvlpg);
assertEquals("failed otlkCondsEndg in " + fileName, e.otlkCondsEndg, r.otlkCondsEndg);
assertEquals("failed in " + fileName, e, r);
}
@Test
public void runRules() {
String xPath = "/rules/rule";
List<Node> nodes = selectNodes(xPath);
StringBuilder sb = new StringBuilder(500);
int errors = 0;
for (Node n : nodes) {
String[] fileNames = n.valueOf("@filenames").split(",");
for(String fileName: fileNames){
// if(!fileName.startsWith("gfa01.xml")) continue;
String fromCondsDvlpg = n.valueOf("@fromCondsDvlpg");
String fromCondsEndg = n.valueOf("@fromCondsEndg");
String genOlk = n.valueOf("@genOlk");
String condsContg = n.valueOf("@condsContg");
String otlkCondsDvlpg = n.valueOf("@otlkCondsDvlpg");
String otlkCondsEndg = n.valueOf("@otlkCondsEndg");
String orderInQueue = n.valueOf("@orderInQueue");
int plus = 0;
if (!orderInQueue.isEmpty()) {
plus = Integer.parseInt(orderInQueue);
}
GfaWording expected = new GfaWording();
expected.fromCondsDvlpg = fromCondsDvlpg;
expected.fromCondsEndg = fromCondsEndg;
expected.genOlk = genOlk;
expected.condsContg = condsContg;
expected.otlkCondsDvlpg = otlkCondsDvlpg;
expected.otlkCondsEndg = otlkCondsEndg;
sb.append("filename=\"" + fileName + "\"\nExpected:\n");
sb.append(expected.toString());
// log.info(sb.toString());
sb.setLength(0);
try {
createSmearsTest(fileName, expected, plus);
} catch (Exception e) {
// log.error("\ncreateSmearsTest failed: " + fileName, e);
e.printStackTrace();
errors++;
}
}
}
assertEquals("Number of failed files ", 0, errors);
// log.info(sb.toString());
}
private List<AbstractDrawableComponent> read(String file) throws FileNotFoundException, SerializationException {
Products products = (Products) Util.read(file);
List<Product> productList = ProductConverter.convert(products);
assertEquals(1, productList.size());
List<Layer> layerList = productList.get(0).getLayers();
assertEquals(1, layerList.size());
List<AbstractDrawableComponent> drawables = layerList.get(0).getDrawables();
return drawables;
}
/**
* Sets base directory and cycle.
*
* @throws NoSuchFieldException
* @throws IllegalAccessException
*/
public static void configure() throws NoSuchFieldException, IllegalAccessException {
long time = System.currentTimeMillis();
LocalizationManager.setBaseDir(GfaFormatTest.BASE_DIR);
// use reflection to update private fields
Field field = PgenCycleTool.class.getDeclaredField("cycleDay");
field.setAccessible(true);
field.set(null, GfaFormatTest.CYCLE_DAY);
field = PgenCycleTool.class.getDeclaredField("cycleHour");
field.setAccessible(true);
field.set(null, GfaFormatTest.CYCLE_HOUR);
//?NcDirectDbQuery.setHttpServer(HTTP_SERVER);
// log.debug("configure() " + (System.currentTimeMillis() - time) + " ms");
if(!PreloadGfaDataThread.loaded) {
// preload the classes to reduce the first GFA format time
new PreloadGfaDataThread().run();
}
}
static int count = 0;
private void getDocument() {
if (doc != null) return;
try {
SAXReader reader = new SAXReader();
doc = reader.read(PACKAGE + rulesXml);
} catch (Exception e) {
// log.error(e);
e.printStackTrace();
}
}
@SuppressWarnings("unchecked")
private List<Node> selectNodes(String xPath) {
return doc.selectNodes(xPath);
}
}

33
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/GfaInfoTest.java
View file

@ -1,33 +0,0 @@
package gov.noaa.nws.ncep.ui.pgen.gfa;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import gov.noaa.nws.ncep.ui.pgen.tools.PgenCycleTool;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class GfaInfoTest {
@Before
public void setUp() throws Exception {
GfaFormatTest.configure();
}
@After
public void tearDown() throws Exception {
}
@Test
public void testCycle() {
assertEquals(GfaFormatTest.CYCLE_DAY, PgenCycleTool.getCycleDay());
assertEquals(GfaFormatTest.CYCLE_HOUR, PgenCycleTool.getCycleHour());
}
@Test
public void getDocument() {
// reads the gfa configuration file
assertNotNull(GfaInfo.getDocument());
}
}

195
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/ReduceGfaPointsTest.java
View file

@ -1,195 +0,0 @@
package gov.noaa.nws.ncep.ui.pgen.gfa;
import static org.junit.Assert.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import com.vividsolutions.jts.geom.Coordinate;
public class ReduceGfaPointsTest {
/**
* Test method for {@link gov.noaa.nws.ncep.ui.pgen.tools.ReduceGfaPoints#reduceBySize(com.vividsolutions.jts.geom.CoordinateList, java.util.List, int, double, double)}.
*/
@Test
public final void testReduceBySize() {
// TODO
Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(1.6666666666666667,1.0), new Coordinate(0.12499999999999996,-3.625), new Coordinate(-1.8571428571428572,1.0)};
List<Coordinate> clAfter= Arrays.asList(coordAfter);
int result = ReduceGfaPoints.reduceBySize(cl, null, orig, 3, 60.0, 100.0);
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceBySize2() {
// TODO
Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,0), new Coordinate(1,-1), new Coordinate(0,-1),
new Coordinate(-1,-1), new Coordinate(-1,0), new Coordinate(-1,1), new Coordinate(0,1)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = {new Coordinate(1,-1), new Coordinate(-1,-1), new Coordinate(-1,1)};
List<Coordinate> clAfter= Arrays.asList(coordAfter);
int result = ReduceGfaPoints.reduceBySize(cl, null, orig, 3, 60.0, 100.0);
assertEquals("Result", clAfter, cl);
}
/**
* Test method for {@link gov.noaa.nws.ncep.ui.pgen.tools.ReduceGfaPoints#reduceByPctDist(com.vividsolutions.jts.geom.CoordinateList, java.util.List, java.util.List, double, double, double, java.lang.String)}.
*/
@Test
public final void testReduceByPctDist() {
// TODO //set LENFROM=35
Coordinate[] coord = {new Coordinate(-110.57, 54.72), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
new Coordinate(-96.65,41.84), new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34),
new Coordinate(-117.95,42.4), new Coordinate(-118.43,47.81), new Coordinate(-115.17,52.63)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-110.57, 54.72), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34), new Coordinate(-118.43,47.81)};
List<Coordinate> clAfter= Arrays.asList(coordAfter);
ReduceGfaPoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 450.0, "BOUNDED BY");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceByPctDist2() {
// TODO //set LENFROM=23
Coordinate[] coord = { new Coordinate(-90,40), new Coordinate(-96,33),
new Coordinate(-155,30), new Coordinate(-177,33), new Coordinate(-100,50)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-90,40), new Coordinate(-96,33),
new Coordinate(-155,30), new Coordinate(-177,33), new Coordinate(-100,50)};
List<Coordinate> clAfter= Arrays.asList(coordAfter);
ReduceGfaPoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 450.0, "BOUNDED BY");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceByPctDist3() {
// TODO FROM 4400ESE YSJ TO 4480ESE YSJ TO 4490ESE YSJ TO 4400ESE YSJ TO 4320ESE YSJ TO 4400ESE YSJ
Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(1.6666666666666667,1.0), new Coordinate(0.12499999999999996,-3.625), new Coordinate(-1.8571428571428572,1.0)}; //1,-1
List<Coordinate> clAfter= Arrays.asList(coordAfter);
ReduceGfaPoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 150.0, "FROM");
assertEquals("Result", clAfter, cl);
}
/**
* Test method for {@link gov.noaa.nws.ncep.ui.pgen.tools.ReduceGfaPoints#reduceKeepConcav(com.vividsolutions.jts.geom.CoordinateList, java.util.List, java.util.List, double, double, java.lang.String)}.
* @throws JAXBException
*/
@Test
public final void testReduceKeepConcav() {
// TODO //to test, set LENFROM=23
Coordinate[] coord = {new Coordinate(-100,50), new Coordinate(-90,40), new Coordinate(-96,33), new Coordinate(-155,30), new Coordinate(-177,33)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-92.7, 51.6), new Coordinate(-88.4, 33.4), new Coordinate(-155,30), new Coordinate(-177,33)};
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceKeepConcav(cl, null, orig, 60.0, 450.0, "FROM");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceKeepConcav2() {
// TODO
Coordinate[] coord = {new Coordinate(-110.57, 54.72), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
new Coordinate(-96.65,41.84), new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34),
new Coordinate(-117.95,42.4), new Coordinate(-118.43,47.81), new Coordinate(-115.17,52.63)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-112.75, 54.76), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
new Coordinate(-96.65,41.84), new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34),
new Coordinate(-117,33), new Coordinate(-118.59,49.62)};
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceKeepConcav(cl, null, orig, 60.0, 450.0, "FROM");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceKeepConcav3() {
// TODO
Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i=0; i<cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(1.6666666666666667,1.0), new Coordinate(0.12499999999999996,-3.625), new Coordinate(-1.8571428571428572,1.0)};
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceKeepConcav(cl, null, orig, 60.0, 150.0, "FROM");
assertEquals("Result", clAfter, cl);
}
@RunWith(Suite.class)
@Suite.SuiteClasses( { ReduceGfaPointsTest.class })
public class AllTests {
}
// public static void main(String[] args) {
// Result result = JUnitCore.runClasses(MyClassTest.class);
// for (Failure failure : result.getFailures()) {
// System.out.println(failure.toString());
// }
// }
}

1
ncep/gov.noaa.nws.ncep.viz.common/.classpath
View file

@ -1,7 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="unit_test"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="output" path="bin"/>

5
ncep/gov.noaa.nws.ncep.viz.common/META-INF/MANIFEST.MF
View file

@ -30,8 +30,5 @@ Export-Package: gov.noaa.nws.ncep.viz.common,
gov.noaa.nws.ncep.viz.common.ui.color
Import-Package: com.raytheon.uf.common.comm,
com.vividsolutions.jts.geom,
javax.measure.unit,
org.junit,
org.junit.runner,
org.junit.runners
javax.measure.unit

319
ncep/gov.noaa.nws.ncep.viz.common/unit_test/gov/noaa/nws/ncep/viz/common/graphicUtil/ReducePointsTest.java
View file

@ -1,319 +0,0 @@
/**
*
*/
package gov.noaa.nws.ncep.viz.common.graphicUtil;
/**
* Test Reduce points of a polygon by examining the angle at each point.
*
* @author Q.Zhou
* @version 1.0
*/
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.CoordinateList;
/**
* @author qzhou
*
*/
public class ReducePointsTest {
public ReducePointsTest() {
}
/**
* @throws java.lang.Exception
*/
@BeforeClass
public static void setUpBeforeClass() throws Exception {
}
/**
* @throws java.lang.Exception
*/
@AfterClass
public static void tearDownAfterClass() throws Exception {
}
/**
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception {
}
/**
* @throws java.lang.Exception
*/
@After
public void tearDown() throws Exception {
}
/**
* Test method for {@link gov.noaa.nws.ncep.viz.common.graphicUtil.ReducePoints#reduceByAngle(com.vividsolutions.jts.geom.CoordinateList, java.util.List, int)}.
*/
@Test
public void testReduceByAngle1() {
// TODO
Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
CoordinateList cl= new CoordinateList(coord);
Coordinate[] coordAfter = { new Coordinate(1,1), new Coordinate(0,-2), new Coordinate(-1,1)};
CoordinateList clAfter= new CoordinateList(coordAfter);
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(i, 1);
CoordinateList result = ReducePoints.reduceByAngle(cl, null, 3);
assertEquals("Result", clAfter, cl);
System.out.println(result);
}
@Test
public void testReduceByAngle2() {
Coordinate[] coord2 = {new Coordinate(1,1), new Coordinate(1,0), new Coordinate(1,-1), new Coordinate(0,-1),
new Coordinate(-1,-1), new Coordinate(-1,0), new Coordinate(-1,1), new Coordinate(0,1)};
CoordinateList cl2 = new CoordinateList(coord2);
Coordinate[] coordAfter2 = { new Coordinate(1,-1), new Coordinate(-1,-1), new Coordinate(-1,1) };
CoordinateList clAfter2 = new CoordinateList(coordAfter2);
CoordinateList result = ReducePoints.reduceByAngle(cl2, null, 3);
assertEquals("Result", clAfter2, cl2);
System.out.println(result);
}
@Test
public void testReduceByAngle3() {
Coordinate[] coord3 = {new Coordinate(1,1), new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(1,-1),
new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
CoordinateList cl3 = new CoordinateList(coord3);
Coordinate[] coordAfter3 = { new Coordinate(1,1),
new Coordinate(0,-2), new Coordinate(-1,1)};
CoordinateList clAfter3 = new CoordinateList(coordAfter3);
CoordinateList result = ReducePoints.reduceByAngle(cl3, null, 3);
assertEquals("Result", clAfter3, cl3);
System.out.println(result);
}
@Test
public void testReduceByAngle4() {
Coordinate[] coord3 = {new Coordinate(1,1), new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(1,-1),
new Coordinate(0,-1), new Coordinate(0,-1), new Coordinate(-1,-1), new Coordinate(-1,-1),
new Coordinate(-1,1), new Coordinate(-1,1)};
CoordinateList cl3 = new CoordinateList(coord3);
Coordinate[] coordAfter3 = { new Coordinate(1,1), new Coordinate(1,-1),
new Coordinate(-1,-1),
new Coordinate(-1,1), new Coordinate(-1,1)};
CoordinateList clAfter3 = new CoordinateList(coordAfter3);
CoordinateList result = ReducePoints.reduceByAngle(cl3, null, 5);
assertEquals("Result", clAfter3, cl3);
System.out.println(result);
}
@Test
public void testReduceByAngle5() {
Coordinate[] coord3 = {new Coordinate(20,20), new Coordinate(23,0), new Coordinate(20,-20), new Coordinate(0,-22),
new Coordinate(-20,-20), new Coordinate(-24,0), new Coordinate(-20,20), new Coordinate(0,21)};
CoordinateList cl3 = new CoordinateList(coord3);
Coordinate[] coordAfter3 = { new Coordinate(20,20), new Coordinate(23,0), new Coordinate(20,-20),
new Coordinate(-20,-20), new Coordinate(-24,0), new Coordinate(-20,20)};
CoordinateList clAfter3 = new CoordinateList(coordAfter3);
CoordinateList result = ReducePoints.reduceByAngle(cl3, null, 6);
assertEquals("Result", clAfter3, cl3);
System.out.println(result);
}
/**
* Test method for {@link gov.noaa.nws.ncep.viz.common.graphicUtil.ReducePoints#reduceBySize(com.vividsolutions.jts.geom.CoordinateList, java.util.List, int, double, double)}.
*/
// @Test
// public final void testReduceBySize() {
// // TODO
// Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(1.6666666666666667,1.0), new Coordinate(0.12499999999999996,-3.625), new Coordinate(-1.8571428571428572,1.0)};
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceBySize(cl, null, orig, 3, 60.0, 100.0);
// assertEquals("Result", clAfter, cl);
// }
//
// @Test
// public final void testReduceBySize2() {
// // TODO
// Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,0), new Coordinate(1,-1), new Coordinate(0,-1),
// new Coordinate(-1,-1), new Coordinate(-1,0), new Coordinate(-1,1), new Coordinate(0,1)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(3,-1), new Coordinate(-1,-1), new Coordinate(-1,3)};
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceBySize(cl, null, orig, 3, 60.0, 150.0);
// assertEquals("Result", clAfter, cl);
//
// }
/**
* Test method for {@link gov.noaa.nws.ncep.viz.common.graphicUtil.ReducePoints#reduceByPctDist(com.vividsolutions.jts.geom.CoordinateList, java.util.List, java.util.List, double, double, double, java.lang.String)}.
*/
// @Test
// public final void testReduceByPctDist() {
// // TODO //set LENFROM=35
// Coordinate[] coord = {new Coordinate(-110.57, 54.72), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
// new Coordinate(-96.65,41.84), new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34),
// new Coordinate(-117.95,42.4), new Coordinate(-118.43,47.81), new Coordinate(-115.17,52.63)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(-110.57, 54.72), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
// new Coordinate(-96.65,41.84), new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34),
// new Coordinate(-117.95,42.4), new Coordinate(-118.43,47.81), new Coordinate(-115.17,52.63)};
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 450.0, "BOUNDED BY");
// assertEquals("Result", clAfter, cl);
// }
// @Test
// public final void testReduceByPctDist2() {
// // TODO //set LENFROM=23
// Coordinate[] coord = { new Coordinate(-90,40), new Coordinate(-96,33),
// new Coordinate(-155,30), new Coordinate(-177,33), new Coordinate(-100,50)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(-92.7, 51.6), new Coordinate(-88.4, 33.4), new Coordinate(-155,30), new Coordinate(-177,33)};
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 450.0, "BOUNDED BY");
// assertEquals("Result", clAfter, cl);
// }
// @Test
// public final void testReduceByPctDist3() {
// // TODO FROM 4400ESE YSJ TO 4480ESE YSJ TO 4490ESE YSJ TO 4400ESE YSJ TO 4320ESE YSJ TO 4400ESE YSJ
// Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(1.6666666666666667,1.0), new Coordinate(0.12499999999999996,-3.625), new Coordinate(-1.8571428571428572,1.0)}; //1,-1
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 150.0, "FROM");
// assertEquals("Result", clAfter, cl);
// }
/**
* Test method for {@link gov.noaa.nws.ncep.viz.common.graphicUtil.ReducePoints#reduceKeepConcav(com.vividsolutions.jts.geom.CoordinateList, java.util.List, java.util.List, double, double, java.lang.String)}.
* @throws JAXBException
*/
// @Test
// public final void testReduceKeepConcav() {
// // TODO //to test, set LENFROM=23
// Coordinate[] coord = {new Coordinate(-100,50), new Coordinate(-90,40), new Coordinate(-96,33), new Coordinate(-155,30), new Coordinate(-177,33)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(-92.7, 51.6), new Coordinate(-88.4, 33.4), new Coordinate(-155,30), new Coordinate(-177,33)};
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceKeepConcav(cl, null, orig, 60.0, 450.0, "FROM");
// assertEquals("Result", clAfter, cl);
//
// }
// @Test
// public final void testReduceKeepConcav2() {
// // TODO
// Coordinate[] coord = {new Coordinate(-110.57, 54.72), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
// new Coordinate(-96.65,41.84), new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34),
// new Coordinate(-117.95,42.4), new Coordinate(-118.43,47.81), new Coordinate(-115.17,52.63)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(-112.75, 54.76), new Coordinate(-100.19, 54.54), new Coordinate(-89.37,48.92),
// new Coordinate(-96.65,41.84), new Coordinate(-103.69,37.25), new Coordinate(-113.93,38.34),
// new Coordinate(-117,33), new Coordinate(-118.59,49.62)};
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceKeepConcav(cl, null, orig, 60.0, 450.0, "FROM");
// assertEquals("Result", clAfter, cl);
// }
// @Test
// public final void testReduceKeepConcav3() {
// // TODO
// Coordinate[] coord = {new Coordinate(1,1), new Coordinate(1,-1), new Coordinate(0,-2), new Coordinate(-1,-1), new Coordinate(-1,1)};
// CoordinateList cl= new CoordinateList(coord);
//
// List<Integer> reduceFlg = new ArrayList<Integer>();
// for (int i=0; i<cl.size(); i++)
// reduceFlg.add(1);
// List<Integer> orig = new ArrayList<Integer>();
//
// Coordinate[] coordAfter = { new Coordinate(1.6666666666666667,1.0), new Coordinate(0.12499999999999996,-3.625), new Coordinate(-1.8571428571428572,1.0)};
// CoordinateList clAfter= new CoordinateList(coordAfter);
//
// CoordinateList result = ReducePoints.reduceKeepConcav(cl, null, orig, 60.0, 150.0, "FROM");
// assertEquals("Result", clAfter, cl);
//
// }
@RunWith(Suite.class)
@Suite.SuiteClasses( { ReducePointsTest.class })
public class AllTests {
}
// public static void main(String[] args) {
// Result result = JUnitCore.runClasses(MyClassTest.class);
// for (Failure failure : result.getFailures()) {
// System.out.println(failure.toString());
// }
// }
}

3
ncep/gov.noaa.nws.ncep.viz.rsc.ffg/META-INF/MANIFEST.MF
View file

@ -23,5 +23,4 @@ Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Export-Package: gov.noaa.nws.ncep.viz.rsc.ffg,
gov.noaa.nws.ncep.viz.rsc.ffg.rsc
Import-Package: gov.noaa.nws.ncep.viz.ui.display,
org.junit
Import-Package: gov.noaa.nws.ncep.viz.ui.display

3
ncep/gov.noaa.nws.ncep.viz.rsc.wavesat/META-INF/MANIFEST.MF
View file

@ -27,5 +27,4 @@ Export-Package: gov.noaa.nws.ncep.viz.rsc.wavesat,
gov.noaa.nws.ncep.viz.rsc.wavesat.rsc
Import-Package: gov.noaa.nws.ncep.viz.ui.display,
com.raytheon.viz.alerts,
com.raytheon.uf.viz.core.alerts,
org.junit
com.raytheon.uf.viz.core.alerts

1
ncep/gov.noaa.nws.ncep.viz.tools/.classpath
View file

@ -3,6 +3,5 @@
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="unit_test"/>
<classpathentry kind="output" path="bin"/>
</classpath>

3
ncep/gov.noaa.nws.ncep.viz.tools/META-INF/MANIFEST.MF
View file

@ -50,5 +50,4 @@ Bundle-ClassPath: .
Import-Package: gov.noaa.nws.ncep.common.log.logger,
gov.noaa.nws.ncep.edex.common.ncinventory,
gov.noaa.nws.ncep.viz.gempak.grid.inv,
org.apache.log4j,
org.junit
org.apache.log4j

250
ncep/gov.noaa.nws.ncep.viz.tools/unit_test/gov/noaa/nws/ncep/viz/tools/contourinterval/ContourDataStringParserTest.java
View file

@ -1,250 +0,0 @@
package gov.noaa.nws.ncep.viz.tools.contourinterval;
import org.junit.Test;
import static org.junit.Assert.*;
import gov.noaa.nws.ncep.viz.tools.contourinterval.ContourDataStringParser;
import java.util.ArrayList;
import java.util.List;
/**
* This Junit file tests the methods of the class ContourDataStringParser<P>
* A single string containing the contour data is fed to the overloaded constructor of ContourDataStringParser.
* The method getContourValuesList returns a list (of type Double) of the contour values.
* Prior to invoking the method getContourValuesList, it should be checked that the input string was parsed correctly, using the
* method isContourStringParsed(). <P>
*<pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 19-Oct-2009 174 Archana.S Initial Creation
* </pre>
* @author Archana.S
* @version 1
*/
public class ContourDataStringParserTest {
@Test
/* Test for valid contour data string of the form contourInterval/minContourValue/maxContourValue */
public void testPositiveContourIntervalWithMinMaxValues(){
ContourDataStringParser cd = new ContourDataStringParser("10/0.5/9");
List<Double> tempContourValList = new ArrayList<Double>();
tempContourValList.add(0.0);
assertEquals(cd.isContourStringParsed(),true);
assertEquals(cd.getContourValuesList(),tempContourValList);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Values List = "+cd.getContourValuesList());
ContourDataStringParser cd2 = new ContourDataStringParser("10/-57/86");
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd2.isContourStringParsed());
System.out.println("Contour Values List = "+cd2.getContourValuesList());
}
@Test
/* Test for valid contour data string of the form contourInterval/minContourValue/maxContourValue
* with a negative contourInterval
* */
public void testNegativeContourIntervalWithMinMaxValues(){
ContourDataStringParser cd = new ContourDataStringParser("-5/-11/23");
assertEquals(cd.isContourStringParsed(),true);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Values List = "+cd.getContourValuesList());
}
@Test
/*Test for valid contour data string of the form contourInterval/minContourValue//numPaddingDigits */
public void testContourIntervalWithMinValueOnly(){
ContourDataStringParser cd = new ContourDataStringParser("-0.345/0//2");
assertEquals(cd.getContourInterval().doubleValue(),-0.345, 0.0);
assertEquals(cd.getMinContourLevel().doubleValue(),0.0, 0.0);
assertEquals(cd.getMaxContourLevel().doubleValue(),Double.NaN, 0.0);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Interval = "+cd.getContourInterval());
System.out.println("Minimum Contour Level = "+cd.getMinContourLevel());
System.out.println("Maximum Contour Level = "+cd.getMaxContourLevel());
}
@Test
/*Test for valid contour data string of the form contourInterval//maxContourValue */
public void testContourIntervalWithMaxValueOnly(){
ContourDataStringParser cd = new ContourDataStringParser("15//30");
assertEquals(cd.getContourInterval().doubleValue(),15, 0.0);
assertEquals(cd.getMinContourLevel().doubleValue(),Double.NaN, 0.0);
assertEquals(cd.getMaxContourLevel().doubleValue(),30, 0.0);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Interval = "+cd.getContourInterval());
System.out.println("Minimum Contour Level = "+cd.getMinContourLevel());
System.out.println("Maximum Contour Level = "+cd.getMaxContourLevel());
}
@Test
/*Test input string containing a single contour value */
public void testLessNumArgsContourIntervalString(){
ContourDataStringParser cd = new ContourDataStringParser("-0.5/");
assertEquals(cd.isContourStringParsed(),true);
System.out.println("=============================================");
System.out.println("List with single contour value = "+cd.getContourValuesList());
ContourDataStringParser cd2 = new ContourDataStringParser("-0.6");
assertEquals(cd2.isContourStringParsed(),true);
System.out.println("=============================================");
System.out.println("List with single contour value = "+cd2.getContourValuesList());
ContourDataStringParser cd3 = new ContourDataStringParser("0.7;");
assertEquals(cd3.isContourStringParsed(),true);
System.out.println("=============================================");
System.out.println("List with single contour value = "+cd3.getContourValuesList());
}
@Test
/*Test for contour data string of the form contourInterval/minContourValue/maxContourValue/numPaddingDigits/extraNumbers/extraNumbers */
public void testMoreNumArgsContourIntervalString(){
ContourDataStringParser cd = new ContourDataStringParser("-0.5/0/700/30/40");
assertEquals(cd.isContourStringParsed(), true);
System.out.println("=============================================");
System.out.println("Contour Interval = "+cd.getContourInterval());
System.out.println("Minimum Contour Level = "+cd.getMinContourLevel());
System.out.println("Maximum Contour Level = "+cd.getMaxContourLevel());
}
@Test
/*Test for non-numeric values in contour interval string*/
public void testNonNumericContourIntervalString(){
ContourDataStringParser cd = new ContourDataStringParser("-def/abc/%^&/30/40");
assertEquals(cd.isContourStringParsed(), false);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Interval = "+cd.getContourInterval());
System.out.println("Minimum Contour Level = "+cd.getMinContourLevel());
System.out.println("Maximum Contour Level = "+cd.getMaxContourLevel());
}
@Test
/*Test contour interval string with invalid delimiters*/
public void testInvalidDelimitersInContourIntervalString(){
ContourDataStringParser cd = new ContourDataStringParser("5.10.60.9");
assertEquals(cd.isContourStringParsed(), false);
assertEquals(cd.getErrorMessage(),"Invalid String Format");
assertEquals(cd.getContourInterval().doubleValue(),Double.NaN, 0.0);
assertEquals(cd.getMinContourLevel().doubleValue(),Double.NaN, 0.0);
assertEquals(cd.getMaxContourLevel().doubleValue(),Double.NaN, 0.0);
System.out.println("=============================================");
System.out.println("Error message = " + cd.getErrorMessage());
System.out.println("Contour Interval = "+cd.getContourInterval());
System.out.println("Minimum Contour Level = "+cd.getMinContourLevel());
System.out.println("Maximum Contour Level = "+cd.getMaxContourLevel());
}
@Test
/*Test contour interval string by interchanging minContourValue and maxContourValue */
public void testMinMaxValuesInterchangedContourIntervalString(){
ContourDataStringParser cd = new ContourDataStringParser("-5/20/5/1");
assertEquals(cd.isContourStringParsed(), true);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Interval = "+cd.getContourInterval());
System.out.println("Minimum Contour Level = "+cd.getMinContourLevel());
System.out.println("Maximum Contour Level = "+cd.getMaxContourLevel());
System.out.println("Contour Values List = "+cd.getContourValuesList());
ContourDataStringParser cd2 = new ContourDataStringParser("5/20/5/1");
assertEquals(cd2.isContourStringParsed(), true);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Interval = "+cd2.getContourInterval());
System.out.println("Minimum Contour Level = "+cd2.getMinContourLevel());
System.out.println("Maximum Contour Level = "+cd2.getMaxContourLevel());
System.out.println("Contour Values List = "+cd2.getContourValuesList());
}
@Test
/*Test for valid contour value string of the form val1;val2;val3;val4..... */
public void testValidContourLevelValuesString(){
ContourDataStringParser cd = new ContourDataStringParser("66.1;0.1;5000;76;-.999;12233459390;0.00009988;1234.567890");
assertEquals(cd.isContourStringParsed(), true);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Values List = "+cd.getContourValuesList());
}
@Test
/*Test for non-numeric vales in contour values' string*/
public void testInvalidContourLevelValuesString(){
ContourDataStringParser cd = new ContourDataStringParser("66.1;abc;5000;76;;@#$%;12233459390");
assertEquals(cd.isContourStringParsed(), false);
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Contour Values List = "+cd.getContourValuesList());
}
@Test
/*Test for invalid delimiters in contour values' string */
public void testInvalidDelimiterContourValuesString(){
ContourDataStringParser cd = new ContourDataStringParser("66.1,0,1,5000,76,-.999,12233459390");
assertEquals(cd.isContourStringParsed(), false);
assertEquals(cd.getErrorMessage(),"Invalid String Format");
System.out.println("=============================================");
System.out.println("Is the contour data string parsed correctly? " + cd.isContourStringParsed());
System.out.println("Error message = " + cd.getErrorMessage());
}
@Test
/*Test for empty contour data string*/
public void testEmptyString(){
ContourDataStringParser cd = new ContourDataStringParser();
assertEquals(cd.isContourStringParsed(), false);
assertEquals(cd.getErrorMessage(),"Contour data string is empty");
System.out.println("=============================================");
System.out.println("Error message = "+cd.getErrorMessage());
ContourDataStringParser cd2 = new ContourDataStringParser("");
assertEquals(cd2.isContourStringParsed(), false);
assertEquals(cd2.getErrorMessage(),"Contour data string is empty");
System.out.println("=============================================");
System.out.println("Error message = "+cd2.getErrorMessage());
}
@Test
/*Test for contour data string with blank-spaces*/
public void testContourDataStringWithBlankSpaces(){
ContourDataStringParser cd = new ContourDataStringParser(" ");
assertEquals(cd.isContourStringParsed(), false);
assertEquals(cd.getErrorMessage(),"Contour data string is empty");
System.out.println("=============================================");
System.out.println("Error message = "+cd.getErrorMessage());
}
}

12
tests/.classpath
View file

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="unit"/>
<classpathentry excluding="com/raytheon/viz/gfe/ui/runtimeui/TestSmartScript.java|com/raytheon/viz/gfe/ui/runtimeui/TestHazardUtils.java|com/raytheon/viz/gfe/core/parm/TestParmManager.java|com/raytheon/viz/gfe/core/parm/TestParm.java|gov/noaa/nws/ncep/gempak/parameters/title/TITLETest.java|gov/noaa/nws/ncep/gempak/parameters/marker/MARKERTest.java|gov/noaa/nws/ncep/gempak/parameters/line/LineDataStringParserTest.java|gov/noaa/nws/ncep/gempak/parameters/hilo/HILOTest.java|gov/noaa/nws/ncep/gempak/parameters/colors/COLORSTest.java|gov/noaa/nws/ncep/gempak/parameters/colorbar/CLRBARTest.java" kind="src" path="unit"/>
<classpathentry kind="src" path="deploy"/>
<classpathentry kind="src" path="resources"/>
<classpathentry kind="src" path="integration"/>
@ -140,5 +140,15 @@
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.common.dataplugin.wcp"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.edex.plugin.wcp"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.edex.uengine"/>
<classpathentry combineaccessrules="false" kind="src" path="/com.raytheon.viz.gfe"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.viz.rsc.pgen"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.viz.common"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.viz.tools"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.gempak.parameters"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.ui.pgen"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.gempak.parameterConversionLibrary"/>
<classpathentry combineaccessrules="false" kind="src" path="/gov.noaa.nws.ncep.gempak.parameters.core"/>
<classpathentry combineaccessrules="false" kind="src" path="/com.raytheon.rcm.lib"/>
<classpathentry combineaccessrules="false" kind="src" path="/com.raytheon.rcm.server"/>
<classpathentry kind="output" path="bin"/>
</classpath>

0
RadarServer/com.raytheon.rcm.server/test/com/raytheon/rcm/coll/CronOTRTests.java → tests/unit/com/raytheon/rcm/coll/CronOTRTests.java
View file

3
cave/com.raytheon.viz.core.gl/test/com/raytheon/viz/core/gl/internal/images/GLFloatColormappedImageTest.java → tests/unit/com/raytheon/viz/core/gl/internal/images/GLFloatColormappedImageTest.java
View file

@ -21,8 +21,11 @@ package com.raytheon.viz.core.gl.internal.images;
import junit.framework.Assert;
import org.junit.Ignore;
import org.junit.Test;
//TODO fix?
@Ignore
public class GLFloatColormappedImageTest {
@Test

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/contours/ContourTextfileReader.java → tests/unit/com/raytheon/viz/gfe/contours/ContourTextfileReader.java
View file

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/contours/FloatArrayReader.java → tests/unit/com/raytheon/viz/gfe/contours/FloatArrayReader.java
View file

2
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/contours/TestContourAnalyzer.java → tests/unit/com/raytheon/viz/gfe/contours/TestContourAnalyzer.java
View file

@ -48,6 +48,8 @@ import com.vividsolutions.jts.geom.Coordinate;
* @author wdougherty
*
*/
// TODO fix?
@Ignore
public class TestContourAnalyzer {
private static final int SUBGRID_FACTOR = 4;

160
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/contours/util/TestCartCoord2D.java → tests/unit/com/raytheon/viz/gfe/contours/util/TestCartCoord2D.java
View file

@ -19,54 +19,65 @@
**/
package com.raytheon.viz.gfe.contours.util;
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import com.raytheon.viz.gfe.contours.util.CartCoord2D;
/**
* JUnit test for selected methods in {@link CartCoord2D}.
*
* <pre>
*
*
* SOFTWARE HISTORY
*
*
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 29Feb2008 968 MW Fegan Initial Creation.
*
* </pre>
*
*
* @author mfegan
* @version 1.0
* @version 1.0
*/
// TODO fix?
@Ignore
public class TestCartCoord2D {
/* test values for setting up the objects */
private Point pt1= new Point((float)5.0,(float)6.0);
private Point pt2= new Point((float)5.0,(float)7.0);
private Point pt3= new Point((float)4.0,(float)8.0);
private Point pt1 = new Point((float) 5.0, (float) 6.0);
private Point pt2 = new Point((float) 5.0, (float) 7.0);
private Point pt3 = new Point((float) 4.0, (float) 8.0);
/* scalars for testing vector ops */
private float TWO = (float)2.0;
private float oneDotTwo =(float)67;
private float oneCrossTwo = (float)5;
private float oneDistThree = (float)Math.sqrt(5);
private float TWO = (float) 2.0;
private float oneDotTwo = (float) 67;
private float oneCrossTwo = (float) 5;
private float oneDistThree = (float) Math.sqrt(5);
/* objects for the tests */
private CartCoord2D ccd1;
private CartCoord2D ccd2;
private CartCoord2D ccd3;
/**
* @throws java.lang.Exception
*/
@Before
public void setUp() throws Exception {
ccd1 = new CartCoord2D(pt1.x,pt1.y);
ccd2 = new CartCoord2D(pt2.x,pt2.y);
ccd3 = new CartCoord2D(pt3.x,pt3.y);
ccd1 = new CartCoord2D(pt1.x, pt1.y);
ccd2 = new CartCoord2D(pt2.x, pt2.y);
ccd3 = new CartCoord2D(pt3.x, pt3.y);
}
/**
@ -78,13 +89,14 @@ public class TestCartCoord2D {
ccd2 = null;
ccd3 = null;
}
/**
* Test method for {@link CartCoord2D#CartCoord2D()}.
*/
@Test
public void testCartCoord2D() {
System.out.println("Testing basic object creation");
assertEquals("Object creation - validating abscissa:",pt1.x, ccd1.x);
assertEquals("Object creation - validating abscissa:", pt1.x, ccd1.x);
assertEquals("Object creation - validating ordinate:", pt1.y, ccd1.y);
}
@ -94,10 +106,12 @@ public class TestCartCoord2D {
@Test
public void testCompareTo() {
System.out.println("Testing object comparisons");
assertEquals("Checking compareTo (equals) ",0,ccd1.compareTo(ccd1));
assertEquals("Checking compareTo (less than)",-1,ccd1.compareTo(ccd2));
assertEquals("Checking compareTo (greater than)",1,ccd1.compareTo(ccd3));
assertEquals("Checking compareTo (equals) ", 0, ccd1.compareTo(ccd1));
assertEquals("Checking compareTo (less than)", -1, ccd1.compareTo(ccd2));
assertEquals("Checking compareTo (greater than)", 1,
ccd1.compareTo(ccd3));
}
/**
* Test method for {@link CartCoord2D#scalarProduct(float)} and
* {@link CartCoord2D#multiply(CartCoord2D, float)} methods.
@ -107,19 +121,20 @@ public class TestCartCoord2D {
System.out.println("Testing scalar product methods");
/* test instance method */
ccd1.scalarProduct(TWO);
assertEquals("Checking instance method, abscissa", TWO * pt1.x,ccd1.x);
assertEquals("Checking instance method, ordinate", TWO * pt1.y,ccd1.y);
assertEquals("Checking instance method, abscissa", TWO * pt1.x, ccd1.x);
assertEquals("Checking instance method, ordinate", TWO * pt1.y, ccd1.y);
assertNotSame("Checking object changed abscissa", pt1.x, ccd1.x);
assertNotSame("Checking object changed ordinate", pt1.y, ccd1.y);
/* reset the objects */
resetCCDs(true, false, false);
/* reset the objects */
CartCoord2D temp = CartCoord2D.multiply(ccd1, TWO);
assertEquals("Checking static method, abscissa", TWO * pt1.x,temp.x);
assertEquals("Checking static method, ordinate", TWO * pt1.y,temp.y);
assertEquals("Checking object not changed, abscissa",pt1.x,ccd1.x);
assertEquals("Checking object not changed, ordinate",pt1.y,ccd1.y);
assertEquals("Checking static method, abscissa", TWO * pt1.x, temp.x);
assertEquals("Checking static method, ordinate", TWO * pt1.y, temp.y);
assertEquals("Checking object not changed, abscissa", pt1.x, ccd1.x);
assertEquals("Checking object not changed, ordinate", pt1.y, ccd1.y);
}
/**
* Test method for {@link CartCoord2D#dotProduct(CartCoord2D)} and
* {@link CartCoord2D#dotProduct(CartCoord2D, CartCoord2D)} methods.
@ -129,21 +144,22 @@ public class TestCartCoord2D {
System.out.println("Testing vector dot product");
/* test instance method */
float dp = ccd1.dotProduct(ccd2);
assertEquals("Checking instance method",oneDotTwo,dp);
assertEquals("Checking object not changed, abscissa 1",pt1.x,ccd1.x);
assertEquals("Checking object not changed, ordinate 1",pt1.y,ccd1.y);
assertEquals("Checking object not changed, abscissa 2",pt2.x,ccd2.x);
assertEquals("Checking object not changed, ordinate 2",pt2.y,ccd2.y);
assertEquals("Checking instance method", oneDotTwo, dp);
assertEquals("Checking object not changed, abscissa 1", pt1.x, ccd1.x);
assertEquals("Checking object not changed, ordinate 1", pt1.y, ccd1.y);
assertEquals("Checking object not changed, abscissa 2", pt2.x, ccd2.x);
assertEquals("Checking object not changed, ordinate 2", pt2.y, ccd2.y);
/* reset the objects */
resetCCDs(true, true, false);
dp = CartCoord2D.dotProduct(ccd1, ccd2);
/* test static method */
assertEquals("Checking static method",oneDotTwo,dp);
assertEquals("Checking object not changed, abscissa 1",pt1.x,ccd1.x);
assertEquals("Checking object not changed, ordinate 1",pt1.y,ccd1.y);
assertEquals("Checking object not changed, abscissa 2",pt2.x,ccd2.x);
assertEquals("Checking object not changed, ordinate 2",pt2.y,ccd2.y);
assertEquals("Checking static method", oneDotTwo, dp);
assertEquals("Checking object not changed, abscissa 1", pt1.x, ccd1.x);
assertEquals("Checking object not changed, ordinate 1", pt1.y, ccd1.y);
assertEquals("Checking object not changed, abscissa 2", pt2.x, ccd2.x);
assertEquals("Checking object not changed, ordinate 2", pt2.y, ccd2.y);
}
/**
* Test method for {@link CartCoord2D#crossProduct(CartCoord2D)} and
* {@link CartCoord2D#crossProduct(CartCoord2D, CartCoord2D)} methods.
@ -153,21 +169,22 @@ public class TestCartCoord2D {
System.out.println("Testing vector cross product");
/* test instance method */
float cp = ccd1.crossProduct(ccd2);
assertEquals("Checking instance method",oneCrossTwo,cp);
assertEquals("Checking object not changed, abscissa 1",pt1.x,ccd1.x);
assertEquals("Checking object not changed, ordinate 1",pt1.y,ccd1.y);
assertEquals("Checking object not changed, abscissa 2",pt2.x,ccd2.x);
assertEquals("Checking object not changed, ordinate 2",pt2.y,ccd2.y);
assertEquals("Checking instance method", oneCrossTwo, cp);
assertEquals("Checking object not changed, abscissa 1", pt1.x, ccd1.x);
assertEquals("Checking object not changed, ordinate 1", pt1.y, ccd1.y);
assertEquals("Checking object not changed, abscissa 2", pt2.x, ccd2.x);
assertEquals("Checking object not changed, ordinate 2", pt2.y, ccd2.y);
/* reset the objects */
resetCCDs(true, true, false);
/* test static method */
cp = CartCoord2D.crossProduct(ccd1, ccd2);
assertEquals("Checking static method",oneCrossTwo,cp);
assertEquals("Checking object not changed, abscissa 1",pt1.x,ccd1.x);
assertEquals("Checking object not changed, ordinate 1",pt1.y,ccd1.y);
assertEquals("Checking object not changed, abscissa 2",pt2.x,ccd2.x);
assertEquals("Checking object not changed, ordinate 2",pt2.y,ccd2.y);
assertEquals("Checking static method", oneCrossTwo, cp);
assertEquals("Checking object not changed, abscissa 1", pt1.x, ccd1.x);
assertEquals("Checking object not changed, ordinate 1", pt1.y, ccd1.y);
assertEquals("Checking object not changed, abscissa 2", pt2.x, ccd2.x);
assertEquals("Checking object not changed, ordinate 2", pt2.y, ccd2.y);
}
/**
* Test method for {@link CartCoord2D#distance(CartCoord2D)} and
* {@link CartCoord2D#distance(CartCoord2D, CartCoord2D)} methods.
@ -177,50 +194,57 @@ public class TestCartCoord2D {
System.out.println("Testing distance calculations");
/* test instance method */
float dist = ccd1.distance(ccd3);
assertEquals("Checking instance method",oneDistThree,dist);
assertEquals("Checking object not changed, abscissa 1",pt1.x,ccd1.x);
assertEquals("Checking object not changed, ordinate 1",pt1.y,ccd1.y);
assertEquals("Checking object not changed, abscissa 2",pt3.x,ccd3.x);
assertEquals("Checking object not changed, ordinate 2",pt3.y,ccd3.y);
assertEquals("Checking instance method", oneDistThree, dist);
assertEquals("Checking object not changed, abscissa 1", pt1.x, ccd1.x);
assertEquals("Checking object not changed, ordinate 1", pt1.y, ccd1.y);
assertEquals("Checking object not changed, abscissa 2", pt3.x, ccd3.x);
assertEquals("Checking object not changed, ordinate 2", pt3.y, ccd3.y);
/* reset objects */
resetCCDs(true, false, true);
/* test static method */
/* test static method */
dist = CartCoord2D.distance(ccd1, ccd3);
assertEquals("Checking static method",oneDistThree,dist);
assertEquals("Checking object not changed, abscissa 1",pt1.x,ccd1.x);
assertEquals("Checking object not changed, ordinate 1",pt1.y,ccd1.y);
assertEquals("Checking object not changed, abscissa 2",pt3.x,ccd3.x);
assertEquals("Checking object not changed, ordinate 2",pt3.y,ccd3.y);
assertEquals("Checking static method", oneDistThree, dist);
assertEquals("Checking object not changed, abscissa 1", pt1.x, ccd1.x);
assertEquals("Checking object not changed, ordinate 1", pt1.y, ccd1.y);
assertEquals("Checking object not changed, abscissa 2", pt3.x, ccd3.x);
assertEquals("Checking object not changed, ordinate 2", pt3.y, ccd3.y);
}
/**
* Helper method, allows resetting of selected {@link CartCoord2D}
* test values to original states.
* Helper method, allows resetting of selected {@link CartCoord2D} test
* values to original states.
*
* @param first indicates if the first test point is to be reset
* @param second indicates if the second test point is to be reset
* @param third indicates if the third test point is to be reset
* @param first
* indicates if the first test point is to be reset
* @param second
* indicates if the second test point is to be reset
* @param third
* indicates if the third test point is to be reset
*/
private void resetCCDs(boolean first, boolean second, boolean third) {
if (first) {
ccd1 = null;
ccd1 = new CartCoord2D(pt1.x,pt1.y);
ccd1 = new CartCoord2D(pt1.x, pt1.y);
}
if (second) {
ccd2 = null;
ccd2 = new CartCoord2D(pt2.x,pt2.y);
ccd2 = new CartCoord2D(pt2.x, pt2.y);
}
if (third) {
ccd3 = null;
ccd3 = new CartCoord2D(pt3.x,pt3.y);
ccd3 = new CartCoord2D(pt3.x, pt3.y);
}
}
/**
*
* Helper class, contains an x/y pair.
*/
private class Point {
public float x;
public float y;
Point(float x, float y) {
this.x = x;
this.y = y;

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/contours/util/TestContourValueDistance.java → tests/unit/com/raytheon/viz/gfe/contours/util/TestContourValueDistance.java
View file

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/contours/util/TestPolyLineFloat.java → tests/unit/com/raytheon/viz/gfe/contours/util/TestPolyLineFloat.java
View file

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/contours/util/TestStopWatch.java → tests/unit/com/raytheon/viz/gfe/contours/util/TestStopWatch.java
View file

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/core/FakeDataManager.java → tests/unit/com/raytheon/viz/gfe/core/FakeDataManager.java
View file

3
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/core/griddata/ScalarGridDataTest.java → tests/unit/com/raytheon/viz/gfe/core/griddata/ScalarGridDataTest.java
View file

@ -25,6 +25,7 @@ import java.util.Date;
import junit.framework.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import com.raytheon.uf.common.dataplugin.gfe.GridDataHistory;
@ -64,6 +65,8 @@ import com.vividsolutions.jts.geom.Coordinate;
* @version 1.0
*/
// TODO fix?
@Ignore
public class ScalarGridDataTest {
private MockParm testDP1;

3
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/core/griddata/VectorGridDataTest.java → tests/unit/com/raytheon/viz/gfe/core/griddata/VectorGridDataTest.java
View file

@ -24,6 +24,7 @@ import java.util.Date;
import junit.framework.Assert;
import org.junit.Ignore;
import org.junit.Test;
import com.raytheon.uf.common.dataplugin.gfe.GridDataHistory;
@ -63,6 +64,8 @@ import com.vividsolutions.jts.geom.Coordinate;
* @version 1.0
*/
// TODO fix?
@Ignore
public class VectorGridDataTest {
private final float testFA1[] = new float[145 * 145];

3
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/core/internal/ReferenceSetManagerTest.java → tests/unit/com/raytheon/viz/gfe/core/internal/ReferenceSetManagerTest.java
View file

@ -31,6 +31,7 @@ import junit.framework.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import com.raytheon.uf.common.dataplugin.gfe.config.ProjectionData;
@ -67,6 +68,8 @@ import com.vividsolutions.jts.geom.Envelope;
* @version 1.0
*/
// TODO fix?
@Ignore
public class ReferenceSetManagerTest {
private static class RefChangedListener implements
IReferenceSetChangedListener {

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/core/parm/TestParm.java → tests/unit/com/raytheon/viz/gfe/core/parm/TestParm.java
View file

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/core/parm/TestParmManager.java → tests/unit/com/raytheon/viz/gfe/core/parm/TestParmManager.java
View file

4
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/ui/runtimeui/TestAbsTime.java → tests/unit/com/raytheon/viz/gfe/ui/runtimeui/TestAbsTime.java
View file

@ -27,6 +27,8 @@ import java.util.Map;
import jep.JepException;
import junit.framework.TestCase;
import org.junit.Ignore;
import com.raytheon.uf.common.python.PythonScript;
import com.raytheon.uf.common.time.TimeRange;
@ -44,6 +46,8 @@ import com.raytheon.uf.common.time.TimeRange;
* @version 1.0
*/
// TODO fix?
@Ignore
public class TestAbsTime extends TestCase {
protected static final String testScriptName = "ROOT/build/static/common/cave/etc/gfe/userPython/tests/TestAbsTime.py";

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/ui/runtimeui/TestHazardUtils.java → tests/unit/com/raytheon/viz/gfe/ui/runtimeui/TestHazardUtils.java
View file

0
cave/com.raytheon.viz.gfe/tests/com/raytheon/viz/gfe/ui/runtimeui/TestSmartScript.java → tests/unit/com/raytheon/viz/gfe/ui/runtimeui/TestSmartScript.java
View file

5593
tests/unit/gov/noaa/nws/ncep/gempak/parameterConversionLibrary/PRLibraryTest.java Normal file
View file

File diff suppressed because it is too large Load diff

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/colorbar/CLRBARTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/colorbar/CLRBARTest.java
View file

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/colors/COLORSTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/colors/COLORSTest.java
View file

427
tests/unit/gov/noaa/nws/ncep/gempak/parameters/core/categorymap/CATMAPTest.java Normal file
View file

@ -0,0 +1,427 @@
package gov.noaa.nws.ncep.gempak.parameters.core.categorymap;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
/**
* <pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 16-Nov-2009 194 Archana.S Initial Creation
* 20-Nov-2009 194 Archana.S Updated per review comments:
* Added a test-case to retrieve the label
* given a value
* Updated method names per design changes in the class
* CATMAP
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
*
* </pre>
*
* @author Archana.S
* @version 1
* <p>
* {@link gov.noaa.nws.ncep.gempak.parameters.core.categorymap.CatMap}.
*/
// TODO fix?
@Ignore
public class CATMAPTest {
private static int testCaseNumber;
private static final double ALLOWABLE_DOUBLE_DELTA = 0.0001;
/**
* Test for valid label/value pair
*/
@Test
public void testGetValueForLabel() {
testCaseNumber = 1;
CatMap catmap = new CatMap("ABC=4;acd=2;lmn=0.5");
assertEquals(catmap.getMatchingValueForLabel("abc"), 4.0);
assertEquals(catmap.getMatchingValueForLabel("ABC"), 4.0);
assertEquals(catmap.getMatchingValueForLabel("LmN"), 0.5);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out
.println("Test for valid label/value pairs without wild-card");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label abc = "
+ catmap.getMatchingValueForLabel("abc"));
System.out.println("The value for label LmN = "
+ catmap.getMatchingValueForLabel("LmN"));
testCaseNumber++;
}
/**
* @param val1
* @param expected
*/
private void assertEquals(Float val1, double expected) {
Assert.assertEquals(expected, val1.doubleValue(),
ALLOWABLE_DOUBLE_DELTA);
}
/**
* Test to retrieve matching label given a floating point value
*/
@Test
public void testGetLabelForValue() {
CatMap catmap = new CatMap("ABC=4;acd=2;lmn=0.5;efg=2;hij=2");
Assert.assertEquals(catmap.getMatchingLabelForValue(0.5f), "lmn");
Assert.assertEquals(catmap.getMatchingLabelForValue(4f), "ABC");
Assert.assertEquals(catmap.getMatchingLabelForValue(2f), "acd");
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out
.println("Test for getting the matching label, given a floating point value");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The label for the value 4 = "
+ catmap.getMatchingLabelForValue(4f));
System.out.println("The label for the value 0.5 = "
+ catmap.getMatchingLabelForValue(0.5f));
System.out.println("The label for the value 2 = "
+ catmap.getMatchingLabelForValue(2f));
testCaseNumber++;
}
/**
* Test to retrieve the label for a floating point value not in the list
*/
@Test
public void testGetLabelForNonExistentValue() {
CatMap catmap = new CatMap("ABC=4;acd=2;lmn=0.5;efg=2;hij=2");
Assert.assertNull(catmap.getMatchingLabelForValue(0.00005f));
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out
.println("Test for getting the matching label, given a floating point value not in the list");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The label for the value 0.00005 = "
+ catmap.getMatchingLabelForValue(0.00005f));
testCaseNumber++;
}
/**
* Test for valid label with a wild-card character
*/
@Test
public void testGetValueForWildcardLabel() {
CatMap catmap = new CatMap("Abc=4;a*=0.5;acd=2");
assertEquals(catmap.getMatchingValueForLabel("abc"), 4.0);
assertEquals(catmap.getMatchingValueForLabel("ACD"), 0.5);
assertEquals(catmap.getMatchingValueForLabel("A*"), 0.5);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out
.println("Test for valid label/value pairs with a wild-card label included");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label aCD = "
+ catmap.getMatchingValueForLabel("aCD"));
System.out.println("The value for label a = "
+ catmap.getMatchingValueForLabel("a"));
testCaseNumber++;
}
/**
* Test CATMAP String with invalid delimiters
*/
@Test
public void testInvalidDelimiter() {
CatMap catmap = new CatMap("Abc=4:a*=0.5:acd=2");
assertEquals(catmap.getMatchingValueForLabel("abc"), Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("ACD"), Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("A*"), Float.NaN);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for invalid delimiters");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label aCD = "
+ catmap.getMatchingValueForLabel("aCD"));
System.out.println("The value for label a = "
+ catmap.getMatchingValueForLabel("a"));
testCaseNumber++;
}
/**
* Test CATMAP String without '=' character between label/value pairs
*/
@Test
public void testCATMAPStringWithoutEqualToSign() {
CatMap catmap = new CatMap("Abc-4;a*-0.5;acd+2");
assertEquals(catmap.getMatchingValueForLabel("abc"), Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("ACD"), Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("A*"), Float.NaN);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for missing '=' character");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label aCD = "
+ catmap.getMatchingValueForLabel("aCD"));
System.out.println("The value for label a = "
+ catmap.getMatchingValueForLabel("a"));
testCaseNumber++;
}
/**
* Test empty CATMAP String
*/
@Test
public void testEmptyCATMAPString() {
CatMap catmap = new CatMap("");
System.out.println("\n=====================Test-Case " + testCaseNumber
+ "a ========================");
System.out.println("Test for empty input string");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label \"\" = "
+ catmap.getMatchingValueForLabel(""));
CatMap catmap3 = new CatMap(null);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ "b ========================");
System.out.println("Test for null string");
System.out.println("The input string = "
+ catmap3.getCategoricalMappingString());
System.out.println("The value for null string = "
+ catmap3.getMatchingValueForLabel(null));
CatMap catmap4 = new CatMap(" ");
System.out.println("\n=====================Test-Case " + testCaseNumber
+ "c ========================");
System.out.println("Test for string with only blanks");
System.out.println("The input string = "
+ catmap4.getCategoricalMappingString());
System.out.println("The value for string with only blanks= "
+ catmap4.getMatchingValueForLabel(" "));
testCaseNumber++;
}
/**
* Test CATMAP String with a missing label
*/
@Test
public void testMissingLabel() {
CatMap catmap = new CatMap("Abc=4;bingo=-0.5; =2");
assertEquals(catmap.getMatchingValueForLabel("abc"), 4.0);
assertEquals(catmap.getMatchingValueForLabel("bINgO"), -0.5);
assertEquals(catmap.getMatchingValueForLabel(" "), Float.NaN);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for missing Label");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "
+ catmap.getMatchingValueForLabel("bINgO"));
System.out.println("The value for the missing label= "
+ catmap.getMatchingValueForLabel(" "));
testCaseNumber++;
}
/**
* Test CATMAP String with a missing value
*/
@Test
public void testMissingValue() {
CatMap catmap = new CatMap("Abc= ;bingo=-.5;label3=2");
assertEquals(catmap.getMatchingValueForLabel("abc"), Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("bINgO"), -0.5);
assertEquals(catmap.getMatchingValueForLabel("label3"), 2);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for missing value");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "
+ catmap.getMatchingValueForLabel("bINgO"));
System.out.println("The value for the label3= "
+ catmap.getMatchingValueForLabel("label3"));
testCaseNumber++;
}
/**
* Test CATMAP string with a missing label and a missing value
*/
@Test
public void testMissingValueAndLabel() {
CatMap catmap = new CatMap("Abc=99.99999; = ;bingo=-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"), 99.99999);
assertEquals(catmap.getMatchingValueForLabel("bINgO"), -0.5);
assertEquals(catmap.getMatchingValueForLabel(" "), Float.NaN);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for missing label and value");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "
+ catmap.getMatchingValueForLabel("bINgO"));
System.out.println("The value for the missing label= "
+ catmap.getMatchingValueForLabel(" "));
testCaseNumber++;
}
/**
* Test CATMAP string with missing label/value pairs
*/
@Test
public void testMissingLabelValuePairs() {
CatMap catmap = new CatMap("Abc=99.99999;;;;bingo=-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"), 99.99999);
assertEquals(catmap.getMatchingValueForLabel("bINgO"), -0.5);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test with missing label/value pairs");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "
+ catmap.getMatchingValueForLabel("bINgO"));
testCaseNumber++;
}
/**
* Test CATMAP string with non-numeric data for value
*/
@Test
public void testNonNumericDataForValue() {
CatMap catmap = new CatMap("Abc=99acd.99999;bingo=-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"), Float.NaN);
assertEquals(catmap.getMatchingValueForLabel("bINgO"), Float.NaN);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for non-numeric characters in the value");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bINgO = "
+ catmap.getMatchingValueForLabel("bINgO"));
testCaseNumber++;
}
/**
* Test CATMAP string with multiple '=' characters
*/
@Test
public void testMultipleEqualToCharaters() {
CatMap catmap = new CatMap("Abc=99;bingo==-.5");
assertEquals(catmap.getMatchingValueForLabel("abc"), 99);
assertEquals(catmap.getMatchingValueForLabel("bINgO"), Float.NaN);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for multiple '=' characters");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString());
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("ABC"));
System.out.println("The value for label bingo = "
+ catmap.getMatchingValueForLabel("bingo"));
testCaseNumber++;
}
/**
* Test CATMAP string with labels containing punctuation symbols
*/
@Test
public void testLabelWithPunctuationSymbols() {
CatMap catmap = new CatMap("@!'Ab#c=99;@#$%^=19.08");
assertEquals(catmap.getMatchingValueForLabel("@!'Ab#c"), 99);
assertEquals(catmap.getMatchingValueForLabel("@#$%^"), 19.08);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Test for labels containing punctuation symbols");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString() + "\n");
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("@!'Ab#c"));
System.out.println("The value for label bINgO = "
+ catmap.getMatchingValueForLabel("@#$%^"));
testCaseNumber++;
}
/**
* Test valid CATMAP string with blanks between labels and values
*/
@Test
public void testCATMAPStringWithBlanksBetweenLabelsAndValues() {
CatMap catmap = new CatMap(
" @!'Ab#c = 99 ; @#$%^ = 19.08 ");
assertEquals(catmap.getMatchingValueForLabel("@!'Ab#c"), 99);
assertEquals(catmap.getMatchingValueForLabel("@#$%^"), 19.08);
System.out.println("\n=====================Test-Case " + testCaseNumber
+ " ========================");
System.out
.println("Test for string containing blanks between labels and values");
System.out.println("The input string = "
+ catmap.getCategoricalMappingString() + "\n");
System.out.println("The value for label ABC = "
+ catmap.getMatchingValueForLabel("@!'Ab#c"));
System.out.println("The value for label bINgO = "
+ catmap.getMatchingValueForLabel("@#$%^"));
testCaseNumber++;
}
}

880
tests/unit/gov/noaa/nws/ncep/gempak/parameters/core/contourinterval/CINTTest.java Normal file
View file

@ -0,0 +1,880 @@
package gov.noaa.nws.ncep.gempak.parameters.core.contourinterval;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
/**
* <pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 12-Nov-2009 174 Archana.S Initial Creation
* 10-Jun-2010 174 Archana.S Added assertion to check that
* the list of String equivalents for the contour
* values is generated correctly.
* 15-Jun-2010 174 Archana.S Updated test-cases per changes in the code design
* 02-Aug-2010 174 Archana.S Updated test-cases per changes in the code design
* </pre>
*
* @author Archana.S
* @version 1
*/
// TODO fix?
@Ignore
public class CINTTest {
private static final double ALLOWABLE_DOUBLE_DELTA = 0.0001;
private static int testCaseNumber;
private List<Double> testList;
private List<Double> testList2;
private List<Double> keySetList;
List<String> contourValuesList;
@Test
/*
* Test for valid fill contour string of the form
* contourInterval/minContourValue/maxContourValue
*/
public void testPositiveContourIntervalWithMinMaxValues() {
testCaseNumber = 1;
CINT cint = new CINT("10/0.5/9");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(0.5, 9.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 0.5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 9, ALLOWABLE_DOUBLE_DELTA);
assertEquals(
cint.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL).intValue(), 0);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
System.out.println("The contour interval: "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The minimum contour value: "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The maximum contour value: "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
CINT cint2 = new CINT(" 10 / -57 / 86 / 4 ");
assertEquals(cint2.isCINTStringParsed(), true);
testList2 = new ArrayList<Double>(Arrays.asList(-50.0, -40.0, -30.0,
-20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0,
80.0));
keySetList = cint2.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(testList2, keySetList);
assertEquals(cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -57, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 86, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL)
.intValue(), 4);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b ========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint2.isCINTStringParsed());
contourValuesList = cint2
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
System.out.println("The contour interval: "
+ cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The minimum contour value: "
+ cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The maximum contour value: "
+ cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test for valid contour data string of the form
* contourInterval/minContourValue/maxContourValue with a negative
* contourInterval
*/
public void testNegativeContourIntervalWithMinMaxValues() {
CINT cint = new CINT("-5/-11/23");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(-10.0, -5.0, 0.0, 5.0,
10.0, 15.0, 20.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/* Test for valid contour value string of the form val1;val2;val3;val4..... */
public void testValidContourLevelValuesString() {
CINT cint = new CINT(
"66.1;0.1;5000;76;-.999;12233459390;0.00009988;1234.567890");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0, 76.0,
-0.999, 1.223345939E10, 9.988E-5, 1234.56789));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/* Test for valid contour value string of the form val1 ; val2 ; val3 */
public void testValidContourLevelValuesStringWithBlanks() {
CINT cint = new CINT(
" 66.1 ; 0.1 ; 5000 ");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/*
* Test for valid contour string of the form
* contourInterval/minContourValue/
*/
public void testContourIntervalWithMinValueOnly() {
CINT cint = new CINT("-0.345/0/");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -0.345, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 0, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test for valid contour data string of the form
* contourInterval//maxContourValue
*/
public void testContourIntervalWithMaxValueOnly() {
CINT cint = new CINT("15//30");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 15, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 30, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
public void testCINTWithOnlyContourIntervalSpecified() {
CINT cint = new CINT("-0.5/");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -0.5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
CINT cint2 = new CINT("-.89//");
assertEquals(cint2.isCINTStringParsed(), true);
assertEquals(cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -0.89, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b ========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint2.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test for valid contour data string of the form
* /minContourValue/maxContourValue
*/
public void testContourIntervalWithNoContourIntervalAndWithMinMaxValueOnly() {
CINT cint = new CINT("/10/30");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 30, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test for valid contour data string of the form
* /minContourValue/maxContourValue
*/
public void testContourIntervalWithMinValSameAsMaxValAndNoContourIntervalSpecified() {
CINT cint = new CINT("/10/10");
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(10.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/* Test input string containing a single contour value */
public void testLessNumArgsContourIntervalString() {
CINT cint = new CINT("-0.6");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(-0.6));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
// assertEquals(keySetList,testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a ========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("The contour interval is: "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = "
+ contourValuesList);
CINT cint2 = new CINT("0.7;");
assertEquals(cint2.isCINTStringParsed(), true);
testList2 = new ArrayList<Double>(Arrays.asList(0.7));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
// assertEquals(keySetList,testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b ========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint2.isCINTStringParsed());
System.out.println("The contour interval is: "
+ cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint2
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = "
+ contourValuesList);
testCaseNumber++;
}
@Test
/*
* Test for contour data string of the form
* contourInterval/minContourValue/maxContourValue
* /extraNumbers/extraNumbers/extraNumbers
*/
public void testExtraNumArgsContourIntervalString() {
CINT cint = new CINT("20/10/70/30/40/500");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 20, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 70, ALLOWABLE_DOUBLE_DELTA);
//
testList = new ArrayList<Double>(Arrays.asList(10.0, 30.0, 50.0, 60.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("The set of contour values: " + contourValuesList);
testCaseNumber++;
}
@Test
/* Test for non-numeric values in contour interval string */
public void testNonNumericContourIntervalString() {
CINT cint = new CINT("-def/abc/%^&/30/40");
assertEquals(cint.isCINTStringParsed(), false);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test contour interval string with invalid delimiters */
public void testInvalidDelimitersInContourIntervalString() {
CINT cint = new CINT("5.10.60.9");
assertEquals(cint.isCINTStringParsed(), false);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), Double.NaN, ALLOWABLE_DOUBLE_DELTA);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test contour interval string by interchanging minContourValue and
* maxContourValue
*/
public void testMinMaxValuesInterchangedContourIntervalString() {
CINT cint = new CINT("-5/20/5");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), -5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 20, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = "
+ contourValuesList);
CINT cint2 = new CINT("5/20/5");
assertEquals(cint2.isCINTStringParsed(), true);
assertEquals(cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 20, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
// assertEquals(cint2.getContourValuesList(),testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b========================");
System.out.println("The input string = "
+ cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint2.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint2.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint2.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint2.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Contour Values List = "
+ cint2.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for non-numeric vales in contour values' string */
public void testInvalidContourLevelValuesString() {
CINT cint = new CINT("66.1;abc;5000;76;;@#$%;12233459390");
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
testCaseNumber++;
}
@Test
/* Test for invalid delimiters in contour values' string */
public void testInvalidDelimiterContourValuesString() {
CINT cint = new CINT("66.1,0,1,5000,76,-.999,12233459390");
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
testCaseNumber++;
}
@Test
/* Test for empty contour data string */
public void testEmptyString() {
CINT cint = new CINT();
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
CINT cint2 = new CINT("");
assertEquals(cint2.isCINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b========================");
System.out.println("The input string = " + cint2.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint2.isCINTStringParsed());
CINT cint3 = new CINT(null);
assertEquals(cint3.isCINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "c========================");
System.out.println("The input string = " + cint3.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint3.isCINTStringParsed());
testCaseNumber++;
}
@Test
/* Test for contour data string with blank-spaces */
public void testContourDataStringWithBlankSpaces() {
CINT cint = new CINT(" ");
assertEquals(cint.isCINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = " + cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
testCaseNumber++;
}
@Test
/*
* Test contour interval string by interchanging minContourValue and
* maxContourValue
*/
public void testSingleLabelledContourIntervalString() {
CINT cint = new CINT("5=good/5/5");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 0, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 5, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(5.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
contourValuesList = cint
.getContourValuesListAsString(CINT.FIRST_ZOOM_LEVEL);
System.out.println("List with single contour value = "
+ contourValuesList);
testCaseNumber++;
}
@Test
/*
* Test contour interval string by interchanging minContourValue and
* maxContourValue
*/
public void testLabelledContourIntervalStrings() {
CINT cint = new CINT("10=ab;35=sdnf");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(10.0, 35.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("HashMap for labeled contour string = "
+ cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test contour interval string of the form:
* contourInterval/minimumContourValue/maximumContourValue/numPaddingDigits
*/
public void testCINTStringWithNumPaddingDigits() {
// CINT cint = new CINT("1/2/10/3");
CINT cint = new CINT("1/2/10/3 > 4/2/18");
assertEquals(cint.isCINTStringParsed(), true);
assertEquals(cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 1, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 2, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 10, ALLOWABLE_DOUBLE_DELTA);
assertEquals(cint.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL)
.doubleValue(), 3, ALLOWABLE_DOUBLE_DELTA);
testList = new ArrayList<Double>(Arrays.asList(2.0, 3.0, 4.0, 5.0, 6.0,
7.0, 8.0, 9.0, 10.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("The parsed input string at first zoom level = "
+ cint.getCINTString(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum number of digits in label = "
+ cint.getNumPaddingDigits(CINT.FIRST_ZOOM_LEVEL));
List<Double> contourList = cint
.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
System.out.println("Contour values list as double= " + contourList);
System.out.println("Set of contour values with padding digits = "
+ cint.getContourLabelsForZoomLevel(CINT.FIRST_ZOOM_LEVEL));
System.out.println("HashMap at first zoom level = "
+ cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
System.out
.println("The parsed input string at second zoom level = "
+ cint.getCINTString(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Contour Interval = "
+ cint.getContourInterval(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Minimum Contour Level = "
+ cint.getMinContourValue(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Maximum Contour Level = "
+ cint.getMaxContourValue(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Minimum number of digits in label = "
+ cint.getNumPaddingDigits(CINT.SECOND_ZOOM_LEVEL));
System.out.println("HashMap at second zoom level = "
+ cint.getCintHashMap(CINT.SECOND_ZOOM_LEVEL));
contourList = new ArrayList<Double>(
cint.getContourValuesListAsDouble(CINT.SECOND_ZOOM_LEVEL));
System.out.println("Contour values list as double= " + contourList);
testCaseNumber++;
}
/*
* Test contour interval string with multiple zoom levels
*/
@Test
public void testCINTMultipleZoomLevels() {
CINT cint = new CINT(
"2/-6/6/3 > 30;50;80 > 60=abc; 80=def > 0.00009999 > 0.0000001;");
assertEquals(cint.isCINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0, -2.0, 0.0,
2.0, 4.0, 6.0));
keySetList = cint.getContourValuesListAsDouble(CINT.FIRST_ZOOM_LEVEL);
assertEquals(testList, keySetList);
testList = new ArrayList<Double>(Arrays.asList(30.0, 50.0, 80.0));
keySetList = cint.getContourValuesListAsDouble(CINT.SECOND_ZOOM_LEVEL);
assertEquals(testList, keySetList);
testList = new ArrayList<Double>(Arrays.asList(60.0, 80.0));
keySetList = cint.getContourValuesListAsDouble(CINT.THIRD_ZOOM_LEVEL);
assertEquals(testList, keySetList);
assertEquals(0.00009999, cint
.getContourInterval(CINT.FOURTH_ZOOM_LEVEL).doubleValue(),
ALLOWABLE_DOUBLE_DELTA);
assertEquals(0.0000001, cint.getContourInterval(CINT.FIFTH_ZOOM_LEVEL)
.doubleValue(), ALLOWABLE_DOUBLE_DELTA);
// testList = new ArrayList<Double>(Arrays.asList(0.00009999));
// keySetList =
// cint.getContourValuesListAsDouble(CINT.FOURTH_ZOOM_LEVEL);
// assertEquals(testList,keySetList);
// testList = new ArrayList<Double>(Arrays.asList(0.0000001));
// keySetList =
// cint.getContourValuesListAsDouble(CINT.FIFTH_ZOOM_LEVEL);
assertEquals(testList, keySetList);
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0, -2.0, 0.0,
2.0, 4.0, 6.0, 30.0, 50.0, 60.0, 80.0));
keySetList = cint.getUniqueSortedContourValuesFromAllZoomLevels();
assertEquals(testList, keySetList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("The HashMap at 1st zoom level"
+ cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The HashMap at 2nd zoom level"
+ cint.getCintHashMap(CINT.SECOND_ZOOM_LEVEL));
System.out.println("The HashMap at 3rd zoom level"
+ cint.getCintHashMap(CINT.THIRD_ZOOM_LEVEL));
System.out.println("The HashMap at 4th zoom level"
+ cint.getCintHashMap(CINT.FOURTH_ZOOM_LEVEL));
System.out.println("The HashMap at 5th zoom level"
+ cint.getCintHashMap(CINT.FIFTH_ZOOM_LEVEL));
System.out
.println("The unique contour values sorted in ascending order: "
+ cint.getUniqueSortedContourValuesFromAllZoomLevelsAsString());
}
/*
* Test contour interval string with more than 5 zoom levels (currently 5 is
* the maximum)
*/
@Test
public void testCINTWithMoreThanFiveZoomLevels() {
CINT cint = new CINT(
"2/-6/6/3 > 30;50;80 > 60=abc; 80=def > 0.00009999 > 0.0000001;1.2 > 90=GoodLuck > 100;200;300;400");
testList = new ArrayList<Double>(Arrays.asList(0.0000001, 1.2));
keySetList = cint.getContourValuesListAsDouble(CINT.MAX_ZOOM_LEVEL);
assertEquals(testList, keySetList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ cint.getUserInputString());
System.out.println("Is the contour data string parsed correctly? "
+ cint.isCINTStringParsed());
System.out.println("The HashMap at 1st zoom level"
+ cint.getCintHashMap(CINT.FIRST_ZOOM_LEVEL));
System.out.println("The HashMap at 2nd zoom level"
+ cint.getCintHashMap(CINT.SECOND_ZOOM_LEVEL));
System.out.println("The HashMap at 3rd zoom level"
+ cint.getCintHashMap(CINT.THIRD_ZOOM_LEVEL));
System.out.println("The HashMap at 4th zoom level"
+ cint.getCintHashMap(CINT.FOURTH_ZOOM_LEVEL));
System.out.println("The HashMap at 5th zoom level"
+ cint.getCintHashMap(CINT.FIFTH_ZOOM_LEVEL));
}
/*
* Test contour interval string with multiple zoom levels, some of which are
* invalid
*/
@Test
public void testCINTWithInvalidZoomLevels()
throws IndexOutOfBoundsException {
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ "2/-6/6/3 > > 60=abc; 80=def > > ");
CINT cint = new CINT("2/-6/6/3 > > 60=abc; 80=def > > ");
System.out.println("Is CINT String parsed correctly? "
+ cint.isCINTStringParsed());
}
}

574
tests/unit/gov/noaa/nws/ncep/gempak/parameters/core/marshaller/garea/GraphicsAreaCoordinatesTest.java Normal file
View file

@ -0,0 +1,574 @@
package gov.noaa.nws.ncep.gempak.parameters.core.marshaller.garea;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Ignore;
import org.junit.Test;
/**
* <pre>
*
* SOFTWARE HISTORY
*
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 29-Sep-2009 171 Archana Initial Version
*
* </pre>
* @author Archana
* @version 1
*/
/**
* This junit test file tests the methods in the class GraphicsAreaCoordinates.
*/
// TODO fix?
@Ignore
public class GraphicsAreaCoordinatesTest {
private boolean flag;
private String error_msg;
@Test
// Test that all Latitude/Longitude values can be set to 0
public void testAllZeroLatLon() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("0;0;0;0");
flag = gac.isGraphicsAreaStringValid();
if (flag == true) {
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0], 0.0f);
assertEquals(lat_lon[1], 0.0f);
assertEquals(lat_lon[2], 0.0f);
assertEquals(lat_lon[3], 0.0f);
assertEquals(lat_lon[4], 0.0f);
assertEquals(lat_lon[5], 0.0f);
}
}
@Test
// Test that Lower Left Latitude is not <-91 or > 90
public void testLowerLeftLatOutOfBounds() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"-90.1;0;20;40");
flag = gac.isGraphicsAreaStringValid();
assertFalse(
"Lower Left Latitude can only take values between -90.00 and 90.00",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Lower Left Latitude can only take values between -90.00 and 90.00");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(
"90.1;0;90.0;40");
flag = gac2.isGraphicsAreaStringValid();
assertFalse(
"Lower Left Latitude can only take values between -90.00 and 90.00",
flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Lower Left Latitude can only take values between -90.00 and 90.00");
// }
}
@Test
// Test that Upper Right Latitude is not <-91 or > 90
public void testUpperRightLatOutOfBounds() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"-60;50;-90.1;0");
flag = gac.isGraphicsAreaStringValid();
assertFalse(
"Upper Right Latitude can only take values between -90.00 and 90.00",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Upper Right Latitude can only take values between -90.00 and 90.00");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(
"0;0;90.1;50");
flag = gac2.isGraphicsAreaStringValid();
assertFalse(
"Upper Right Latitude can only take values between -90.00 and 90.00",
flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Upper Right Latitude can only take values between -90.00 and 90.00");
// }
}
@Test
// Test that Lower Left Longitude is not > 360 or < -181
public void testLowerLeftLonOutOfBounds() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"-89;-180.1;60;0");
flag = gac.isGraphicsAreaStringValid();
assertFalse(
"Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(
"0;360.1;50;0");
flag = gac2.isGraphicsAreaStringValid();
assertFalse(
"Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00",
flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Lower Left Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
}
@Test
// Test that Upper Right Longitude is not > 360 or < -181
public void testUpperRightLonOutOfBounds() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"-89;59;50;-180.1");
flag = gac.isGraphicsAreaStringValid();
assertTrue(
"After adding convertLongitudeValue(...) logic, Upper Right Longitude -180.1 is valid now",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Upper Right Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(
"0;0;0;360.1");
flag = gac2.isGraphicsAreaStringValid();
assertTrue(
"After adding convertLongitudeValue(...) logic, Upper Right Longitude 360.1 is valid now",
flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Upper Right Longitude can only take values between -180.00 to 180.00 or 0.00 to 360.00");
// }
}
@Test
// Test for valid values of Lower Left and Upper Right Latitude/Longitude
// values
public void testValidLatLonDataRange() {
String gAreaString = "-90;-180;90;180";
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(gAreaString);
// flag = gac.parseGraphicsAreaString(gAreaString);
flag = gac.isGraphicsAreaStringValid();
assertTrue("The input Graphics Area Coordinates should be valid", flag);
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0], -90.0f);
assertEquals(lat_lon[1], -180.0f);
assertEquals(lat_lon[2], 90.0f);
assertEquals(lat_lon[3], 180.0f);
assertEquals(lat_lon[4], 0.0f);
assertEquals(lat_lon[5], 0.0f);
gAreaString = "-89;-179;89;179";
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(gAreaString);
flag = gac2.isGraphicsAreaStringValid();
// flag = gac2.parseGraphicsAreaString(gAreaString);
assertTrue("The input Graphics Area Coordinates should be valid", flag);
lat_lon = gac2.getGAREACoordinates();
assertEquals(lat_lon[0], -89f);
assertEquals(lat_lon[1], -179.0f);
assertEquals(lat_lon[2], 89.0f);
assertEquals(lat_lon[3], 179.0f);
assertEquals(lat_lon[4], 0.0f);
assertEquals(lat_lon[5], 0.0f);
}
@Test
// Test if Latitude/Longitude values can be entered without any digit
// preceding the '.' character.
public void testValiLatLonNoLeadingDigit() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"-.55;.66;30.45678;170");
flag = gac.isGraphicsAreaStringValid();
assertTrue("The input Graphics Area Coordinates should be valid", flag);
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0], -0.55f);
assertEquals(lat_lon[1], 0.66f);
assertEquals(lat_lon[2], 30.45678f);
assertEquals(lat_lon[3], 170.0f);
assertEquals(lat_lon[4], 14.95339f);
assertEquals(lat_lon[5], 85.33f);
}
@Test
// Test for less than 4 Latitude/Longitude values
public void testLessThanFourLatLonValues() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("10;20;30");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Too few arguments entered", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Too few arguments entered");
// }
}
@Test
// Test for more than 4 Latitude/Longitude values
public void testMoreThanFourLatLonValues() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"10;20;30;40;50");
flag = gac.isGraphicsAreaStringValid();
assertTrue(
"For the number of arguments more than 4, it should be considered a valid string, the extra arguments is simply ignored",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// }
}
@Test
// Test that Lower Left Latitude value cannot exceed the Upper Right
// Latitude
public void testLowerLeftLatLessThanUpperRightLat() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"70.55;40.45;30.02;80.44");
flag = gac.isGraphicsAreaStringValid();
assertFalse(
"Lower left latitude must be less than or equal to upper right latitude",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Lower left latitude must be less than or equal to upper right latitude");
// }
GraphicsAreaCoordinates gac_1 = new GraphicsAreaCoordinates(
"90;180;-90;-180");
flag = gac_1.isGraphicsAreaStringValid();
assertFalse(
"Lower left latitude must be less than or equal to upper right latitude",
flag);
// if(!flag){
// error_msg = gac_1.getErrorCode();
// assertEquals(error_msg,"Lower left latitude must be less than or equal to upper right latitude");
// }
}
@Test
// Test that Lower Left Longitude value cannot exceed the Upper Right
// Longitude
public void testLowerLeftLonLessThanUpperRightLon() {
GraphicsAreaCoordinates gac19 = new GraphicsAreaCoordinates(
"20.55;140.45;30.02;80.44");
flag = gac19.isGraphicsAreaStringValid();
assertFalse(
"Lower left longitude must be less than or equal to upper right longitude",
flag);
// if(!flag){
// error_msg = gac19.getErrorCode();
// assertEquals(error_msg,"Lower left longitude must be less than or equal to upper right longitude");
// }
GraphicsAreaCoordinates gac_1 = new GraphicsAreaCoordinates(
"90;180;90;-180");
flag = gac_1.isGraphicsAreaStringValid();
assertFalse(
"The two coordinate points are the same point, thus it is invalid",
flag);
// if(!flag){
// error_msg = gac_1.getErrorCode();
// assertEquals(error_msg,"Lower left longitude must be less than or equal to upper right longitude");
// }
}
@Test
// Test for invalid separator like a ',' character or a '.' character
// instead of ';'
public void testInvalidDelimiter() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("0.0.0.0");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Invalid String Format", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Invalid String Format");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("#0,0,0,0");
flag = gac2.isGraphicsAreaStringValid();
assertFalse("String Format '#0,0,0,0' should be invalid", flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"Invalid String Format");
// }
}
@Test
// Test for the presence of an extra '.' character
public void testExtraDemialPoint() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"-.55;90..77;30.45678;170");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Invalid lat/lon String Format", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Invalid lat/lon values entered");
// }
}
@Test
// Test for non-numeric characters in the input Latitude/Longitude string
public void testInvalidNonNumericLatLonInput() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("0;$0;0-;0");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Invalid lat/lon values entered", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Invalid lat/lon values entered");
// }
}
@Test
// Test that the Upper Right and Lower Left Latitude Values computed from
// the Center/Delta Lat/Lon Values
// lie in the correct range from -90.0 to 90.0
public void testInvalidCenterDeltaLatValues() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"#-90.0;10.4;0.1;0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse(
"center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(
"#90.0;10.4;0.1;0.45");
flag = gac2.isGraphicsAreaStringValid();
assertFalse(
"center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0",
flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"center_lat - delta_lat should be >= -90.0 and center_lat + delta_lat should be <=90.0");
// }
}
@Test
// Test that the Upper Right and Lower Left Longitude Values computed from
// the Center/Delta Latitude/Longitude Values
// lie in the correct range from -180.0 to 360.0
public void testInvalidCenterDeltaLonValues() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"#89.0;-180;0.1;0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse(
"center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0",
flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0");
// }
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates(
"#89.0;180;0.1;0.45");
flag = gac2.isGraphicsAreaStringValid();
assertTrue(
"A valid string pattern meets the logic of center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0",
flag);
// if(!flag){
// error_msg = gac2.getErrorCode();
// assertEquals(error_msg,"center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0");
// }
GraphicsAreaCoordinates gac3 = new GraphicsAreaCoordinates(
"#89.0;360;0.1;0.45");
flag = gac3.isGraphicsAreaStringValid();
/*
* After convertLongitudeValue(..) logic, the center Lon=360 is
* converted to Lon=0, thus, (center_lon + delta_lon=0.45) <=360.0
*/
assertTrue(
"After convertLongitudeValue(..) logic,, this string should be valid",
flag);
// if(!flag){
// error_msg = gac3.getErrorCode();
// assertEquals(error_msg,"center_lon - delta_lon should be >= -180.0 and center_lon + delta_lon should be <=360.0");
// }
}
@Test
// Test for negative delta latitude value
public void testNegativeDeltaLat() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"#30.0;160.00;-0.761;0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Delta Latitude values cannot be negative", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Delta Latitude values cannot be negative");
// }
}
@Test
// Test for negative delta longitude value
public void testNegativeDeltaLon() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates(
"#30.0;160.00;0.761;-0.45");
flag = gac.isGraphicsAreaStringValid();
assertFalse("Delta Longitude values cannot be negative", flag);
// if(!flag){
// error_msg = gac.getErrorCode();
// assertEquals(error_msg,"Delta Longitude values cannot be negative");
// }
}
@Test
// Test if the Latitude/Longitude and Projection String Data can be
// retrieved from the Geog Table (geog.xml)
// When the input string is a Geographical Area Code.
public void testValidInputGeogTable() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("MAAR");
flag = gac.isGraphicsAreaStringValid();
assertTrue("MAAR is a valid name in geog.xml table", flag);
assertEquals(gac.getGeogAreaCode(), "MAAR");
assertEquals(gac.getMapProjectionString(), "MER");
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[0], 17.00f);
assertEquals(lat_lon[1], -63.90f);
assertEquals(lat_lon[2], 18.60f);
assertEquals(lat_lon[3], -62.30f);
assertEquals(lat_lon[4], 17.80f);
assertEquals(lat_lon[5], -63.10f);
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("105");
flag = gac2.isGraphicsAreaStringValid();
assertTrue("105 is a valid name in geog.xml table", flag);
assertEquals(gac2.getMapProjectionString(), "STR/90;-105;0");
lat_lon = gac2.getGAREACoordinates();
assertEquals(lat_lon[0], 17.52f);
assertEquals(lat_lon[1], -129.30f);
assertEquals(lat_lon[2], 53.78f);
assertEquals(lat_lon[3], -22.37f);
assertEquals(lat_lon[4], 35.65f);
assertEquals(lat_lon[5], -105.00f);
GraphicsAreaCoordinates gac3 = new GraphicsAreaCoordinates("105**");
flag = gac3.isGraphicsAreaStringValid();
assertTrue("105** is a valid name in geog.xml table", flag);
assertEquals(gac3.getMapProjectionString(), "STR/90;-105;0");
lat_lon = gac3.getGAREACoordinates();
assertEquals(lat_lon[0], 26.585f);
assertEquals(lat_lon[1], -102.567f);
assertEquals(lat_lon[2], 46.981f);
assertEquals(lat_lon[3], -42.419f);
assertEquals(lat_lon[4], 35.65f);
assertEquals(lat_lon[5], -105.00f);
GraphicsAreaCoordinates gac4 = new GraphicsAreaCoordinates("105---");
flag = gac4.isGraphicsAreaStringValid();
assertTrue("105--- is a valid name in geog.xml table", flag);
assertEquals(gac4.getMapProjectionString(), "STR/90;-105;0");
lat_lon = gac4.getGAREACoordinates();
assertEquals(lat_lon[0], -0.609f);
assertEquals(lat_lon[1], -182.765f);
assertEquals(lat_lon[2], 80.975f);
assertEquals(lat_lon[3], 57.827f);
assertEquals(lat_lon[4], 35.65f);
assertEquals(lat_lon[5], -105.00f);
}
@Test
public void testInvalidInputGeogTable() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("105$%&");
flag = gac.isGraphicsAreaStringValid();
assertFalse("105$%& is NOT a valid name in geog.xml table", flag);
// if(!flag){
// assertEquals(gac.getGeogAreaCode(),"Invalid String Format");
// }
}
@Test
public void testValidInputStationTable() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("LFK");
flag = gac.isGraphicsAreaStringValid();
assertTrue("LFK is a valid name in sfstas.xml station table", flag);
assertEquals(gac.getStationCode(), "LFK");
double lat_lon[] = gac.getGAREACoordinates();
assertEquals(lat_lon[4], 31.00f);
assertEquals(lat_lon[5], -94.00f);
GraphicsAreaCoordinates gac2 = new GraphicsAreaCoordinates("BLI++");
flag = gac2.isGraphicsAreaStringValid();
assertTrue("BLI++ is a valid name in sfstas.xml station table", flag);
assertEquals(gac2.getStationCode(), "BLI");
lat_lon = gac2.getGAREACoordinates();
assertEquals(lat_lon[0], 46.00f);
assertEquals(lat_lon[1], -125.50f);
assertEquals(lat_lon[2], 51.50f);
assertEquals(lat_lon[3], -118.50f);
assertEquals(lat_lon[4], 48.00f);
assertEquals(lat_lon[5], -122.00f);
GraphicsAreaCoordinates gac3 = new GraphicsAreaCoordinates("BLI-");
flag = gac3.isGraphicsAreaStringValid();
assertTrue("BLI- is a valid name in sfstas.xml station table", flag);
assertEquals(gac3.getStationCode(), "BLI");
lat_lon = gac3.getGAREACoordinates();
assertEquals(lat_lon[0], 40.00f);
assertEquals(lat_lon[1], -136.00f);
assertEquals(lat_lon[2], 62.00f);
assertEquals(lat_lon[3], -108.00f);
assertEquals(lat_lon[4], 48.00f);
assertEquals(lat_lon[5], -122.00f);
}
@Test
public void testInvalidInputStationTable() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("#BLI!@#$%&");
flag = gac.isGraphicsAreaStringValid();
assertFalse("invalid station table name is entered", flag);
// if(!flag){
// assertEquals(gac.getGeogAreaCode(),"Invalid String Format");
// }
}
@Test
public void testEmptyString() {
GraphicsAreaCoordinates gac = new GraphicsAreaCoordinates("");
flag = gac.isGraphicsAreaStringValid();
assertFalse(
"Empty String is not a valid Graphic Area Coordinate string",
flag);
// if(!flag){
// assertEquals(gac.getGeogAreaCode(),"Empty String");
// }
}
}

0
ncep/gov.noaa.nws.ncep.gempak.parameters.core/unit_test/gov/noaa/nws/ncep/gempak/parameters/core/marshaller/garea/MapProjectionTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/core/marshaller/garea/MapProjectionTest.java
View file

1019
tests/unit/gov/noaa/nws/ncep/gempak/parameters/discrete/DiscreteTest.java Normal file
View file

File diff suppressed because it is too large Load diff

210
tests/unit/gov/noaa/nws/ncep/gempak/parameters/dlines/DLINESTest.java Normal file
View file

@ -0,0 +1,210 @@
package gov.noaa.nws.ncep.gempak.parameters.dlines;
import static org.junit.Assert.assertEquals;
import org.junit.Ignore;
import org.junit.Test;
/**
* <pre>
* Junit test-case for DLINES and DLINEData
*
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 29-Dec-2009 211 Archana.S Initial Creation
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
* </pre>
*
* @author Archana.S
* @version 1
*/
// TODO fix?
@Ignore
public class DLINESTest {
/**
* Test method for
* {@link gov.noaa.nws.ncep.gempak.parameters.dlines.DLines#getDlineData()}.
*/
@Test
public void testGetDlineData() {
String[] testCaseDescription = {
"Test DLINES with both right and left states set to true and epsilon set to 0.25",
"Test DLINES with both right and left states set to true and epsilon undefined",
"Test DLINES with only right state (set to true)",
"Test DLINES with both right and left states set to false and epsilon set to 1.3",
"Test DLINES with both right and left states set to false and epsilon undefined",
"Test DLINES with only right state (set to false)",
"Test DLINES with right state set to false and left state set to true",
"Test DLINES with right state set to true and left state set to false",
"Test DLINES for case-insensitive comparisons",
"Test DLINES with an invalid delimiter - using , instead of ;",
"Test DLINES with an invalid delimiter - using / instead of |",
"Test DLINES with a malformed input",
"Test DLINES with an empty string",
"Test DLINES with a null string",
"Test DLINES with a string containing only blanks",
"Test DLINES with extra arguments",
"Test DLINES with input parameters in reverse order"
};
String[] inputString = { "yes;yes|0.25", "yes;yes", "yes", "no;no|1.3",
"no;no", "no", "no ; yes", "yes ; no", "YES ; YeS",
"Yes , yes ", "Yes ; yes / 0.9", " ; |", "", null,
" ", "yes;yes;yes;yes | 0.9 | 0.8", "0.9 | yes ; yes" };
for (int i = 0; i < inputString.length; i++) {
DLines dlines = new DLines(inputString[i]);
System.out.println("Test-case number: " + (i + 1));
System.out.println(testCaseDescription[i]);
System.out.println("\nThe input string is: " + dlines.getDString());
if (dlines.getDlineData() != null) {
System.out
.println("Contour values to the right of the current contour line are greater = "
+ dlines.getDlineData()
.isRightOfContourLineGreater());
System.out
.println("Contour values to the left of the current contour line are greater = "
+ dlines.getDlineData()
.isLeftOfContourLineGreater());
System.out.println("Epsilon value = "
+ dlines.getDlineData().getEpsilon());
} else {
System.out.println("\nEmpty DLINES string");
}
System.out
.println("==================================================");
switch (i) {
case 0:
assertEquals(
"Contour values to the right of the current contour line should be greater",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), true);
assertEquals(
"Contour values to the left of the current contour line should be greater",
dlines.getDlineData().isLeftOfContourLineGreater(),
true);
assertEquals("Epsilon should be set to 0.25", dlines
.getDlineData().getEpsilon(), 0.25, 0.01);
break;
case 1:
assertEquals(
"Contour values to the right of the current contour line should be greater",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), true);
assertEquals(
"Contour values to the left of the current contour line should be greater",
dlines.getDlineData().isLeftOfContourLineGreater(),
true);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
break;
case 2:
assertEquals(
"Contour values to the right of the current contour line should be greater",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), true);
assertEquals(
"Contour values to the left of the current contour line should be lesser",
dlines.getDlineData().isLeftOfContourLineGreater(),
false);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
break;
case 3:
assertEquals(
"Contour values to the right of the current contour line should be lesser",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), false);
assertEquals(
"Contour values to the left of the current contour line should be lesser",
dlines.getDlineData().isLeftOfContourLineGreater(),
false);
assertEquals("Epsilon should be set to 1.3", dlines
.getDlineData().getEpsilon(), 1.3, 0.01);
break;
case 6:
assertEquals(
"Contour values to the right of the current contour line should be lesser",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), false);
assertEquals(
"Contour values to the left of the current contour line should be greater",
dlines.getDlineData().isLeftOfContourLineGreater(),
true);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
break;
case 7:
assertEquals(
"Contour values to the right of the current contour line should be greater",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), true);
assertEquals(
"Contour values to the left of the current contour line should be lesser",
dlines.getDlineData().isLeftOfContourLineGreater(),
false);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
break;
case 8:
assertEquals(
"Contour values to the right of the current contour line should be greater",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), true);
assertEquals(
"Contour values to the left of the current contour line should be greater",
dlines.getDlineData().isLeftOfContourLineGreater(),
true);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
break;
case 10:
assertEquals(
"Contour values to the right of the current contour line should be greater",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), true);
assertEquals(
"Contour values to the left of the current contour line should be lesser",
dlines.getDlineData().isLeftOfContourLineGreater(),
false);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
break;
default:
if (dlines.getDlineData() != null) {
assertEquals(
"Contour values to the right of the current contour line should be lesser",
dlines.getDlineData().isRightOfContourLineGreater()
.booleanValue(), false);
assertEquals(
"Contour values to the left of the current contour line should be lesser",
dlines.getDlineData().isLeftOfContourLineGreater(),
false);
assertEquals("Epsilon should be undefined", dlines
.getDlineData().getEpsilon(), Double.NaN, 0.01);
} else {
assertEquals("DLINES should be null",
dlines.getDlineData(), null);
}
break;
}
}
}
}

1389
tests/unit/gov/noaa/nws/ncep/gempak/parameters/gridlimits/GGLIMSTest.java Normal file
View file

File diff suppressed because it is too large Load diff

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/hilo/GridRelativeTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/hilo/GridRelativeTest.java
View file

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/hilo/HILOTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/hilo/HILOTest.java
View file

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/hlsym/HLSYMTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/hlsym/HLSYMTest.java
View file

683
tests/unit/gov/noaa/nws/ncep/gempak/parameters/infill/FINTTest.java Normal file
View file

@ -0,0 +1,683 @@
package gov.noaa.nws.ncep.gempak.parameters.infill;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
/**
* <pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 10-Nov-2009 184 Archana.S Initial Creation
* 17-Jun-2010 184 Archana.S Updated test-cases to test
* updated code in FINT
* 03-Aug-2010 184 Archana.S Updated test-cases to test
* updated code in FINT
* 25-Aug-2012 743 djohnson Upgrade to JUnit 4.10.
* </pre>
*
* @author Archana.S
* @version 1
*/
// TODO fix?
@Ignore
public class FINTTest {
private static int testCaseNumber;
private List<Double> testList;
private List<Double> testList2;
private List<Double> keySetList;
@Test
/*
* Test for valid FINT string of the form
* fillInterval/minFillValue/maxFillValue
*/
public void testPositiveFillFillIntervalWithMinMaxValues() {
testCaseNumber = 1;
FINT fint = new FINT("10/0.5/9");
assertEquals(fint.isFINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(0.5, 9.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
assertEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue(),
10);
assertEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(),
0.5);
assertEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(),
9);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Interval in First Zoom Level"
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Min Fill Value in First Zoom Level"
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Max Fill Value in First Zoom Level"
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
FINT fint2 = new FINT(" 10 / -57 / 86 ");
assertEquals(fint2.isFINTStringParsed(), true);
testList2 = new ArrayList<Double>(Arrays.asList(-50.0, -40.0, -30.0,
-20.0, -10.0, 0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0,
80.0));
keySetList = fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList2);
assertEquals(
fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue(), 10);
assertEquals(
fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(),
-57.0);
assertEquals(
fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue(), 86);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b ========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the fill data string parsed correctly? "
+ fint2.isFINTStringParsed());
System.out.println("Fill Values List = "
+ fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Interval in First Zoom Level"
+ fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Min Fill Value in First Zoom Level"
+ fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
System.out.println("Max Fill Value in First Zoom Level"
+ fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL).doubleValue());
testCaseNumber++;
}
/**
* @param doubleValue
* @param i
*/
// private static void assertEquals(double doubleValue, int i) {
// Assert.assertEquals(doubleValue, i, 0.001);
// }
@Test
/*
* Test for valid FINT string of the form
* fillInterval/minFillValue/maxFillValue with a negative contourInterval
*/
public void testNegativeFillIntervalWithMinMaxValues() {
FINT fint = new FINT("-5/-11/23");
assertEquals(fint.isFINTStringParsed(), true);
testList = new ArrayList<Double>(Arrays.asList(-10.0, -5.0, 0.0, 5.0,
10.0, 15.0, 20.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for valid FINT string of the form val1;val2;val3;val4..... */
public void testValidFillLevelValuesString() {
FINT fint = new FINT(
"66.1;0.1;5000;76;-.999;12233459390;0.00009988;1234.567890");
Assert.assertTrue(fint.isFINTStringParsed());
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0, 76.0,
-0.999, 1.223345939E10, 9.988E-5, 1234.56789));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for valid FINT string of the form val1 ; val2 ; val3 */
public void testValidFillLevelValuesStringWithBlanks() {
FINT fint = new FINT(
" 66.1 ; 0.1 ; 5000 ");
Assert.assertTrue(fint.isFINTStringParsed());
testList = new ArrayList<Double>(Arrays.asList(66.1, 0.1, 5000.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for valid FINT string of the form fillInterval/minFillValue/ */
public void testFillIntervalWithMinValueOnly() {
FINT fint = new FINT("-0.345/0/");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -0.345);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 0);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
/**
* @param fillInterval
* @param d
*/
private void assertDoubleEquals(Double fillInterval, double d) {
Assert.assertEquals(d, fillInterval.doubleValue(), 0.01);
}
@Test
/* Test for valid FINT string of the form fillInterval//maxFillValue */
public void testFillIntervalWithMaxValueOnly() {
FINT fint = new FINT("15//30");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), 15);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 30);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for valid FINT string containing only the fill interval */
public void testFINTWithOnlyFillIntervalSpecified() {
FINT fint = new FINT("-0.5/");
assertEquals(fint.isFINTStringParsed(), true);
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -0.5);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
FINT fint2 = new FINT("-.89//");
assertEquals(fint2.isFINTStringParsed(), true);
assertDoubleEquals(fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -0.89);
assertDoubleEquals(fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b ========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint2.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for valid FINT string of the form /minFillValue/maxFillValue */
public void testFillIntervalWithNoFillIntervalAndWithMinMaxValueOnly() {
FINT fint = new FINT("/10/30");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 30);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test for valid FINT string of the form /minFillValue/maxFillValue,where
* both minFillValueand maxFillValue are the same
*/
public void testFillIntervalWithMinValSameAsMaxValAndNoFillIntervalSpecified() {
FINT fint = new FINT("/10/10");
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
testList = new ArrayList<Double>(Arrays.asList(10.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ " ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test input string containing a single fill contour value */
public void testLessNumArgsFillIntervalString() {
FINT fint = new FINT("-0.6");
assertEquals(fint.isFINTStringParsed(), true);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a ========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
FINT fint2 = new FINT("0.7;");
assertEquals(fint2.isFINTStringParsed(), true);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b ========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint2.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "
+ fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/*
* Test for FINT string of the form
* fillInterval/minFillValue/maxFillValue/extraNumbers
* /extraNumbers/extraNumbers
*/
public void testExtraNumArgsFillIntervalString() {
FINT fint = new FINT("20/10/70/30/40/500");
Assert.assertTrue(fint.isFINTStringParsed());
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), 20);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 10);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 70);
testList = new ArrayList<Double>(Arrays.asList(10.0, 30.0, 50.0, 60.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for non-numeric values in FINT string */
public void testNonNumericFillIntervalString() {
FINT fint = new FINT("-def/abc/%^&/30/40");
assertEquals(fint.isFINTStringParsed(), false);
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test FINT string with invalid delimiters */
public void testInvalidDelimitersInFillIntervalString() {
FINT fint = new FINT("5.10.60.9");
assertEquals(fint.isFINTStringParsed(), false);
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL),
Double.NaN);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test FINT string by interchanging minFillValue and maxFillValue */
public void testMinMaxValuesInterchangedFillIntervalString() {
FINT fint = new FINT("-5/20/5");
Assert.assertTrue(fint.isFINTStringParsed());
assertDoubleEquals(fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL), -5);
assertDoubleEquals(fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 5);
assertDoubleEquals(fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 20);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(keySetList, testList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
FINT fint2 = new FINT("5/20/5");
assertEquals(fint2.isFINTStringParsed(), true);
assertDoubleEquals(fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL), 5);
assertDoubleEquals(fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL), 5);
assertDoubleEquals(fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL), 20);
testList = new ArrayList<Double>(Arrays.asList(5.0, 10.0, 15.0, 20.0));
keySetList = fint2.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(testList, keySetList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b========================");
System.out.println("The input string = "
+ fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint2.isFINTStringParsed());
System.out.println("Fill Interval = "
+ fint2.getFillInterval(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Minimum Fill Level = "
+ fint2.getMinFillValue(FINT.FIRST_ZOOM_LEVEL));
System.out.println("Maximum Fill Level = "
+ fint2.getMaxFillValue(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for non-numeric vales in fill values' string */
public void testInvalidFillLevelValuesString() {
FINT fint = new FINT("66.1;abc;5000;76;;@#$%;12233459390");
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Values List = "
+ fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL));
testCaseNumber++;
}
@Test
/* Test for invalid delimiters in fill values' string */
public void testInvalidDelimiterFillValuesString() {
FINT fint = new FINT("66.1,0,1,5000,76,-.999,12233459390");
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
testCaseNumber++;
}
@Test
/* Test for empty FINT string */
public void testEmptyString() {
FINT fint = new FINT();
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "a========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
FINT fint2 = new FINT("");
assertEquals(fint2.isFINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "b========================");
System.out.println("The input string = " + fint2.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint2.isFINTStringParsed());
FINT fint3 = new FINT(null);
assertEquals(fint3.isFINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "c========================");
System.out.println("The input string = " + fint3.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint3.isFINTStringParsed());
testCaseNumber++;
}
@Test
/* Test for FINT string with blank-spaces */
public void testFillDataStringWithBlankSpaces() {
FINT fint = new FINT(" ");
assertEquals(fint.isFINTStringParsed(), false);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = " + fint.getUserInputString());
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
testCaseNumber++;
}
/*
* Test contour interval string with multiple zoom levels
*/
@Test
public void testFINTMultipleZoomLevels() {
FINT fint = new FINT(
"2/-6/6/3 > 30;50;80 > 60 ; 80 > 0.00009999 > 0.0000001;");
Assert.assertTrue(fint.isFINTStringParsed());
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0, -2.0, 0.0,
2.0, 4.0, 6.0));
keySetList = fint.getFillValuesListAsDouble(FINT.FIRST_ZOOM_LEVEL);
assertEquals(testList, keySetList);
testList = new ArrayList<Double>(Arrays.asList(30.0, 50.0, 80.0));
keySetList = fint.getFillValuesListAsDouble(FINT.SECOND_ZOOM_LEVEL);
assertEquals(testList, keySetList);
testList = new ArrayList<Double>(Arrays.asList(60.0, 80.0));
keySetList = fint.getFillValuesListAsDouble(FINT.THIRD_ZOOM_LEVEL);
assertEquals(testList, keySetList);
keySetList = fint.getFillValuesListAsDouble(FINT.FOURTH_ZOOM_LEVEL);
assertEquals(Collections.EMPTY_LIST, keySetList);
keySetList = fint.getFillValuesListAsDouble(FINT.FIFTH_ZOOM_LEVEL);
assertEquals(Collections.EMPTY_LIST, keySetList);
testList = new ArrayList<Double>(Arrays.asList(-6.0, -4.0, -2.0, 0.0,
2.0, 4.0, 6.0, 30.0, 50.0, 60.0, 80.0));
keySetList = fint.getUniqueSortedFillValuesFromAllZoomLevels();
assertEquals(testList, keySetList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Interval at the 4th zoom level "
+ fint.getFillInterval(FINT.FOURTH_ZOOM_LEVEL));
System.out.println("Fill Interval at the 5th zoom level "
+ fint.getFillInterval(FINT.FIFTH_ZOOM_LEVEL));
System.out.println("The unique fill values sorted in ascending order: "
+ fint.getUniqueSortedFillValuesFromAllZoomLevelsAsString());
}
/*
* Test contour interval string with more than 5 zoom levels (currently 5 is
* the maximum)
*/
@Test
public void testFINTWithMoreThanFiveZoomLevels() {
FINT fint = new FINT(
"2/-6/6/3 > 30;50;80 > 60;80 > 0.00009999 > 0.0000001;0.2 > 90 > 100;200;300;400");
testList = new ArrayList<Double>(Arrays.asList(0.0000001, 0.2));
keySetList = fint.getFillValuesListAsDouble(FINT.MAX_ZOOM_LEVEL);
assertEquals(testList, keySetList);
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
System.out.println("The input string = "
+ fint.getUserInputString());
System.out.println("Is the fill data string parsed correctly? "
+ fint.isFINTStringParsed());
System.out.println("Fill Values at the maximum zoom level "
+ fint.getFillValuesListAsDouble(FINT.MAX_ZOOM_LEVEL));
}
/*
* Test contour interval string with multiple zoom levels, some of which are
* invalid
*/
@Test
public void testFINTWithInvalidZoomLevels()
throws IndexOutOfBoundsException {
System.out.println("=====================Test-Case " + testCaseNumber
+ "========================");
FINT fint = new FINT("2/-6/6/3 > > 60; 80 > > ");
System.out.println("The input string = "
+ "2/-6/6/3 > > 60; 80 > > ");
System.out.println("Is the FINT string parsed correctly? "
+ fint.isFINTStringParsed());
}
}

543
tests/unit/gov/noaa/nws/ncep/gempak/parameters/infill/FLineTest.java Normal file
View file

@ -0,0 +1,543 @@
package gov.noaa.nws.ncep.gempak.parameters.infill;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Ignore;
import org.junit.Test;
/**
* <pre>
* SOFTWARE HISTORY
* Date Ticket# Engineer Description
* ------------ ---------- ----------- --------------------------
* 04-Nov-2009 185 Archana.S Initial Creation
* </pre>
*
* @author Archana.S
* @version 1
*/
// TODO fix?
@Ignore
public class FLineTest {
private static Integer testCaseNumber = 1;
private List<Integer> testColorList;
private List<Integer> testPatternList;
private List<Integer> testColorList2;
private List<Integer> testPatternList2;
private List<Integer> testColorList3;
private List<Integer> testPatternList3;
@Test
public void testValidListOfColorsWithRepeatingPatterns() {
System.out.println("------------------Test-case " + testCaseNumber
+ "a----------------");
FLine fline = new FLine("1;2;3;4/4;5");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "a? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4));
testPatternList = new ArrayList<Integer>(Arrays.asList(4, 5, 4, 5));
assertEquals(fline.getFillColorList(), testColorList);
assertEquals(fline.getFillTypeList(), testPatternList);
System.out.println("------------------Test-case " + testCaseNumber
+ "b----------------");
FLine fline2 = new FLine("6;5;4;3;2;1/1;2;3;4;5;6");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "b? " + fline2.isFLineStringParsed());
System.out.println("The input string : " + fline2.getFLineString());
System.out.println("The list of colors: " + fline2.getFillColorList());
System.out.println("The list of patterns: " + fline2.getFillTypeList());
assertEquals(fline2.isFLineStringParsed(), true);
testColorList2 = new ArrayList<Integer>(Arrays.asList(6, 5, 4, 3, 2, 1));
testPatternList2 = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5,
6));
assertEquals(fline2.getFillColorList(), testColorList2);
assertEquals(fline2.getFillTypeList(), testPatternList2);
System.out
.println("--------------------------------------------------------");
testCaseNumber++;
}
@Test
public void testValidListOfColors() {
System.out.println("------------------Test-case " + testCaseNumber
+ "a----------------");
FLine fline = new FLine("1;2;3;4");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "a? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
System.out.println("------------------Test-case " + testCaseNumber
+ "b----------------");
FLine fline2 = new FLine("6;5;4;3;2;1/");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "b? " + fline2.isFLineStringParsed());
System.out.println("The input string : " + fline2.getFLineString());
System.out.println("The list of colors: " + fline2.getFillColorList());
System.out.println("The list of patterns: " + fline2.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline2.isFLineStringParsed(), true);
testColorList2 = new ArrayList<Integer>(Arrays.asList(6, 5, 4, 3, 2, 1));
assertEquals(fline2.getFillColorList(), testColorList2);
testPatternList2 = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1, 1,
1));
assertEquals(fline2.getFillTypeList(), testPatternList2);
testCaseNumber++;
}
@Test
public void testListOfColorsWithSomeMissingNumbers() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine(";5;;15;;25");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(
Arrays.asList(0, 5, 0, 15, 0, 25));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(
Arrays.asList(1, 1, 1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testListOfColorsWithBlanksAndMissingNumbers() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine("5; 4 ;6 ;; ; 8");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(5, 4, 6, 0, 0, 8));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(
Arrays.asList(1, 1, 1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testLisOfColorsWithAllNumbersMissing() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline2 = new FLine(";;;;;");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline2.isFLineStringParsed());
System.out.println("The input string : " + fline2.getFLineString());
System.out.println("The list of colors: " + fline2.getFillColorList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline2.isFLineStringParsed(), false);
testCaseNumber++;
}
@Test
public void testValidSingleColorInputs() {
System.out.println("------------------Test-case " + testCaseNumber
+ "a----------------");
FLine fline = new FLine("10;");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "a? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out.println("------------------Test-case " + testCaseNumber
+ "b----------------");
FLine fline2 = new FLine("11/");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "b? " + fline2.isFLineStringParsed());
System.out.println("The input string : " + fline2.getFLineString());
System.out.println("The list of colors: " + fline2.getFillColorList());
System.out.println("The list of patterns: " + fline2.getFillTypeList());
System.out.println("------------------Test-case " + testCaseNumber
+ "c----------------");
FLine fline3 = new FLine("13");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "c? " + fline3.isFLineStringParsed());
System.out.println("The input string : " + fline3.getFLineString());
System.out.println("The list of colors: " + fline3.getFillColorList());
System.out.println("The list of patterns: " + fline3.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(10));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1));
assertEquals(fline.getFillTypeList(), testPatternList);
assertEquals(fline2.isFLineStringParsed(), true);
testColorList2 = new ArrayList<Integer>(Arrays.asList(11));
assertEquals(fline2.getFillColorList(), testColorList2);
testPatternList2 = new ArrayList<Integer>(Arrays.asList(1));
assertEquals(fline2.getFillTypeList(), testPatternList2);
assertEquals(fline3.isFLineStringParsed(), true);
testColorList3 = new ArrayList<Integer>(Arrays.asList(13));
assertEquals(fline3.getFillColorList(), testColorList3);
testPatternList3 = new ArrayList<Integer>(Arrays.asList(1));
assertEquals(fline3.getFillTypeList(), testPatternList3);
testCaseNumber++;
}
@Test
public void testValidColorInputRange() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine("30-45");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithMinMaxValuesAltered() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine("30-4");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(30, 29, 28, 27,
26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11,
10, 9, 8, 7, 6, 5, 4));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithMissingMinValue() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine("-20");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithMissingMaxValue() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine("10-");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(10, 9, 8, 7, 6, 5,
4, 3, 2, 1));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1, 1,
1, 1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testColorInputRangeWithExcessParameters() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine("30-45-70-80");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45));
assertEquals(fline.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
assertEquals(fline.getFillTypeList(), testPatternList);
testCaseNumber++;
}
@Test
public void testFLineWithEmptyStringInput() {
System.out.println("------------------Test-case " + testCaseNumber
+ "a----------------");
FLine fline = new FLine("");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "a? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("------------------Test-case " + testCaseNumber
+ "b----------------");
FLine fline2 = new FLine();
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "b? " + fline2.isFLineStringParsed());
System.out.println("The input string : " + fline2.getFLineString());
System.out.println("The list of colors: " + fline2.getFillColorList());
System.out.println("------------------Test-case " + testCaseNumber
+ "c----------------");
FLine fline3 = new FLine(" ");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "c? " + fline3.isFLineStringParsed());
System.out.println("The input string : " + fline3.getFLineString());
System.out.println("The list of colors: " + fline3.getFillColorList());
System.out.println("------------------Test-case " + testCaseNumber
+ "d----------------");
FLine fline4 = new FLine(null);
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "d? " + fline4.isFLineStringParsed());
System.out.println("The input string : " + fline4.getFLineString());
System.out.println("The list of colors: " + fline4.getFillColorList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), false);
assertEquals(fline2.isFLineStringParsed(), false);
assertEquals(fline3.isFLineStringParsed(), false);
assertEquals(fline4.isFLineStringParsed(), false);
testCaseNumber++;
}
@Test
public void testFLineWithInvalidDelimiters() {
System.out.println("------------------Test-case " + testCaseNumber
+ "a----------------");
FLine fline = new FLine("10,20,30,");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "a? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
assertEquals(fline.isFLineStringParsed(), false);
System.out.println("------------------Test-case " + testCaseNumber
+ "b----------------");
FLine fline2 = new FLine("40;50//60");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "b? " + fline2.isFLineStringParsed());
System.out.println("The input string : " + fline2.getFLineString());
System.out.println("The list of colors: " + fline2.getFillColorList());
assertEquals(fline2.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(40, 50));
assertEquals(fline2.getFillColorList(), testColorList);
testPatternList = new ArrayList<Integer>(Arrays.asList(1, 1));
assertEquals(fline2.getFillTypeList(), testPatternList);
System.out.println("------------------Test-case " + testCaseNumber
+ "c----------------");
FLine fline3 = new FLine("10=40");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "c? " + fline3.isFLineStringParsed());
System.out.println("The input string : " + fline3.getFLineString());
System.out.println("The list of colors: " + fline3.getFillColorList());
assertEquals(fline3.isFLineStringParsed(), false);
System.out
.println("--------------------------------------------------------");
testCaseNumber++;
}
@Test
public void testFLineWithNonNumericInputs() {
System.out.println("------------------Test-case " + testCaseNumber
+ "a----------------");
FLine fline = new FLine("10a;gp##$%;*jsao/");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "a? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("------------------Test-case " + testCaseNumber
+ "b----------------");
FLine fline2 = new FLine("10a;bcd");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "b? " + fline2.isFLineStringParsed());
System.out.println("The input string : " + fline2.getFLineString());
System.out.println("The list of colors: " + fline2.getFillColorList());
System.out.println("------------------Test-case " + testCaseNumber
+ "c----------------");
FLine fline3 = new FLine("abc-def");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "c? " + fline3.isFLineStringParsed());
System.out.println("The input string : " + fline3.getFLineString());
System.out.println("The list of colors: " + fline3.getFillColorList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), false);
assertEquals(fline2.isFLineStringParsed(), false);
assertEquals(fline3.isFLineStringParsed(), false);
testCaseNumber++;
}
@Test
public void testColorRange() {
System.out.println("------------------Test-case " + testCaseNumber
+ "----------------");
FLine fline = new FLine("0;30-20");
System.out.println("Is line data parsed in test-case " + testCaseNumber
+ "? " + fline.isFLineStringParsed());
System.out.println("The input string : " + fline.getFLineString());
System.out.println("The list of colors: " + fline.getFillColorList());
System.out.println("The list of patterns: " + fline.getFillTypeList());
System.out
.println("--------------------------------------------------------");
assertEquals(fline.isFLineStringParsed(), true);
testColorList = new ArrayList<Integer>(Arrays.asList(0, 30, 29, 28, 27,
26, 25, 24, 23, 22, 21, 20));
assertEquals(fline.getFillColorList(), testColorList);
testCaseNumber++;
}
}

1347
tests/unit/gov/noaa/nws/ncep/gempak/parameters/inline/LineDataStringParserTest.java Normal file
View file

File diff suppressed because it is too large Load diff

244
tests/unit/gov/noaa/nws/ncep/gempak/parameters/intext/TextStringParserTest.java Normal file
View file

@ -0,0 +1,244 @@
package gov.noaa.nws.ncep.gempak.parameters.intext;
import static org.junit.Assert.assertEquals;
import org.junit.Ignore;
import org.junit.Test;
/**
* TEXT format: size/font/width/hwflgs
*
*/
// TODO fix?
@Ignore
public class TextStringParserTest {
private static int testCaseNumber = 1;
@Test
public void testTextInputStringParse1() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with blank string----------------");
TextStringParser txt = new TextStringParser("");
if (!txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), false);
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
}
testCaseNumber++;
}
@Test
public void testHLSYMInputStringParse2() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with sizes----------------");
TextStringParser txt = new TextStringParser("1.286");
if (txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), true);
assertEquals(txt.getSymbolMarkerSize(), 1.286f);
assertEquals(txt.getTextSize(), 18);
assertEquals(txt.getTextFont(), 1);
assertEquals(txt.getTextWidth(), 2);
assertEquals(txt.getTextHWFlag(), "HW");
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
System.out.println(" Symbol/Marker size : "
+ txt.getSymbolMarkerSize());
System.out.println(" Text size : " + txt.getTextSize());
System.out.println(" Text font : " + txt.getTextFont());
System.out.println(" Text width : " + txt.getTextWidth());
System.out.println(" Text hwflg : " + txt.getTextHWFlag());
}
testCaseNumber++;
}
@Test
public void testHLSYMInputStringParse3() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with size name ----------------");
TextStringParser txt = new TextStringParser("tin");
if (txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), true);
assertEquals(txt.getSymbolMarkerSize(), 0.714f);
assertEquals(txt.getTextSize(), 10);
assertEquals(txt.getTextFont(), 1);
assertEquals(txt.getTextWidth(), 2);
assertEquals(txt.getTextHWFlag(), "HW");
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
System.out.println(" Symbol/Marker size : "
+ txt.getSymbolMarkerSize());
System.out.println(" Text size : " + txt.getTextSize());
System.out.println(" Text font : " + txt.getTextFont());
System.out.println(" Text width : " + txt.getTextWidth());
System.out.println(" Text hwflg : " + txt.getTextHWFlag());
}
testCaseNumber++;
}
@Test
public void testHLSYMInputStringParse4() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with size/font ----------------");
TextStringParser txt = new TextStringParser("1.286/2");
if (txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), true);
assertEquals(txt.getSymbolMarkerSize(), 1.286f);
assertEquals(txt.getTextSize(), 18);
assertEquals(txt.getTextFont(), 2);
assertEquals(txt.getTextWidth(), 2);
assertEquals(txt.getTextHWFlag(), "HW");
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
System.out.println(" Symbol/Marker size : "
+ txt.getSymbolMarkerSize());
System.out.println(" Text size : " + txt.getTextSize());
System.out.println(" Text font : " + txt.getTextFont());
System.out.println(" Text width : " + txt.getTextWidth());
System.out.println(" Text hwflg : " + txt.getTextHWFlag());
}
testCaseNumber++;
}
@Test
public void testHLSYMInputStringParse5() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with size/invalid font ----------------");
TextStringParser txt = new TextStringParser("1.286/5");
if (txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), true);
assertEquals(txt.getSymbolMarkerSize(), 1.286f);
assertEquals(txt.getTextSize(), 18);
assertEquals(txt.getTextFont(), 1);
assertEquals(txt.getTextWidth(), 2);
assertEquals(txt.getTextHWFlag(), "HW");
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
System.out.println(" Symbol/Marker size : "
+ txt.getSymbolMarkerSize());
System.out.println(" Text size : " + txt.getTextSize());
System.out.println(" Text font : " + txt.getTextFont());
System.out.println(" Text width : " + txt.getTextWidth());
System.out.println(" Text hwflg : " + txt.getTextHWFlag());
}
testCaseNumber++;
}
@Test
public void testHLSYMInputStringParse6() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with size/ font / width ----------------");
TextStringParser txt = new TextStringParser("1.714/3/8");
if (txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), true);
assertEquals(txt.getSymbolMarkerSize(), 1.714f);
assertEquals(txt.getTextSize(), 24);
assertEquals(txt.getTextFont(), 3);
assertEquals(txt.getTextWidth(), 8);
assertEquals(txt.getTextHWFlag(), "HW");
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
System.out.println(" Symbol/Marker size : "
+ txt.getSymbolMarkerSize());
System.out.println(" Text size : " + txt.getTextSize());
System.out.println(" Text font : " + txt.getTextFont());
System.out.println(" Text width : " + txt.getTextWidth());
System.out.println(" Text hwflg : " + txt.getTextHWFlag());
}
testCaseNumber++;
}
@Test
public void testHLSYMInputStringParse7() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with size/ font / width /hw flag ----------------");
TextStringParser txt = new TextStringParser("2.429/2/8/HW");
if (txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), true);
assertEquals(txt.getSymbolMarkerSize(), 2.429f);
assertEquals(txt.getTextSize(), 34);
assertEquals(txt.getTextFont(), 2);
assertEquals(txt.getTextWidth(), 8);
assertEquals(txt.getTextHWFlag(), "HW");
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
System.out.println(" Symbol/Marker size : "
+ txt.getSymbolMarkerSize());
System.out.println(" Text size : " + txt.getTextSize());
System.out.println(" Text font : " + txt.getTextFont());
System.out.println(" Text width : " + txt.getTextWidth());
System.out.println(" Text hwflg : " + txt.getTextHWFlag());
}
testCaseNumber++;
}
@Test
public void testHLSYMInputStringParse8() {
System.out.println("------------------Test-case " + testCaseNumber
+ " with size/ font / width /hw flag ----------------");
TextStringParser txt = new TextStringParser("2.429/2/8/SW");
if (txt.isTextParsed()) {
assertEquals(txt.isTextParsed(), true);
assertEquals(txt.getSymbolMarkerSize(), 2.429f);
assertEquals(txt.getTextSize(), 34);
assertEquals(txt.getTextFont(), 2);
assertEquals(txt.getTextWidth(), 8);
assertEquals(txt.getTextHWFlag(), "SW");
System.out.println("--User Input Text parameter:"
+ txt.getInputTextString());
System.out.println("-----------------------------");
System.out.println(" Symbol/Marker size : "
+ txt.getSymbolMarkerSize());
System.out.println(" Text size : " + txt.getTextSize());
System.out.println(" Text font : " + txt.getTextFont());
System.out.println(" Text width : " + txt.getTextWidth());
System.out.println(" Text hwflg : " + txt.getTextHWFlag());
}
testCaseNumber++;
}
}

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/line/LineDataStringParserTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/line/LineDataStringParserTest.java
View file

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/marker/MARKERTest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/marker/MARKERTest.java
View file

0
ncep/gov.noaa.nws.ncep.gempak.parameters/unit_test/gov/noaa/nws/ncep/gempak/parameters/title/TITLETest.java → tests/unit/gov/noaa/nws/ncep/gempak/parameters/title/TITLETest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/AllTests.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/AllTests.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/display/AbstractPatternApplicatorTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/display/AbstractPatternApplicatorTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/display/ArcPatternApplicatorTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/display/ArcPatternApplicatorTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/display/CornerPatternApplicatorTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/display/CornerPatternApplicatorTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/display/DisplaySuite.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/display/DisplaySuite.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/DrawableTypeTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/DrawableTypeTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/ElementsSuite.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/ElementsSuite.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/LayerTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/LayerTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/ProductInfoTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/ProductInfoTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/ProductRelationshipTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/ProductRelationshipTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/ProductTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/ProductTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/ProductTimeTest.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/ProductTimeTest.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/elements/TestCollection.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/elements/TestCollection.java
View file

220
tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/GfaFormatTest.java Normal file
View file

@ -0,0 +1,220 @@
package gov.noaa.nws.ncep.ui.pgen.gfa;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import gov.noaa.nws.ncep.ui.pgen.elements.AbstractDrawableComponent;
import gov.noaa.nws.ncep.ui.pgen.elements.Layer;
import gov.noaa.nws.ncep.ui.pgen.elements.Product;
import gov.noaa.nws.ncep.ui.pgen.file.ProductConverter;
import gov.noaa.nws.ncep.ui.pgen.file.Products;
import gov.noaa.nws.ncep.ui.pgen.tools.PgenCycleTool;
import java.io.FileNotFoundException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import com.raytheon.uf.common.serialization.SerializationException;
import com.raytheon.uf.viz.core.localization.LocalizationManager;
//import org.apache.log4j.Logger;
//TODO fix?
@Ignore
public class GfaFormatTest {
/** Logger */
// private final static Logger log = Logger.getLogger(GfaFormatTest.class);
public static final String BASE_DIR = "../../eclipse/";
public static final int CYCLE_DAY = 20;
public static final int CYCLE_HOUR = 14;
public static final String HTTP_SERVER = "http://localhost:9581/services";
public static final String PACKAGE = "unit-test/"
+ GfaFormatTest.class.getPackage().getName().replace(".", "/")
+ "/xml/";
public static String rulesXml = "rules.xml";
private static Document doc;
@Before
public void setUp() throws Exception {
configure();
getDocument();
}
@After
public void tearDown() throws Exception {
}
@Ignore
public void getDocumentTest() {
// reads the rules file
assertNotNull(doc);
}
private void createSmearsTest(String fileName, GfaWording expectedWording,
int adj) throws FileNotFoundException, SerializationException {
List<AbstractDrawableComponent> drawables = read(PACKAGE + fileName);
// test if all gfa and size
ArrayList<Gfa> gfaList = new ArrayList<Gfa>();
for (AbstractDrawableComponent adc : drawables) {
if (adc instanceof Gfa)
gfaList.add((Gfa) adc);
}
assertFalse(gfaList.isEmpty());
int sizeBefore = gfaList.size();
GfaFormat gf = new GfaFormat();
// actual test
gf.createSmears(drawables);
int sizeAfter = drawables.size();
assertTrue(sizeAfter > sizeBefore);
Gfa gfa = (Gfa) drawables.get(sizeBefore + adj);
GfaWording e = expectedWording; // expected
GfaWording r = gfa.getAttribute("WORDING", GfaWording.class); // result
assertEquals("failed fromCondsDvlpg in " + fileName, e.fromCondsDvlpg,
r.fromCondsDvlpg);
assertEquals("failed fromCondsEndg in " + fileName, e.fromCondsEndg,
r.fromCondsEndg);
assertEquals("failed genOlk in " + fileName, e.genOlk, r.genOlk);
assertEquals("failed condsContg in " + fileName, e.condsContg,
r.condsContg);
assertEquals("failed otlkCondsDvlpg in " + fileName, e.otlkCondsDvlpg,
r.otlkCondsDvlpg);
assertEquals("failed otlkCondsEndg in " + fileName, e.otlkCondsEndg,
r.otlkCondsEndg);
assertEquals("failed in " + fileName, e, r);
}
@Test
public void runRules() {
String xPath = "/rules/rule";
List<Node> nodes = selectNodes(xPath);
StringBuilder sb = new StringBuilder(500);
int errors = 0;
for (Node n : nodes) {
String[] fileNames = n.valueOf("@filenames").split(",");
for (String fileName : fileNames) {
// if(!fileName.startsWith("gfa01.xml")) continue;
String fromCondsDvlpg = n.valueOf("@fromCondsDvlpg");
String fromCondsEndg = n.valueOf("@fromCondsEndg");
String genOlk = n.valueOf("@genOlk");
String condsContg = n.valueOf("@condsContg");
String otlkCondsDvlpg = n.valueOf("@otlkCondsDvlpg");
String otlkCondsEndg = n.valueOf("@otlkCondsEndg");
String orderInQueue = n.valueOf("@orderInQueue");
int plus = 0;
if (!orderInQueue.isEmpty()) {
plus = Integer.parseInt(orderInQueue);
}
GfaWording expected = new GfaWording();
expected.fromCondsDvlpg = fromCondsDvlpg;
expected.fromCondsEndg = fromCondsEndg;
expected.genOlk = genOlk;
expected.condsContg = condsContg;
expected.otlkCondsDvlpg = otlkCondsDvlpg;
expected.otlkCondsEndg = otlkCondsEndg;
sb.append("filename=\"" + fileName + "\"\nExpected:\n");
sb.append(expected.toString());
// log.info(sb.toString());
sb.setLength(0);
try {
createSmearsTest(fileName, expected, plus);
} catch (Exception e) {
// log.error("\ncreateSmearsTest failed: " + fileName, e);
e.printStackTrace();
errors++;
}
}
}
assertEquals("Number of failed files ", 0, errors);
// log.info(sb.toString());
}
private List<AbstractDrawableComponent> read(String file)
throws FileNotFoundException, SerializationException {
Products products = (Products) Util.read(file);
List<Product> productList = ProductConverter.convert(products);
assertEquals(1, productList.size());
List<Layer> layerList = productList.get(0).getLayers();
assertEquals(1, layerList.size());
List<AbstractDrawableComponent> drawables = layerList.get(0)
.getDrawables();
return drawables;
}
/**
* Sets base directory and cycle.
*
* @throws NoSuchFieldException
* @throws IllegalAccessException
*/
public static void configure() throws NoSuchFieldException,
IllegalAccessException {
long time = System.currentTimeMillis();
LocalizationManager.setBaseDir(GfaFormatTest.BASE_DIR);
// use reflection to update private fields
Field field = PgenCycleTool.class.getDeclaredField("cycleDay");
field.setAccessible(true);
field.set(null, GfaFormatTest.CYCLE_DAY);
field = PgenCycleTool.class.getDeclaredField("cycleHour");
field.setAccessible(true);
field.set(null, GfaFormatTest.CYCLE_HOUR);
// ?NcDirectDbQuery.setHttpServer(HTTP_SERVER);
// log.debug("configure() " + (System.currentTimeMillis() - time) +
// " ms");
if (!PreloadGfaDataThread.loaded) {
// preload the classes to reduce the first GFA format time
new PreloadGfaDataThread().run();
}
}
static int count = 0;
private void getDocument() {
if (doc != null)
return;
try {
SAXReader reader = new SAXReader();
doc = reader.read(PACKAGE + rulesXml);
} catch (Exception e) {
// log.error(e);
e.printStackTrace();
}
}
@SuppressWarnings("unchecked")
private List<Node> selectNodes(String xPath) {
return doc.selectNodes(xPath);
}
}

36
tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/GfaInfoTest.java Normal file
View file

@ -0,0 +1,36 @@
package gov.noaa.nws.ncep.ui.pgen.gfa;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import gov.noaa.nws.ncep.ui.pgen.tools.PgenCycleTool;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
//TODO fix?
@Ignore
public class GfaInfoTest {
@Before
public void setUp() throws Exception {
GfaFormatTest.configure();
}
@After
public void tearDown() throws Exception {
}
@Test
public void testCycle() {
assertEquals(GfaFormatTest.CYCLE_DAY, PgenCycleTool.getCycleDay());
assertEquals(GfaFormatTest.CYCLE_HOUR, PgenCycleTool.getCycleHour());
}
@Test
public void getDocument() {
// reads the gfa configuration file
assertNotNull(GfaInfo.getDocument());
}
}

12
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/GfaSuite.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/GfaSuite.java
View file

@ -1,14 +1,14 @@
package gov.noaa.nws.ncep.ui.pgen.gfa;
import org.junit.Ignore;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses({
GfaInfoTest.class,
GfaFormatTest.class
})
@Suite.SuiteClasses({ GfaInfoTest.class, GfaFormatTest.class })
// TODO fix?
@Ignore
public class GfaSuite {
// the class remains completely empty,
// the class remains completely empty,
// being used only as a holder for the above annotations
}

241
tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/ReduceGfaPointsTest.java Normal file
View file

@ -0,0 +1,241 @@
package gov.noaa.nws.ncep.ui.pgen.gfa;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.xml.bind.JAXBException;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import com.vividsolutions.jts.geom.Coordinate;
//TODO fix?
@Ignore
public class ReduceGfaPointsTest {
/**
* Test method for
* {@link gov.noaa.nws.ncep.ui.pgen.tools.ReduceGfaPoints#reduceBySize(com.vividsolutions.jts.geom.CoordinateList, java.util.List, int, double, double)}
* .
*/
@Test
public final void testReduceBySize() {
// TODO
Coordinate[] coord = { new Coordinate(1, 1), new Coordinate(1, -1),
new Coordinate(0, -2), new Coordinate(-1, -1),
new Coordinate(-1, 1) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(1.6666666666666667, 1.0),
new Coordinate(0.12499999999999996, -3.625),
new Coordinate(-1.8571428571428572, 1.0) };
List<Coordinate> clAfter = Arrays.asList(coordAfter);
int result = ReduceGfaPoints.reduceBySize(cl, null, orig, 3, 60.0,
100.0);
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceBySize2() {
// TODO
Coordinate[] coord = { new Coordinate(1, 1), new Coordinate(1, 0),
new Coordinate(1, -1), new Coordinate(0, -1),
new Coordinate(-1, -1), new Coordinate(-1, 0),
new Coordinate(-1, 1), new Coordinate(0, 1) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(1, -1),
new Coordinate(-1, -1), new Coordinate(-1, 1) };
List<Coordinate> clAfter = Arrays.asList(coordAfter);
int result = ReduceGfaPoints.reduceBySize(cl, null, orig, 3, 60.0,
100.0);
assertEquals("Result", clAfter, cl);
}
/**
* Test method for
* {@link gov.noaa.nws.ncep.ui.pgen.tools.ReduceGfaPoints#reduceByPctDist(com.vividsolutions.jts.geom.CoordinateList, java.util.List, java.util.List, double, double, double, java.lang.String)}
* .
*/
@Test
public final void testReduceByPctDist() {
// TODO //set LENFROM=35
Coordinate[] coord = { new Coordinate(-110.57, 54.72),
new Coordinate(-100.19, 54.54), new Coordinate(-89.37, 48.92),
new Coordinate(-96.65, 41.84), new Coordinate(-103.69, 37.25),
new Coordinate(-113.93, 38.34), new Coordinate(-117.95, 42.4),
new Coordinate(-118.43, 47.81), new Coordinate(-115.17, 52.63) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-110.57, 54.72),
new Coordinate(-100.19, 54.54), new Coordinate(-89.37, 48.92),
new Coordinate(-103.69, 37.25), new Coordinate(-113.93, 38.34),
new Coordinate(-118.43, 47.81) };
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 450.0,
"BOUNDED BY");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceByPctDist2() {
// TODO //set LENFROM=23
Coordinate[] coord = { new Coordinate(-90, 40),
new Coordinate(-96, 33), new Coordinate(-155, 30),
new Coordinate(-177, 33), new Coordinate(-100, 50) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-90, 40),
new Coordinate(-96, 33), new Coordinate(-155, 30),
new Coordinate(-177, 33), new Coordinate(-100, 50) };
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 450.0,
"BOUNDED BY");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceByPctDist3() {
// TODO FROM 4400ESE YSJ TO 4480ESE YSJ TO 4490ESE YSJ TO 4400ESE YSJ TO
// 4320ESE YSJ TO 4400ESE YSJ
Coordinate[] coord = { new Coordinate(1, 1), new Coordinate(1, -1),
new Coordinate(0, -2), new Coordinate(-1, -1),
new Coordinate(-1, 1) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(1.6666666666666667, 1.0),
new Coordinate(0.12499999999999996, -3.625),
new Coordinate(-1.8571428571428572, 1.0) }; // 1,-1
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceByPctDist(cl, null, orig, 60.0, 80.0, 150.0,
"FROM");
assertEquals("Result", clAfter, cl);
}
/**
* Test method for
* {@link gov.noaa.nws.ncep.ui.pgen.tools.ReduceGfaPoints#reduceKeepConcav(com.vividsolutions.jts.geom.CoordinateList, java.util.List, java.util.List, double, double, java.lang.String)}
* .
*
* @throws JAXBException
*/
@Test
public final void testReduceKeepConcav() {
// TODO //to test, set LENFROM=23
Coordinate[] coord = { new Coordinate(-100, 50),
new Coordinate(-90, 40), new Coordinate(-96, 33),
new Coordinate(-155, 30), new Coordinate(-177, 33) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-92.7, 51.6),
new Coordinate(-88.4, 33.4), new Coordinate(-155, 30),
new Coordinate(-177, 33) };
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceKeepConcav(cl, null, orig, 60.0, 450.0, "FROM");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceKeepConcav2() {
// TODO
Coordinate[] coord = { new Coordinate(-110.57, 54.72),
new Coordinate(-100.19, 54.54), new Coordinate(-89.37, 48.92),
new Coordinate(-96.65, 41.84), new Coordinate(-103.69, 37.25),
new Coordinate(-113.93, 38.34), new Coordinate(-117.95, 42.4),
new Coordinate(-118.43, 47.81), new Coordinate(-115.17, 52.63) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(-112.75, 54.76),
new Coordinate(-100.19, 54.54), new Coordinate(-89.37, 48.92),
new Coordinate(-96.65, 41.84), new Coordinate(-103.69, 37.25),
new Coordinate(-113.93, 38.34), new Coordinate(-117, 33),
new Coordinate(-118.59, 49.62) };
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceKeepConcav(cl, null, orig, 60.0, 450.0, "FROM");
assertEquals("Result", clAfter, cl);
}
@Test
public final void testReduceKeepConcav3() {
// TODO
Coordinate[] coord = { new Coordinate(1, 1), new Coordinate(1, -1),
new Coordinate(0, -2), new Coordinate(-1, -1),
new Coordinate(-1, 1) };
List<Coordinate> cl = Arrays.asList(coord);
List<Integer> reduceFlg = new ArrayList<Integer>();
for (int i = 0; i < cl.size(); i++)
reduceFlg.add(1);
List<Integer> orig = new ArrayList<Integer>();
Coordinate[] coordAfter = { new Coordinate(1.6666666666666667, 1.0),
new Coordinate(0.12499999999999996, -3.625),
new Coordinate(-1.8571428571428572, 1.0) };
List<Coordinate> clAfter = Arrays.asList(coordAfter);
ReduceGfaPoints.reduceKeepConcav(cl, null, orig, 60.0, 150.0, "FROM");
assertEquals("Result", clAfter, cl);
}
@RunWith(Suite.class)
@Suite.SuiteClasses({ ReduceGfaPointsTest.class })
public class AllTests {
}
// public static void main(String[] args) {
// Result result = JUnitCore.runClasses(MyClassTest.class);
// for (Failure failure : result.getFailures()) {
// System.out.println(failure.toString());
// }
// }
}

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/Util.java → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/Util.java
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa01.xml → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa01.xml
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa01_1.xml → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa01_1.xml
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa02.xml → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa02.xml
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa03.xml → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa03.xml
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa04.xml → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa04.xml
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa05.xml → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa05.xml
View file

0
ncep/gov.noaa.nws.ncep.ui.pgen/unit-test/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa05_1.xml → tests/unit/gov/noaa/nws/ncep/ui/pgen/gfa/xml/gfa05_1.xml
View file

Some files were not shown because too many files have changed in this diff Show more