Summary Table
Categories |
Total Count |
PII |
0 |
URL |
0 |
DNS |
1 |
EKL |
0 |
IP |
0 |
PORT |
0 |
VsID |
0 |
CF |
0 |
AI |
0 |
VPD |
0 |
PL |
0 |
Other |
0 |
File Content
/**
*
*/
package gov.va.med.ewv.util;
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 java.math.BigDecimal;
import java.time.LocalDate;
import static gov.va.med.ewv.util.NullsLastComparator.*;
/**
* @author
DNS
*
*/
public class NullsLastComparatorTest {
// Check results of compare(a,b)
static void assertLT(int cmp) { assertTrue(cmp < 0); }
static void assertEQ(int cmp) { assertTrue(cmp == 0); }
static void assertGT(int cmp) { assertTrue(cmp > 0); }
/**
* @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.va.med.ewv.util.NullsLastComparator#nullsLastBigDecimalComparator.compare(java.math.BigDecimal, java.math.BigDecimal)}.
*/
@Test
public void test_nullsLastBigDecimalComparator() {
BigDecimal noVal = null;
BigDecimal loVal = BigDecimal.valueOf(1.5);
BigDecimal hiVal = BigDecimal.valueOf(1.5e6);
// Use nullsLastBigDecimalComparator
assertEQ(nullsLastBigDecimalComparator.compare(loVal, loVal));
assertEQ(nullsLastBigDecimalComparator.compare(hiVal, hiVal));
assertLT(nullsLastBigDecimalComparator.compare(loVal, hiVal));
assertGT(nullsLastBigDecimalComparator.compare(hiVal, loVal));
assertEQ(nullsLastBigDecimalComparator.compare(noVal, noVal));
assertLT(nullsLastBigDecimalComparator.compare(loVal, noVal));
assertLT(nullsLastBigDecimalComparator.compare(hiVal, noVal));
assertGT(nullsLastBigDecimalComparator.compare(noVal, loVal));
assertGT(nullsLastBigDecimalComparator.compare(noVal, hiVal));
}
/**
* Test method for {@link gov.va.med.ewv.util.NullsLastComparator#compare(java.math.BigDecimal, java.math.BigDecimal)}.
*/
@Test
public void testCompareBigDecimalBigDecimal() {
BigDecimal noVal = null;
BigDecimal loVal = BigDecimal.valueOf(1.5);
BigDecimal hiVal = BigDecimal.valueOf(1.5e6);
assertEQ(NullsLastComparator.compare(loVal, loVal));
assertEQ(NullsLastComparator.compare(hiVal, hiVal));
assertLT(NullsLastComparator.compare(loVal, hiVal));
assertGT(NullsLastComparator.compare(hiVal, loVal));
assertEQ(NullsLastComparator.compare(noVal, noVal));
assertLT(NullsLastComparator.compare(loVal, noVal));
assertLT(NullsLastComparator.compare(hiVal, noVal));
assertGT(NullsLastComparator.compare(noVal, loVal));
assertGT(NullsLastComparator.compare(noVal, hiVal));
// Should be overloaded
assertEQ(compare(loVal, loVal));
assertEQ(compare(hiVal, hiVal));
assertLT(compare(loVal, hiVal));
assertGT(compare(hiVal, loVal));
assertEQ(compare(noVal, noVal));
assertLT(compare(loVal, noVal));
assertLT(compare(hiVal, noVal));
assertGT(compare(noVal, loVal));
assertGT(compare(noVal, hiVal));
}
/**
* Test method for {@link gov.va.med.ewv.util.NullsLastComparator#localDateUSA(String)}.
*/
@Test
public void test_localDateUSA() {
int year = 2018;
int month = 10;
int dayOfMonth = 25;
LocalDate somedayExpect = LocalDate.of(year, month, dayOfMonth);
String somedayArg = "10/25/2018";
LocalDate somedayActual = localDateUSA(somedayArg);
assertEquals(somedayExpect, somedayActual);
// Try null, should return null
String noArg = null;
LocalDate nullActual = localDateUSA(noArg);
assertNull(nullActual);
// Try malformed dates, should all return null
String[] xxArgs = {
"10/25/2018,", // too long
"",
"oops",
"10-25-2018",
"10.25.2018",
"10252018",
"2018/10/25",
"2018-10-25",
"10-25-2018",
}; // OK to have ,}
// You could have millions of incorrect values.
for (String xxArg : xxArgs) {
LocalDate xxActual = NullsLastComparator.localDateUSA(xxArg);
assertNull(xxActual);
}
}
/**
* Test method for {@link gov.va.med.ewv.util.NullsLastComparator#localDateUSA(String)}.
*/
@Test
public void test_localDateUSA_static() {
int year = 2018;
int month = 10;
int dayOfMonth = 25;
LocalDate somedayExpect = LocalDate.of(year, month, dayOfMonth);
String somedayArg = "10/25/2018";
LocalDate somedayActual = localDateUSA(somedayArg);
assertEquals(somedayExpect, somedayActual);
// Try null, should return null
String noArg = null;
LocalDate nullActual = localDateUSA(noArg);
assertNull(nullActual);
// Try malformed dates, should all return null
String[] xxArgs = {
"10/25/2018,", // too long
"",
"oops",
"10-25-2018",
"10.25.2018",
"10252018",
"2018/10/25",
"2018-10-25",
"10-25-2018",
}; // OK to have ,}
// You could have millions of incorrect values.
for (String xxArg : xxArgs) {
LocalDate xxActual = localDateUSA(xxArg);
assertNull(xxActual);
}
}
/**
* Test method for {@link gov.va.med.ewv.util.NullsLastComparator#nullsLastLocalDateStringComparator}.
*/
@Test
public void test_nullsLastLocalDateStringComparator() {
String noVal = null;
// Choose values that would sort in the opposite order as Strings
String loVal = "10/25/1018";
String hiVal = "01/01/2018";
assertEQ(nullsLastLocalDateStringComparator.compare(loVal, loVal));
assertEQ(nullsLastLocalDateStringComparator.compare(hiVal, hiVal));
assertLT(nullsLastLocalDateStringComparator.compare(loVal, hiVal));
assertGT(nullsLastLocalDateStringComparator.compare(hiVal, loVal));
assertEQ(nullsLastLocalDateStringComparator.compare(noVal, noVal));
assertLT(nullsLastLocalDateStringComparator.compare(loVal, noVal));
assertLT(nullsLastLocalDateStringComparator.compare(hiVal, noVal));
assertGT(nullsLastLocalDateStringComparator.compare(noVal, loVal));
assertGT(nullsLastLocalDateStringComparator.compare(noVal, hiVal));
// Try malformed dates, should all return null, get sorted last
String[] xxArgs = {
"10/25/2018,", // too long
"",
"oops",
"10-25-2018",
"10.25.2018",
"10252018",
"2018/10/25",
"2018-10-25",
"10-25-2018",
}; // OK to have ,}
// You could have millions of incorrect values.
for (String xxVal : xxArgs) {
assertEQ(nullsLastLocalDateStringComparator.compare(xxVal, xxVal));
assertLT(nullsLastLocalDateStringComparator.compare(loVal, xxVal));
assertLT(nullsLastLocalDateStringComparator.compare(hiVal, xxVal));
assertGT(nullsLastLocalDateStringComparator.compare(xxVal, loVal));
assertGT(nullsLastLocalDateStringComparator.compare(xxVal, hiVal));
}
}
/**nullsLastLocalDateStringComparator
* Test method for {@link gov.va.med.ewv.util.NullsLastComparator#compare(java.time.LocalDate, java.time.LocalDate)}.
*/
@Test
public void test_nullsLastLocalDateComparator() {
LocalDate noVal = null;
int year = 2018;
int month = 10;
int dayOfMonth = 25;
LocalDate loVal = LocalDate.of(year, month, dayOfMonth);
LocalDate hiVal = LocalDate.of(2525, month, dayOfMonth);
// Check natural order
assertEQ(loVal.compareTo(loVal));
assertEQ(hiVal.compareTo(hiVal));
assertLT(loVal.compareTo(hiVal));
assertGT(hiVal.compareTo(loVal));
assertEQ(nullsLastLocalDateComparator.compare(loVal, loVal));
assertEQ(nullsLastLocalDateComparator.compare(hiVal, hiVal));
assertLT(nullsLastLocalDateComparator.compare(loVal, hiVal));
assertGT(nullsLastLocalDateComparator.compare(hiVal, loVal));
assertEQ(nullsLastLocalDateComparator.compare(noVal, noVal));
assertLT(nullsLastLocalDateComparator.compare(loVal, noVal));
assertLT(nullsLastLocalDateComparator.compare(hiVal, noVal));
assertGT(nullsLastLocalDateComparator.compare(noVal, loVal));
assertGT(nullsLastLocalDateComparator.compare(noVal, hiVal));
// overloaded static compare
assertEQ(compare(loVal, loVal));
assertEQ(compare(hiVal, hiVal));
assertLT(compare(loVal, hiVal));
assertGT(compare(hiVal, loVal));
assertEQ(compare(noVal, noVal));
assertLT(compare(loVal, noVal));
assertLT(compare(hiVal, noVal));
assertGT(compare(noVal, loVal));
assertGT(compare(noVal, hiVal));
}
/**
* Test method for {@link gov.va.med.ewv.util.NullsLastComparator#compare(java.lang.String, java.lang.String)}.
*/
@Test
public void testCompareStringString() {
String noVal = null;
// Choose values that would sort in the opposite order as LocalDate Strings
String loVal = "01/01/2018";
String hiVal = "10/25/1018";
assertEQ(nullsLastStringComparator.compare(loVal, loVal));
assertEQ(nullsLastStringComparator.compare(hiVal, hiVal));
assertLT(nullsLastStringComparator.compare(loVal, hiVal));
assertGT(nullsLastStringComparator.compare(hiVal, loVal));
assertEQ(nullsLastStringComparator.compare(noVal, noVal));
assertLT(nullsLastStringComparator.compare(loVal, noVal));
assertLT(nullsLastStringComparator.compare(hiVal, noVal));
assertGT(nullsLastStringComparator.compare(noVal, loVal));
assertGT(nullsLastStringComparator.compare(noVal, hiVal));
assertLT(nullsLastStringComparator.compare("", noVal));
assertGT(nullsLastStringComparator.compare(noVal,""));
assertEQ(nullsLastStringComparator.compare("", ""));
assertLT(nullsLastStringComparator.compare("°", noVal));
assertGT(nullsLastStringComparator.compare(noVal,"°"));
assertEQ(nullsLastStringComparator.compare("°", "°"));
assertLT(nullsLastStringComparator.compare("", "°"));
assertGT(nullsLastStringComparator.compare("°",""));
assertLT(nullsLastStringComparator.compare("", " "));
assertGT(nullsLastStringComparator.compare(" ",""));
}
/**
* Test method for {@link gov.va.med.ewv.util.NullsLastComparator#compare(java.lang.String, java.lang.String)}.
*/
@Test
public void testCompareStringString_static() {
String noVal = null;
// Choose values that would sort in the opposite order as LocalDate Strings
String loVal = "01/01/2018";
String hiVal = "10/25/1018";
assertEQ(compare(loVal, loVal));
assertEQ(compare(hiVal, hiVal));
assertLT(compare(loVal, hiVal));
assertGT(compare(hiVal, loVal));
assertEQ(compare(noVal, noVal));
assertLT(compare(loVal, noVal));
assertLT(compare(hiVal, noVal));
assertGT(compare(noVal, loVal));
assertGT(compare(noVal, hiVal));
assertLT(compare("", noVal));
assertGT(compare(noVal,""));
assertEQ(compare("", ""));
assertLT(compare("°", noVal));
assertGT(compare(noVal,"°"));
assertEQ(compare("°", "°"));
assertLT(compare("", "°"));
assertGT(compare("°",""));
assertLT(compare("", " "));
assertGT(compare(" ",""));
}
}