1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package tests.security.spec;
19
20import junit.framework.TestCase;
21
22import java.math.BigInteger;
23import java.security.spec.ECField;
24import java.security.spec.ECFieldF2m;
25import java.security.spec.ECFieldFp;
26import java.security.spec.EllipticCurve;
27import java.util.Arrays;
28
29/**
30 * Tests for <code>EllipticCurve</code> class fields and methods.
31 *
32 */
33public class EllipticCurveTest extends TestCase {
34
35    /**
36     * Test #1 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
37     * constructor<br>
38     * Assertion: creates instance of EllipticCurve<br>
39     * Test preconditions: valid parameters passed<br>
40     * Expected: must pass without any exceptions
41     */
42    public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray01() {
43        // test case 1 parameters set
44        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
45        BigInteger a = BigInteger.ONE;
46        BigInteger b = BigInteger.valueOf(19L);
47        byte[] seed = new byte[24];
48        // perform test case 1
49        new EllipticCurve(f, a, b, seed);
50
51        // test case 2 parameters set
52        ECFieldF2m f1 = new ECFieldF2m(5);
53        a = BigInteger.ZERO;
54        b = BigInteger.valueOf(23L);
55        // perform test case 2
56        new EllipticCurve(f1, a, b, seed);
57
58        // test case 3 parameters set,
59        // the seed parameter may be null
60        f = new ECFieldFp(BigInteger.valueOf(23L));
61        a = BigInteger.ONE;
62        b = BigInteger.valueOf(19L);
63        seed = null;
64        // perform test case 3
65        new EllipticCurve(f, a, b, seed);
66    }
67
68    /**
69     * Test #2 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
70     * constructor<br>
71     * Assertion: throws <code>NullPointerException</code> if <code>field</code>,
72     * <code>a</code> or <code>b</code> is <code>null</code><br>
73     * Test preconditions: pass <code>null</code> as mentioned parameters<br>
74     * Expected: must throw <code>NullPointerException</code>
75     */
76    public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray02() {
77        // test case 1 parameters set
78        ECFieldFp f = null;
79        BigInteger a = BigInteger.ONE;
80        BigInteger b = BigInteger.valueOf(19L);
81        byte[] seed = new byte[24];
82
83        // perform test case 1
84        try {
85            new EllipticCurve(f, a, b, seed);
86            fail("#1: Expected NPE not thrown");
87        } catch (NullPointerException ok) {}
88
89        // test case 2 parameters set,
90        f = new ECFieldFp(BigInteger.valueOf(23L));
91        a = null;
92        b = BigInteger.valueOf(19L);
93        seed = new byte[24];
94        // perform test case 2
95        try {
96            new EllipticCurve(f, a, b, seed);
97            fail("#2: Expected NPE not thrown");
98        } catch (NullPointerException ok) {}
99
100        // test case 3 parameters set,
101        f = new ECFieldFp(BigInteger.valueOf(23L));
102        a = BigInteger.ONE;
103        b = null;
104        seed = new byte[24];
105        // perform test case 2
106        try {
107            new EllipticCurve(f, a, b, seed);
108            fail("#3: Expected NPE not thrown");
109        } catch (NullPointerException ok) {}
110    }
111
112    /**
113     * Test #3 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
114     * constructor<br>
115     * Assertion: throws <code>IllegalArgumentException</code> if
116     * <code>a</code> or <code>b</code> is not <code>null</code> and not in
117     * the <code>field</code><br>
118     * Test preconditions: pass <code>a</code>, <code>b</code> which are
119     * not in the <code>field</code> of type <code>ECFieldFp</code><br>
120     * Expected: must throw <code>IllegalArgumentException</code>
121     */
122    public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray03() {
123        // test case 1 parameters set,
124        // a is not in field
125        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
126        BigInteger a = BigInteger.valueOf(24L);
127        BigInteger b = BigInteger.valueOf(19L);
128        byte[] seed = new byte[24];
129
130        // perform test case 1
131        try {
132            new EllipticCurve(f, a, b, seed);
133            fail("#1: Expected IAE not thrown");
134        } catch (IllegalArgumentException ok) {}
135
136        // test case 1.1 parameters set,
137        // b is not in field
138        f = new ECFieldFp(BigInteger.valueOf(23L));
139        a = BigInteger.valueOf(1L);
140        b = BigInteger.valueOf(23L);
141        seed = new byte[24];
142        // perform test case 1.1
143        try {
144            new EllipticCurve(f, a, b, seed);
145            fail("#1.1: Expected IAE not thrown");
146        } catch (IllegalArgumentException ok) {}
147
148        // test case 2 parameters set,
149        // b is not in field
150        f = new ECFieldFp(BigInteger.valueOf(23L));
151        a = BigInteger.valueOf(19L);
152        b = BigInteger.valueOf(24L);
153        seed = new byte[24];
154        // perform test case 2
155        try {
156            new EllipticCurve(f, a, b, seed);
157            fail("#2: Expected IAE not thrown");
158        } catch (IllegalArgumentException ok) {}
159
160        // test case 3 parameters set,
161        // both a and b are not in field
162        f = new ECFieldFp(BigInteger.valueOf(23L));
163        a = BigInteger.valueOf(25L);
164        b = BigInteger.valueOf(240L);
165        seed = new byte[24];
166        // perform test case 3
167        try {
168            new EllipticCurve(f, a, b, seed);
169            fail("#3: Expected IAE not thrown");
170        } catch (IllegalArgumentException ok) {}
171    }
172
173    /**
174     * Test #4 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
175     * constructor<br>
176     * Assertion: throws <code>IllegalArgumentException</code> if
177     * <code>a</code> or <code>b</code> is not <code>null</code> and not in
178     * the <code>field</code><br>
179     * Test preconditions: pass <code>a</code>, <code>b</code> which are
180     * not in the <code>field</code> of type <code>ECFieldF2m</code><br>
181     * Expected: must throw <code>IllegalArgumentException</code>
182     */
183    public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray04() {
184        // test case 1 parameters set,
185        // a is not in field
186        ECFieldF2m f = new ECFieldF2m(5);
187        BigInteger a = BigInteger.valueOf(32L);
188        BigInteger b = BigInteger.valueOf(19L);
189        byte[] seed = new byte[24];
190
191        // perform test case 1
192        try {
193            new EllipticCurve(f, a, b, seed);
194            fail("#1: Expected IAE not thrown");
195        } catch (IllegalArgumentException ok) {}
196
197        // test case 2 parameters set,
198        // b is not in field
199        f = new ECFieldF2m(5);
200        a = BigInteger.valueOf(19L);
201        b = BigInteger.valueOf(32L);
202        seed = new byte[24];
203        // perform test case 2
204        try {
205            new EllipticCurve(f, a, b, seed);
206            fail("#2: Expected IAE not thrown");
207        } catch (IllegalArgumentException ok) {}
208
209        // test case 3 parameters set,
210        // both a and b are not in field
211        f = new ECFieldF2m(5);
212        a = BigInteger.valueOf(32L);
213        b = BigInteger.valueOf(43L);
214        seed = new byte[24];
215        // perform test case 3
216        try {
217            new EllipticCurve(f, a, b, seed);
218            fail("#3: Expected IAE not thrown");
219        } catch (IllegalArgumentException ok) {}
220    }
221
222    /**
223     * Test #5 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
224     * constructor<br>
225     * Assertion: array <code>seed</code> is copied to prevent subsequent modification<br>
226     * Test preconditions: pass <code>seed</code> to the ctor then modify it<br>
227     * Expected: getSeed() must return unmodified array
228     */
229    public final void testEllipticCurveECFieldBigIntegerBigIntegerbyteArray05() {
230        ECFieldF2m f = new ECFieldF2m(5);
231        BigInteger a = BigInteger.valueOf(0L);
232        BigInteger b = BigInteger.valueOf(19L);
233        byte[] seed = new byte[24];
234        byte[] seedCopy = seed.clone();
235        EllipticCurve c = new EllipticCurve(f, a, b, seedCopy);
236        // modify array passed
237        seedCopy[0] = (byte) 1;
238        // check that above modification did not changed
239        // internal state of test object
240        assertTrue(Arrays.equals(seed, c.getSeed()));
241    }
242
243    /**
244     * Test #1 for <code>EllipticCurve(ECField, BigInteger, BigInteger)</code>
245     * constructor<br>
246     * Assertion: creates instance of EllipticCurve<br>
247     * Test preconditions: valid parameters passed, field type is ECFieldFp<br>
248     * Expected: must pass without any exceptions
249     */
250    public final void testEllipticCurveECFieldBigIntegerBigInteger01() {
251        // test case 1 parameters set
252        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
253        BigInteger a = BigInteger.ONE;
254        BigInteger b = BigInteger.valueOf(19L);
255        // perform test case 1
256        new EllipticCurve(f, a, b);
257
258        // test case 2 parameters set
259        ECFieldF2m f1 = new ECFieldF2m(5);
260        a = BigInteger.ZERO;
261        b = BigInteger.valueOf(23L);
262        // perform test case 2
263        new EllipticCurve(f1, a, b);
264
265        // test case 3 parameters set,
266        // the seed parameter may be null
267        f = new ECFieldFp(BigInteger.valueOf(23L));
268        a = BigInteger.ONE;
269        b = BigInteger.valueOf(19L);
270        // perform test case 3
271        new EllipticCurve(f, a, b);
272    }
273
274    /**
275     * Test #2 for <code>EllipticCurve(ECField, BigInteger, BigInteger)</code>
276     * constructor<br>
277     * Assertion: throws <code>NullPointerException</code> if <code>field</code>,
278     * <code>a</code> or <code>b</code> is <code>null</code><br>
279     * Test preconditions: pass <code>null</code> as mentioned parameters<br>
280     * Expected: must throw <code>NullPointerException</code>
281     */
282    public final void testEllipticCurveECFieldBigIntegerBigInteger02() {
283        // test case 1 parameters set
284        ECFieldFp f = null;
285        BigInteger a = BigInteger.ONE;
286        BigInteger b = BigInteger.valueOf(19L);
287
288        // perform test case 1
289        try {
290            new EllipticCurve(f, a, b);
291            fail("#1: Expected NPE not thrown");
292        } catch (NullPointerException ok) {}
293
294        // test case 2 parameters set,
295        f = new ECFieldFp(BigInteger.valueOf(23L));
296        a = null;
297        b = BigInteger.valueOf(19L);
298        // perform test case 2
299        try {
300            new EllipticCurve(f, a, b);
301            fail("#2: Expected NPE not thrown");
302        } catch (NullPointerException ok) {}
303
304        // test case 3 parameters set,
305        f = new ECFieldFp(BigInteger.valueOf(23L));
306        a = BigInteger.ONE;
307        b = null;
308        // perform test case 3
309        try {
310            new EllipticCurve(f, a, b);
311            fail("#3: Expected NPE not thrown");
312        } catch (NullPointerException ok) {}
313    }
314
315    /**
316     * Test #3 for <code>EllipticCurve(ECField, BigInteger, BigInteger)</code>
317     * constructor<br>
318     * Assertion: throws <code>IllegalArgumentException</code> if
319     * <code>a</code> or <code>b</code> is not <code>null</code> and not in
320     * the <code>field</code><br>
321     * Test preconditions: pass <code>a</code>, <code>b</code> which are
322     * not in the <code>field</code> of type <code>ECFieldFp</code><br>
323     * Expected: must throw <code>IllegalArgumentException</code>
324     */
325    public final void testEllipticCurveECFieldBigIntegerBigInteger03() {
326        // test case 1 parameters set,
327        // a is not in field
328        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
329        BigInteger a = BigInteger.valueOf(24L);
330        BigInteger b = BigInteger.valueOf(19L);
331
332        // perform test case 1
333        try {
334            new EllipticCurve(f, a, b);
335            fail("#1: Expected IAE not thrown");
336        } catch (IllegalArgumentException ok) {}
337
338        // test case 1.1 parameters set,
339        // a is not in field
340        f = new ECFieldFp(BigInteger.valueOf(23L));
341        a = BigInteger.valueOf(23L);
342        b = BigInteger.valueOf(19L);
343        // perform test case 1.1
344        try {
345            new EllipticCurve(f, a, b);
346            fail("#1.1: Expected IAE not thrown");
347        } catch (IllegalArgumentException ok) {}
348
349        // test case 2 parameters set,
350        // b is not in field
351        f = new ECFieldFp(BigInteger.valueOf(23L));
352        a = BigInteger.valueOf(19L);
353        b = BigInteger.valueOf(24L);
354        // perform test case 2
355        try {
356            new EllipticCurve(f, a, b);
357            fail("#2: Expected IAE not thrown");
358        } catch (IllegalArgumentException ok) {}
359
360        // test case 3 parameters set,
361        // both a and b are not in field
362        f = new ECFieldFp(BigInteger.valueOf(23L));
363        a = BigInteger.valueOf(25L);
364        b = BigInteger.valueOf(240L);
365        // perform test case 3
366        try {
367            new EllipticCurve(f, a, b);
368            fail("#3: Expected IAE not thrown");
369        } catch (IllegalArgumentException ok) {}
370    }
371
372    /**
373     * Test #4 for <code>EllipticCurve(ECField, BigInteger, BigInteger, byte[])</code>
374     * constructor<br>
375     * Assertion: throws <code>IllegalArgumentException</code> if
376     * <code>a</code> or <code>b</code> is not <code>null</code> and not in
377     * the <code>field</code><br>
378     * Test preconditions: pass <code>a</code>, <code>b</code> which are
379     * not in the <code>field</code> of type <code>ECFieldF2m</code><br>
380     * Expected: must throw <code>IllegalArgumentException</code>
381     */
382    public final void testEllipticCurveECFieldBigIntegerBigInteger04() {
383        // test case 1 parameters set,
384        // a is not in field
385        ECFieldF2m f = new ECFieldF2m(5);
386        BigInteger a = BigInteger.valueOf(32L);
387        BigInteger b = BigInteger.valueOf(19L);
388        // perform test case 1
389        try {
390            new EllipticCurve(f, a, b);
391            fail("#1: Expected IAE not thrown");
392        } catch (IllegalArgumentException ok) {}
393
394        // test case 2 parameters set,
395        // b is not in field
396        f = new ECFieldF2m(5);
397        a = BigInteger.valueOf(19L);
398        b = BigInteger.valueOf(32L);
399        // perform test case 2
400        try {
401            new EllipticCurve(f, a, b);
402            fail("#2: Expected IAE not thrown");
403        } catch (IllegalArgumentException ok) {}
404
405        // test case 3 parameters set,
406        // both a and b are not in field
407        f = new ECFieldF2m(5);
408        a = BigInteger.valueOf(32L);
409        b = BigInteger.valueOf(43L);
410        // perform test case 3
411        try {
412            new EllipticCurve(f, a, b);
413            fail("#3: Expected IAE not thrown");
414        } catch (IllegalArgumentException ok) {}
415    }
416
417    /**
418     * Test for <code>getA()</code> method<br>
419     * Assertion: returns coefficient <code>a</code><br>
420     * Test preconditions: <code>ECFieldF2m</code> instance
421     * created using valid parameters<br>
422     * Expected: must return coefficient <code>a</code> which is equal
423     * to the one passed to the constructor; (both must refer
424     * the same object)
425     */
426    public final void testGetA() {
427        ECFieldF2m f = new ECFieldF2m(5);
428        BigInteger a = BigInteger.valueOf(5L);
429        BigInteger b = BigInteger.valueOf(19L);
430        EllipticCurve c = new EllipticCurve(f, a, b);
431        assertEquals(a, c.getA());
432        assertSame(a, c.getA());
433    }
434
435    /**
436     * java/security/spec/EllipticCurve#EllipticCurve(EcField,BigInteger,BigInteger)
437     */
438    public final void testEllipticCurveECFieldBigIntegerBigInteger05() {
439        // Regression for Harmony-731
440        EllipticCurve ec = new EllipticCurve(new testECField(), BigInteger
441                .valueOf(4L), BigInteger.ONE);
442        assertEquals("incorrect a", ec.getA(), BigInteger.valueOf(4L));
443        assertEquals("incorrect b", ec.getB(), BigInteger.ONE);
444        assertEquals("incorrect size", ec.getField().getFieldSize(), 2);
445    }
446
447    /**
448     * Test for <code>getB()</code> method<br>
449     * Assertion: returns coefficient <code>b</code><br>
450     * Test preconditions: <code>ECFieldF2m</code> instance
451     * created using valid parameters<br>
452     * Expected: must return coefficient <code>b</code> which is equal
453     * to the one passed to the constructor; (both must refer
454     * the same object)
455     */
456    public final void testGetB() {
457        ECFieldF2m f = new ECFieldF2m(5);
458        BigInteger a = BigInteger.valueOf(5L);
459        BigInteger b = BigInteger.valueOf(19L);
460        EllipticCurve c = new EllipticCurve(f, a, b);
461        assertEquals(b, c.getB());
462        assertSame(b, c.getB());
463    }
464
465    /**
466     * Test for <code>getField()</code> method<br>
467     * Assertion: returns <code>field</code><br>
468     * Test preconditions: <code>ECFieldF2m</code> instance
469     * created using valid parameters<br>
470     * Expected: must return <code>field</code> which is equal
471     * to the one passed to the constructor; (both must refer
472     * the same object)
473     */
474    public final void testGetField() {
475        ECFieldF2m f = new ECFieldF2m(5);
476        BigInteger a = BigInteger.valueOf(5L);
477        BigInteger b = BigInteger.valueOf(19L);
478        EllipticCurve c = new EllipticCurve(f, a, b);
479        assertEquals(f, c.getField());
480        assertSame(f, c.getField());
481    }
482
483    /**
484     * Test #1 for <code>getSeed()</code> method<br>
485     * Assertion: returns <code>seed</code><br>
486     * Test preconditions: <code>ECFieldF2m</code> instance
487     * created using valid parameters<br>
488     * Expected: must return <code>seed</code> which is equal
489     * to the one passed to the constructor
490     */
491    public final void testGetSeed01() {
492        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
493        BigInteger a = BigInteger.ONE;
494        BigInteger b = BigInteger.valueOf(19L);
495        byte[] seed = new byte[24];
496        EllipticCurve c = new EllipticCurve(f, a, b, seed);
497        byte[] seedRet = c.getSeed();
498        assertNotNull(seedRet);
499        assertTrue(Arrays.equals(seed, seedRet));
500    }
501
502    /**
503     * Test #2 for <code>getSeed()</code> method<br>
504     * Assertion: returned array is copied to prevent subsequent modification<br>
505     * Test preconditions: <code>ECFieldF2m</code> instance
506     * created using valid parameters; <code>getSeed()</code>
507     * called and then returned array modified<br>
508     * Expected: internal state must not be affected by the modification
509     */
510    public final void testGetSeed02() {
511        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
512        BigInteger a = BigInteger.ONE;
513        BigInteger b = BigInteger.valueOf(19L);
514        byte[] seed = new byte[24];
515        EllipticCurve c = new EllipticCurve(f, a, b, seed.clone());
516        byte[] seedRet = c.getSeed();
517        // modify returned array
518        seedRet[0] = (byte) 1;
519        // check that above modification did not changed
520        // internal state of test object
521        assertTrue(Arrays.equals(seed, c.getSeed()));
522    }
523
524    /**
525     * Test #3 for <code>getSeed()</code> method<br>
526     * Assertion: returned array is copied to prevent subsequent modification<br>
527     * Test preconditions: <code>ECFieldF2m</code> instance
528     * created using valid parameters<br>
529     * Expected: repeated method calls must return different refs
530     */
531    public final void testGetSeed03() {
532        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
533        BigInteger a = BigInteger.ONE;
534        BigInteger b = BigInteger.valueOf(19L);
535        byte[] seed = new byte[24];
536        EllipticCurve c = new EllipticCurve(f, a, b, seed);
537        c.getSeed();
538        assertNotSame(c.getSeed(), c.getSeed());
539    }
540
541    /**
542     * java.security.spec.EllipticCurve#getSeed()
543     * Assertion: null if not specified
544     */
545    public final void testGetSeed04() {
546        //Regression for HARMONY-732
547        ECFieldFp f = new ECFieldFp(BigInteger.valueOf(23L));
548        BigInteger a = BigInteger.ONE;
549        assertNull(new EllipticCurve(f, a, a).getSeed());
550    }
551
552    /**
553     * Test #1 for <code>equals(Object other)</code> method<br>
554     * Assertion: return true if this and other objects are equal<br>
555     * Test preconditions: see test comments<br>
556     * Expected: all objects in this test must be equal
557     */
558    public final void testEqualsObject01() {
559        // test case 1: must be equal to itself
560        EllipticCurve c2 = null, c1 = new EllipticCurve(new ECFieldFp(
561                BigInteger.valueOf(23L)), BigInteger.ONE, BigInteger
562                .valueOf(19L));
563        assertTrue(c1.equals(c1));
564
565        // test case 2: equal objects
566        c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
567                BigInteger.ONE, BigInteger.valueOf(19L));
568        c2 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
569                BigInteger.valueOf(1L), BigInteger.valueOf(19L));
570        assertTrue(c1.equals(c2) && c2.equals(c1));
571
572        // test case 3: equal objects with seed not null
573        c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
574                BigInteger.ONE, BigInteger.valueOf(19L), new byte[24]);
575        c2 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
576                BigInteger.valueOf(1L), BigInteger.valueOf(19L), new byte[24]);
577        assertTrue(c1.equals(c2) && c2.equals(c1));
578
579        // test case 4: equal object and subclass object
580        c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
581                BigInteger.ONE, BigInteger.valueOf(19L), new byte[24]);
582        MyEllipticCurve c3 = new MyEllipticCurve(new ECFieldFp(BigInteger
583                .valueOf(23L)), BigInteger.ONE, BigInteger.valueOf(19L),
584                new byte[24]);
585        assertTrue(c1.equals(c3) && c3.equals(c1));
586
587        // test case 5: equal objects
588        c1 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
589                BigInteger.ONE, BigInteger.valueOf(19L));
590        c2 = new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
591                BigInteger.valueOf(1L), BigInteger.valueOf(19L), null);
592        assertTrue(c1.equals(c2) && c2.equals(c1));
593    }
594
595    /**
596     * Test #1 for <code>hashCode()</code> method.<br>
597     *
598     * Assertion: must return the same value if invoked
599     * repeatedly on the same object.
600     */
601    public final void testHashCode01() {
602        int hc = 0;
603        EllipticCurve f = new EllipticCurve(new ECFieldFp(BigInteger
604                .valueOf(23L)), BigInteger.ONE, BigInteger.valueOf(19L),
605                new byte[24]);
606        hc = f.hashCode();
607        assertTrue(hc == f.hashCode() && hc == f.hashCode()
608                && hc == f.hashCode() && hc == f.hashCode()
609                && hc == f.hashCode() && hc == f.hashCode()
610                && hc == f.hashCode() && hc == f.hashCode());
611    }
612
613    /**
614     * Test #2 for <code>hashCode()</code> method.<br>
615     *
616     * Assertion: must return the same value if invoked
617     * on equal (according to the <code>equals(Object)</code> method) objects.
618     */
619    public final void testHashCode02() {
620        assertEquals(new EllipticCurve(new ECFieldFp(BigInteger.valueOf(23L)),
621                BigInteger.ONE, BigInteger.valueOf(19L), new byte[24])
622                .hashCode(), new EllipticCurve(new ECFieldFp(BigInteger
623                .valueOf(23L)), BigInteger.ONE, BigInteger.valueOf(19L),
624                new byte[24]).hashCode());
625    }
626
627    //
628    // Private stuff
629    //
630
631    class testECField implements ECField {
632
633        public int getFieldSize() {
634            return 2;
635        }
636    }
637
638    /**
639     * EllipticCurve subclass for testing purposes
640     *
641     */
642    private static class MyEllipticCurve extends EllipticCurve {
643
644        MyEllipticCurve(ECField f, BigInteger a, BigInteger b, byte[] seed) {
645            super(f, a, b, seed);
646        }
647    }
648}
649