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(" ",""));

}
}