/*
* 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.
*/
/**
* @author Alexander Y. Kleymenov
* @version $Revision$
*/
package org.apache.harmony.crypto.tests.javax.crypto.spec;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import java.lang.IllegalArgumentException;
import java.util.Arrays;
import javax.crypto.spec.RC2ParameterSpec;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
@TestTargetClass(RC2ParameterSpec.class)
/**
*/
public class RC2ParameterSpecTest extends TestCase {
/**
* RC2ParameterSpec(int effectiveKeyBits, byte[] iv) method testing.
* Tests that IllegalArgumentException is thrown in the case of
* inappropriate constructor parameters and that input iv array is
* copied to protect against subsequent modification.
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "RC2ParameterSpec",
args = {int.class, byte[].class}
)
public void testRC2ParameterSpec1() {
int effectiveKeyBits = 10;
byte[] iv = {1, 2, 3, 4, 5, 6, 7, 8};
try {
new RC2ParameterSpec(effectiveKeyBits, null);
fail("An IllegalArgumentException should be thrown "
+ "in the case of null iv.");
} catch (IllegalArgumentException e) {
}
try {
new RC2ParameterSpec(effectiveKeyBits, new byte[] {1, 2, 3, 4, 5});
fail("An IllegalArgumentException should be thrown "
+ "in the case of short iv.");
} catch (IllegalArgumentException e) {
}
RC2ParameterSpec ps = new RC2ParameterSpec(effectiveKeyBits, iv);
iv[0] ++;
assertFalse("The change of iv specified in the constructor "
+ "should not cause the change of internal array.",
iv[0] == ps.getIV()[0]);
}
/**
* RC2ParameterSpec(int effectiveKeyBits, byte[] iv, int offset) method
* testing. Tests that IllegalArgumentException is thrown in the case of
* inappropriate constructor parameters and that input iv array is
* copied to protect against subsequent modification.
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "RC2ParameterSpec",
args = {int.class, byte[].class, int.class}
)
public void testRC2ParameterSpec2() {
int effectiveKeyBits = 10;
byte[] iv = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
int offset = 2;
try {
new RC2ParameterSpec(effectiveKeyBits, null, offset);
fail("An IllegalArgumentException should be thrown "
+ "in the case of null iv.");
} catch (IllegalArgumentException e) {
}
try {
new RC2ParameterSpec(effectiveKeyBits, iv, 4);
fail("An IllegalArgumentException should be thrown "
+ "in the case of short iv.");
} catch (IllegalArgumentException e) {
}
RC2ParameterSpec ps = new RC2ParameterSpec(effectiveKeyBits, iv, offset);
iv[offset] ++;
assertFalse("The change of iv specified in the constructor "
+ "should not cause the change of internal array.",
iv[offset] == ps.getIV()[0]);
}
/**
* getEffectiveKeyBits() method testing. Tests that returned value is
* equal to the value specified in the constructor.
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getEffectiveKeyBits",
args = {}
)
public void testGetEffectiveKeyBits() {
int effectiveKeyBits = 10;
byte[] iv = {1, 2, 3, 4, 5, 6, 7, 8};
RC2ParameterSpec ps = new RC2ParameterSpec(effectiveKeyBits, iv);
assertTrue("The returned effectiveKeyBits value is not equal to the "
+ "value specified in the constructor.",
effectiveKeyBits == ps.getEffectiveKeyBits());
}
/**
* getIV() method testing. Tests that returned array is equal to the
* array specified in the constructor. Checks that modification
* of returned array does not affect the internal array. Also it checks
* that getIV() method returns null if iv is not specified.
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getIV",
args = {}
)
public void testGetIV() {
int effectiveKeyBits = 10;
byte[] iv = new byte[] {1, 2, 3, 4, 5, 6, 7, 8};
RC2ParameterSpec ps = new RC2ParameterSpec(effectiveKeyBits, iv);
byte[] result = ps.getIV();
if (! Arrays.equals(iv, result)) {
fail("The returned iv is not equal to the specified "
+ "in the constructor.");
}
result[0] ++;
assertFalse("The change of returned by getIV() method iv "
+ "should not cause the change of internal array.",
result[0] == ps.getIV()[0]);
ps = new RC2ParameterSpec(effectiveKeyBits);
assertNull("The getIV() method should return null if the parameter "
+ "set does not contain iv.", ps.getIV());
}
/**
* equals(Object obj) method testing. Tests the correctness of equal
* operation: it should be reflexive, symmetric, transitive, consistent
* and should be false on null object.
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
public void testEquals() {
int effectiveKeyBits = 10;
byte[] iv = new byte[] {1, 2, 3, 4, 5, 6, 7, 8};
RC2ParameterSpec ps1 = new RC2ParameterSpec(effectiveKeyBits, iv);
RC2ParameterSpec ps2 = new RC2ParameterSpec(effectiveKeyBits, iv);
RC2ParameterSpec ps3 = new RC2ParameterSpec(10,
new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9});
// checking for reflexive law:
assertTrue("The equivalence relation should be reflexive.",
ps1.equals(ps1));
assertTrue("Objects built on the same parameters should be equal.",
ps1.equals(ps2));
// checking for symmetric law:
assertTrue("The equivalence relation should be symmetric.",
ps2.equals(ps1));
assertTrue("Objects built on the equal parameters should be equal.",
ps2.equals(ps3));
// checking for transitive law:
assertTrue("The equivalence relation should be transitive.",
ps1.equals(ps3));
assertFalse("Should return not be equal to null object.",
ps1.equals(null));
ps2 = new RC2ParameterSpec(11, iv);
assertFalse("Objects should not be equal.", ps1.equals(ps2));
ps2 = new RC2ParameterSpec(11, new byte[] {9, 8, 7, 6, 5, 4, 3, 2, 1});
assertFalse("Objects should not be equal.", ps1.equals(ps2));
}
/**
* hashCode() method testing. Tests that for equal objects hash codes
* are equal.
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
public void testHashCode() {
int effectiveKeyBits = 0;
byte[] iv = new byte[] {1, 2, 3, 4, 5, 6, 7, 8};
RC2ParameterSpec ps1 = new RC2ParameterSpec(effectiveKeyBits, iv);
RC2ParameterSpec ps2 = new RC2ParameterSpec(effectiveKeyBits, iv);
assertTrue("Equal objects should have the same hash codes.",
ps1.hashCode() == ps2.hashCode());
}
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "RC2ParameterSpec",
args = {int.class}
)
public void test_constructorI() {
int effectiveKeyBits = 0;
RC2ParameterSpec ps1 = new RC2ParameterSpec(effectiveKeyBits);
RC2ParameterSpec ps2 = new RC2ParameterSpec(effectiveKeyBits);
assertTrue(ps1.equals(ps2));
}
public static Test suite() {
return new TestSuite(RC2ParameterSpecTest.class);
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
}
|
