@Test public void testParseHexPrefixEquals() throws Exception { long i = 123456; String s = Long.toHexString(i); String s1 = "0x" + s; String s2 = "0X" + s; // Transitive property means we only have to test twice assertEquals(ParseLong.parseHex(s), ParseLong.parseHex(s1)); assertEquals(ParseLong.parseHex(s1), ParseLong.parseHex(s2)); }
@Test public void testParseHexOrDefaultOk() throws Exception { long i = 0x12; String s = "0x" + Long.toHexString(i); int def = 14; assertEquals(i, ParseLong.parseHexOrDefault(s, def)); }
@Test public void testParseDecOrDefaultOk() throws Exception { long i = 12; String s = Long.toString(i); int def = 14; assertEquals(i, ParseLong.parseDecOrDefault(s, def)); }
@Test public void testParseHexOptionalOk() throws Exception { long i = 0x14; String s = Long.toHexString(i); OptionalLong ret = ParseLong.parseHexOptional(s); assertTrue(ret.isPresent()); assertEquals(i, ret.getAsLong()); }
@Test public void testParseHexOrDefaultNull() throws Exception { int def = 14; assertEquals(def, ParseLong.parseHexOrDefault(null, def)); }
@Test public void testParseHexOrDefaultFail() throws Exception { String s = "aq12.g"; int def = 14; assertEquals(def, ParseLong.parseHexOrDefault(s, def)); }
// Test dec/hex picking @Test public void testParse_Hex() throws Exception { long i = 0x123ABC; String s = "0x" + Long.toHexString(i); assertEquals(i, ParseLong.parse(s)); }
// For values lower than the signed min, the method shouldn't thrown an exception but it will // return a // garbage result @Test public void testParseDec_MinSignedUnderflow() throws Exception { String s = "-9223372036854775809"; ParseLong.parseDec(s); }
// Test empty @Test(expected = NumberFormatException.class) public void testParseDec_Empty() throws Exception { ParseLong.parseDec(""); }
// Test negative sign inside @Test(expected = NumberFormatException.class) public void testParseDec_NegativeBad() throws Exception { ParseLong.parseDec("-12-34"); }
// Test negative sign prefix @Test public void testParseDec_Negative() throws Exception { long i = -123456; String s = Long.toString(i); assertEquals(i, ParseLong.parseDec(s)); }
@Test public void testParseHexOptionalFail() throws Exception { String s = "astg2148465klkast12hkls"; OptionalLong ret = ParseLong.parseHexOptional(s); assertFalse(ret.isPresent()); }
@Test public void testParseHexOptionalNull() throws Exception { OptionalLong ret = ParseLong.parseHexOptional(null); assertFalse(ret.isPresent()); }
// Test negative sign prefix reject (after prefix) @Test(expected = NumberFormatException.class) public void testParseHex_Negative2() throws Exception { String s = "0x-12AC"; ParseLong.parseHex(s); }
// Test bad @Test(expected = NumberFormatException.class) public void testParseHex_Bad() throws Exception { ParseLong.parseHex("12AB-**&1'"); }
// Technically this is the same as MaxUnsigned @Test public void testParseHexMinSigned() throws Exception { long i = Long.MIN_VALUE; String s = "0x" + Long.toHexString(i); assertEquals(i, ParseLong.parseHex(s)); }
// For values larger than the unsigned max, the method shouldn't thrown an exception but it will // return a // garbage result @Test public void testParseHexMaxUnsignedOverflow() throws Exception { String s = "0x10000000000000000"; ParseLong.parseHex(s); }
@Test public void testParseHexMaxUnsigned() throws Exception { long i = 0xFFFFFFFFFFFFFFFFL; String s = "0xFFFFFFFFFFFFFFFF"; assertEquals(i, ParseLong.parseHex(s)); }
@Test public void testParseOptionalHexFail() throws Exception { String s = "0x12akjhsdr?"; OptionalLong ret = ParseLong.parseOptional(s); assertFalse(ret.isPresent()); }
// Test null reject @Test(expected = NumberFormatException.class) public void testParse_Null() throws Exception { ParseLong.parse(null); }
// Test positive sign prefix reject (no prefix) @Test(expected = NumberFormatException.class) public void testParseHex_Positive3() throws Exception { String s = "+12AB"; ParseLong.parseHex(s); }
// Test positive sign inside @Test(expected = NumberFormatException.class) public void testParseDec_PositiveBad() throws Exception { ParseLong.parseDec("+12+34"); }
// Test dec/hex dec trimming @Test public void testParse_DecTrim() throws Exception { long i = 123456; String s = WHITESPACE + Long.toString(i) + WHITESPACE; assertEquals(i, ParseLong.parse(s)); }
// Test dec/hex picking @Test public void testParse_Dec() throws Exception { long i = 123456; String s = Long.toString(i); assertEquals(i, ParseLong.parse(s)); }
// Test dec/hex hex trimming @Test public void testParse_HexTrim() throws Exception { long i = 0x123ABC; String s = WHITESPACE + "0x" + Long.toHexString(i) + WHITESPACE; assertEquals(i, ParseLong.parse(s)); }
// Test prefix with no value reject @Test(expected = NumberFormatException.class) public void testParseHex_PrefixNoValue() throws Exception { String s = "0x"; ParseLong.parseHex(s); }
// Test missing hex digits reject @Test(expected = NumberFormatException.class) public void testParse_EmptyHex() throws Exception { String s = "0x"; ParseLong.parse(s); }
@Test public void testParseOrDefaultDecDefault() throws Exception { String s = "abcd"; int def = 14; assertEquals(def, ParseLong.parseOrDefault(s, def)); }
@Test public void testParseDec_MaxSigned() throws Exception { long i = Long.MAX_VALUE; String s = Long.toString(i); assertEquals(i, ParseLong.parseDec(s)); }
// For values larger than the unsigned max, the method shouldn't thrown an exception but it will // return a // garbage result @Test public void testParseDec_UnsignedOverflow() throws Exception { String s = "18446744073709551616"; ParseLong.parseDec(s); }