001: /*
002: *
003: *
004: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: */
026:
027: package com.sun.midp.content;
028:
029: import com.sun.midp.i3test.TestCase;
030:
031: import javax.microedition.content.ActionNameMap;
032:
033: /**
034: * Tests for creation of ActionNameMaps.
035: */
036: public class TestActionNameMap extends ExtendedTestCase {
037:
038: /** Valid locale. */
039: static final String locale = "en_US";
040:
041: /** Empty string arrays. */
042: static final String[] zeroStrings = new String[0];
043:
044: /** Length 1 string array. */
045: static final String[] oneString = { "1" };
046:
047: /** Length 1 name string array. */
048: static final String[] oneNameString = { "N1" };
049:
050: /** Length 5 string array. */
051: static final String[] fiveStrings = { "1", "2", "3", "4", "5" };
052:
053: /** Length 5 names string array. */
054: static final String[] fiveNameStrings = { "N1", "N2", "N3", "N4",
055: "N5" };
056:
057: /** String array containing a null. */
058: static final String[] nullString = { "n1", "n2", "n3", "n4", null };
059:
060: /** String array containing an empty string. */
061: static final String[] emptyString = { "e1", "e2", "e3", "e4", "" };
062:
063: /** String array containing a duplicate string. */
064: static final String[] dupString = { "dup", "d2", "d3", "dup", "d5" };
065:
066: /**
067: * Run the tests of the Listener.
068: */
069: public void runTests() {
070: test001();
071: test002();
072: test003();
073: }
074:
075: /**
076: * Test that the listener is notified when a new Invocation
077: * is queued.
078: */
079: private void test001() {
080: declare("Create Valid maps");
081:
082: assertLegal("one action/name pair", oneString, oneNameString,
083: locale);
084: assertLegal("five action/name pairs", fiveStrings,
085: fiveNameStrings, locale);
086: }
087:
088: /**
089: * Test for all the IllegalArgument combinations.
090: */
091: private void test002() {
092: declare("Create Illegal cases");
093: assertIllegal("empty arrays", zeroStrings, zeroStrings, locale,
094: new IllegalArgumentException());
095: assertIllegal("null actions", null, oneNameString, locale,
096: new NullPointerException());
097:
098: assertIllegal("null actionname", oneString, null, locale,
099: new NullPointerException());
100:
101: assertIllegal("unequal action/name pairs", oneString,
102: fiveNameStrings, locale, new IllegalArgumentException());
103:
104: assertIllegal("null locale", oneString, oneNameString, null,
105: new NullPointerException());
106:
107: assertIllegal("empty locale", oneString, oneNameString, "",
108: new IllegalArgumentException());
109:
110: assertIllegal("null action string", nullString,
111: fiveNameStrings, locale, new NullPointerException());
112:
113: assertIllegal("empty action string", emptyString,
114: fiveNameStrings, locale, new IllegalArgumentException());
115:
116: assertIllegal("null action name string", fiveStrings,
117: nullString, locale, new NullPointerException());
118:
119: assertIllegal("empty action name string", fiveStrings,
120: emptyString, locale, new IllegalArgumentException());
121:
122: assertIllegal("duplicate action string", dupString,
123: fiveNameStrings, locale, new IllegalArgumentException());
124: }
125:
126: /**
127: * Test NullPointerException cases.
128: */
129: void test003() {
130:
131: ActionNameMap map;
132: map = new ActionNameMap(oneString, oneNameString, locale);
133:
134: try {
135: String a = map.getActionName(null);
136: fail("getActionName(null) must throw npe");
137: } catch (NullPointerException npe) {
138: assertNotNull("verify exception occurred", npe);
139: }
140: try {
141: String a = map.getAction(null);
142: fail("getActionName(null) must throw npe");
143: } catch (NullPointerException npe) {
144: assertNotNull("verify exception occurred", npe);
145: }
146:
147: }
148:
149: /**
150: * Create an actionNameMap from the args and verify it was created
151: * correctly. Each of the method of the resulting map is
152: * checked with the test case asserts. Exceptions are not handled.
153: * @param message the message for the errors
154: * @param actions the array of actions
155: * @param actionnames the array of actionnames
156: * @param locale the locale
157: */
158: void assertLegal(String message, String[] actions,
159: String[] actionnames, String locale) {
160: ActionNameMap map;
161: map = new ActionNameMap(actions, actionnames, locale);
162:
163: int size = map.size();
164: assertEquals(message, actions.length, size);
165: assertEquals(message, actionnames.length, size);
166: assertEquals(message, locale, map.getLocale());
167:
168: for (int i = 0; i < size; i++) {
169: assertEquals(message, actions[i], map.getAction(i));
170: }
171:
172: for (int i = 0; i < size; i++) {
173: assertEquals(message, actionnames[i], map.getActionName(i));
174: }
175:
176: for (int i = 0; i < size; i++) {
177: assertEquals(message, actionnames[i], map
178: .getActionName(actions[i]));
179: }
180:
181: for (int i = 0; i < size; i++) {
182: assertEquals(message, actions[i], map
183: .getAction(actionnames[i]));
184: }
185: }
186:
187: /**
188: * Create an actionNameMap from the args and verify that
189: * ane xception is thrown.
190: * @param message the message for the errors
191: * @param actions the array of actions
192: * @param actionnames the array of actionnames
193: * @param locale the locale
194: * @param expected the expected exception
195: */
196: void assertIllegal(String message, String[] actions,
197: String[] actionnames, String locale, Exception expected) {
198: ActionNameMap map;
199: try {
200: map = new ActionNameMap(actions, actionnames, locale);
201: // Always report an error
202: assertEquals("MUST throw an exception", null, map);
203: } catch (IllegalArgumentException ill) {
204: assertEquals(message, expected.getClass().getName(), ill
205: .getClass().getName());
206: } catch (NullPointerException npe) {
207: assertEquals(message, expected.getClass().getName(), npe
208: .getClass().getName());
209: }
210: }
211: }
|