001: /*
002: * JBoss, Home of Professional Open Source.
003: * Copyright 2006, Red Hat Middleware LLC, and individual contributors
004: * as indicated by the @author tags. See the copyright.txt file in the
005: * distribution for a full listing of individual contributors.
006: *
007: * This is free software; you can redistribute it and/or modify it
008: * under the terms of the GNU Lesser General Public License as
009: * published by the Free Software Foundation; either version 2.1 of
010: * the License, or (at your option) any later version.
011: *
012: * This software is distributed in the hope that it will be useful,
013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015: * Lesser General Public License for more details.
016: *
017: * You should have received a copy of the GNU Lesser General Public
018: * License along with this software; if not, write to the Free
019: * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
021: */
022: package test.compliance.objectname;
023:
024: import junit.framework.TestCase;
025:
026: import javax.management.MalformedObjectNameException;
027: import javax.management.ObjectName;
028: import java.util.Hashtable;
029:
030: public class BasicTEST extends TestCase {
031: public static final String STD_DOMAIN = "domain";
032: public static final String WHITESPACE = " ";
033: public static final String COMMA = ",";
034: public static final String EQUALS = "=";
035: public static final String COLON = ":";
036: public static final String EMPTY = "";
037: public static final String ASTERISK = "*";
038: public static final String QUESTION = "?";
039: public static final String QUOTE = "\"";
040: public static final String ESCAPE = "\\";
041: public static final String STD_KEYPROP_STRING = "key1=val1,key2=val2";
042: public static final String REV_KEYPROP_STRING = "key2=val2,key1=val1";
043: public static final String KEY1 = "key1";
044: public static final String KEY2 = "key2";
045: public static final String VAL1 = "val1";
046: public static final String VAL2 = "val2";
047:
048: public static final int JMX1_0 = 0;
049: public static final int JMX1_2 = 1;
050: public static final int QUOTED = 100;
051: public static final int QUOTEDBACKSLASH = 101;
052:
053: public BasicTEST(String s) {
054: super (s);
055: }
056:
057: public void testStringNoDomain() {
058: String nameArg = COLON + STD_KEYPROP_STRING;
059: try {
060: ObjectName name = new ObjectName(nameArg);
061: String domain = name.getDomain();
062: if (null == domain) {
063: fail("getDomain() should return empty string rather than null");
064: }
065: assertTrue("domain should have been zero size", domain
066: .length() == 0);
067: assertEquals("value for key: " + KEY1 + " should be: "
068: + VAL1, VAL1, name.getKeyProperty(KEY1));
069: assertEquals("value for key: " + KEY2 + " should be: "
070: + VAL2, VAL2, name.getKeyProperty(KEY2));
071: } catch (MalformedObjectNameException e) {
072: fail("spurious MalformedObjectNameException on ('"
073: + nameArg + "')");
074: }
075: }
076:
077: public void testStringWithDomain() {
078: String nameArg = STD_DOMAIN + COLON + STD_KEYPROP_STRING;
079: try {
080: ObjectName name = new ObjectName(nameArg);
081: assertEquals("domain should be equivalent", STD_DOMAIN,
082: name.getDomain());
083: assertEquals("value for key: " + KEY1 + " should be: "
084: + VAL1, VAL1, name.getKeyProperty(KEY1));
085: assertEquals("value for key: " + KEY2 + " should be: "
086: + VAL2, VAL2, name.getKeyProperty(KEY2));
087: } catch (MalformedObjectNameException e) {
088: fail("spurious MalformedObjectNameException on ('"
089: + nameArg + "')");
090: }
091: }
092:
093: public void testSingleKVP() {
094: try {
095: ObjectName name = new ObjectName(STD_DOMAIN, KEY1, VAL1);
096: assertEquals("domain should be equivalent", STD_DOMAIN,
097: name.getDomain());
098: assertEquals("value for key: " + KEY1 + " should be: "
099: + VAL1, VAL1, name.getKeyProperty(KEY1));
100: assertNull("should return NULL key property for: " + KEY2,
101: name.getKeyProperty(KEY2));
102:
103: String kplistString = name.getKeyPropertyListString();
104: if (null == kplistString) {
105: fail("key property list string was null;");
106: }
107: assertTrue("KeyPropertyListString should match",
108: kplistString.equals("key1=val1"));
109:
110: } catch (MalformedObjectNameException e) {
111: fail("spurious MalformedObjectNameException on ('"
112: + STD_DOMAIN + "','" + KEY1 + "','" + VAL1 + "')");
113: }
114: }
115:
116: public void testHashtable() {
117: try {
118: Hashtable properties = new Hashtable();
119: properties.put(KEY1, VAL1);
120: properties.put(KEY2, VAL2);
121: ObjectName name = new ObjectName(STD_DOMAIN, properties);
122: assertEquals("domain should be equivalent", STD_DOMAIN,
123: name.getDomain());
124: assertEquals("value for key: " + KEY1 + " should be: "
125: + VAL1, VAL1, name.getKeyProperty(KEY1));
126: assertEquals("value for key: " + KEY2 + " should be: "
127: + VAL2, VAL2, name.getKeyProperty(KEY2));
128:
129: String kplistString = name.getKeyPropertyListString();
130: if (null == kplistString) {
131: fail("key property list string was null;");
132: }
133: assertTrue(
134: "KeyPropertyListString should match",
135: (kplistString.equals(STD_KEYPROP_STRING) || kplistString
136: .equals(REV_KEYPROP_STRING)));
137: } catch (MalformedObjectNameException e) {
138: fail("spurious MalformedObjectNameException on ('"
139: + STD_DOMAIN + "','" + KEY1 + "','" + VAL1 + "')");
140: }
141: }
142:
143: public void testWhitespaceDomain() {
144: domainTest(WHITESPACE, JMX1_0);
145: }
146:
147: public void testCommaDomain() {
148: domainTest(COMMA, JMX1_2);
149: }
150:
151: public void testEqualsDomain() {
152: domainTest(EQUALS, JMX1_2);
153: }
154:
155: public void testQuestionValue() {
156: valueTest(QUESTION, QUOTEDBACKSLASH);
157: }
158:
159: public void testAsteriskValue() {
160: valueTest(ASTERISK, QUOTEDBACKSLASH);
161: }
162:
163: public void testQuoteValue() {
164: valueTest(QUOTE, QUOTEDBACKSLASH);
165: }
166:
167: public void testEqualsValue() {
168: valueTest(EQUALS, QUOTED);
169: }
170:
171: public void testCommaValue() {
172: valueTest(COMMA, QUOTED);
173: }
174:
175: public void testColonValue() {
176: valueTest(COLON, QUOTED);
177: }
178:
179: public void testEscapeValue() {
180: valueTest(ESCAPE, QUOTEDBACKSLASH);
181: valueTest(ESCAPE, JMX1_0);
182: }
183:
184: public void testEmptyQuotesValue() {
185: valueTest(QUOTE + QUOTE, JMX1_0);
186: }
187:
188: public void testKeyPropertyList() {
189: String nameArg = ":" + STD_KEYPROP_STRING;
190: try {
191: ObjectName name = new ObjectName(nameArg);
192: String kplistString = name.getKeyPropertyListString();
193: if (null == kplistString) {
194: fail("key property list string was null;");
195: }
196: assertTrue(
197: "KeyPropertyListString should match",
198: (kplistString.equals(STD_KEYPROP_STRING) || kplistString
199: .equals(REV_KEYPROP_STRING)));
200:
201: } catch (MalformedObjectNameException e) {
202: fail("spurious MalformedObjectNameException on ('"
203: + nameArg + "')");
204: }
205: }
206:
207: public void testToString() {
208: String nameArg1 = ":key1=val1";
209: String nameArg2 = "domain:key1=val1";
210:
211: try {
212: ObjectName name1 = new ObjectName(nameArg1);
213: assertEquals("toString should match", nameArg1, name1
214: .toString());
215: } catch (MalformedObjectNameException e) {
216: fail("spurious MalformedObjectNameException on ('"
217: + nameArg1 + "')");
218: }
219:
220: try {
221: ObjectName name2 = new ObjectName(nameArg2);
222: assertEquals("toString should match", nameArg2, name2
223: .toString());
224: } catch (MalformedObjectNameException e) {
225: fail("spurious MalformedObjectNameException on ('"
226: + nameArg2 + "')");
227: }
228: }
229:
230: private void domainTest(String domain, int version) {
231: String nameArg = domain + COLON + STD_KEYPROP_STRING;
232: try {
233: ObjectName name = new ObjectName(nameArg);
234: assertEquals("domain should be equivalent", domain, name
235: .getDomain());
236: } catch (MalformedObjectNameException e) {
237: if (version == JMX1_2)
238: fail("spurious MalformedObjectNameException on ('"
239: + nameArg + "') as of JMX 1.2 " + domain
240: + " is allowed in a domain");
241: else
242: fail("spurious MalformedObjectNameException on ('"
243: + nameArg + "')");
244: }
245:
246: try {
247: ObjectName name = new ObjectName(domain, KEY1, VAL1);
248: assertEquals("domain should be equivalent", domain, name
249: .getDomain());
250: } catch (MalformedObjectNameException e) {
251: if (version == JMX1_2)
252: fail("spurious MalformedObjectNameException on ('"
253: + domain + "','" + KEY1 + "','" + VAL1
254: + "') as of JMX 1.2 " + domain
255: + " is allowed in a domain");
256: else
257: fail("spurious MalformedObjectNameException on ('"
258: + domain + "','" + KEY1 + "','" + VAL1 + "')");
259: }
260:
261: Hashtable table = new Hashtable();
262: try {
263: table.put(KEY1, VAL1);
264: ObjectName name = new ObjectName(domain, table);
265: assertEquals("domain should be equivalent", domain, name
266: .getDomain());
267: } catch (MalformedObjectNameException e) {
268: if (version == JMX1_2)
269: fail("spurious MalformedObjectNameException on ('"
270: + domain + " " + table + "') as of JMX 1.2 "
271: + domain + " is allowed in a domain");
272: else
273: fail("spurious MalformedObjectNameException on ('"
274: + domain + " " + table + "')");
275: }
276: }
277:
278: public void valueTest(String value, int type) {
279: String name = null;
280: if (type == QUOTEDBACKSLASH)
281: name = STD_DOMAIN + COLON + KEY1 + EQUALS + QUOTE + ESCAPE
282: + value + QUOTE;
283: else if (type == QUOTED)
284: name = STD_DOMAIN + COLON + KEY1 + EQUALS + QUOTE + value
285: + QUOTE;
286: else
287: name = STD_DOMAIN + COLON + KEY1 + EQUALS + value;
288: try {
289: ObjectName result = new ObjectName(name);
290: } catch (MalformedObjectNameException e) {
291: if (type == QUOTEDBACKSLASH)
292: fail("spurious MalformedObjectNameException on ('"
293: + name
294: + "') as of JMX 1.2 "
295: + value
296: + " is allowed inside quotes escaped by a backslash");
297: else if (type == QUOTED)
298: fail("spurious MalformedObjectNameException on ('"
299: + name + "') as of JMX 1.2 " + value
300: + " is allowed inside quotes");
301: else
302: fail("FAILS IN RI: spurious MalformedObjectNameException on ('"
303: + name + "')");
304: }
305:
306: String test = null;
307: if (type == QUOTEDBACKSLASH)
308: test = QUOTE + ESCAPE + value + QUOTE;
309: else if (type == QUOTED)
310: test = QUOTE + value + QUOTE;
311: else
312: test = value;
313: try {
314: ObjectName result = new ObjectName(STD_DOMAIN, KEY1, test);
315: } catch (MalformedObjectNameException e) {
316: if (type == QUOTEDBACKSLASH)
317: fail("spurious MalformedObjectNameException on ('"
318: + STD_DOMAIN
319: + "','"
320: + KEY1
321: + "','"
322: + value
323: + "') as of JMX 1.2 "
324: + STD_DOMAIN
325: + " is allowed inside quotes escaped by a backslah");
326: if (type == QUOTED)
327: fail("spurious MalformedObjectNameException on ('"
328: + STD_DOMAIN + "','" + KEY1 + "','" + value
329: + "') as of JMX 1.2 " + STD_DOMAIN
330: + " is allowed inside quotes");
331: else
332: fail("spurious MalformedObjectNameException on ('"
333: + STD_DOMAIN + "','" + KEY1 + "','" + value
334: + "')");
335: }
336:
337: Hashtable table = new Hashtable();
338: if (type == QUOTEDBACKSLASH)
339: table.put(KEY1, QUOTE + ESCAPE + value + QUOTE);
340: else if (type == QUOTED)
341: table.put(KEY1, QUOTE + value + QUOTE);
342: else
343: table.put(KEY1, value);
344: try {
345: ObjectName result = new ObjectName(STD_DOMAIN, table);
346: } catch (MalformedObjectNameException e) {
347: if (type == QUOTEDBACKSLASH)
348: fail("spurious MalformedObjectNameException on ('"
349: + STD_DOMAIN
350: + " "
351: + table
352: + "') as of JMX 1.2 "
353: + STD_DOMAIN
354: + " is allowed inside quotes escaped by a backslah");
355: if (type == QUOTED)
356: fail("spurious MalformedObjectNameException on ('"
357: + STD_DOMAIN + " " + table
358: + "') as of JMX 1.2 " + STD_DOMAIN
359: + " is allowed inside quotes");
360: else
361: fail("spurious MalformedObjectNameException on ('"
362: + STD_DOMAIN + " " + table + "')");
363: }
364: }
365: }
|