@Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 97440432: // first return ((IntDoublePair) bean).getFirst(); case -906279820: // second return ((IntDoublePair) bean).getSecond(); } return super.propertyGet(bean, propertyName, quiet); }
@Override public IntDoublePair build() { return new IntDoublePair( first, second); }
public void test_compareTo() { IntDoublePair p12 = IntDoublePair.of(1, 2d); IntDoublePair p13 = IntDoublePair.of(1, 3d); IntDoublePair p21 = IntDoublePair.of(2, 1d); assertTrue(p12.compareTo(p12) == 0); assertTrue(p12.compareTo(p13) < 0); assertTrue(p12.compareTo(p21) < 0); assertTrue(p13.compareTo(p12) > 0); assertTrue(p13.compareTo(p13) == 0); assertTrue(p13.compareTo(p21) < 0); assertTrue(p21.compareTo(p12) > 0); assertTrue(p21.compareTo(p13) > 0); assertTrue(p21.compareTo(p21) == 0); }
public void coverage() { IntDoublePair test = IntDoublePair.of(1, 1.7d); TestHelper.coverImmutableBean(test); }
@Test(dataProvider = "parseBad", expectedExceptions = IllegalArgumentException.class) public void test_parse_bad(String text) { IntDoublePair.parse(text); }
public void test_equals() { IntDoublePair a = IntDoublePair.of(1, 2.0d); IntDoublePair a2 = IntDoublePair.of(1, 2.0d); IntDoublePair b = IntDoublePair.of(1, 3.0d); IntDoublePair c = IntDoublePair.of(2, 2.0d); IntDoublePair d = IntDoublePair.of(2, 3.0d); assertEquals(a.equals(a), true); assertEquals(a.equals(b), false); assertEquals(a.equals(c), false); assertEquals(a.equals(d), false); assertEquals(a.equals(a2), true); assertEquals(b.equals(a), false); assertEquals(b.equals(b), true); assertEquals(b.equals(c), false); assertEquals(b.equals(d), false); assertEquals(c.equals(a), false); assertEquals(c.equals(b), false); assertEquals(c.equals(c), true); assertEquals(c.equals(d), false); assertEquals(d.equals(a), false); assertEquals(d.equals(b), false); assertEquals(d.equals(c), false); assertEquals(d.equals(d), true); }
public void test_serialization() { assertSerialization(IntDoublePair.of(1, 1.7d)); }
/** * Obtains an instance from an {@code int} and a {@code double}. * * @param first the first element * @param second the second element * @return a pair formed from the two parameters */ public static IntDoublePair of(int first, double second) { return new IntDoublePair(first, second); }
public void test_jodaConvert() { assertJodaConvert(IntDoublePair.class, IntDoublePair.of(1, 1.7d)); }
/** * Parses an {@code IntDoublePair} from the standard string format. * <p> * The standard format is '[$first, $second]'. Spaces around the values are trimmed. * * @param pairStr the text to parse * @return the parsed pair * @throws IllegalArgumentException if the pair cannot be parsed */ @FromString public static IntDoublePair parse(String pairStr) { ArgChecker.notNull(pairStr, "pairStr"); if (pairStr.length() < 5) { throw new IllegalArgumentException("Invalid pair format, too short: " + pairStr); } if (pairStr.charAt(0) != '[') { throw new IllegalArgumentException("Invalid pair format, must start with [: " + pairStr); } if (pairStr.charAt(pairStr.length() - 1) != ']') { throw new IllegalArgumentException("Invalid pair format, must end with ]: " + pairStr); } String content = pairStr.substring(1, pairStr.length() - 1); List<String> split = Splitter.on(',').trimResults().splitToList(content); if (split.size() != 2) { throw new IllegalArgumentException("Invalid pair format, must have two values: " + pairStr); } int first = Integer.parseInt(split.get(0)); double second = Double.parseDouble(split.get(1)); return new IntDoublePair(first, second); }
/** * Obtains an instance from a {@code Pair}. * * @param pair the pair to convert * @return a pair formed by extracting values from the pair */ public static IntDoublePair ofPair(Pair<Integer, Double> pair) { ArgChecker.notNull(pair, "pair"); return new IntDoublePair(pair.getFirst(), pair.getSecond()); }