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.openmbean;
0023:
0024: import junit.framework.TestCase;
0025:
0026: import java.io.ByteArrayInputStream;
0027: import java.io.ByteArrayOutputStream;
0028: import java.io.ObjectInputStream;
0029: import java.io.ObjectOutputStream;
0030:
0031: import javax.management.openmbean.ArrayType;
0032: import javax.management.openmbean.CompositeType;
0033: import javax.management.openmbean.OpenDataException;
0034: import javax.management.openmbean.OpenMBeanParameterInfoSupport;
0035: import javax.management.openmbean.OpenType;
0036: import javax.management.openmbean.SimpleType;
0037: import javax.management.openmbean.TabularDataSupport;
0038: import javax.management.openmbean.TabularType;
0039:
0040: /**
0041: * Open MBean Parameter Info tests.<p>
0042: *
0043: * @author <a href="mailto:Adrian.Brock@HappeningTimes.com">Adrian Brock</a>.
0044: */
0045: public class OpenMBeanParameterInfoSupportTestCase extends TestCase {
0046: // Static --------------------------------------------------------------------
0047:
0048: // Attributes ----------------------------------------------------------------
0049:
0050: // Constructor ---------------------------------------------------------------
0051:
0052: /**
0053: * Construct the test
0054: */
0055: public OpenMBeanParameterInfoSupportTestCase(String s) {
0056: super (s);
0057: }
0058:
0059: // Tests ---------------------------------------------------------------------
0060:
0061: public void testOpenMBeanParameterInfoSupport() throws Exception {
0062: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0063: "name", "description", SimpleType.STRING);
0064: assertEquals("name", info.getName());
0065: assertEquals("description", info.getDescription());
0066: assertEquals("java.lang.String", info.getType());
0067:
0068: info = new OpenMBeanParameterInfoSupport("name", "description",
0069: SimpleType.STRING, "default");
0070: assertEquals("name", info.getName());
0071: assertEquals("description", info.getDescription());
0072: assertEquals("java.lang.String", info.getType());
0073: assertEquals("default", info.getDefaultValue());
0074: assertEquals(true, info.hasDefaultValue());
0075:
0076: info = new OpenMBeanParameterInfoSupport("name", "description",
0077: SimpleType.STRING, null);
0078: assertEquals("name", info.getName());
0079: assertEquals("description", info.getDescription());
0080: assertEquals("java.lang.String", info.getType());
0081: assertEquals(null, info.getDefaultValue());
0082: assertEquals(false, info.hasDefaultValue());
0083:
0084: info = new OpenMBeanParameterInfoSupport("name", "description",
0085: SimpleType.INTEGER, new Integer(3), new Integer(2),
0086: new Integer(4));
0087: assertEquals("name", info.getName());
0088: assertEquals("description", info.getDescription());
0089: assertEquals("java.lang.Integer", info.getType());
0090: assertEquals(new Integer(3), info.getDefaultValue());
0091: assertEquals(new Integer(2), info.getMinValue());
0092: assertEquals(new Integer(4), info.getMaxValue());
0093:
0094: info = new OpenMBeanParameterInfoSupport("name", "description",
0095: SimpleType.INTEGER, null, new Integer(2),
0096: new Integer(4));
0097: assertEquals("name", info.getName());
0098: assertEquals("description", info.getDescription());
0099: assertEquals("java.lang.Integer", info.getType());
0100: assertEquals(null, info.getDefaultValue());
0101: assertEquals(new Integer(2), info.getMinValue());
0102: assertEquals(new Integer(4), info.getMaxValue());
0103:
0104: info = new OpenMBeanParameterInfoSupport("name", "description",
0105: SimpleType.INTEGER, new Integer(3), null,
0106: new Integer(4));
0107: assertEquals("name", info.getName());
0108: assertEquals("description", info.getDescription());
0109: assertEquals("java.lang.Integer", info.getType());
0110: assertEquals(new Integer(3), info.getDefaultValue());
0111: assertEquals(null, info.getMinValue());
0112: assertEquals(new Integer(4), info.getMaxValue());
0113:
0114: info = new OpenMBeanParameterInfoSupport("name", "description",
0115: SimpleType.INTEGER, new Integer(3), new Integer(2),
0116: null);
0117: assertEquals("name", info.getName());
0118: assertEquals("description", info.getDescription());
0119: assertEquals("java.lang.Integer", info.getType());
0120: assertEquals(new Integer(3), info.getDefaultValue());
0121: assertEquals(new Integer(2), info.getMinValue());
0122: assertEquals(null, info.getMaxValue());
0123:
0124: info = new OpenMBeanParameterInfoSupport("name", "description",
0125: SimpleType.INTEGER, null, null, new Integer(4));
0126: assertEquals("name", info.getName());
0127: assertEquals("description", info.getDescription());
0128: assertEquals("java.lang.Integer", info.getType());
0129: assertEquals(null, info.getDefaultValue());
0130: assertEquals(null, info.getMinValue());
0131: assertEquals(new Integer(4), info.getMaxValue());
0132:
0133: info = new OpenMBeanParameterInfoSupport("name", "description",
0134: SimpleType.INTEGER, null, new Integer(2), null);
0135: assertEquals("name", info.getName());
0136: assertEquals("description", info.getDescription());
0137: assertEquals("java.lang.Integer", info.getType());
0138: assertEquals(null, info.getDefaultValue());
0139: assertEquals(new Integer(2), info.getMinValue());
0140: assertEquals(null, info.getMaxValue());
0141:
0142: info = new OpenMBeanParameterInfoSupport("name", "description",
0143: SimpleType.INTEGER, new Integer(3), null, null);
0144: assertEquals("name", info.getName());
0145: assertEquals("description", info.getDescription());
0146: assertEquals("java.lang.Integer", info.getType());
0147: assertEquals(new Integer(3), info.getDefaultValue());
0148: assertEquals(null, info.getMinValue());
0149: assertEquals(null, info.getMaxValue());
0150:
0151: info = new OpenMBeanParameterInfoSupport("name", "description",
0152: SimpleType.INTEGER, null, null, null);
0153: assertEquals("name", info.getName());
0154: assertEquals("description", info.getDescription());
0155: assertEquals("java.lang.Integer", info.getType());
0156: assertEquals(null, info.getDefaultValue());
0157: assertEquals(null, info.getMinValue());
0158: assertEquals(null, info.getMaxValue());
0159:
0160: info = new OpenMBeanParameterInfoSupport("name", "description",
0161: SimpleType.STRING, "default", new Object[] { "legal1",
0162: "legal2", "default" });
0163: assertEquals("name", info.getName());
0164: assertEquals("description", info.getDescription());
0165: assertEquals("java.lang.String", info.getType());
0166: assertEquals("default", info.getDefaultValue());
0167: assertEquals(3, info.getLegalValues().size());
0168: assertTrue("legal1 should be a legal value", info
0169: .getLegalValues().contains("legal1"));
0170: assertTrue("legal2 should be a legal value", info
0171: .getLegalValues().contains("legal2"));
0172: assertTrue("default should be a legal value", info
0173: .getLegalValues().contains("default"));
0174:
0175: info = new OpenMBeanParameterInfoSupport("name", "description",
0176: SimpleType.STRING, null, new Object[] { "legal1",
0177: "legal2", "default" });
0178: assertEquals("name", info.getName());
0179: assertEquals("description", info.getDescription());
0180: assertEquals("java.lang.String", info.getType());
0181: assertEquals(null, info.getDefaultValue());
0182: assertEquals(3, info.getLegalValues().size());
0183: assertTrue("legal1 should be a legal value", info
0184: .getLegalValues().contains("legal1"));
0185: assertTrue("legal2 should be a legal value", info
0186: .getLegalValues().contains("legal2"));
0187: assertTrue("default should be a legal value", info
0188: .getLegalValues().contains("default"));
0189:
0190: info = new OpenMBeanParameterInfoSupport("name", "description",
0191: SimpleType.STRING, "default", null);
0192: assertEquals("name", info.getName());
0193: assertEquals("description", info.getDescription());
0194: assertEquals("java.lang.String", info.getType());
0195: assertEquals("default", info.getDefaultValue());
0196: assertEquals(null, info.getLegalValues());
0197:
0198: info = new OpenMBeanParameterInfoSupport("name", "description",
0199: SimpleType.STRING, null, null);
0200: assertEquals("name", info.getName());
0201: assertEquals("description", info.getDescription());
0202: assertEquals("java.lang.String", info.getType());
0203: assertEquals(null, info.getDefaultValue());
0204: assertEquals(null, info.getLegalValues());
0205: }
0206:
0207: public void testOpenType() throws Exception {
0208: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0209: "name", "description", SimpleType.STRING);
0210: assertEquals(SimpleType.STRING, info.getOpenType());
0211: }
0212:
0213: public void testHas() throws Exception {
0214: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0215: "name", "description", SimpleType.STRING, "default");
0216: assertEquals(true, info.hasDefaultValue());
0217:
0218: info = new OpenMBeanParameterInfoSupport("name", "description",
0219: SimpleType.STRING, null);
0220: assertEquals(false, info.hasDefaultValue());
0221:
0222: info = new OpenMBeanParameterInfoSupport("name", "description",
0223: SimpleType.INTEGER, null, new Integer(3), null);
0224: assertEquals(true, info.hasMinValue());
0225:
0226: info = new OpenMBeanParameterInfoSupport("name", "description",
0227: SimpleType.INTEGER, null, null, null);
0228: assertEquals(false, info.hasMinValue());
0229:
0230: info = new OpenMBeanParameterInfoSupport("name", "description",
0231: SimpleType.INTEGER, null, null, new Integer(3));
0232: assertEquals(true, info.hasMaxValue());
0233:
0234: info = new OpenMBeanParameterInfoSupport("name", "description",
0235: SimpleType.INTEGER, null, null, null);
0236: assertEquals(false, info.hasMaxValue());
0237:
0238: info = new OpenMBeanParameterInfoSupport("name", "description",
0239: SimpleType.INTEGER, null,
0240: new Object[] { new Integer(3) });
0241: assertEquals(true, info.hasLegalValues());
0242:
0243: info = new OpenMBeanParameterInfoSupport("name", "description",
0244: SimpleType.INTEGER, null, null);
0245: assertEquals(false, info.hasLegalValues());
0246: }
0247:
0248: public void testIsValue() throws Exception {
0249: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0250: "name", "description", SimpleType.STRING);
0251: assertTrue("String should be a value", info.isValue("string"));
0252: assertTrue("Integer should not be a value", info
0253: .isValue(new Integer(3)) == false);
0254: assertTrue("Null should not be a value",
0255: info.isValue(null) == false);
0256: }
0257:
0258: public void testEquals() throws Exception {
0259: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0260: "name", "description", SimpleType.STRING);
0261:
0262: assertTrue("Null should not be equal",
0263: info.equals(null) == false);
0264: assertTrue("Only OpenMBeanParameterInfo should be equal", info
0265: .equals(new Object()) == false);
0266:
0267: OpenMBeanParameterInfoSupport info2 = new OpenMBeanParameterInfoSupport(
0268: "name", "description", SimpleType.STRING);
0269:
0270: assertTrue("Different instances of the same data are equal",
0271: info.equals(info2));
0272: assertTrue("Different instances of the same data are equal",
0273: info2.equals(info));
0274:
0275: info2 = new OpenMBeanParameterInfoSupport("name",
0276: "description2", SimpleType.STRING);
0277:
0278: assertTrue(
0279: "Different instances with different descriptions are equal",
0280: info.equals(info2));
0281: assertTrue(
0282: "Different instances with different descritpions are equal",
0283: info2.equals(info));
0284:
0285: info2 = new OpenMBeanParameterInfoSupport("name2",
0286: "description", SimpleType.STRING);
0287:
0288: assertTrue("Instances with different names are not equal", info
0289: .equals(info2) == false);
0290: assertTrue("Instances with different names are not equal",
0291: info2.equals(info) == false);
0292:
0293: info2 = new OpenMBeanParameterInfoSupport("name",
0294: "description", SimpleType.INTEGER);
0295:
0296: assertTrue("Instances with different types are not equal", info
0297: .equals(info2) == false);
0298: assertTrue("Instances with different types are not equal",
0299: info2.equals(info) == false);
0300:
0301: info = new OpenMBeanParameterInfoSupport("name", "description",
0302: SimpleType.INTEGER, new Integer(3), new Integer(2),
0303: new Integer(4));
0304: info2 = new OpenMBeanParameterInfoSupport("name",
0305: "description", SimpleType.INTEGER, new Integer(2),
0306: new Integer(2), new Integer(4));
0307:
0308: assertTrue(
0309: "Instances with different default values are not equal",
0310: info.equals(info2) == false);
0311: assertTrue(
0312: "Instances with different default values are not equal",
0313: info2.equals(info) == false);
0314:
0315: info = new OpenMBeanParameterInfoSupport("name", "description",
0316: SimpleType.INTEGER, new Integer(3), new Integer(2),
0317: new Integer(4));
0318: info2 = new OpenMBeanParameterInfoSupport("name",
0319: "description", SimpleType.INTEGER, new Integer(2),
0320: null, new Integer(4));
0321:
0322: assertTrue(
0323: "Instances with different default values are not equal",
0324: info.equals(info2) == false);
0325: assertTrue(
0326: "Instances with different default values are not equal",
0327: info2.equals(info) == false);
0328:
0329: info = new OpenMBeanParameterInfoSupport("name", "description",
0330: SimpleType.INTEGER, new Integer(3));
0331: info2 = new OpenMBeanParameterInfoSupport("name",
0332: "description", SimpleType.INTEGER, new Integer(3));
0333:
0334: assertTrue(
0335: "Different instances of the same default value are equal",
0336: info.equals(info2));
0337: assertTrue(
0338: "Different instances of the same default value are equal",
0339: info2.equals(info));
0340:
0341: info = new OpenMBeanParameterInfoSupport("name", "description",
0342: SimpleType.INTEGER, null, new Integer(2), null);
0343: info2 = new OpenMBeanParameterInfoSupport("name",
0344: "description", SimpleType.INTEGER, null,
0345: new Integer(2), null);
0346:
0347: assertTrue("Different instances of the same minimum are equal",
0348: info.equals(info2));
0349: assertTrue("Different instances of the same minimum are equal",
0350: info2.equals(info));
0351:
0352: info = new OpenMBeanParameterInfoSupport("name", "description",
0353: SimpleType.INTEGER, null, null, new Integer(2));
0354: info2 = new OpenMBeanParameterInfoSupport("name",
0355: "description", SimpleType.INTEGER, null, null,
0356: new Integer(2));
0357:
0358: assertTrue("Different instances of the same maximum are equal",
0359: info.equals(info2));
0360: assertTrue("Different instances of the same maximum are equal",
0361: info2.equals(info));
0362:
0363: info = new OpenMBeanParameterInfoSupport("name", "description",
0364: SimpleType.INTEGER, new Integer(3), new Integer(2),
0365: new Integer(4));
0366: info2 = new OpenMBeanParameterInfoSupport("name",
0367: "description", SimpleType.INTEGER, new Integer(3),
0368: new Integer(1), new Integer(4));
0369:
0370: assertTrue("Instances with different minimums are not equal",
0371: info.equals(info2) == false);
0372: assertTrue("Instances with different minimums are not equal",
0373: info2.equals(info) == false);
0374:
0375: info = new OpenMBeanParameterInfoSupport("name", "description",
0376: SimpleType.INTEGER, new Integer(3), new Integer(2),
0377: new Integer(4));
0378: info2 = new OpenMBeanParameterInfoSupport("name",
0379: "description", SimpleType.INTEGER, new Integer(3),
0380: null, new Integer(4));
0381:
0382: assertTrue("Instances with different minimums are not equal",
0383: info.equals(info2) == false);
0384: assertTrue("Instances with different minimums are not equal",
0385: info2.equals(info) == false);
0386:
0387: info = new OpenMBeanParameterInfoSupport("name", "description",
0388: SimpleType.INTEGER, new Integer(3), new Integer(2),
0389: new Integer(4));
0390: info2 = new OpenMBeanParameterInfoSupport("name",
0391: "description", SimpleType.INTEGER, new Integer(3),
0392: new Integer(2), new Integer(5));
0393:
0394: assertTrue("Instances with different maximums are not equal",
0395: info.equals(info2) == false);
0396: assertTrue("Instances with different maximums are not equal",
0397: info2.equals(info) == false);
0398:
0399: info = new OpenMBeanParameterInfoSupport("name", "description",
0400: SimpleType.INTEGER, new Integer(3), new Integer(2),
0401: new Integer(4));
0402: info2 = new OpenMBeanParameterInfoSupport("name",
0403: "description", SimpleType.INTEGER, new Integer(3),
0404: new Integer(2), null);
0405:
0406: assertTrue("Instances with different maximums are not equal",
0407: info.equals(info2) == false);
0408: assertTrue("Instances with different maximums are not equal",
0409: info2.equals(info) == false);
0410:
0411: info = new OpenMBeanParameterInfoSupport("name", "description",
0412: SimpleType.INTEGER, null, new Object[] {
0413: new Integer(2), new Integer(3) });
0414: info2 = new OpenMBeanParameterInfoSupport("name",
0415: "description", SimpleType.INTEGER, null, new Object[] {
0416: new Integer(2), new Integer(3) });
0417:
0418: assertTrue(
0419: "Different instances of the same legal values are equal",
0420: info.equals(info2));
0421: assertTrue(
0422: "Different instances of the same legal values are equal",
0423: info2.equals(info));
0424:
0425: info = new OpenMBeanParameterInfoSupport("name", "description",
0426: SimpleType.INTEGER, null, new Object[] {
0427: new Integer(2), new Integer(3) });
0428: info2 = new OpenMBeanParameterInfoSupport("name",
0429: "description", SimpleType.INTEGER, null, new Object[] {
0430: new Integer(2), new Integer(4) });
0431:
0432: assertTrue(
0433: "Different instances with different legal values are equal",
0434: info.equals(info2) == false);
0435: assertTrue(
0436: "Different instances with different legal values are equal",
0437: info2.equals(info) == false);
0438:
0439: info = new OpenMBeanParameterInfoSupport("name", "description",
0440: SimpleType.INTEGER, null, new Object[] {
0441: new Integer(2), new Integer(3) });
0442: info2 = new OpenMBeanParameterInfoSupport("name",
0443: "description", SimpleType.INTEGER, null,
0444: new Object[] { new Integer(2) });
0445:
0446: assertTrue(
0447: "Different instances with different legal values are equal",
0448: info.equals(info2) == false);
0449: assertTrue(
0450: "Different instances with different legal values are equal",
0451: info2.equals(info) == false);
0452:
0453: info = new OpenMBeanParameterInfoSupport("name", "description",
0454: SimpleType.INTEGER, null, new Object[] {
0455: new Integer(2), new Integer(3) });
0456: info2 = new OpenMBeanParameterInfoSupport("name",
0457: "description", SimpleType.INTEGER, null, null);
0458:
0459: assertTrue(
0460: "Different instances with different legal values are equal",
0461: info.equals(info2) == false);
0462: assertTrue(
0463: "Different instances with different legal values are equal",
0464: info2.equals(info) == false);
0465: }
0466:
0467: public void testHashCode() throws Exception {
0468:
0469: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0470: "name", "description", SimpleType.INTEGER, new Integer(
0471: 3), new Integer(2), new Integer(4));
0472: int myHash = "name".hashCode() + SimpleType.INTEGER.hashCode()
0473: + new Integer(3).hashCode() + new Integer(2).hashCode()
0474: + new Integer(4).hashCode();
0475: assertEquals(myHash, info.hashCode());
0476: info = new OpenMBeanParameterInfoSupport("name", "description",
0477: SimpleType.INTEGER, new Integer(3),
0478: new Object[] { new Integer(2), new Integer(3),
0479: new Integer(4) });
0480: myHash = "name".hashCode() + SimpleType.INTEGER.hashCode()
0481: + new Integer(3).hashCode() + new Integer(2).hashCode()
0482: + new Integer(3).hashCode() + new Integer(4).hashCode();
0483: assertEquals(myHash, info.hashCode());
0484: }
0485:
0486: public void testToString() throws Exception {
0487: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0488: "name", "description", SimpleType.INTEGER, new Integer(
0489: 3), new Integer(2), new Integer(4));
0490:
0491: String toString = info.toString();
0492: assertTrue("info.toString() should contain the name", toString
0493: .indexOf("name") != -1);
0494: assertTrue("info.toString() should contain the simple type",
0495: toString.indexOf(SimpleType.INTEGER.toString()) != -1);
0496: assertTrue("info.toString() should contain the default value",
0497: toString.indexOf(new Integer(3).toString()) != -1);
0498: assertTrue("info.toString() should contain the minimum value",
0499: toString.indexOf(new Integer(2).toString()) != -1);
0500: assertTrue("info.toString() should contain the maximum value",
0501: toString.indexOf(new Integer(4).toString()) != -1);
0502:
0503: info = new OpenMBeanParameterInfoSupport("name", "description",
0504: SimpleType.INTEGER, new Integer(3),
0505: new Object[] { new Integer(2), new Integer(3),
0506: new Integer(4) });
0507: assertTrue("info.toString() should contain the legal value 2",
0508: toString.indexOf(new Integer(2).toString()) != -1);
0509: assertTrue("info.toString() should contain the legal value 3",
0510: toString.indexOf(new Integer(3).toString()) != -1);
0511: assertTrue("info.toString() should contain the legal value 4",
0512: toString.indexOf(new Integer(4).toString()) != -1);
0513: }
0514:
0515: public void testSerialization() throws Exception {
0516: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0517: "name", "description", SimpleType.INTEGER, new Integer(
0518: 3), new Integer(2), new Integer(4));
0519:
0520: // Serialize it
0521: ByteArrayOutputStream baos = new ByteArrayOutputStream();
0522: ObjectOutputStream oos = new ObjectOutputStream(baos);
0523: oos.writeObject(info);
0524:
0525: // Deserialize it
0526: ByteArrayInputStream bais = new ByteArrayInputStream(baos
0527: .toByteArray());
0528: ObjectInputStream ois = new ObjectInputStream(bais);
0529: Object result = ois.readObject();
0530:
0531: assertEquals(info, result);
0532:
0533: info = new OpenMBeanParameterInfoSupport("name", "description",
0534: SimpleType.INTEGER, new Integer(3),
0535: new Object[] { new Integer(2), new Integer(3),
0536: new Integer(4) });
0537:
0538: // Serialize it
0539: baos = new ByteArrayOutputStream();
0540: oos = new ObjectOutputStream(baos);
0541: oos.writeObject(info);
0542:
0543: // Deserialize it
0544: bais = new ByteArrayInputStream(baos.toByteArray());
0545: ois = new ObjectInputStream(bais);
0546: result = ois.readObject();
0547:
0548: assertEquals(info, result);
0549: }
0550:
0551: public void testErrors1() throws Exception {
0552: boolean caught = false;
0553: try {
0554: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0555: null, "description", SimpleType.INTEGER);
0556: } catch (IllegalArgumentException e) {
0557: caught = true;
0558: }
0559: if (caught == false)
0560: fail("Expected IllegalArgumentException for null name");
0561:
0562: caught = false;
0563: try {
0564: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0565: "", "description", SimpleType.INTEGER);
0566: } catch (IllegalArgumentException e) {
0567: caught = true;
0568: }
0569: if (caught == false)
0570: fail("Expected IllegalArgumentException for an empty name");
0571:
0572: caught = false;
0573: try {
0574: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0575: "name", null, SimpleType.INTEGER);
0576: } catch (IllegalArgumentException e) {
0577: caught = true;
0578: }
0579: if (caught == false)
0580: fail("Expected IllegalArgumentException for null description");
0581:
0582: caught = false;
0583: try {
0584: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0585: "name", "", SimpleType.INTEGER);
0586: } catch (IllegalArgumentException e) {
0587: caught = true;
0588: }
0589: if (caught == false)
0590: fail("Expected IllegalArgumentException for an empty description");
0591:
0592: caught = false;
0593: try {
0594: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0595: "", "description", SimpleType.INTEGER);
0596: } catch (IllegalArgumentException e) {
0597: caught = true;
0598: }
0599: if (caught == false)
0600: fail("Expected IllegalArgumentException for an empty name");
0601:
0602: caught = false;
0603: try {
0604: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0605: "name", "description", null);
0606: } catch (IllegalArgumentException e) {
0607: caught = true;
0608: }
0609: if (caught == false)
0610: fail("Expected IllegalArgumentException for null simple type");
0611: }
0612:
0613: public void testErrors2() throws Exception {
0614: boolean caught = false;
0615: try {
0616: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0617: null, "description", SimpleType.INTEGER,
0618: new Integer(3));
0619: } catch (IllegalArgumentException e) {
0620: caught = true;
0621: }
0622: if (caught == false)
0623: fail("Expected IllegalArgumentException for null name");
0624:
0625: caught = false;
0626: try {
0627: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0628: "", "description", SimpleType.INTEGER, new Integer(
0629: 3));
0630: } catch (IllegalArgumentException e) {
0631: caught = true;
0632: }
0633: if (caught == false)
0634: fail("Expected IllegalArgumentException for an empty name");
0635:
0636: caught = false;
0637: try {
0638: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0639: "name", null, SimpleType.INTEGER, new Integer(3));
0640: } catch (IllegalArgumentException e) {
0641: caught = true;
0642: }
0643: if (caught == false)
0644: fail("Expected IllegalArgumentException for null description");
0645:
0646: caught = false;
0647: try {
0648: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0649: "name", "", SimpleType.INTEGER, new Integer(3));
0650: } catch (IllegalArgumentException e) {
0651: caught = true;
0652: }
0653: if (caught == false)
0654: fail("Expected IllegalArgumentException for an empty description");
0655:
0656: caught = false;
0657: try {
0658: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0659: "", "description", SimpleType.INTEGER, new Integer(
0660: 3));
0661: } catch (IllegalArgumentException e) {
0662: caught = true;
0663: }
0664: if (caught == false)
0665: fail("Expected IllegalArgumentException for an empty name");
0666:
0667: caught = false;
0668: try {
0669: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0670: "name", "description", null, new Integer(3));
0671: } catch (IllegalArgumentException e) {
0672: caught = true;
0673: }
0674: if (caught == false)
0675: fail("Expected IllegalArgumentException for null simple type");
0676:
0677: caught = false;
0678: try {
0679: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0680: "name", "description", SimpleType.STRING,
0681: new Integer(3));
0682: } catch (OpenDataException e) {
0683: caught = true;
0684: }
0685: if (caught == false)
0686: fail("Expected OpenDataException for wrong simple type and default value");
0687:
0688: caught = false;
0689: try {
0690: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
0691: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0692: "name", "description", arrayType, new String[0]);
0693: } catch (OpenDataException e) {
0694: caught = true;
0695: }
0696: if (caught == false)
0697: fail("Expected OpenDataException for array type and default value");
0698:
0699: caught = false;
0700: try {
0701: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
0702: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0703: "name", "description", arrayType, null);
0704: } catch (OpenDataException e) {
0705: caught = true;
0706: }
0707: if (caught == true)
0708: fail("Didn't execpt OpenDataException for array type and no default value");
0709:
0710: caught = false;
0711: try {
0712: String[] itemNames = new String[] { "name1", "name2" };
0713: String[] itemDescriptions = new String[] { "desc1", "desc2" };
0714: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
0715: SimpleType.INTEGER };
0716: CompositeType rowType = new CompositeType("rowTypeName",
0717: "rowDescription", itemNames, itemDescriptions,
0718: itemTypes);
0719:
0720: String[] indexNames = new String[] { "name1", "name2" };
0721: TabularType tabularType = new TabularType("typeName",
0722: "description", rowType, indexNames);
0723: TabularDataSupport data = new TabularDataSupport(
0724: tabularType);
0725:
0726: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0727: "name", "description", tabularType, data);
0728: } catch (OpenDataException e) {
0729: caught = true;
0730: }
0731: if (caught == false)
0732: fail("Expected OpenDataException for tabular type and default value");
0733:
0734: caught = false;
0735: try {
0736: String[] itemNames = new String[] { "name1", "name2" };
0737: String[] itemDescriptions = new String[] { "desc1", "desc2" };
0738: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
0739: SimpleType.INTEGER };
0740: CompositeType rowType = new CompositeType("rowTypeName",
0741: "rowDescription", itemNames, itemDescriptions,
0742: itemTypes);
0743:
0744: String[] indexNames = new String[] { "name1", "name2" };
0745: TabularType tabularType = new TabularType("typeName",
0746: "description", rowType, indexNames);
0747:
0748: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0749: "name", "description", tabularType, null);
0750: } catch (OpenDataException e) {
0751: caught = true;
0752: }
0753: if (caught == true)
0754: fail("Didn't execpt OpenDataException for tabular type and null default value");
0755: }
0756:
0757: public void testErrors3() throws Exception {
0758: boolean caught = false;
0759: try {
0760: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0761: null, "description", SimpleType.INTEGER,
0762: new Integer(3), new Integer[] { new Integer(3),
0763: new Integer(4) });
0764: } catch (IllegalArgumentException e) {
0765: caught = true;
0766: }
0767: if (caught == false)
0768: fail("Expected IllegalArgumentException for null name");
0769:
0770: caught = false;
0771: try {
0772: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0773: "", "description", SimpleType.INTEGER, new Integer(
0774: 3), new Integer[] { new Integer(3),
0775: new Integer(4) });
0776: } catch (IllegalArgumentException e) {
0777: caught = true;
0778: }
0779: if (caught == false)
0780: fail("Expected IllegalArgumentException for an empty name");
0781:
0782: caught = false;
0783: try {
0784: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0785: "name", null, SimpleType.INTEGER, new Integer(3),
0786: new Integer[] { new Integer(3), new Integer(4) });
0787: } catch (IllegalArgumentException e) {
0788: caught = true;
0789: }
0790: if (caught == false)
0791: fail("Expected IllegalArgumentException for null description");
0792:
0793: caught = false;
0794: try {
0795: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0796: "name", "", SimpleType.INTEGER, new Integer(3),
0797: new Integer[] { new Integer(3), new Integer(4) });
0798: } catch (IllegalArgumentException e) {
0799: caught = true;
0800: }
0801: if (caught == false)
0802: fail("Expected IllegalArgumentException for an empty description");
0803:
0804: caught = false;
0805: try {
0806: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0807: "", "description", SimpleType.INTEGER, new Integer(
0808: 3), new Integer[] { new Integer(3),
0809: new Integer(4) });
0810: } catch (IllegalArgumentException e) {
0811: caught = true;
0812: }
0813: if (caught == false)
0814: fail("Expected IllegalArgumentException for an empty name");
0815:
0816: caught = false;
0817: try {
0818: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0819: "name", "description", null, new Integer(3),
0820: new Integer[] { new Integer(3), new Integer(4) });
0821: } catch (IllegalArgumentException e) {
0822: caught = true;
0823: }
0824: if (caught == false)
0825: fail("Expected IllegalArgumentException for null simple type");
0826:
0827: caught = false;
0828: try {
0829: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0830: "name", "description", SimpleType.STRING,
0831: new Integer(3), new Integer[] { new Integer(3),
0832: new Integer(4) });
0833: } catch (OpenDataException e) {
0834: caught = true;
0835: }
0836: if (caught == false)
0837: fail("Expected OpenDataException for wrong simple type and default value");
0838:
0839: caught = false;
0840: try {
0841: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
0842: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0843: "name", "description", arrayType, new String[0],
0844: null);
0845: } catch (OpenDataException e) {
0846: caught = true;
0847: }
0848: if (caught == false)
0849: fail("Expected OpenDataException for array type and default value");
0850:
0851: caught = false;
0852: try {
0853: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
0854: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0855: "name", "description", arrayType, null, null);
0856: } catch (OpenDataException e) {
0857: caught = true;
0858: }
0859: if (caught == true)
0860: fail("Didn't expect OpenDataException for array type and no default value and legals");
0861:
0862: caught = false;
0863: try {
0864: String[] itemNames = new String[] { "name1", "name2" };
0865: String[] itemDescriptions = new String[] { "desc1", "desc2" };
0866: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
0867: SimpleType.INTEGER };
0868: CompositeType rowType = new CompositeType("rowTypeName",
0869: "rowDescription", itemNames, itemDescriptions,
0870: itemTypes);
0871:
0872: String[] indexNames = new String[] { "name1", "name2" };
0873: TabularType tabularType = new TabularType("typeName",
0874: "description", rowType, indexNames);
0875: TabularDataSupport data = new TabularDataSupport(
0876: tabularType);
0877:
0878: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0879: "name", "description", tabularType, data, null);
0880: } catch (OpenDataException e) {
0881: caught = true;
0882: }
0883: if (caught == false)
0884: fail("Expected OpenDataException for tabular type and default value");
0885:
0886: caught = false;
0887: try {
0888: String[] itemNames = new String[] { "name1", "name2" };
0889: String[] itemDescriptions = new String[] { "desc1", "desc2" };
0890: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
0891: SimpleType.INTEGER };
0892: CompositeType rowType = new CompositeType("rowTypeName",
0893: "rowDescription", itemNames, itemDescriptions,
0894: itemTypes);
0895:
0896: String[] indexNames = new String[] { "name1", "name2" };
0897: TabularType tabularType = new TabularType("typeName",
0898: "description", rowType, indexNames);
0899:
0900: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0901: "name", "description", tabularType, null, null);
0902: } catch (OpenDataException e) {
0903: caught = true;
0904: }
0905: if (caught == true)
0906: fail("Didn't expect OpenDataException for tabular type and null default value and legals");
0907:
0908: caught = false;
0909: try {
0910: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
0911: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0912: "name", "description", arrayType, null,
0913: new String[] { "hello", "goodbye" });
0914: } catch (OpenDataException e) {
0915: caught = true;
0916: }
0917: if (caught == false)
0918: fail("Expected OpenDataException for array type and default value");
0919:
0920: caught = false;
0921: try {
0922: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
0923: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0924: "name", "description", arrayType, null,
0925: new String[0]);
0926: } catch (OpenDataException e) {
0927: caught = true;
0928: }
0929: if (caught == true)
0930: fail("Didn't expect OpenDataException for array type and no default value and empty legals");
0931:
0932: caught = false;
0933: try {
0934: String[] itemNames = new String[] { "name1", "name2" };
0935: String[] itemDescriptions = new String[] { "desc1", "desc2" };
0936: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
0937: SimpleType.INTEGER };
0938: CompositeType rowType = new CompositeType("rowTypeName",
0939: "rowDescription", itemNames, itemDescriptions,
0940: itemTypes);
0941:
0942: String[] indexNames = new String[] { "name1", "name2" };
0943: TabularType tabularType = new TabularType("typeName",
0944: "description", rowType, indexNames);
0945: TabularDataSupport data = new TabularDataSupport(
0946: tabularType);
0947:
0948: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0949: "name", "description", tabularType, null,
0950: new TabularDataSupport[] { data });
0951: } catch (OpenDataException e) {
0952: caught = true;
0953: }
0954: if (caught == false)
0955: fail("Expected OpenDataException for tabular type and legal values");
0956:
0957: caught = false;
0958: try {
0959: String[] itemNames = new String[] { "name1", "name2" };
0960: String[] itemDescriptions = new String[] { "desc1", "desc2" };
0961: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
0962: SimpleType.INTEGER };
0963: CompositeType rowType = new CompositeType("rowTypeName",
0964: "rowDescription", itemNames, itemDescriptions,
0965: itemTypes);
0966:
0967: String[] indexNames = new String[] { "name1", "name2" };
0968: TabularType tabularType = new TabularType("typeName",
0969: "description", rowType, indexNames);
0970:
0971: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0972: "name", "description", tabularType, null,
0973: new TabularDataSupport[0]);
0974: } catch (OpenDataException e) {
0975: caught = true;
0976: }
0977: if (caught == true)
0978: fail("Didn't expect OpenDataException for tabular type and null default value and empty legals");
0979:
0980: caught = false;
0981: try {
0982: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0983: "name", "description", SimpleType.STRING,
0984: new Integer(3), new Integer[] { new Integer(2),
0985: new Integer(4) });
0986: } catch (OpenDataException e) {
0987: caught = true;
0988: }
0989: if (caught == false)
0990: fail("Expected OpenDataException for default value not a legal value");
0991: }
0992:
0993: public void testErrors4() throws Exception {
0994: boolean caught = false;
0995: try {
0996: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
0997: null, "description", SimpleType.INTEGER,
0998: new Integer(3), new Integer(3), new Integer(4));
0999: } catch (IllegalArgumentException e) {
1000: caught = true;
1001: }
1002: if (caught == false)
1003: fail("Expected IllegalArgumentException for null name");
1004:
1005: caught = false;
1006: try {
1007: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1008: "", "description", SimpleType.INTEGER, new Integer(
1009: 3), new Integer(3), new Integer(4));
1010: } catch (IllegalArgumentException e) {
1011: caught = true;
1012: }
1013: if (caught == false)
1014: fail("Expected IllegalArgumentException for an empty name");
1015:
1016: caught = false;
1017: try {
1018: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1019: "name", null, SimpleType.INTEGER, new Integer(3),
1020: new Integer(3), new Integer(4));
1021: } catch (IllegalArgumentException e) {
1022: caught = true;
1023: }
1024: if (caught == false)
1025: fail("Expected IllegalArgumentException for null description");
1026:
1027: caught = false;
1028: try {
1029: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1030: "name", "", SimpleType.INTEGER, new Integer(3),
1031: new Integer(3), new Integer(4));
1032: } catch (IllegalArgumentException e) {
1033: caught = true;
1034: }
1035: if (caught == false)
1036: fail("Expected IllegalArgumentException for an empty description");
1037:
1038: caught = false;
1039: try {
1040: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1041: "", "description", SimpleType.INTEGER, new Integer(
1042: 3), new Integer(3), new Integer(4));
1043: } catch (IllegalArgumentException e) {
1044: caught = true;
1045: }
1046: if (caught == false)
1047: fail("Expected IllegalArgumentException for an empty name");
1048:
1049: caught = false;
1050: try {
1051: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1052: "name", "description", null, new Integer(3),
1053: new Integer(3), new Integer(4));
1054: } catch (IllegalArgumentException e) {
1055: caught = true;
1056: }
1057: if (caught == false)
1058: fail("Expected IllegalArgumentException for null simple type");
1059:
1060: caught = false;
1061: try {
1062: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1063: "name", "description", SimpleType.STRING,
1064: new Integer(3), null, null);
1065: } catch (OpenDataException e) {
1066: caught = true;
1067: }
1068: if (caught == false)
1069: fail("Expected OpenDataException for wrong simple type and default value");
1070:
1071: caught = false;
1072: try {
1073: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1074: "name", "description", SimpleType.STRING, null,
1075: new Integer(3), null);
1076: } catch (OpenDataException e) {
1077: caught = true;
1078: }
1079: if (caught == false)
1080: fail("Expected OpenDataException for wrong simple type and minimum value");
1081:
1082: caught = false;
1083: try {
1084: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1085: "name", "description", SimpleType.STRING, null,
1086: null, new Integer(3));
1087: } catch (OpenDataException e) {
1088: caught = true;
1089: }
1090: if (caught == false)
1091: fail("Expected OpenDataException for wrong simple type and maximum value");
1092:
1093: caught = false;
1094: try {
1095: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
1096: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1097: "name", "description", arrayType, new String[0],
1098: null, null);
1099: } catch (OpenDataException e) {
1100: caught = true;
1101: }
1102: if (caught == false)
1103: fail("Expected OpenDataException for array type and default value");
1104:
1105: caught = false;
1106: try {
1107: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
1108: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1109: "name", "description", arrayType, null, null, null);
1110: } catch (OpenDataException e) {
1111: caught = true;
1112: }
1113: if (caught == true)
1114: fail("Didn't expect OpenDataException for array type and no default value");
1115:
1116: caught = false;
1117: try {
1118: String[] itemNames = new String[] { "name1", "name2" };
1119: String[] itemDescriptions = new String[] { "desc1", "desc2" };
1120: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
1121: SimpleType.INTEGER };
1122: CompositeType rowType = new CompositeType("rowTypeName",
1123: "rowDescription", itemNames, itemDescriptions,
1124: itemTypes);
1125:
1126: String[] indexNames = new String[] { "name1", "name2" };
1127: TabularType tabularType = new TabularType("typeName",
1128: "description", rowType, indexNames);
1129: TabularDataSupport data = new TabularDataSupport(
1130: tabularType);
1131:
1132: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1133: "name", "description", tabularType, data, null,
1134: null);
1135: } catch (OpenDataException e) {
1136: caught = true;
1137: }
1138: if (caught == false)
1139: fail("Expected OpenDataException for tabular type and default value");
1140:
1141: caught = false;
1142: try {
1143: String[] itemNames = new String[] { "name1", "name2" };
1144: String[] itemDescriptions = new String[] { "desc1", "desc2" };
1145: OpenType[] itemTypes = new OpenType[] { SimpleType.STRING,
1146: SimpleType.INTEGER };
1147: CompositeType rowType = new CompositeType("rowTypeName",
1148: "rowDescription", itemNames, itemDescriptions,
1149: itemTypes);
1150:
1151: String[] indexNames = new String[] { "name1", "name2" };
1152: TabularType tabularType = new TabularType("typeName",
1153: "description", rowType, indexNames);
1154:
1155: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1156: "name", "description", tabularType, null, null,
1157: null);
1158: } catch (OpenDataException e) {
1159: caught = true;
1160: }
1161: if (caught == true)
1162: fail("Didn't expect OpenDataException for tabular type and null default value");
1163:
1164: caught = false;
1165: try {
1166: ArrayType arrayType = new ArrayType(1, SimpleType.STRING);
1167: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1168: "name", "description", arrayType, new String[] {
1169: "hello", "goodbye" }, null, null);
1170: } catch (OpenDataException e) {
1171: caught = true;
1172: }
1173: if (caught == false)
1174: fail("Expected OpenDataException for array type and default value");
1175:
1176: caught = false;
1177: try {
1178: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1179: "name", "description", SimpleType.STRING,
1180: new Integer(3), new Integer(4), new Integer(5));
1181: } catch (OpenDataException e) {
1182: caught = true;
1183: }
1184: if (caught == false)
1185: fail("Expected OpenDataException for default value less than minimum value");
1186:
1187: caught = false;
1188: try {
1189: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1190: "name", "description", SimpleType.INTEGER,
1191: new Integer(4), new Integer(4), new Integer(5));
1192: } catch (OpenDataException e) {
1193: caught = true;
1194: }
1195: if (caught == true)
1196: fail("Didn't expect OpenDataException for default value equal minimum value");
1197:
1198: caught = false;
1199: try {
1200: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1201: "name", "description", SimpleType.INTEGER,
1202: new Integer(6), new Integer(4), new Integer(5));
1203: } catch (OpenDataException e) {
1204: caught = true;
1205: }
1206: if (caught == false)
1207: fail("Expected OpenDataException for default value greater than maximum value");
1208:
1209: caught = false;
1210: try {
1211: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1212: "name", "description", SimpleType.INTEGER,
1213: new Integer(5), new Integer(4), new Integer(5));
1214: } catch (OpenDataException e) {
1215: caught = true;
1216: }
1217: if (caught == true)
1218: fail("Didn't expect OpenDataException for default value equal maximum value");
1219:
1220: caught = false;
1221: try {
1222: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1223: "name", "description", SimpleType.INTEGER, null,
1224: new Integer(4), new Integer(3));
1225: } catch (OpenDataException e) {
1226: caught = true;
1227: }
1228: if (caught == false)
1229: fail("Expected OpenDataException for minimum greater than maximum value");
1230:
1231: caught = false;
1232: try {
1233: OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
1234: "name", "description", SimpleType.INTEGER, null,
1235: new Integer(4), new Integer(4));
1236: } catch (OpenDataException e) {
1237: caught = true;
1238: }
1239: if (caught == true)
1240: fail("Didn't expect OpenDataException for minimum equal maximum value");
1241: }
1242: }
|