001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Vera Y. Petrashkova
020: * @version $Revision$
021: */package org.apache.harmony.security.tests.java.security;
022:
023: import java.security.KeyManagementException;
024:
025: import junit.framework.TestCase;
026:
027: /**
028: * Tests for <code>KeyManagementException</code> class constructors and
029: * methods.
030: *
031: */
032: public class KeyManagementExceptionTest extends TestCase {
033:
034: public static void main(String[] args) {
035: }
036:
037: /**
038: * Constructor for KeyManagementExceptionTests.
039: *
040: * @param arg0
041: */
042: public KeyManagementExceptionTest(String arg0) {
043: super (arg0);
044: }
045:
046: private static String[] msgs = {
047: "",
048: "Check new message",
049: "Check new message Check new message Check new message Check new message Check new message" };
050:
051: private static Throwable tCause = new Throwable(
052: "Throwable for exception");
053:
054: /**
055: * Test for <code>KeyManagementException()</code> constructor Assertion:
056: * constructs KeyManagementException with no detail message
057: */
058: public void testKeyManagementException01() {
059: KeyManagementException tE = new KeyManagementException();
060: assertNull("getMessage() must return null.", tE.getMessage());
061: assertNull("getCause() must return null", tE.getCause());
062: }
063:
064: /**
065: * Test for <code>KeyManagementException(String)</code> constructor
066: * Assertion: constructs KeyManagementException with detail message msg.
067: * Parameter <code>msg</code> is not null.
068: */
069: public void testKeyManagementException02() {
070: KeyManagementException tE;
071: for (int i = 0; i < msgs.length; i++) {
072: tE = new KeyManagementException(msgs[i]);
073: assertEquals("getMessage() must return: ".concat(msgs[i]),
074: tE.getMessage(), msgs[i]);
075: assertNull("getCause() must return null", tE.getCause());
076: }
077: }
078:
079: /**
080: * Test for <code>KeyManagementException(String)</code> constructor
081: * Assertion: constructs KeyManagementException when <code>msg</code> is
082: * null
083: */
084: public void testKeyManagementException03() {
085: String msg = null;
086: KeyManagementException tE = new KeyManagementException(msg);
087: assertNull("getMessage() must return null.", tE.getMessage());
088: assertNull("getCause() must return null", tE.getCause());
089: }
090:
091: /**
092: * Test for <code>KeyManagementException(Throwable)</code> constructor
093: * Assertion: constructs KeyManagementException when <code>cause</code> is
094: * null
095: */
096: public void testKeyManagementException04() {
097: Throwable cause = null;
098: KeyManagementException tE = new KeyManagementException(cause);
099: assertNull("getMessage() must return null.", tE.getMessage());
100: assertNull("getCause() must return null", tE.getCause());
101: }
102:
103: /**
104: * Test for <code>KeyManagementException(Throwable)</code> constructor
105: * Assertion: constructs KeyManagementException when <code>cause</code> is
106: * not null
107: */
108: public void testKeyManagementException05() {
109: KeyManagementException tE = new KeyManagementException(tCause);
110: if (tE.getMessage() != null) {
111: String toS = tCause.toString();
112: String getM = tE.getMessage();
113: assertTrue("getMessage() should contain ".concat(toS),
114: (getM.indexOf(toS) != -1));
115: }
116: assertNotNull("getCause() must not return null", tE.getCause());
117: assertEquals("getCause() must return "
118: .concat(tCause.toString()), tE.getCause(), tCause);
119: }
120:
121: /**
122: * Test for <code>KeyManagementException(String, Throwable)</code>
123: * constructor Assertion: constructs KeyManagementException when
124: * <code>cause</code> is null <code>msg</code> is null
125: */
126: public void testKeyManagementException06() {
127: KeyManagementException tE = new KeyManagementException(null,
128: null);
129: assertNull("getMessage() must return null", tE.getMessage());
130: assertNull("getCause() must return null", tE.getCause());
131: }
132:
133: /**
134: * Test for <code>KeyManagementException(String, Throwable)</code>
135: * constructor Assertion: constructs KeyManagementException when
136: * <code>cause</code> is null <code>msg</code> is not null
137: */
138: public void testKeyManagementException07() {
139: KeyManagementException tE;
140: for (int i = 0; i < msgs.length; i++) {
141: tE = new KeyManagementException(msgs[i], null);
142: assertEquals("getMessage() must return: ".concat(msgs[i]),
143: tE.getMessage(), msgs[i]);
144: assertNull("getCause() must return null", tE.getCause());
145: }
146: }
147:
148: /**
149: * Test for <code>KeyManagementException(String, Throwable)</code>
150: * constructor Assertion: constructs KeyManagementException when
151: * <code>cause</code> is not null <code>msg</code> is null
152: */
153: public void testKeyManagementException08() {
154: KeyManagementException tE = new KeyManagementException(null,
155: tCause);
156: if (tE.getMessage() != null) {
157: String toS = tCause.toString();
158: String getM = tE.getMessage();
159: assertTrue("getMessage() must should ".concat(toS), (getM
160: .indexOf(toS) != -1));
161: }
162: assertNotNull("getCause() must not return null", tE.getCause());
163: assertEquals("getCause() must return "
164: .concat(tCause.toString()), tE.getCause(), tCause);
165: }
166:
167: /**
168: * Test for <code>KeyManagementException(String, Throwable)</code>
169: * constructor Assertion: constructs KeyManagementException when
170: * <code>cause</code> is not null <code>msg</code> is not null
171: */
172: public void testKeyManagementException09() {
173: KeyManagementException tE;
174: for (int i = 0; i < msgs.length; i++) {
175: tE = new KeyManagementException(msgs[i], tCause);
176: String getM = tE.getMessage();
177: String toS = tCause.toString();
178: if (msgs[i].length() > 0) {
179: assertTrue(
180: "getMessage() must contain ".concat(msgs[i]),
181: getM.indexOf(msgs[i]) != -1);
182: if (!getM.equals(msgs[i])) {
183: assertTrue("getMessage() should contain "
184: .concat(toS), getM.indexOf(toS) != -1);
185: }
186: }
187: assertNotNull("getCause() must not return null", tE
188: .getCause());
189: assertEquals("getCause() must return ".concat(tCause
190: .toString()), tE.getCause(), tCause);
191: }
192: }
193: }
|