/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.util.tuple;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import org.testng.annotations.Test;
import com.opengamma.util.test.TestGroup;
/**
* Test IntDoublePair.
*/
@Test(groups = TestGroup.UNIT)
public class IntDoublePairTest {
public void test_IntDoublePair_of() {
IntDoublePair test = IntDoublePair.of(2, 2.5d);
assertEquals(Integer.valueOf(2), test.getFirst());
assertEquals(Double.valueOf(2.5d), test.getSecond());
assertEquals(2, test.getFirstInt());
assertEquals(2.5d, test.getSecondDouble(), 0.00001d);
assertEquals(Integer.valueOf(2), test.getKey());
assertEquals(Double.valueOf(2.5d), test.getValue());
assertEquals(2, test.getIntKey());
assertEquals(2.5d, test.getDoubleValue(), 0.00001d);
assertEquals("[2, 2.5]", test.toString());
}
public void test_IntDoublePair_parse1() {
IntDoublePair test = IntDoublePair.parse("[2, 2.5]");
assertEquals(Integer.valueOf(2), test.getFirst());
assertEquals(Double.valueOf(2.5d), test.getSecond());
}
public void test_IntDoublePair_parse2() {
IntDoublePair test = IntDoublePair.parse("[2,2.5]");
assertEquals(Integer.valueOf(2), test.getFirst());
assertEquals(Double.valueOf(2.5d), test.getSecond());
}
//-------------------------------------------------------------------------
@Test(expectedExceptions = UnsupportedOperationException.class)
public void testSetValue() {
IntDoublePair pair = IntDoublePair.of(2, -0.3d);
pair.setValue(Double.valueOf(1.2d));
}
@Test(expectedExceptions = UnsupportedOperationException.class)
public void testSetValue_null() {
IntDoublePair pair = IntDoublePair.of(2, -0.3d);
pair.setValue(null);
}
@Test(expectedExceptions = UnsupportedOperationException.class)
public void testSetValue_primitives() {
IntDoublePair pair = IntDoublePair.of(2, -0.3d);
pair.setValue(1.2d);
}
//-------------------------------------------------------------------------
public void compareTo_IntDoublePair() {
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 compareTo_IntDoublePairAsPair() {
Pair<Integer, Double> p12 = IntDoublePair.of(1, 2d);
Pair<Integer, Double> p13 = IntDoublePair.of(1, 3d);
Pair<Integer, Double> 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 compareTo_comparatorFirstThenSecond() {
IntDoublePair ab = IntDoublePair.of(1, 1.7d);
IntDoublePair ac = IntDoublePair.of(1, 1.9d);
IntDoublePair ba = IntDoublePair.of(2, 1.5d);
FirstThenSecondPairComparator<Integer, Double> comparator = new FirstThenSecondPairComparator<Integer, Double>();
assertTrue(comparator.compare(ab, ab) == 0);
assertTrue(comparator.compare(ac, ab) > 0);
assertTrue(comparator.compare(ba, ab) > 0);
assertTrue(comparator.compare(ab, ac) < 0);
assertTrue(comparator.compare(ac, ac) == 0);
assertTrue(comparator.compare(ba, ac) > 0);
assertTrue(comparator.compare(ab, ba) < 0);
assertTrue(comparator.compare(ac, ba) < 0);
assertTrue(comparator.compare(ba, ba) == 0);
}
//-------------------------------------------------------------------------
public void testEquals() {
IntDoublePair a = IntDoublePair.of(1, 2.0);
IntDoublePair b = IntDoublePair.of(1, 3.0);
IntDoublePair c = IntDoublePair.of(2, 2.0);
IntDoublePair d = IntDoublePair.of(2, 3.0);
assertEquals(true, a.equals(a));
assertEquals(false, a.equals(b));
assertEquals(false, a.equals(c));
assertEquals(false, a.equals(d));
assertEquals(false, b.equals(a));
assertEquals(true, b.equals(b));
assertEquals(false, b.equals(c));
assertEquals(false, b.equals(d));
assertEquals(false, c.equals(a));
assertEquals(false, c.equals(b));
assertEquals(true, c.equals(c));
assertEquals(false, c.equals(d));
assertEquals(false, d.equals(a));
assertEquals(false, d.equals(b));
assertEquals(false, d.equals(c));
assertEquals(true, d.equals(d));
}
public void testEquals_toObjectVersion() {
IntDoublePair a = IntDoublePair.of(1, 1.7d);
Pair<Integer, Double> b = ObjectsPair.of(Integer.valueOf(1), Double.valueOf(1.7d));
assertEquals(true, a.equals(b));
assertEquals(true, b.equals(a));
}
public void testEquals_toObjectVersion_null() {
IntDoublePair b = IntDoublePair.of(1, 1.7d);
Pair<Integer, Double> a = ObjectsPair.of(null, Double.valueOf(1.9d));
assertEquals(true, a.equals(a));
assertEquals(false, a.equals(b));
assertEquals(false, b.equals(a));
assertEquals(true, b.equals(b));
}
public void testHashCode() {
IntDoublePair a = IntDoublePair.of(1, 1.7d);
Pair<Integer, Double> b = ObjectsPair.of(Integer.valueOf(1), Double.valueOf(1.7d));
assertEquals(a.hashCode(), b.hashCode());
}
public void testHashCode_value() {
IntDoublePair a = IntDoublePair.of(1, 2.0);
assertEquals(a.hashCode(), a.hashCode());
assertEquals(Integer.valueOf(1).hashCode() ^ Double.valueOf(2.0).hashCode(), a.hashCode());
// can't test for different hash codes as they might not be different
}
}