/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.security.spec;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.framework.TestCase;
import java.math.BigInteger;
import java.security.spec.ECField;
import java.security.spec.ECFieldF2m;
import java.security.spec.ECFieldFp;
import java.security.spec.EllipticCurve;
import java.util.Arrays;
/**
* Tests for <code>EllipticCurve</code> class fields and methods.
*
*/
@TestTargetClass(EllipticCurve.class)
public class EllipticCurveTest extends TestCase {
/**
* Test #1 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
* constructor<br>
* Assertion: creates instance of EllipticCurve<br>
* Test preconditions: valid parameters passed<br>
* Expected: must pass without any exceptions
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies positive cases.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class, byte[].class}
)
public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray01() {
// test case 1 parameters set
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
// perform test case 1
new EllipticCurve(f, a, b, seed);
// test case 2 parameters set
ECFieldF2m f1 = new ECFieldF2m(5);
a = BigInteger.ZERO;
b = BigInteger.valueOf(23L);
// perform test case 2
new EllipticCurve(f1, a, b, seed);
// test case 3 parameters set,
// the seed parameter may be null
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.ONE;
b = BigInteger.valueOf(19L);
seed = null;
// perform test case 3
new EllipticCurve(f, a, b, seed);
}
/**
* Test #2 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
* constructor<br>
* Assertion: throws <code>NullPointerException</code> if <code>field</code>,
* <code>a</code> or <code>b</code> is <code>null</code><br>
* Test preconditions: pass <code>null</code> as mentioned parameters<br>
* Expected: must throw <code>NullPointerException</code>
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class, byte[].class}
)
public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray02() {
// test case 1 parameters set
ECFieldFp f = null;
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
// perform test case 1
try {
new EllipticCurve(f, a, b, seed);
fail("#1: Expected NPE not thrown");
} catch (NullPointerException ok) {}
// test case 2 parameters set,
f = new ECFieldFp(BigInteger.valueOf(23L));
a = null;
b = BigInteger.valueOf(19L);
seed = new byte[24];
// perform test case 2
try {
new EllipticCurve(f, a, b, seed);
fail("#2: Expected NPE not thrown");
} catch (NullPointerException ok) {}
// test case 3 parameters set,
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.ONE;
b = null;
seed = new byte[24];
// perform test case 2
try {
new EllipticCurve(f, a, b, seed);
fail("#3: Expected NPE not thrown");
} catch (NullPointerException ok) {}
}
/**
* Test #3 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
* constructor<br>
* Assertion: throws <code>IllegalArgumentException</code> if
* <code>a</code> or <code>b</code> is not <code>null</code> and not in
* the <code>field</code><br>
* Test preconditions: pass <code>a</code>, <code>b</code> which are
* not in the <code>field</code> of type <code>ECFieldFp</code><br>
* Expected: must throw <code>IllegalArgumentException</code>
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalArgumentException.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class, byte[].class}
)
public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray03() {
// test case 1 parameters set,
// a is not in field
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.valueOf(24L);
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
// perform test case 1
try {
new EllipticCurve(f, a, b, seed);
fail("#1: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 1.1 parameters set,
// b is not in field
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.valueOf(1L);
b = BigInteger.valueOf(23L);
seed = new byte[24];
// perform test case 1.1
try {
new EllipticCurve(f, a, b, seed);
fail("#1.1: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 2 parameters set,
// b is not in field
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.valueOf(19L);
b = BigInteger.valueOf(24L);
seed = new byte[24];
// perform test case 2
try {
new EllipticCurve(f, a, b, seed);
fail("#2: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 3 parameters set,
// both a and b are not in field
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.valueOf(25L);
b = BigInteger.valueOf(240L);
seed = new byte[24];
// perform test case 3
try {
new EllipticCurve(f, a, b, seed);
fail("#3: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
}
/**
* Test #4 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
* constructor<br>
* Assertion: throws <code>IllegalArgumentException</code> if
* <code>a</code> or <code>b</code> is not <code>null</code> and not in
* the <code>field</code><br>
* Test preconditions: pass <code>a</code>, <code>b</code> which are
* not in the <code>field</code> of type <code>ECFieldF2m</code><br>
* Expected: must throw <code>IllegalArgumentException</code>
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalArgumentException.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class, byte[].class}
)
public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray04() {
// test case 1 parameters set,
// a is not in field
ECFieldF2m f = new ECFieldF2m(5);
BigInteger a = BigInteger.valueOf(32L);
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
// perform test case 1
try {
new EllipticCurve(f, a, b, seed);
fail("#1: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 2 parameters set,
// b is not in field
f = new ECFieldF2m(5);
a = BigInteger.valueOf(19L);
b = BigInteger.valueOf(32L);
seed = new byte[24];
// perform test case 2
try {
new EllipticCurve(f, a, b, seed);
fail("#2: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 3 parameters set,
// both a and b are not in field
f = new ECFieldF2m(5);
a = BigInteger.valueOf(32L);
b = BigInteger.valueOf(43L);
seed = new byte[24];
// perform test case 3
try {
new EllipticCurve(f, a, b, seed);
fail("#3: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
}
/**
* Test #5 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
* constructor<br>
* Assertion: array <code>seed</code> is copied to prevent subsequent modification<br>
* Test preconditions: pass <code>seed</code> to the ctor then modify it<br>
* Expected: getSeed() must return unmodified array
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies that byte array of EllipticCurve can't be modified",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class, byte[].class}
)
public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray05() {
ECFieldF2m f = new ECFieldF2m(5);
BigInteger a = BigInteger.valueOf(0L);
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
byte[] seedCopy = seed.clone();
EllipticCurve c = new EllipticCurve(f, a, b, seedCopy);
// modify array passed
seedCopy[0] = (byte) 1;
// check that above modification did not changed
// internal state of test object
assertTrue(Arrays.equals(seed, c.getSeed()));
}
/**
* Test #1 for <code>EllipticCurve(ECField, BigInteger, BigInteger)</code>
* constructor<br>
* Assertion: creates instance of EllipticCurve<br>
* Test preconditions: valid parameters passed, field type is ECFieldFp<br>
* Expected: must pass without any exceptions
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify exceptions.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class}
)
public final void testEllipticCurveECFieldBigIntegerBigInteger01() {
// test case 1 parameters set
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.valueOf(19L);
// perform test case 1
new EllipticCurve(f, a, b);
// test case 2 parameters set
ECFieldF2m f1 = new ECFieldF2m(5);
a = BigInteger.ZERO;
b = BigInteger.valueOf(23L);
// perform test case 2
new EllipticCurve(f1, a, b);
// test case 3 parameters set,
// the seed parameter may be null
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.ONE;
b = BigInteger.valueOf(19L);
// perform test case 3
new EllipticCurve(f, a, b);
}
/**
* Test #2 for <code>EllipticCurve(ECField, BigInteger, BigInteger)</code>
* constructor<br>
* Assertion: throws <code>NullPointerException</code> if <code>field</code>,
* <code>a</code> or <code>b</code> is <code>null</code><br>
* Test preconditions: pass <code>null</code> as mentioned parameters<br>
* Expected: must throw <code>NullPointerException</code>
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class}
)
public final void testEllipticCurveECFieldBigIntegerBigInteger02() {
// test case 1 parameters set
ECFieldFp f = null;
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.valueOf(19L);
// perform test case 1
try {
new EllipticCurve(f, a, b);
fail("#1: Expected NPE not thrown");
} catch (NullPointerException ok) {}
// test case 2 parameters set,
f = new ECFieldFp(BigInteger.valueOf(23L));
a = null;
b = BigInteger.valueOf(19L);
// perform test case 2
try {
new EllipticCurve(f, a, b);
fail("#2: Expected NPE not thrown");
} catch (NullPointerException ok) {}
// test case 3 parameters set,
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.ONE;
b = null;
// perform test case 3
try {
new EllipticCurve(f, a, b);
fail("#3: Expected NPE not thrown");
} catch (NullPointerException ok) {}
}
/**
* Test #3 for <code>EllipticCurve(ECField, BigInteger, BigInteger)</code>
* constructor<br>
* Assertion: throws <code>IllegalArgumentException</code> if
* <code>a</code> or <code>b</code> is not <code>null</code> and not in
* the <code>field</code><br>
* Test preconditions: pass <code>a</code>, <code>b</code> which are
* not in the <code>field</code> of type <code>ECFieldFp</code><br>
* Expected: must throw <code>IllegalArgumentException</code>
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalArgumentException.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class}
)
public final void testEllipticCurveECFieldBigIntegerBigInteger03() {
// test case 1 parameters set,
// a is not in field
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.valueOf(24L);
BigInteger b = BigInteger.valueOf(19L);
// perform test case 1
try {
new EllipticCurve(f, a, b);
fail("#1: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 1.1 parameters set,
// a is not in field
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.valueOf(23L);
b = BigInteger.valueOf(19L);
// perform test case 1.1
try {
new EllipticCurve(f, a, b);
fail("#1.1: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 2 parameters set,
// b is not in field
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.valueOf(19L);
b = BigInteger.valueOf(24L);
// perform test case 2
try {
new EllipticCurve(f, a, b);
fail("#2: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 3 parameters set,
// both a and b are not in field
f = new ECFieldFp(BigInteger.valueOf(23L));
a = BigInteger.valueOf(25L);
b = BigInteger.valueOf(240L);
// perform test case 3
try {
new EllipticCurve(f, a, b);
fail("#3: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
}
/**
* Test #4 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
* constructor<br>
* Assertion: throws <code>IllegalArgumentException</code> if
* <code>a</code> or <code>b</code> is not <code>null</code> and not in
* the <code>field</code><br>
* Test preconditions: pass <code>a</code>, <code>b</code> which are
* not in the <code>field</code> of type <code>ECFieldF2m</code><br>
* Expected: must throw <code>IllegalArgumentException</code>
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalArgumentException.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class}
)
public final void testEllipticCurveECFieldBigIntegerBigInteger04() {
// test case 1 parameters set,
// a is not in field
ECFieldF2m f = new ECFieldF2m(5);
BigInteger a = BigInteger.valueOf(32L);
BigInteger b = BigInteger.valueOf(19L);
// perform test case 1
try {
new EllipticCurve(f, a, b);
fail("#1: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 2 parameters set,
// b is not in field
f = new ECFieldF2m(5);
a = BigInteger.valueOf(19L);
b = BigInteger.valueOf(32L);
// perform test case 2
try {
new EllipticCurve(f, a, b);
fail("#2: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
// test case 3 parameters set,
// both a and b are not in field
f = new ECFieldF2m(5);
a = BigInteger.valueOf(32L);
b = BigInteger.valueOf(43L);
// perform test case 3
try {
new EllipticCurve(f, a, b);
fail("#3: Expected IAE not thrown");
} catch (IllegalArgumentException ok) {}
}
/**
* Test for <code>getA()</code> method<br>
* Assertion: returns coefficient <code>a</code><br>
* Test preconditions: <code>ECFieldF2m</code> instance
* created using valid parameters<br>
* Expected: must return coefficient <code>a</code> which is equal
* to the one passed to the constructor; (both must refer
* the same object)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getA",
args = {}
)
public final void testGetA() {
ECFieldF2m f = new ECFieldF2m(5);
BigInteger a = BigInteger.valueOf(5L);
BigInteger b = BigInteger.valueOf(19L);
EllipticCurve c = new EllipticCurve(f, a, b);
assertEquals(a, c.getA());
assertSame(a, c.getA());
}
/**
* @tests java/security/spec/EllipticCurve#EllipticCurve(EcField,BigInteger,BigInteger)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Regression test.",
method = "EllipticCurve",
args = {java.security.spec.ECField.class, java.math.BigInteger.class, java.math.BigInteger.class}
)
public final void testEllipticCurveECFieldBigIntegerBigInteger05() {
// Regression for Harmony-731
EllipticCurve ec = new EllipticCurve(new testECField(), BigInteger
.valueOf(4L), BigInteger.ONE);
assertEquals("incorrect a", ec.getA(), BigInteger.valueOf(4L));
assertEquals("incorrect b", ec.getB(), BigInteger.ONE);
assertEquals("incorrect size", ec.getField().getFieldSize(), 2);
}
/**
* Test for <code>getB()</code> method<br>
* Assertion: returns coefficient <code>b</code><br>
* Test preconditions: <code>ECFieldF2m</code> instance
* created using valid parameters<br>
* Expected: must return coefficient <code>b</code> which is equal
* to the one passed to the constructor; (both must refer
* the same object)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getB",
args = {}
)
public final void testGetB() {
ECFieldF2m f = new ECFieldF2m(5);
BigInteger a = BigInteger.valueOf(5L);
BigInteger b = BigInteger.valueOf(19L);
EllipticCurve c = new EllipticCurve(f, a, b);
assertEquals(b, c.getB());
assertSame(b, c.getB());
}
/**
* Test for <code>getField()</code> method<br>
* Assertion: returns <code>field</code><br>
* Test preconditions: <code>ECFieldF2m</code> instance
* created using valid parameters<br>
* Expected: must return <code>field</code> which is equal
* to the one passed to the constructor; (both must refer
* the same object)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getField",
args = {}
)
public final void testGetField() {
ECFieldF2m f = new ECFieldF2m(5);
BigInteger a = BigInteger.valueOf(5L);
BigInteger b = BigInteger.valueOf(19L);
EllipticCurve c = new EllipticCurve(f, a, b);
assertEquals(f, c.getField());
assertSame(f, c.getField());
}
/**
* Test #1 for <code>getSeed()</code> method<br>
* Assertion: returns <code>seed</code><br>
* Test preconditions: <code>ECFieldF2m</code> instance
* created using valid parameters<br>
* Expected: must return <code>seed</code> which is equal
* to the one passed to the constructor
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies positive case.",
method = "getSeed",
args = {}
)
public final void testGetSeed01() {
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
EllipticCurve c = new EllipticCurve(f, a, b, seed);
byte[] seedRet = c.getSeed();
assertNotNull(seedRet);
assertTrue(Arrays.equals(seed, seedRet));
}
/**
* Test #2 for <code>getSeed()</code> method<br>
* Assertion: returned array is copied to prevent subsequent modification<br>
* Test preconditions: <code>ECFieldF2m</code> instance
* created using valid parameters; <code>getSeed()</code>
* called and then returned array modified<br>
* Expected: internal state must not be affected by the modification
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies that modification of byte array doesn't change internal state of test object.",
method = "getSeed",
args = {}
)
public final void testGetSeed02() {
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
EllipticCurve c = new EllipticCurve(f, a, b, seed.clone());
byte[] seedRet = c.getSeed();
// modify returned array
seedRet[0] = (byte) 1;
// check that above modification did not changed
// internal state of test object
assertTrue(Arrays.equals(seed, c.getSeed()));
}
/**
* Test #3 for <code>getSeed()</code> method<br>
* Assertion: returned array is copied to prevent subsequent modification<br>
* Test preconditions: <code>ECFieldF2m</code> instance
* created using valid parameters<br>
* Expected: repeated method calls must return different refs
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies that repeated calls of getSeed method must return different refs.",
method = "getSeed",
args = {}
)
public final void testGetSeed03() {
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.ONE;
BigInteger b = BigInteger.valueOf(19L);
byte[] seed = new byte[24];
EllipticCurve c = new EllipticCurve(f, a, b, seed);
c.getSeed();
assertNotSame(c.getSeed(), c.getSeed());
}
/**
* @tests java.security.spec.EllipticCurve#getSeed()
* Assertion: null if not specified
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Regression test.",
method = "getSeed",
args = {}
)
public final void testGetSeed04() {
//Regression for HARMONY-732
ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
BigInteger a = BigInteger.ONE;
assertNull(new EllipticCurve(f, a, a).getSeed());
}
/**
* Test #1 for <code>equals(Object other)</code> method<br>
* Assertion: return true if this and other objects are equal<br>
* Test preconditions: see test comments<br>
* Expected: all objects in this test must be equal
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
public final void testEqualsObject01() {
// test case 1: must be equal to itself
EllipticCurve c2 = null, c1 = new EllipticCurve(new ECFieldFp(
BigInteger.valueOf(23L)), BigInteger.ONE, BigInteger
.valueOf(19L));
assertTrue(c1.equals(c1));
// test case 2: equal objects
c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.ONE, BigInteger.valueOf(19L));
c2 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.valueOf(1L), BigInteger.valueOf(19L));
assertTrue(c1.equals(c2) && c2.equals(c1));
// test case 3: equal objects with seed not null
c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.ONE, BigInteger.valueOf(19L), new byte[24]);
c2 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.valueOf(1L), BigInteger.valueOf(19L), new byte[24]);
assertTrue(c1.equals(c2) && c2.equals(c1));
// test case 4: equal object and subclass object
c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.ONE, BigInteger.valueOf(19L), new byte[24]);
MyEllipticCurve c3 = new MyEllipticCurve(new ECFieldFp(BigInteger
.valueOf(23L)), BigInteger.ONE, BigInteger.valueOf(19L),
new byte[24]);
assertTrue(c1.equals(c3) && c3.equals(c1));
// test case 5: equal objects
c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.ONE, BigInteger.valueOf(19L));
c2 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.valueOf(1L), BigInteger.valueOf(19L), null);
assertTrue(c1.equals(c2) && c2.equals(c1));
}
/**
* Test #1 for <code>hashCode()</code> method.<br>
*
* Assertion: must return the same value if invoked
* repeatedly on the same object.
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies that several calls of hashCode method for the same objects return the same values.",
method = "hashCode",
args = {}
)
public final void testHashCode01() {
int hc = 0;
EllipticCurve f = new EllipticCurve(new ECFieldFp(BigInteger
.valueOf(23L)), BigInteger.ONE, BigInteger.valueOf(19L),
new byte[24]);
hc = f.hashCode();
assertTrue(hc == f.hashCode() && hc == f.hashCode()
&& hc == f.hashCode() && hc == f.hashCode()
&& hc == f.hashCode() && hc == f.hashCode()
&& hc == f.hashCode() && hc == f.hashCode());
}
/**
* Test #2 for <code>hashCode()</code> method.<br>
*
* Assertion: must return the same value if invoked
* on equal (according to the <code>equals(Object)</code> method) objects.
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
public final void testHashCode02() {
assertEquals(new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
BigInteger.ONE, BigInteger.valueOf(19L), new byte[24])
.hashCode(), new EllipticCurve(new ECFieldFp(BigInteger
.valueOf(23L)), BigInteger.ONE, BigInteger.valueOf(19L),
new byte[24]).hashCode());
}
//
// Private stuff
//
class testECField implements ECField {
public int getFieldSize() {
return 2;
}
}
/**
* EllipticCurve subclass for testing purposes
*
*/
private static class MyEllipticCurve extends EllipticCurve {
MyEllipticCurve(ECField f, BigInteger a, BigInteger b, byte[] seed) {
super(f, a, b, seed);
}
}
}
|
