0001: /*
0002: * JBoss, Home of Professional Open Source.
0003: * Copyright 2006, Red Hat Middleware LLC, and individual contributors
0004: * as indicated by the @author tags. See the copyright.txt file in the
0005: * distribution for a full listing of individual contributors.
0006: *
0007: * This is free software; you can redistribute it and/or modify it
0008: * under the terms of the GNU Lesser General Public License as
0009: * published by the Free Software Foundation; either version 2.1 of
0010: * the License, or (at your option) any later version.
0011: *
0012: * This software is distributed in the hope that it will be useful,
0013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0015: * Lesser General Public License for more details.
0016: *
0017: * You should have received a copy of the GNU Lesser General Public
0018: * License along with this software; if not, write to the Free
0019: * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
0020: * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
0021: */
0022: package test.compliance.modelmbean;
0023:
0024: import java.io.ByteArrayInputStream;
0025: import java.io.ByteArrayOutputStream;
0026: import java.io.ObjectInputStream;
0027: import java.io.ObjectOutputStream;
0028: import java.util.ArrayList;
0029: import java.util.Arrays;
0030: import java.util.HashMap;
0031: import java.util.Iterator;
0032: import java.util.List;
0033: import java.util.Map;
0034: import java.util.Set;
0035:
0036: import junit.framework.TestCase;
0037:
0038: import javax.management.RuntimeOperationsException;
0039: import javax.management.modelmbean.DescriptorSupport;
0040:
0041: /**
0042: * Tests the standard required <tt>DescriptorSupport</tt> implementation.
0043: *
0044: * @author <a href="mailto:juha@jboss.org">Juha Lindfors</a>.
0045: * @author <a href="mailto:Adrian.Brock@HappeningTimes.com">Adrian Brock</a>.
0046: * @version $Revision: 57200 $
0047: */
0048: public class DescriptorTEST extends TestCase {
0049: public DescriptorTEST(String s) {
0050: super (s);
0051: }
0052:
0053: // Tests ------------------------------------------------------------
0054:
0055: public void testDefaultConstructor() throws Exception {
0056: DescriptorSupport descriptor = new DescriptorSupport();
0057: assertTrue("Should be empty",
0058: descriptor.getFields().length == 0);
0059: boolean caught = false;
0060: try {
0061: descriptor.isValid();
0062: } catch (RuntimeOperationsException expected) {
0063: caught = true;
0064: }
0065: assertTrue("Should not be valid", caught);
0066: }
0067:
0068: public void testSizeConstructor() throws Exception {
0069: DescriptorSupport descriptor = new DescriptorSupport(100);
0070: assertTrue("Should be empty",
0071: descriptor.getFields().length == 0);
0072: boolean caught = false;
0073: try {
0074: descriptor.isValid();
0075: } catch (RuntimeOperationsException expected) {
0076: caught = true;
0077: }
0078: assertTrue("Should not be valid", caught);
0079:
0080: caught = false;
0081: try {
0082: descriptor = new DescriptorSupport(-1);
0083: } catch (RuntimeOperationsException e) {
0084: caught = true;
0085: }
0086: assertTrue("Expected an exception for a negative size", caught);
0087: }
0088:
0089: public void testCopyConstructor() throws Exception {
0090: DescriptorSupport descriptor = new DescriptorSupport(
0091: (DescriptorSupport) null);
0092: assertTrue("Should be empty",
0093: descriptor.getFields().length == 0);
0094: boolean caught = false;
0095: try {
0096: descriptor.isValid();
0097: } catch (RuntimeOperationsException expected) {
0098: caught = true;
0099: }
0100: assertTrue("Should not be valid", caught);
0101:
0102: descriptor = new DescriptorSupport(descriptor);
0103: assertTrue("Should be empty",
0104: descriptor.getFields().length == 0);
0105: caught = false;
0106: try {
0107: descriptor.isValid();
0108: } catch (RuntimeOperationsException expected) {
0109: caught = true;
0110: }
0111: assertTrue("Should not be valid", caught);
0112:
0113: descriptor.setField("name", "testName");
0114: descriptor.setField("descriptorType", "testType");
0115: descriptor = new DescriptorSupport(descriptor);
0116: assertTrue("Should be two fields",
0117: descriptor.getFields().length == 2);
0118: assertEquals("testName", descriptor.getFieldValue("name"));
0119: assertEquals("testType", descriptor
0120: .getFieldValue("descriptorType"));
0121: assertTrue("Should be valid", descriptor.isValid());
0122: }
0123:
0124: public void testNamesValuesConstructor() throws Exception {
0125: String[] names = new String[] { "name", "descriptorType" };
0126: Object[] values = new Object[] { "testName", "testType" };
0127: DescriptorSupport descriptor = new DescriptorSupport(names,
0128: values);
0129: assertTrue("Should be two fields",
0130: descriptor.getFields().length == 2);
0131: assertEquals("testName", descriptor.getFieldValue("name"));
0132: assertEquals("testType", descriptor
0133: .getFieldValue("descriptorType"));
0134: assertTrue("Should be valid", descriptor.isValid());
0135:
0136: descriptor = new DescriptorSupport(new String[0], new Object[0]);
0137: assertTrue("Should be empty",
0138: descriptor.getFields().length == 0);
0139: boolean caught = false;
0140: try {
0141: descriptor.isValid();
0142: } catch (RuntimeOperationsException expected) {
0143: caught = true;
0144: }
0145: assertTrue("Should not be valid", caught);
0146:
0147: caught = false;
0148: try {
0149: descriptor = new DescriptorSupport(null, null);
0150: } catch (RuntimeOperationsException e) {
0151: caught = true;
0152: }
0153: assertTrue("Expected an exception for null names and values",
0154: caught);
0155:
0156: caught = false;
0157: try {
0158: descriptor = new DescriptorSupport(null, values);
0159: } catch (RuntimeOperationsException e) {
0160: caught = true;
0161: }
0162: assertTrue("Expected an exception for null names", caught);
0163:
0164: caught = false;
0165: try {
0166: descriptor = new DescriptorSupport(names, null);
0167: } catch (RuntimeOperationsException e) {
0168: caught = true;
0169: }
0170: assertTrue("Expected an exception for null values", caught);
0171:
0172: Object[] tooManyValues = new Object[] { "testName", "testType",
0173: "tooMany" };
0174: caught = false;
0175: try {
0176: descriptor = new DescriptorSupport(names, tooManyValues);
0177: } catch (RuntimeOperationsException e) {
0178: caught = true;
0179: }
0180: assertTrue("Expected an exception for too many values", caught);
0181:
0182: Object[] tooFewValues = new Object[] { "testName" };
0183: caught = false;
0184: try {
0185: descriptor = new DescriptorSupport(names, tooFewValues);
0186: } catch (RuntimeOperationsException e) {
0187: caught = true;
0188: }
0189: assertTrue("Expected an exception for too few values", caught);
0190:
0191: String[] nullName = new String[] { "name", null };
0192: caught = false;
0193: try {
0194: descriptor = new DescriptorSupport(nullName, values);
0195: } catch (RuntimeOperationsException e) {
0196: caught = true;
0197: }
0198: assertTrue("Expected an exception for null name", caught);
0199:
0200: String[] emptyName = new String[] { "name", "" };
0201: caught = false;
0202: try {
0203: descriptor = new DescriptorSupport(emptyName, values);
0204: } catch (RuntimeOperationsException e) {
0205: caught = true;
0206: }
0207: assertTrue("Expected an exception for empty name ", caught);
0208:
0209: // This is legal?
0210: String[] notEmptyName = new String[] { "name", " " };
0211: descriptor = new DescriptorSupport(notEmptyName, values);
0212: assertTrue("Should be two fields",
0213: descriptor.getFields().length == 2);
0214: assertEquals("testName", descriptor.getFieldValue("name"));
0215: assertEquals("testType", descriptor.getFieldValue(" "));
0216: caught = false;
0217: try {
0218: descriptor.isValid();
0219: } catch (RuntimeOperationsException expected) {
0220: caught = true;
0221: }
0222: assertTrue("Should not be valid", caught);
0223:
0224: names = new String[] { "name", "descriptorType", "another" };
0225: values = new Object[] { "testName", "testType", null };
0226: descriptor = new DescriptorSupport(names, values);
0227: assertTrue("Should be three fields",
0228: descriptor.getFields().length == 3);
0229: assertEquals("testName", descriptor.getFieldValue("name"));
0230: assertEquals("testType", descriptor
0231: .getFieldValue("descriptorType"));
0232: assertTrue("another should be null", descriptor
0233: .getFieldValue("another") == null);
0234: assertTrue("Should be valid", descriptor.isValid());
0235: }
0236:
0237: public void testNameEqualsValueConstructor() throws Exception {
0238: String[] fields = new String[] { "name=testName",
0239: "descriptorType=testType" };
0240: DescriptorSupport descriptor = new DescriptorSupport(fields);
0241: assertTrue("Should be two fields",
0242: descriptor.getFields().length == 2);
0243: assertEquals("testName", descriptor.getFieldValue("name"));
0244: assertEquals("testType", descriptor
0245: .getFieldValue("descriptorType"));
0246: assertTrue("Should be valid", descriptor.isValid());
0247:
0248: descriptor = new DescriptorSupport((String[]) null);
0249: assertTrue("Should be empty",
0250: descriptor.getFields().length == 0);
0251: boolean caught = false;
0252: try {
0253: descriptor.isValid();
0254: } catch (RuntimeOperationsException expected) {
0255: caught = true;
0256: }
0257: assertTrue("Should not be valid", caught);
0258:
0259: descriptor = new DescriptorSupport(new String[0]);
0260: assertTrue("Should be empty",
0261: descriptor.getFields().length == 0);
0262: caught = false;
0263: try {
0264: descriptor.isValid();
0265: } catch (RuntimeOperationsException expected) {
0266: caught = true;
0267: }
0268: assertTrue("Should not be valid", caught);
0269:
0270: String[] nullName = new String[] { "name=testName", "=rubbish" };
0271: caught = false;
0272: try {
0273: descriptor = new DescriptorSupport(nullName);
0274: } catch (RuntimeOperationsException e) {
0275: caught = true;
0276: }
0277: assertTrue("Expected an exception for '=rubbish'", caught);
0278:
0279: // This is legal?
0280: String[] notEmptyName = new String[] { "name=testName",
0281: " =rubbish" };
0282: descriptor = new DescriptorSupport(notEmptyName);
0283: assertTrue("Should be two fields",
0284: descriptor.getFields().length == 2);
0285: assertEquals("testName", descriptor.getFieldValue("name"));
0286: assertEquals("rubbish", descriptor.getFieldValue(" "));
0287: caught = false;
0288: try {
0289: descriptor.isValid();
0290: } catch (RuntimeOperationsException expected) {
0291: caught = true;
0292: }
0293: assertTrue("Should not be valid", caught);
0294: }
0295:
0296: public void testNameEqualsValueConstructorError() throws Exception {
0297: try {
0298: String[] fields = new String[] { "name=testName",
0299: "descriptorType=testType", "another=" };
0300: DescriptorSupport descriptor = new DescriptorSupport(fields);
0301: assertTrue("Should be three fields",
0302: descriptor.getFields().length == 3);
0303: assertEquals("testName", descriptor.getFieldValue("name"));
0304: assertEquals("testType", descriptor
0305: .getFieldValue("descriptorType"));
0306: assertTrue("another should be null", descriptor
0307: .getFieldValue("another") == null);
0308: assertTrue("Should be valid", descriptor.isValid());
0309: } catch (Exception e) {
0310: fail("FAILS IN RI: 'another=' should be valid according to the javadoc "
0311: + e.toString());
0312: }
0313: }
0314:
0315: public void testGetFieldValue() throws Exception {
0316: String[] fields = new String[] { "name=testName",
0317: "descriptorType=testType" };
0318: DescriptorSupport descriptor = new DescriptorSupport(fields);
0319: assertEquals("testName", descriptor.getFieldValue("name"));
0320: assertTrue("Field names are not case sensitive", "testName"
0321: .equals(descriptor.getFieldValue("NAME")));
0322: assertTrue("Non existent field should be null", descriptor
0323: .getFieldValue("nonExistent") == null);
0324:
0325: boolean caught = false;
0326: try {
0327: descriptor.getFieldValue(null);
0328: } catch (RuntimeOperationsException e) {
0329: caught = true;
0330: }
0331: assertTrue("Expected an exception for null name", caught);
0332:
0333: caught = false;
0334: try {
0335: descriptor.getFieldValue("");
0336: } catch (RuntimeOperationsException e) {
0337: caught = true;
0338: }
0339: assertTrue("Expected an exception for empty name", caught);
0340:
0341: // This is legal?
0342: assertTrue("Blank field name is allowed", descriptor
0343: .getFieldValue(" ") == null);
0344: }
0345:
0346: public void testSetFieldValue() throws Exception {
0347: String[] fields = new String[] { "name=testName",
0348: "descriptorType=testType" };
0349: DescriptorSupport descriptor = new DescriptorSupport(fields);
0350: assertEquals("testName", descriptor.getFieldValue("name"));
0351: descriptor.setField("name", "newName");
0352: assertEquals("newName", descriptor.getFieldValue("name"));
0353: descriptor.setField("NAME", "newNAME");
0354: assertEquals("newNAME", descriptor.getFieldValue("name"));
0355:
0356: boolean caught = false;
0357: try {
0358: descriptor.setField(null, "null");
0359: } catch (RuntimeOperationsException e) {
0360: caught = true;
0361: }
0362: assertTrue("Expected an exception for null name", caught);
0363:
0364: caught = false;
0365: try {
0366: descriptor.setField("", "empty");
0367: } catch (RuntimeOperationsException e) {
0368: caught = true;
0369: }
0370: assertTrue("Expected an exception for empty name", caught);
0371:
0372: // This is legal?
0373: descriptor.setField(" ", "blank");
0374: assertEquals("blank", descriptor.getFieldValue(" "));
0375:
0376: descriptor.setField("newField", "newValue");
0377: assertEquals("newValue", descriptor.getFieldValue("newField"));
0378: }
0379:
0380: public void testGetFields() throws Exception {
0381: String[] fields = new String[] { "name=testName",
0382: "descriptorType=testType" };
0383: DescriptorSupport descriptor = new DescriptorSupport(fields);
0384: String[] getFields = descriptor.getFields();
0385: compareFields(fields, getFields);
0386: }
0387:
0388: public void testGetFieldNames() throws Exception {
0389: String[] fields = new String[] { "name=testName",
0390: "descriptorType=testType" };
0391: DescriptorSupport descriptor = new DescriptorSupport(fields);
0392: String[] names = descriptor.getFieldNames();
0393: compareFieldNames(fields, names);
0394: }
0395:
0396: public void testGetFieldValues() throws Exception {
0397: String[] names = new String[] { "name", "descriptorType" };
0398: String[] values = new String[] { "testName", "testType" };
0399: DescriptorSupport descriptor = new DescriptorSupport(names,
0400: values);
0401:
0402: Object[] result = descriptor.getFieldValues(null);
0403: compareFieldValuesUnsorted(values, result);
0404:
0405: result = descriptor.getFieldValues(new String[0]);
0406: compareFieldValues(new Object[0], result);
0407:
0408: result = descriptor.getFieldValues(names);
0409: compareFieldValues(values, result);
0410:
0411: result = descriptor.getFieldValues(new String[] { "name" });
0412: compareFieldValues(new Object[] { "testName" }, result);
0413:
0414: result = descriptor.getFieldValues(new String[] {
0415: "descriptorType", "name" });
0416: compareFieldValues(new Object[] { "testType", "testName" },
0417: result);
0418:
0419: result = descriptor.getFieldValues(new String[] { "NAME" });
0420: compareFieldValues(new Object[] { "testName" }, result);
0421:
0422: result = descriptor.getFieldValues(new String[] { null });
0423: compareFieldValues(new Object[] { null }, result);
0424:
0425: result = descriptor.getFieldValues(new String[] { "" });
0426: compareFieldValues(new Object[] { null }, result);
0427: }
0428:
0429: public void testSetFieldValues() throws Exception {
0430: DescriptorSupport descriptor = new DescriptorSupport();
0431: String[] names = new String[] { "name", "descriptorType" };
0432: Object[] values = new Object[] { "testName", "testType" };
0433: descriptor.setFields(names, values);
0434: assertTrue("Should be two fields",
0435: descriptor.getFields().length == 2);
0436: assertEquals("testName", descriptor.getFieldValue("name"));
0437: assertEquals("testType", descriptor
0438: .getFieldValue("descriptorType"));
0439: assertTrue("Should be valid", descriptor.isValid());
0440:
0441: descriptor = new DescriptorSupport();
0442: descriptor.setFields(new String[0], new Object[0]);
0443: assertTrue("Should be empty",
0444: descriptor.getFields().length == 0);
0445: boolean caught = false;
0446: try {
0447: descriptor.isValid();
0448: } catch (RuntimeOperationsException expected) {
0449: caught = true;
0450: }
0451:
0452: caught = false;
0453: try {
0454: descriptor = new DescriptorSupport();
0455: descriptor.setFields(null, null);
0456: } catch (RuntimeOperationsException e) {
0457: caught = true;
0458: }
0459: assertTrue("Expected an exception for null names and values",
0460: caught);
0461:
0462: caught = false;
0463: try {
0464: descriptor = new DescriptorSupport();
0465: descriptor.setFields(null, values);
0466: } catch (RuntimeOperationsException e) {
0467: caught = true;
0468: }
0469: assertTrue("Expected an exception for null names", caught);
0470:
0471: caught = false;
0472: try {
0473: descriptor = new DescriptorSupport();
0474: descriptor.setFields(names, null);
0475: } catch (RuntimeOperationsException e) {
0476: caught = true;
0477: }
0478: assertTrue("Expected an exception for null values", caught);
0479:
0480: Object[] tooManyValues = new Object[] { "testName", "testType",
0481: "tooMany" };
0482: caught = false;
0483: try {
0484: descriptor = new DescriptorSupport();
0485: descriptor.setFields(names, tooManyValues);
0486: } catch (RuntimeOperationsException e) {
0487: caught = true;
0488: }
0489: assertTrue("Expected an exception for too many values", caught);
0490:
0491: Object[] tooFewValues = new Object[] { "testName" };
0492: caught = false;
0493: try {
0494: descriptor = new DescriptorSupport();
0495: descriptor.setFields(names, tooFewValues);
0496: } catch (RuntimeOperationsException e) {
0497: caught = true;
0498: }
0499: assertTrue("Expected an exception for too few values", caught);
0500:
0501: String[] nullName = new String[] { "name", null };
0502: caught = false;
0503: try {
0504: descriptor = new DescriptorSupport();
0505: descriptor.setFields(nullName, values);
0506: } catch (RuntimeOperationsException e) {
0507: caught = true;
0508: }
0509: assertTrue("Expected an exception for null name", caught);
0510:
0511: String[] emptyName = new String[] { "name", "" };
0512: caught = false;
0513: try {
0514: descriptor = new DescriptorSupport();
0515: descriptor.setFields(emptyName, values);
0516: } catch (RuntimeOperationsException e) {
0517: caught = true;
0518: }
0519: assertTrue("Expected an exception for empty name ", caught);
0520:
0521: // This is legal?
0522: String[] notEmptyName = new String[] { "name", " " };
0523: descriptor = new DescriptorSupport();
0524: descriptor.setFields(notEmptyName, values);
0525: assertTrue("Should be two fields",
0526: descriptor.getFields().length == 2);
0527: assertEquals("testName", descriptor.getFieldValue("name"));
0528: assertEquals("testType", descriptor.getFieldValue(" "));
0529: caught = false;
0530: try {
0531: descriptor.isValid();
0532: } catch (RuntimeOperationsException expected) {
0533: caught = true;
0534: }
0535: assertTrue("Should not be valid", caught);
0536:
0537: names = new String[] { "name", "descriptorType", "another" };
0538: values = new Object[] { "testName", "testType", null };
0539: descriptor = new DescriptorSupport();
0540: descriptor.setFields(names, values);
0541: assertTrue("Should be three fields",
0542: descriptor.getFields().length == 3);
0543: assertEquals("testName", descriptor.getFieldValue("name"));
0544: assertEquals("testType", descriptor
0545: .getFieldValue("descriptorType"));
0546: assertTrue("another should be null", descriptor
0547: .getFieldValue("another") == null);
0548: assertTrue("Should be valid", descriptor.isValid());
0549: }
0550:
0551: public void testClone() throws Exception {
0552: String[] names = new String[] { "name", "descriptorType" };
0553: Object[] values = new Object[] { "testName", "testType" };
0554: DescriptorSupport descriptor = new DescriptorSupport(names,
0555: values);
0556:
0557: DescriptorSupport clone = (DescriptorSupport) descriptor
0558: .clone();
0559: compareFields(descriptor.getFields(), clone.getFields());
0560: }
0561:
0562: public void testRemove() throws Exception {
0563: String[] names = new String[] { "name", "descriptorType" };
0564: Object[] values = new Object[] { "testName", "testType" };
0565: DescriptorSupport descriptor = new DescriptorSupport(names,
0566: values);
0567:
0568: descriptor.removeField("name");
0569: assertTrue("Should be one field",
0570: descriptor.getFields().length == 1);
0571: assertTrue("name should not be present", descriptor
0572: .getFieldValue("name") == null);
0573: assertEquals("testType", descriptor
0574: .getFieldValue("descriptorType"));
0575:
0576: descriptor = new DescriptorSupport(names, values);
0577: descriptor.removeField("NAME");
0578: assertTrue("Should be one field",
0579: descriptor.getFields().length == 1);
0580: assertTrue("name should not be present", descriptor
0581: .getFieldValue("name") == null);
0582: assertEquals("testType", descriptor
0583: .getFieldValue("descriptorType"));
0584:
0585: descriptor = new DescriptorSupport(names, values);
0586: descriptor.removeField("notPresent");
0587: assertTrue("Should be two fields",
0588: descriptor.getFields().length == 2);
0589: assertEquals("testName", descriptor.getFieldValue("name"));
0590: assertEquals("testType", descriptor
0591: .getFieldValue("descriptorType"));
0592:
0593: descriptor.removeField(null);
0594: assertTrue("Should be two fields",
0595: descriptor.getFields().length == 2);
0596: assertEquals("testName", descriptor.getFieldValue("name"));
0597: assertEquals("testType", descriptor
0598: .getFieldValue("descriptorType"));
0599:
0600: descriptor.removeField("");
0601: assertTrue("Should be two fields",
0602: descriptor.getFields().length == 2);
0603: assertEquals("testName", descriptor.getFieldValue("name"));
0604: assertEquals("testType", descriptor
0605: .getFieldValue("descriptorType"));
0606: }
0607:
0608: public void testIsValidMandatory() throws Exception {
0609: String[] names = new String[] { "name", "descriptorType" };
0610: Object[] values = new Object[] { "testName", "testType" };
0611: validate(names, values, true);
0612:
0613: names = new String[] { "name", "descriptorType" };
0614: values = new Object[] { null, "testType" };
0615: validate(names, values, false);
0616:
0617: names = new String[] { "name", "descriptorType" };
0618: values = new Object[] { "", "testType" };
0619: validate(names, values, false);
0620:
0621: names = new String[] { "name", "descriptorType" };
0622: values = new Object[] { "testName", null };
0623: validate(names, values, false);
0624:
0625: names = new String[] { "name", "descriptorType" };
0626: values = new Object[] { "testName", "" };
0627: validate(names, values, false);
0628: }
0629:
0630: public void testIsValidRole() throws Exception {
0631: doTestString("role", "operation");
0632: }
0633:
0634: public void testIsValidGetMethod() throws Exception {
0635: doTestString("getMethod", "getSomething");
0636: }
0637:
0638: public void testIsValidSetMethod() throws Exception {
0639: doTestString("setMethod", "setSomething");
0640: }
0641:
0642: public void testIsValidPersistPeriod() throws Exception {
0643: doTestInteger("persistPeriod");
0644: }
0645:
0646: public void testIsValidCurrencyTimeLimit() throws Exception {
0647: doTestInteger("currencyTimeLimit");
0648: }
0649:
0650: public void testIsValidLastUpdateTimeStamp() throws Exception {
0651: doTestInteger("lastUpdatedTimeStamp");
0652: }
0653:
0654: public void testIsValidLog() throws Exception {
0655: String[] names = new String[] { "name", "descriptorType", "log" };
0656: Object[] values = new Object[] { "testName", "testType", "true" };
0657: validate(names, values, true);
0658:
0659: names = new String[] { "name", "descriptorType", "log" };
0660: values = new Object[] { "testName", "testType", "false" };
0661: validate(names, values, true);
0662:
0663: names = new String[] { "name", "descriptorType", "log" };
0664: values = new Object[] { "testName", "testType", "t" };
0665: validate(names, values, true);
0666:
0667: names = new String[] { "name", "descriptorType", "log" };
0668: values = new Object[] { "testName", "testType", "f" };
0669: validate(names, values, true);
0670:
0671: names = new String[] { "name", "descriptorType", "log" };
0672: values = new Object[] { "testName", "testType", "TRUE" };
0673: validate(names, values, true);
0674:
0675: names = new String[] { "name", "descriptorType", "log" };
0676: values = new Object[] { "testName", "testType", "FALSE" };
0677: validate(names, values, true);
0678:
0679: names = new String[] { "name", "descriptorType", "log" };
0680: values = new Object[] { "testName", "testType", "T" };
0681: validate(names, values, true);
0682:
0683: names = new String[] { "name", "descriptorType", "log" };
0684: values = new Object[] { "testName", "testType", "F" };
0685: validate(names, values, true);
0686:
0687: names = new String[] { "name", "descriptorType", "log" };
0688: values = new Object[] { "testName", "testType", null };
0689: validate(names, values, false);
0690:
0691: names = new String[] { "name", "descriptorType", "log" };
0692: values = new Object[] { "testName", "testType", "" };
0693: validate(names, values, false);
0694:
0695: names = new String[] { "name", "descriptorType", "log" };
0696: values = new Object[] { "testName", "testType", "rubbish" };
0697: validate(names, values, false);
0698: }
0699:
0700: public void testIsValidVisibility() throws Exception {
0701: String[] names = new String[] { "name", "descriptorType",
0702: "visibility" };
0703: Object[] values = new Object[] { "testName", "testType", "1" };
0704: validate(names, values, true);
0705:
0706: names = new String[] { "name", "descriptorType", "visibility" };
0707: values = new Object[] { "testName", "testType", "2" };
0708: validate(names, values, true);
0709:
0710: names = new String[] { "name", "descriptorType", "visibility" };
0711: values = new Object[] { "testName", "testType", "3" };
0712: validate(names, values, true);
0713:
0714: names = new String[] { "name", "descriptorType", "visibility" };
0715: values = new Object[] { "testName", "testType", "4" };
0716: validate(names, values, true);
0717:
0718: names = new String[] { "name", "descriptorType", "visibility" };
0719: values = new Object[] { "testName", "testType", "0" };
0720: validate(names, values, false);
0721:
0722: names = new String[] { "name", "descriptorType", "visibility" };
0723: values = new Object[] { "testName", "testType", "5" };
0724: validate(names, values, false);
0725:
0726: names = new String[] { "name", "descriptorType", "visibility" };
0727: values = new Object[] { "testName", "testType", new Integer(1) };
0728: validate(names, values, true);
0729:
0730: names = new String[] { "name", "descriptorType", "visibility" };
0731: values = new Object[] { "testName", "testType", new Integer(2) };
0732: validate(names, values, true);
0733:
0734: names = new String[] { "name", "descriptorType", "visibility" };
0735: values = new Object[] { "testName", "testType", new Integer(3) };
0736: validate(names, values, true);
0737:
0738: names = new String[] { "name", "descriptorType", "visibility" };
0739: values = new Object[] { "testName", "testType", new Integer(4) };
0740: validate(names, values, true);
0741:
0742: names = new String[] { "name", "descriptorType", "visibility" };
0743: values = new Object[] { "testName", "testType", new Integer(0) };
0744: validate(names, values, false);
0745:
0746: names = new String[] { "name", "descriptorType", "visibility" };
0747: values = new Object[] { "testName", "testType", new Integer(6) };
0748: validate(names, values, false);
0749:
0750: names = new String[] { "name", "descriptorType", "visibility" };
0751: values = new Object[] { "testName", "testType", null };
0752: validate(names, values, false);
0753:
0754: names = new String[] { "name", "descriptorType", "visibility" };
0755: values = new Object[] { "testName", "testType", "" };
0756: validate(names, values, false);
0757: }
0758:
0759: public void testIsValidSeverity() throws Exception {
0760: String[] names = new String[] { "name", "descriptorType",
0761: "severity" };
0762: Object[] values = new Object[] { "testName", "testType", "1" };
0763: validate(names, values, true);
0764:
0765: names = new String[] { "name", "descriptorType", "severity" };
0766: values = new Object[] { "testName", "testType", "2" };
0767: validate(names, values, true);
0768:
0769: names = new String[] { "name", "descriptorType", "severity" };
0770: values = new Object[] { "testName", "testType", "3" };
0771: validate(names, values, true);
0772:
0773: names = new String[] { "name", "descriptorType", "severity" };
0774: values = new Object[] { "testName", "testType", "4" };
0775: validate(names, values, true);
0776:
0777: names = new String[] { "name", "descriptorType", "severity" };
0778: values = new Object[] { "testName", "testType", "5" };
0779: validate(names, values, true);
0780:
0781: names = new String[] { "name", "descriptorType", "severity" };
0782: values = new Object[] { "testName", "testType", new Integer(1) };
0783: validate(names, values, true);
0784:
0785: names = new String[] { "name", "descriptorType", "severity" };
0786: values = new Object[] { "testName", "testType", new Integer(2) };
0787: validate(names, values, true);
0788:
0789: names = new String[] { "name", "descriptorType", "severity" };
0790: values = new Object[] { "testName", "testType", new Integer(3) };
0791: validate(names, values, true);
0792:
0793: names = new String[] { "name", "descriptorType", "severity" };
0794: values = new Object[] { "testName", "testType", new Integer(4) };
0795: validate(names, values, true);
0796:
0797: names = new String[] { "name", "descriptorType", "severity" };
0798: values = new Object[] { "testName", "testType", new Integer(5) };
0799: validate(names, values, true);
0800:
0801: names = new String[] { "name", "descriptorType", "severity" };
0802: values = new Object[] { "testName", "testType", null };
0803: validate(names, values, false);
0804:
0805: names = new String[] { "name", "descriptorType", "severity" };
0806: values = new Object[] { "testName", "testType", "" };
0807: validate(names, values, false);
0808:
0809: names = new String[] { "name", "descriptorType", "severity" };
0810: values = new Object[] { "testName", "testType", "0" };
0811: validate(names, values, false);
0812:
0813: names = new String[] { "name", "descriptorType", "severity" };
0814: values = new Object[] { "testName", "testType", "7" };
0815: validate(names, values, false);
0816:
0817: names = new String[] { "name", "descriptorType", "severity" };
0818: values = new Object[] { "testName", "testType", new Integer(0) };
0819: validate(names, values, false);
0820:
0821: names = new String[] { "name", "descriptorType", "severity" };
0822: values = new Object[] { "testName", "testType", new Integer(7) };
0823: validate(names, values, false);
0824: }
0825:
0826: public void testIsValidError() throws Exception {
0827: try {
0828: String[] names = new String[] { "name", "descriptorType",
0829: "severity" };
0830: Object[] values = new Object[] { "testName", "testType",
0831: "6" };
0832: validate(names, values, true);
0833:
0834: names = new String[] { "name", "descriptorType", "severity" };
0835: values = new Object[] { "testName", "testType",
0836: new Integer(6) };
0837: validate(names, values, true);
0838: } catch (Exception e) {
0839: fail("FAILS IN RI: javadoc and spec are inconsistent on whether severity=6 is valid");
0840: }
0841: }
0842:
0843: public void testIsValidPersistPolicy() throws Exception {
0844: String[] names = new String[] { "name", "descriptorType",
0845: "persistPolicy" };
0846: Object[] values = new Object[] { "testName", "testType",
0847: "onUpdate" };
0848: validate(names, values, true);
0849:
0850: names = new String[] { "name", "descriptorType",
0851: "persistPolicy" };
0852: values = new Object[] { "testName", "testType",
0853: "noMoreOftenThan" };
0854: validate(names, values, true);
0855:
0856: names = new String[] { "name", "descriptorType",
0857: "persistPolicy" };
0858: values = new Object[] { "testName", "testType", "never" };
0859: validate(names, values, true);
0860:
0861: names = new String[] { "name", "descriptorType",
0862: "persistPolicy" };
0863: values = new Object[] { "testName", "testType", "onTimer" };
0864: validate(names, values, true);
0865:
0866: names = new String[] { "name", "descriptorType",
0867: "persistPolicy" };
0868: values = new Object[] { "testName", "testType", null };
0869: validate(names, values, false);
0870:
0871: names = new String[] { "name", "descriptorType",
0872: "persistPolicy" };
0873: values = new Object[] { "testName", "testType", "" };
0874: validate(names, values, false);
0875:
0876: names = new String[] { "name", "descriptorType",
0877: "persistPolicy" };
0878: values = new Object[] { "testName", "testType", "rubbish" };
0879: validate(names, values, false);
0880: }
0881:
0882: public void testSerialization() throws Exception {
0883: String[] names = new String[] { "name", "descriptorType" };
0884: Object[] values = new Object[] { "testName", "testType" };
0885: DescriptorSupport descriptor = new DescriptorSupport(names,
0886: values);
0887:
0888: // Serialize it
0889: ByteArrayOutputStream baos = new ByteArrayOutputStream();
0890: ObjectOutputStream oos = new ObjectOutputStream(baos);
0891: oos.writeObject(descriptor);
0892:
0893: // Deserialize it
0894: ByteArrayInputStream bais = new ByteArrayInputStream(baos
0895: .toByteArray());
0896: ObjectInputStream ois = new ObjectInputStream(bais);
0897: Object result = ois.readObject();
0898:
0899: compareFields(descriptor.getFields(),
0900: ((DescriptorSupport) result).getFields());
0901: }
0902:
0903: // Support -------------------------------------------
0904:
0905: private void doTestString(String field, String value)
0906: throws Exception {
0907: String[] names = new String[] { "name", "descriptorType", field };
0908: Object[] values = new Object[] { "testName", "testType", value };
0909: validate(names, values, true);
0910:
0911: names = new String[] { "name", "descriptorType", field };
0912: values = new Object[] { "testName", "testType", null };
0913: validate(names, values, false);
0914:
0915: names = new String[] { "name", "descriptorType", field };
0916: values = new Object[] { "testName", "testType", "" };
0917: validate(names, values, false);
0918: }
0919:
0920: public void doTestInteger(String field) {
0921: String[] names = new String[] { "name", "descriptorType", field };
0922: Object[] values = new Object[] { "testName", "testType", "0" };
0923: validate(names, values, true);
0924:
0925: names = new String[] { "name", "descriptorType", field };
0926: values = new Object[] { "testName", "testType", "-1" };
0927: validate(names, values, true);
0928:
0929: names = new String[] { "name", "descriptorType", field };
0930: values = new Object[] { "testName", "testType", "100" };
0931: validate(names, values, true);
0932:
0933: names = new String[] { "name", "descriptorType", field };
0934: values = new Object[] { "testName", "testType", "-2" };
0935: validate(names, values, false);
0936:
0937: names = new String[] { "name", "descriptorType", field };
0938: values = new Object[] { "testName", "testType", null };
0939: validate(names, values, false);
0940:
0941: names = new String[] { "name", "descriptorType", field };
0942: values = new Object[] { "testName", "testType", "" };
0943: validate(names, values, false);
0944:
0945: names = new String[] { "name", "descriptorType", field };
0946: values = new Object[] { "testName", "testType", "rubbish" };
0947: validate(names, values, false);
0948:
0949: names = new String[] { "name", "descriptorType", field };
0950: values = new Object[] { "testName", "testType", new Integer(0) };
0951: validate(names, values, true);
0952:
0953: names = new String[] { "name", "descriptorType", field };
0954: values = new Object[] { "testName", "testType", new Integer(-1) };
0955: validate(names, values, true);
0956:
0957: names = new String[] { "name", "descriptorType", field };
0958: values = new Object[] { "testName", "testType",
0959: new Integer(100) };
0960: validate(names, values, true);
0961:
0962: names = new String[] { "name", "descriptorType", field };
0963: values = new Object[] { "testName", "testType", new Integer(-2) };
0964: validate(names, values, false);
0965: }
0966:
0967: private void validate(String[] names, Object[] values, boolean valid) {
0968: DescriptorSupport descriptor = null;
0969: RuntimeOperationsException caught = null;
0970: try {
0971: descriptor = new DescriptorSupport(names, values);
0972: descriptor.isValid();
0973: } catch (RuntimeOperationsException e) {
0974: caught = e;
0975: }
0976: if (valid && caught != null)
0977: throw caught;
0978: if (valid == false && caught == null)
0979: fail("Expected an exception for new Descriptor(String[], String[]) names="
0980: + Arrays.asList(names)
0981: + " values="
0982: + Arrays.asList(values));
0983:
0984: caught = null;
0985: try {
0986: String[] fields = new String[names.length];
0987: for (int i = 0; i < fields.length; i++) {
0988: if (values[i] == null)
0989: fields[i] = names[i] + "=";
0990: else
0991: fields[i] = names[i] + "=" + values[i].toString();
0992: }
0993: descriptor = new DescriptorSupport(names, values);
0994: descriptor.isValid();
0995: } catch (RuntimeOperationsException e) {
0996: caught = e;
0997: }
0998: if (valid && caught != null)
0999: throw caught;
1000: if (valid == false && caught == null)
1001: fail("Expected an exception for new Descriptor(String[], String[]) names="
1002: + Arrays.asList(names)
1003: + " values="
1004: + Arrays.asList(values));
1005:
1006: caught = null;
1007: try {
1008: descriptor = new DescriptorSupport();
1009: for (int i = 0; i < names.length; i++)
1010: descriptor.setField(names[i], values[i]);
1011: descriptor.isValid();
1012: } catch (RuntimeOperationsException e) {
1013: caught = e;
1014: }
1015: if (valid && caught != null)
1016: throw caught;
1017: if (valid == false && caught == null)
1018: fail("Expected an exception for new Descriptor(String[], String[]) names="
1019: + Arrays.asList(names)
1020: + " values="
1021: + Arrays.asList(values));
1022:
1023: caught = null;
1024: try {
1025: descriptor = new DescriptorSupport();
1026: descriptor.setFields(names, values);
1027: descriptor.isValid();
1028: } catch (RuntimeOperationsException e) {
1029: caught = e;
1030: }
1031: if (valid && caught != null)
1032: throw caught;
1033: if (valid == false && caught == null)
1034: fail("Expected an exception for new Descriptor(String[], String[]) names="
1035: + Arrays.asList(names)
1036: + " values="
1037: + Arrays.asList(values));
1038: }
1039:
1040: private void compareFieldNames(String[] one, String[] two)
1041: throws Exception {
1042: Set setOne = makeMap(one).keySet();
1043: List setTwo = new ArrayList(Arrays.asList(two));
1044: for (Iterator i = setOne.iterator(); i.hasNext();) {
1045: Object key = i.next();
1046: if (setTwo.remove(key) == false)
1047: fail("Expected " + Arrays.asList(two)
1048: + " to contain field " + key);
1049: }
1050: assertTrue("Didn't expect the following fields " + setTwo,
1051: setTwo.isEmpty());
1052: }
1053:
1054: private void compareFieldValuesUnsorted(Object[] one, Object[] two)
1055: throws Exception {
1056: if (one.length != two.length)
1057: fail("Lengths are different original=" + Arrays.asList(one)
1058: + " result=" + Arrays.asList(two));
1059:
1060: List listOne = Arrays.asList(one);
1061: List listTwo = new ArrayList(Arrays.asList(two));
1062: for (Iterator i = listOne.iterator(); i.hasNext();) {
1063: Object value = i.next();
1064: if (listTwo.remove(value) == false)
1065: fail("Expected " + two + " to contain " + value);
1066: }
1067: assertTrue("Didn't expect the following fields " + listTwo,
1068: listTwo.isEmpty());
1069: }
1070:
1071: private void compareFieldValues(Object[] one, Object[] two)
1072: throws Exception {
1073: if (one.length != two.length)
1074: fail("Lengths are different original=" + Arrays.asList(one)
1075: + " result=" + Arrays.asList(two));
1076: for (int i = 0; i < one.length; i++) {
1077: if (one[i] == null && two[i] != null)
1078: fail("For index " + i + " original=" + one[i]
1079: + " result=" + two[i]);
1080: else if (one[i] != null && two[i] == null)
1081: fail("For index " + i + " original=" + one[i]
1082: + " result=" + two[i]);
1083: else if (one[i] != null && one[i].equals(two[i]) == false)
1084: fail("For index " + i + " original=" + one[i]
1085: + " result=" + two[i]);
1086: }
1087: }
1088:
1089: private void compareFields(String[] one, String[] two)
1090: throws Exception {
1091: Map mapOne = makeMap(one);
1092: Map mapTwo = makeMap(two);
1093: for (Iterator i = mapOne.entrySet().iterator(); i.hasNext();) {
1094: Map.Entry entry = (Map.Entry) i.next();
1095: Object key = entry.getKey();
1096: Object value = entry.getValue();
1097: if (value.equals(mapTwo.remove(key)) == false)
1098: fail("Expected " + Arrays.asList(two)
1099: + " to contain field " + key);
1100: }
1101: assertTrue("Didn't expect the following fields " + mapTwo,
1102: mapTwo.isEmpty());
1103: }
1104:
1105: private Map makeMap(String[] fields) throws Exception {
1106: HashMap result = new HashMap(fields.length);
1107: for (int i = 0; i < fields.length; i++) {
1108: int index = fields[i].indexOf("=");
1109: String key = fields[i].substring(0, index).toLowerCase();
1110: String value = null;
1111: if (index != fields[i].length() - 1)
1112: value = fields[i].substring(index);
1113: result.put(key, value);
1114: }
1115: return result;
1116: }
1117: }
|