0001: /*
0002: * Copyright 2001-2006 Stephen Colebourne
0003: *
0004: * Licensed under the Apache License, Version 2.0 (the "License");
0005: * you may not use this file except in compliance with the License.
0006: * You may obtain a copy of the License at
0007: *
0008: * http://www.apache.org/licenses/LICENSE-2.0
0009: *
0010: * Unless required by applicable law or agreed to in writing, software
0011: * distributed under the License is distributed on an "AS IS" BASIS,
0012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0013: * See the License for the specific language governing permissions and
0014: * limitations under the License.
0015: */
0016: package org.joda.time.convert;
0017:
0018: import java.io.Serializable;
0019: import java.lang.reflect.Constructor;
0020: import java.lang.reflect.Field;
0021: import java.lang.reflect.Modifier;
0022: import java.security.AllPermission;
0023: import java.security.CodeSource;
0024: import java.security.Permission;
0025: import java.security.PermissionCollection;
0026: import java.security.Permissions;
0027: import java.security.Policy;
0028: import java.security.ProtectionDomain;
0029: import java.util.Calendar;
0030: import java.util.Date;
0031: import java.util.GregorianCalendar;
0032:
0033: import junit.framework.TestCase;
0034: import junit.framework.TestSuite;
0035:
0036: import org.joda.time.Chronology;
0037: import org.joda.time.DateTime;
0038: import org.joda.time.DateTimeZone;
0039: import org.joda.time.Duration;
0040: import org.joda.time.ReadablePartial;
0041: import org.joda.time.ReadablePeriod;
0042: import org.joda.time.Period;
0043: import org.joda.time.PeriodType;
0044: import org.joda.time.Interval;
0045: import org.joda.time.JodaTimePermission;
0046: import org.joda.time.ReadWritablePeriod;
0047: import org.joda.time.ReadWritableInterval;
0048: import org.joda.time.ReadableDateTime;
0049: import org.joda.time.ReadableDuration;
0050: import org.joda.time.ReadableInstant;
0051: import org.joda.time.ReadableInterval;
0052: import org.joda.time.TimeOfDay;
0053: import org.joda.time.format.DateTimeFormatter;
0054:
0055: /**
0056: * This class is a JUnit test for ConverterManager.
0057: *
0058: * @author Stephen Colebourne
0059: */
0060: public class TestConverterManager extends TestCase {
0061: private static final boolean OLD_JDK;
0062: static {
0063: String str = System.getProperty("java.version");
0064: boolean old = true;
0065: if (str.length() > 3
0066: && str.charAt(0) == '1'
0067: && str.charAt(1) == '.'
0068: && (str.charAt(2) == '4' || str.charAt(2) == '5' || str
0069: .charAt(2) == '6')) {
0070: old = false;
0071: }
0072: OLD_JDK = old;
0073: }
0074:
0075: private static final Policy RESTRICT;
0076: private static final Policy ALLOW;
0077: static {
0078: // don't call Policy.getPolicy()
0079: RESTRICT = new Policy() {
0080: public PermissionCollection getPermissions(
0081: CodeSource codesource) {
0082: Permissions p = new Permissions();
0083: p.add(new AllPermission()); // enable everything
0084: return p;
0085: }
0086:
0087: public void refresh() {
0088: }
0089:
0090: public boolean implies(ProtectionDomain domain,
0091: Permission permission) {
0092: if (permission instanceof JodaTimePermission) {
0093: return false;
0094: }
0095: return true;
0096: // return super.implies(domain, permission);
0097: }
0098: };
0099: ALLOW = new Policy() {
0100: public PermissionCollection getPermissions(
0101: CodeSource codesource) {
0102: Permissions p = new Permissions();
0103: p.add(new AllPermission()); // enable everything
0104: return p;
0105: }
0106:
0107: public void refresh() {
0108: }
0109: };
0110: }
0111:
0112: public static void main(String[] args) {
0113: junit.textui.TestRunner.run(suite());
0114: }
0115:
0116: public static TestSuite suite() {
0117: return new TestSuite(TestConverterManager.class);
0118: }
0119:
0120: public TestConverterManager(String name) {
0121: super (name);
0122: }
0123:
0124: //-----------------------------------------------------------------------
0125: public void testSingleton() throws Exception {
0126: Class cls = ConverterManager.class;
0127: assertEquals(true, Modifier.isPublic(cls.getModifiers()));
0128:
0129: Constructor con = cls.getDeclaredConstructor((Class[]) null);
0130: assertEquals(1, cls.getDeclaredConstructors().length);
0131: assertEquals(true, Modifier.isProtected(con.getModifiers()));
0132:
0133: Field fld = cls.getDeclaredField("INSTANCE");
0134: assertEquals(true, Modifier.isPrivate(fld.getModifiers()));
0135: }
0136:
0137: //-----------------------------------------------------------------------
0138: public void testGetInstantConverter() {
0139: InstantConverter c = ConverterManager.getInstance()
0140: .getInstantConverter(new Long(0L));
0141: assertEquals(Long.class, c.getSupportedType());
0142:
0143: c = ConverterManager.getInstance().getInstantConverter(
0144: new DateTime());
0145: assertEquals(ReadableInstant.class, c.getSupportedType());
0146:
0147: c = ConverterManager.getInstance().getInstantConverter("");
0148: assertEquals(String.class, c.getSupportedType());
0149:
0150: c = ConverterManager.getInstance().getInstantConverter(
0151: new Date());
0152: assertEquals(Date.class, c.getSupportedType());
0153:
0154: c = ConverterManager.getInstance().getInstantConverter(
0155: new GregorianCalendar());
0156: assertEquals(Calendar.class, c.getSupportedType());
0157:
0158: c = ConverterManager.getInstance().getInstantConverter(null);
0159: assertEquals(null, c.getSupportedType());
0160:
0161: try {
0162: ConverterManager.getInstance().getInstantConverter(
0163: Boolean.TRUE);
0164: fail();
0165: } catch (IllegalArgumentException ex) {
0166: }
0167: }
0168:
0169: public void testGetInstantConverterRemovedNull() {
0170: try {
0171: ConverterManager.getInstance().removeInstantConverter(
0172: NullConverter.INSTANCE);
0173: try {
0174: ConverterManager.getInstance()
0175: .getInstantConverter(null);
0176: fail();
0177: } catch (IllegalArgumentException ex) {
0178: }
0179: } finally {
0180: ConverterManager.getInstance().addInstantConverter(
0181: NullConverter.INSTANCE);
0182: }
0183: assertEquals(6, ConverterManager.getInstance()
0184: .getInstantConverters().length);
0185: }
0186:
0187: public void testGetInstantConverterOKMultipleMatches() {
0188: InstantConverter c = new InstantConverter() {
0189: public long getInstantMillis(Object object,
0190: Chronology chrono) {
0191: return 0;
0192: }
0193:
0194: public Chronology getChronology(Object object,
0195: DateTimeZone zone) {
0196: return null;
0197: }
0198:
0199: public Chronology getChronology(Object object,
0200: Chronology chrono) {
0201: return null;
0202: }
0203:
0204: public Class getSupportedType() {
0205: return ReadableDateTime.class;
0206: }
0207: };
0208: try {
0209: ConverterManager.getInstance().addInstantConverter(c);
0210: InstantConverter ok = ConverterManager.getInstance()
0211: .getInstantConverter(new DateTime());
0212: // ReadableDateTime and ReadableInstant both match, but RI discarded as less specific
0213: assertEquals(ReadableDateTime.class, ok.getSupportedType());
0214: } finally {
0215: ConverterManager.getInstance().removeInstantConverter(c);
0216: }
0217: assertEquals(6, ConverterManager.getInstance()
0218: .getInstantConverters().length);
0219: }
0220:
0221: public void testGetInstantConverterBadMultipleMatches() {
0222: InstantConverter c = new InstantConverter() {
0223: public long getInstantMillis(Object object,
0224: Chronology chrono) {
0225: return 0;
0226: }
0227:
0228: public Chronology getChronology(Object object,
0229: DateTimeZone zone) {
0230: return null;
0231: }
0232:
0233: public Chronology getChronology(Object object,
0234: Chronology chrono) {
0235: return null;
0236: }
0237:
0238: public Class getSupportedType() {
0239: return Serializable.class;
0240: }
0241: };
0242: try {
0243: ConverterManager.getInstance().addInstantConverter(c);
0244: try {
0245: ConverterManager.getInstance().getInstantConverter(
0246: new DateTime());
0247: fail();
0248: } catch (IllegalStateException ex) {
0249: // Serializable and ReadableInstant both match, so cannot pick
0250: }
0251: } finally {
0252: ConverterManager.getInstance().removeInstantConverter(c);
0253: }
0254: assertEquals(6, ConverterManager.getInstance()
0255: .getInstantConverters().length);
0256: }
0257:
0258: //-----------------------------------------------------------------------
0259: public void testGetInstantConverters() {
0260: InstantConverter[] array = ConverterManager.getInstance()
0261: .getInstantConverters();
0262: assertEquals(6, array.length);
0263: }
0264:
0265: //-----------------------------------------------------------------------
0266: public void testAddInstantConverter1() {
0267: InstantConverter c = new InstantConverter() {
0268: public long getInstantMillis(Object object,
0269: Chronology chrono) {
0270: return 0;
0271: }
0272:
0273: public Chronology getChronology(Object object,
0274: DateTimeZone zone) {
0275: return null;
0276: }
0277:
0278: public Chronology getChronology(Object object,
0279: Chronology chrono) {
0280: return null;
0281: }
0282:
0283: public Class getSupportedType() {
0284: return Boolean.class;
0285: }
0286: };
0287: try {
0288: InstantConverter removed = ConverterManager.getInstance()
0289: .addInstantConverter(c);
0290: assertEquals(null, removed);
0291: assertEquals(Boolean.class, ConverterManager.getInstance()
0292: .getInstantConverter(Boolean.TRUE)
0293: .getSupportedType());
0294: assertEquals(7, ConverterManager.getInstance()
0295: .getInstantConverters().length);
0296: } finally {
0297: ConverterManager.getInstance().removeInstantConverter(c);
0298: }
0299: assertEquals(6, ConverterManager.getInstance()
0300: .getInstantConverters().length);
0301: }
0302:
0303: public void testAddInstantConverter2() {
0304: InstantConverter c = new InstantConverter() {
0305: public long getInstantMillis(Object object,
0306: Chronology chrono) {
0307: return 0;
0308: }
0309:
0310: public Chronology getChronology(Object object,
0311: DateTimeZone zone) {
0312: return null;
0313: }
0314:
0315: public Chronology getChronology(Object object,
0316: Chronology chrono) {
0317: return null;
0318: }
0319:
0320: public Class getSupportedType() {
0321: return String.class;
0322: }
0323: };
0324: try {
0325: InstantConverter removed = ConverterManager.getInstance()
0326: .addInstantConverter(c);
0327: assertEquals(StringConverter.INSTANCE, removed);
0328: assertEquals(String.class, ConverterManager.getInstance()
0329: .getInstantConverter("").getSupportedType());
0330: assertEquals(6, ConverterManager.getInstance()
0331: .getInstantConverters().length);
0332: } finally {
0333: ConverterManager.getInstance().addInstantConverter(
0334: StringConverter.INSTANCE);
0335: }
0336: assertEquals(6, ConverterManager.getInstance()
0337: .getInstantConverters().length);
0338: }
0339:
0340: public void testAddInstantConverter3() {
0341: InstantConverter removed = ConverterManager.getInstance()
0342: .addInstantConverter(StringConverter.INSTANCE);
0343: assertEquals(null, removed);
0344: assertEquals(6, ConverterManager.getInstance()
0345: .getInstantConverters().length);
0346: }
0347:
0348: public void testAddInstantConverter4() {
0349: InstantConverter removed = ConverterManager.getInstance()
0350: .addInstantConverter(null);
0351: assertEquals(null, removed);
0352: assertEquals(6, ConverterManager.getInstance()
0353: .getInstantConverters().length);
0354: }
0355:
0356: public void testAddInstantConverterSecurity() {
0357: if (OLD_JDK) {
0358: return;
0359: }
0360: try {
0361: Policy.setPolicy(RESTRICT);
0362: System.setSecurityManager(new SecurityManager());
0363: ConverterManager.getInstance().addInstantConverter(
0364: StringConverter.INSTANCE);
0365: fail();
0366: } catch (SecurityException ex) {
0367: // ok
0368: } finally {
0369: System.setSecurityManager(null);
0370: Policy.setPolicy(ALLOW);
0371: }
0372: assertEquals(6, ConverterManager.getInstance()
0373: .getInstantConverters().length);
0374: }
0375:
0376: //-----------------------------------------------------------------------
0377: public void testRemoveInstantConverter1() {
0378: try {
0379: InstantConverter removed = ConverterManager.getInstance()
0380: .removeInstantConverter(StringConverter.INSTANCE);
0381: assertEquals(StringConverter.INSTANCE, removed);
0382: assertEquals(5, ConverterManager.getInstance()
0383: .getInstantConverters().length);
0384: } finally {
0385: ConverterManager.getInstance().addInstantConverter(
0386: StringConverter.INSTANCE);
0387: }
0388: assertEquals(6, ConverterManager.getInstance()
0389: .getInstantConverters().length);
0390: }
0391:
0392: public void testRemoveInstantConverter2() {
0393: InstantConverter c = new InstantConverter() {
0394: public long getInstantMillis(Object object,
0395: Chronology chrono) {
0396: return 0;
0397: }
0398:
0399: public Chronology getChronology(Object object,
0400: DateTimeZone zone) {
0401: return null;
0402: }
0403:
0404: public Chronology getChronology(Object object,
0405: Chronology chrono) {
0406: return null;
0407: }
0408:
0409: public Class getSupportedType() {
0410: return Boolean.class;
0411: }
0412: };
0413: InstantConverter removed = ConverterManager.getInstance()
0414: .removeInstantConverter(c);
0415: assertEquals(null, removed);
0416: assertEquals(6, ConverterManager.getInstance()
0417: .getInstantConverters().length);
0418: }
0419:
0420: public void testRemoveInstantConverter3() {
0421: InstantConverter removed = ConverterManager.getInstance()
0422: .removeInstantConverter(null);
0423: assertEquals(null, removed);
0424: assertEquals(6, ConverterManager.getInstance()
0425: .getInstantConverters().length);
0426: }
0427:
0428: public void testRemoveInstantConverterSecurity() {
0429: if (OLD_JDK) {
0430: return;
0431: }
0432: try {
0433: Policy.setPolicy(RESTRICT);
0434: System.setSecurityManager(new SecurityManager());
0435: ConverterManager.getInstance().removeInstantConverter(
0436: StringConverter.INSTANCE);
0437: fail();
0438: } catch (SecurityException ex) {
0439: // ok
0440: } finally {
0441: System.setSecurityManager(null);
0442: Policy.setPolicy(ALLOW);
0443: }
0444: assertEquals(6, ConverterManager.getInstance()
0445: .getInstantConverters().length);
0446: }
0447:
0448: //-----------------------------------------------------------------------
0449: //-----------------------------------------------------------------------
0450: private static final int PARTIAL_SIZE = 7;
0451:
0452: public void testGetPartialConverter() {
0453: PartialConverter c = ConverterManager.getInstance()
0454: .getPartialConverter(new Long(0L));
0455: assertEquals(Long.class, c.getSupportedType());
0456:
0457: c = ConverterManager.getInstance().getPartialConverter(
0458: new TimeOfDay());
0459: assertEquals(ReadablePartial.class, c.getSupportedType());
0460:
0461: c = ConverterManager.getInstance().getPartialConverter(
0462: new DateTime());
0463: assertEquals(ReadableInstant.class, c.getSupportedType());
0464:
0465: c = ConverterManager.getInstance().getPartialConverter("");
0466: assertEquals(String.class, c.getSupportedType());
0467:
0468: c = ConverterManager.getInstance().getPartialConverter(
0469: new Date());
0470: assertEquals(Date.class, c.getSupportedType());
0471:
0472: c = ConverterManager.getInstance().getPartialConverter(
0473: new GregorianCalendar());
0474: assertEquals(Calendar.class, c.getSupportedType());
0475:
0476: c = ConverterManager.getInstance().getPartialConverter(null);
0477: assertEquals(null, c.getSupportedType());
0478:
0479: try {
0480: ConverterManager.getInstance().getPartialConverter(
0481: Boolean.TRUE);
0482: fail();
0483: } catch (IllegalArgumentException ex) {
0484: }
0485: }
0486:
0487: public void testGetPartialConverterRemovedNull() {
0488: try {
0489: ConverterManager.getInstance().removePartialConverter(
0490: NullConverter.INSTANCE);
0491: try {
0492: ConverterManager.getInstance()
0493: .getPartialConverter(null);
0494: fail();
0495: } catch (IllegalArgumentException ex) {
0496: }
0497: } finally {
0498: ConverterManager.getInstance().addPartialConverter(
0499: NullConverter.INSTANCE);
0500: }
0501: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0502: .getPartialConverters().length);
0503: }
0504:
0505: public void testGetPartialConverterOKMultipleMatches() {
0506: PartialConverter c = new PartialConverter() {
0507: public int[] getPartialValues(ReadablePartial partial,
0508: Object object, Chronology chrono) {
0509: return null;
0510: }
0511:
0512: public int[] getPartialValues(ReadablePartial partial,
0513: Object object, Chronology chrono,
0514: DateTimeFormatter parser) {
0515: return null;
0516: }
0517:
0518: public Chronology getChronology(Object object,
0519: DateTimeZone zone) {
0520: return null;
0521: }
0522:
0523: public Chronology getChronology(Object object,
0524: Chronology chrono) {
0525: return null;
0526: }
0527:
0528: public Class getSupportedType() {
0529: return ReadableDateTime.class;
0530: }
0531: };
0532: try {
0533: ConverterManager.getInstance().addPartialConverter(c);
0534: PartialConverter ok = ConverterManager.getInstance()
0535: .getPartialConverter(new DateTime());
0536: // ReadableDateTime and ReadablePartial both match, but RI discarded as less specific
0537: assertEquals(ReadableDateTime.class, ok.getSupportedType());
0538: } finally {
0539: ConverterManager.getInstance().removePartialConverter(c);
0540: }
0541: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0542: .getPartialConverters().length);
0543: }
0544:
0545: public void testGetPartialConverterBadMultipleMatches() {
0546: PartialConverter c = new PartialConverter() {
0547: public int[] getPartialValues(ReadablePartial partial,
0548: Object object, Chronology chrono) {
0549: return null;
0550: }
0551:
0552: public int[] getPartialValues(ReadablePartial partial,
0553: Object object, Chronology chrono,
0554: DateTimeFormatter parser) {
0555: return null;
0556: }
0557:
0558: public Chronology getChronology(Object object,
0559: DateTimeZone zone) {
0560: return null;
0561: }
0562:
0563: public Chronology getChronology(Object object,
0564: Chronology chrono) {
0565: return null;
0566: }
0567:
0568: public Class getSupportedType() {
0569: return Serializable.class;
0570: }
0571: };
0572: try {
0573: ConverterManager.getInstance().addPartialConverter(c);
0574: try {
0575: ConverterManager.getInstance().getPartialConverter(
0576: new DateTime());
0577: fail();
0578: } catch (IllegalStateException ex) {
0579: // Serializable and ReadablePartial both match, so cannot pick
0580: }
0581: } finally {
0582: ConverterManager.getInstance().removePartialConverter(c);
0583: }
0584: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0585: .getPartialConverters().length);
0586: }
0587:
0588: //-----------------------------------------------------------------------
0589: public void testGetPartialConverters() {
0590: PartialConverter[] array = ConverterManager.getInstance()
0591: .getPartialConverters();
0592: assertEquals(PARTIAL_SIZE, array.length);
0593: }
0594:
0595: //-----------------------------------------------------------------------
0596: public void testAddPartialConverter1() {
0597: PartialConverter c = new PartialConverter() {
0598: public int[] getPartialValues(ReadablePartial partial,
0599: Object object, Chronology chrono) {
0600: return null;
0601: }
0602:
0603: public int[] getPartialValues(ReadablePartial partial,
0604: Object object, Chronology chrono,
0605: DateTimeFormatter parser) {
0606: return null;
0607: }
0608:
0609: public Chronology getChronology(Object object,
0610: DateTimeZone zone) {
0611: return null;
0612: }
0613:
0614: public Chronology getChronology(Object object,
0615: Chronology chrono) {
0616: return null;
0617: }
0618:
0619: public Class getSupportedType() {
0620: return Boolean.class;
0621: }
0622: };
0623: try {
0624: PartialConverter removed = ConverterManager.getInstance()
0625: .addPartialConverter(c);
0626: assertEquals(null, removed);
0627: assertEquals(Boolean.class, ConverterManager.getInstance()
0628: .getPartialConverter(Boolean.TRUE)
0629: .getSupportedType());
0630: assertEquals(PARTIAL_SIZE + 1, ConverterManager
0631: .getInstance().getPartialConverters().length);
0632: } finally {
0633: ConverterManager.getInstance().removePartialConverter(c);
0634: }
0635: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0636: .getPartialConverters().length);
0637: }
0638:
0639: public void testAddPartialConverter2() {
0640: PartialConverter c = new PartialConverter() {
0641: public int[] getPartialValues(ReadablePartial partial,
0642: Object object, Chronology chrono) {
0643: return null;
0644: }
0645:
0646: public int[] getPartialValues(ReadablePartial partial,
0647: Object object, Chronology chrono,
0648: DateTimeFormatter parser) {
0649: return null;
0650: }
0651:
0652: public Chronology getChronology(Object object,
0653: DateTimeZone zone) {
0654: return null;
0655: }
0656:
0657: public Chronology getChronology(Object object,
0658: Chronology chrono) {
0659: return null;
0660: }
0661:
0662: public Class getSupportedType() {
0663: return String.class;
0664: }
0665: };
0666: try {
0667: PartialConverter removed = ConverterManager.getInstance()
0668: .addPartialConverter(c);
0669: assertEquals(StringConverter.INSTANCE, removed);
0670: assertEquals(String.class, ConverterManager.getInstance()
0671: .getPartialConverter("").getSupportedType());
0672: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0673: .getPartialConverters().length);
0674: } finally {
0675: ConverterManager.getInstance().addPartialConverter(
0676: StringConverter.INSTANCE);
0677: }
0678: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0679: .getPartialConverters().length);
0680: }
0681:
0682: public void testAddPartialConverter3() {
0683: PartialConverter removed = ConverterManager.getInstance()
0684: .addPartialConverter(StringConverter.INSTANCE);
0685: assertEquals(null, removed);
0686: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0687: .getPartialConverters().length);
0688: }
0689:
0690: public void testAddPartialConverter4() {
0691: PartialConverter removed = ConverterManager.getInstance()
0692: .addPartialConverter(null);
0693: assertEquals(null, removed);
0694: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0695: .getPartialConverters().length);
0696: }
0697:
0698: public void testAddPartialConverterSecurity() {
0699: if (OLD_JDK) {
0700: return;
0701: }
0702: try {
0703: Policy.setPolicy(RESTRICT);
0704: System.setSecurityManager(new SecurityManager());
0705: ConverterManager.getInstance().addPartialConverter(
0706: StringConverter.INSTANCE);
0707: fail();
0708: } catch (SecurityException ex) {
0709: // ok
0710: } finally {
0711: System.setSecurityManager(null);
0712: Policy.setPolicy(ALLOW);
0713: }
0714: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0715: .getPartialConverters().length);
0716: }
0717:
0718: //-----------------------------------------------------------------------
0719: public void testRemovePartialConverter1() {
0720: try {
0721: PartialConverter removed = ConverterManager.getInstance()
0722: .removePartialConverter(StringConverter.INSTANCE);
0723: assertEquals(StringConverter.INSTANCE, removed);
0724: assertEquals(PARTIAL_SIZE - 1, ConverterManager
0725: .getInstance().getPartialConverters().length);
0726: } finally {
0727: ConverterManager.getInstance().addPartialConverter(
0728: StringConverter.INSTANCE);
0729: }
0730: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0731: .getPartialConverters().length);
0732: }
0733:
0734: public void testRemovePartialConverter2() {
0735: PartialConverter c = new PartialConverter() {
0736: public int[] getPartialValues(ReadablePartial partial,
0737: Object object, Chronology chrono) {
0738: return null;
0739: }
0740:
0741: public int[] getPartialValues(ReadablePartial partial,
0742: Object object, Chronology chrono,
0743: DateTimeFormatter parser) {
0744: return null;
0745: }
0746:
0747: public Chronology getChronology(Object object,
0748: DateTimeZone zone) {
0749: return null;
0750: }
0751:
0752: public Chronology getChronology(Object object,
0753: Chronology chrono) {
0754: return null;
0755: }
0756:
0757: public Class getSupportedType() {
0758: return Boolean.class;
0759: }
0760: };
0761: PartialConverter removed = ConverterManager.getInstance()
0762: .removePartialConverter(c);
0763: assertEquals(null, removed);
0764: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0765: .getPartialConverters().length);
0766: }
0767:
0768: public void testRemovePartialConverter3() {
0769: PartialConverter removed = ConverterManager.getInstance()
0770: .removePartialConverter(null);
0771: assertEquals(null, removed);
0772: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0773: .getPartialConverters().length);
0774: }
0775:
0776: public void testRemovePartialConverterSecurity() {
0777: if (OLD_JDK) {
0778: return;
0779: }
0780: try {
0781: Policy.setPolicy(RESTRICT);
0782: System.setSecurityManager(new SecurityManager());
0783: ConverterManager.getInstance().removeInstantConverter(
0784: StringConverter.INSTANCE);
0785: fail();
0786: } catch (SecurityException ex) {
0787: // ok
0788: } finally {
0789: System.setSecurityManager(null);
0790: Policy.setPolicy(ALLOW);
0791: }
0792: assertEquals(PARTIAL_SIZE, ConverterManager.getInstance()
0793: .getPartialConverters().length);
0794: }
0795:
0796: //-----------------------------------------------------------------------
0797: //-----------------------------------------------------------------------
0798: private static int DURATION_SIZE = 5;
0799:
0800: public void testGetDurationConverter() {
0801: DurationConverter c = ConverterManager.getInstance()
0802: .getDurationConverter(new Long(0L));
0803: assertEquals(Long.class, c.getSupportedType());
0804:
0805: c = ConverterManager.getInstance().getDurationConverter(
0806: new Duration(123L));
0807: assertEquals(ReadableDuration.class, c.getSupportedType());
0808:
0809: c = ConverterManager.getInstance().getDurationConverter(
0810: new Interval(0L, 1000L));
0811: assertEquals(ReadableInterval.class, c.getSupportedType());
0812:
0813: c = ConverterManager.getInstance().getDurationConverter("");
0814: assertEquals(String.class, c.getSupportedType());
0815:
0816: c = ConverterManager.getInstance().getDurationConverter(null);
0817: assertEquals(null, c.getSupportedType());
0818:
0819: try {
0820: ConverterManager.getInstance().getDurationConverter(
0821: Boolean.TRUE);
0822: fail();
0823: } catch (IllegalArgumentException ex) {
0824: }
0825: }
0826:
0827: public void testGetDurationConverterRemovedNull() {
0828: try {
0829: ConverterManager.getInstance().removeDurationConverter(
0830: NullConverter.INSTANCE);
0831: try {
0832: ConverterManager.getInstance().getDurationConverter(
0833: null);
0834: fail();
0835: } catch (IllegalArgumentException ex) {
0836: }
0837: } finally {
0838: ConverterManager.getInstance().addDurationConverter(
0839: NullConverter.INSTANCE);
0840: }
0841: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0842: .getDurationConverters().length);
0843: }
0844:
0845: //-----------------------------------------------------------------------
0846: public void testGetDurationConverters() {
0847: DurationConverter[] array = ConverterManager.getInstance()
0848: .getDurationConverters();
0849: assertEquals(DURATION_SIZE, array.length);
0850: }
0851:
0852: //-----------------------------------------------------------------------
0853: public void testAddDurationConverter1() {
0854: DurationConverter c = new DurationConverter() {
0855: public long getDurationMillis(Object object) {
0856: return 0;
0857: }
0858:
0859: public Class getSupportedType() {
0860: return Boolean.class;
0861: }
0862: };
0863: try {
0864: DurationConverter removed = ConverterManager.getInstance()
0865: .addDurationConverter(c);
0866: assertEquals(null, removed);
0867: assertEquals(Boolean.class, ConverterManager.getInstance()
0868: .getDurationConverter(Boolean.TRUE)
0869: .getSupportedType());
0870: assertEquals(DURATION_SIZE + 1, ConverterManager
0871: .getInstance().getDurationConverters().length);
0872: } finally {
0873: ConverterManager.getInstance().removeDurationConverter(c);
0874: }
0875: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0876: .getDurationConverters().length);
0877: }
0878:
0879: public void testAddDurationConverter2() {
0880: DurationConverter c = new DurationConverter() {
0881: public long getDurationMillis(Object object) {
0882: return 0;
0883: }
0884:
0885: public Class getSupportedType() {
0886: return String.class;
0887: }
0888: };
0889: try {
0890: DurationConverter removed = ConverterManager.getInstance()
0891: .addDurationConverter(c);
0892: assertEquals(StringConverter.INSTANCE, removed);
0893: assertEquals(String.class, ConverterManager.getInstance()
0894: .getDurationConverter("").getSupportedType());
0895: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0896: .getDurationConverters().length);
0897: } finally {
0898: ConverterManager.getInstance().addDurationConverter(
0899: StringConverter.INSTANCE);
0900: }
0901: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0902: .getDurationConverters().length);
0903: }
0904:
0905: public void testAddDurationConverter3() {
0906: DurationConverter removed = ConverterManager.getInstance()
0907: .addDurationConverter(null);
0908: assertEquals(null, removed);
0909: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0910: .getDurationConverters().length);
0911: }
0912:
0913: public void testAddDurationConverterSecurity() {
0914: if (OLD_JDK) {
0915: return;
0916: }
0917: try {
0918: Policy.setPolicy(RESTRICT);
0919: System.setSecurityManager(new SecurityManager());
0920: ConverterManager.getInstance().addDurationConverter(
0921: StringConverter.INSTANCE);
0922: fail();
0923: } catch (SecurityException ex) {
0924: // ok
0925: } finally {
0926: System.setSecurityManager(null);
0927: Policy.setPolicy(ALLOW);
0928: }
0929: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0930: .getDurationConverters().length);
0931: }
0932:
0933: //-----------------------------------------------------------------------
0934: public void testRemoveDurationConverter1() {
0935: try {
0936: DurationConverter removed = ConverterManager.getInstance()
0937: .removeDurationConverter(StringConverter.INSTANCE);
0938: assertEquals(StringConverter.INSTANCE, removed);
0939: assertEquals(DURATION_SIZE - 1, ConverterManager
0940: .getInstance().getDurationConverters().length);
0941: } finally {
0942: ConverterManager.getInstance().addDurationConverter(
0943: StringConverter.INSTANCE);
0944: }
0945: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0946: .getDurationConverters().length);
0947: }
0948:
0949: public void testRemoveDurationConverter2() {
0950: DurationConverter c = new DurationConverter() {
0951: public long getDurationMillis(Object object) {
0952: return 0;
0953: }
0954:
0955: public Class getSupportedType() {
0956: return Boolean.class;
0957: }
0958: };
0959: DurationConverter removed = ConverterManager.getInstance()
0960: .removeDurationConverter(c);
0961: assertEquals(null, removed);
0962: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0963: .getDurationConverters().length);
0964: }
0965:
0966: public void testRemoveDurationConverter3() {
0967: DurationConverter removed = ConverterManager.getInstance()
0968: .removeDurationConverter(null);
0969: assertEquals(null, removed);
0970: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0971: .getDurationConverters().length);
0972: }
0973:
0974: public void testRemoveDurationConverterSecurity() {
0975: if (OLD_JDK) {
0976: return;
0977: }
0978: try {
0979: Policy.setPolicy(RESTRICT);
0980: System.setSecurityManager(new SecurityManager());
0981: ConverterManager.getInstance().removeDurationConverter(
0982: StringConverter.INSTANCE);
0983: fail();
0984: } catch (SecurityException ex) {
0985: // ok
0986: } finally {
0987: System.setSecurityManager(null);
0988: Policy.setPolicy(ALLOW);
0989: }
0990: assertEquals(DURATION_SIZE, ConverterManager.getInstance()
0991: .getDurationConverters().length);
0992: }
0993:
0994: //-----------------------------------------------------------------------
0995: //-----------------------------------------------------------------------
0996: private static int PERIOD_SIZE = 5;
0997:
0998: public void testGetPeriodConverter() {
0999: PeriodConverter c = ConverterManager.getInstance()
1000: .getPeriodConverter(new Period(1, 2, 3, 4, 5, 6, 7, 8));
1001: assertEquals(ReadablePeriod.class, c.getSupportedType());
1002:
1003: c = ConverterManager.getInstance().getPeriodConverter(
1004: new Duration(123L));
1005: assertEquals(ReadableDuration.class, c.getSupportedType());
1006:
1007: c = ConverterManager.getInstance().getPeriodConverter(
1008: new Interval(0L, 1000L));
1009: assertEquals(ReadableInterval.class, c.getSupportedType());
1010:
1011: c = ConverterManager.getInstance().getPeriodConverter("");
1012: assertEquals(String.class, c.getSupportedType());
1013:
1014: c = ConverterManager.getInstance().getPeriodConverter(null);
1015: assertEquals(null, c.getSupportedType());
1016:
1017: try {
1018: ConverterManager.getInstance().getPeriodConverter(
1019: Boolean.TRUE);
1020: fail();
1021: } catch (IllegalArgumentException ex) {
1022: }
1023: }
1024:
1025: public void testGetPeriodConverterRemovedNull() {
1026: try {
1027: ConverterManager.getInstance().removePeriodConverter(
1028: NullConverter.INSTANCE);
1029: try {
1030: ConverterManager.getInstance().getPeriodConverter(null);
1031: fail();
1032: } catch (IllegalArgumentException ex) {
1033: }
1034: } finally {
1035: ConverterManager.getInstance().addPeriodConverter(
1036: NullConverter.INSTANCE);
1037: }
1038: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1039: .getPeriodConverters().length);
1040: }
1041:
1042: //-----------------------------------------------------------------------
1043: public void testGetPeriodConverters() {
1044: PeriodConverter[] array = ConverterManager.getInstance()
1045: .getPeriodConverters();
1046: assertEquals(PERIOD_SIZE, array.length);
1047: }
1048:
1049: //-----------------------------------------------------------------------
1050: public void testAddPeriodConverter1() {
1051: PeriodConverter c = new PeriodConverter() {
1052: public void setInto(ReadWritablePeriod duration,
1053: Object object, Chronology c) {
1054: }
1055:
1056: public PeriodType getPeriodType(Object object) {
1057: return null;
1058: }
1059:
1060: public Class getSupportedType() {
1061: return Boolean.class;
1062: }
1063: };
1064: try {
1065: PeriodConverter removed = ConverterManager.getInstance()
1066: .addPeriodConverter(c);
1067: assertEquals(null, removed);
1068: assertEquals(Boolean.class, ConverterManager.getInstance()
1069: .getPeriodConverter(Boolean.TRUE)
1070: .getSupportedType());
1071: assertEquals(PERIOD_SIZE + 1, ConverterManager
1072: .getInstance().getPeriodConverters().length);
1073: } finally {
1074: ConverterManager.getInstance().removePeriodConverter(c);
1075: }
1076: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1077: .getPeriodConverters().length);
1078: }
1079:
1080: public void testAddPeriodConverter2() {
1081: PeriodConverter c = new PeriodConverter() {
1082: public void setInto(ReadWritablePeriod duration,
1083: Object object, Chronology c) {
1084: }
1085:
1086: public PeriodType getPeriodType(Object object) {
1087: return null;
1088: }
1089:
1090: public Class getSupportedType() {
1091: return String.class;
1092: }
1093: };
1094: try {
1095: PeriodConverter removed = ConverterManager.getInstance()
1096: .addPeriodConverter(c);
1097: assertEquals(StringConverter.INSTANCE, removed);
1098: assertEquals(String.class, ConverterManager.getInstance()
1099: .getPeriodConverter("").getSupportedType());
1100: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1101: .getPeriodConverters().length);
1102: } finally {
1103: ConverterManager.getInstance().addPeriodConverter(
1104: StringConverter.INSTANCE);
1105: }
1106: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1107: .getPeriodConverters().length);
1108: }
1109:
1110: public void testAddPeriodConverter3() {
1111: PeriodConverter removed = ConverterManager.getInstance()
1112: .addPeriodConverter(null);
1113: assertEquals(null, removed);
1114: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1115: .getPeriodConverters().length);
1116: }
1117:
1118: public void testAddPeriodConverterSecurity() {
1119: if (OLD_JDK) {
1120: return;
1121: }
1122: try {
1123: Policy.setPolicy(RESTRICT);
1124: System.setSecurityManager(new SecurityManager());
1125: ConverterManager.getInstance().addPeriodConverter(
1126: StringConverter.INSTANCE);
1127: fail();
1128: } catch (SecurityException ex) {
1129: // ok
1130: } finally {
1131: System.setSecurityManager(null);
1132: Policy.setPolicy(ALLOW);
1133: }
1134: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1135: .getPeriodConverters().length);
1136: }
1137:
1138: //-----------------------------------------------------------------------
1139: public void testRemovePeriodConverter1() {
1140: try {
1141: PeriodConverter removed = ConverterManager.getInstance()
1142: .removePeriodConverter(StringConverter.INSTANCE);
1143: assertEquals(StringConverter.INSTANCE, removed);
1144: assertEquals(PERIOD_SIZE - 1, ConverterManager
1145: .getInstance().getPeriodConverters().length);
1146: } finally {
1147: ConverterManager.getInstance().addPeriodConverter(
1148: StringConverter.INSTANCE);
1149: }
1150: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1151: .getPeriodConverters().length);
1152: }
1153:
1154: public void testRemovePeriodConverter2() {
1155: PeriodConverter c = new PeriodConverter() {
1156: public void setInto(ReadWritablePeriod duration,
1157: Object object, Chronology c) {
1158: }
1159:
1160: public PeriodType getPeriodType(Object object) {
1161: return null;
1162: }
1163:
1164: public Class getSupportedType() {
1165: return Boolean.class;
1166: }
1167: };
1168: PeriodConverter removed = ConverterManager.getInstance()
1169: .removePeriodConverter(c);
1170: assertEquals(null, removed);
1171: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1172: .getPeriodConverters().length);
1173: }
1174:
1175: public void testRemovePeriodConverter3() {
1176: PeriodConverter removed = ConverterManager.getInstance()
1177: .removePeriodConverter(null);
1178: assertEquals(null, removed);
1179: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1180: .getPeriodConverters().length);
1181: }
1182:
1183: public void testRemovePeriodConverterSecurity() {
1184: if (OLD_JDK) {
1185: return;
1186: }
1187: try {
1188: Policy.setPolicy(RESTRICT);
1189: System.setSecurityManager(new SecurityManager());
1190: ConverterManager.getInstance().removePeriodConverter(
1191: StringConverter.INSTANCE);
1192: fail();
1193: } catch (SecurityException ex) {
1194: // ok
1195: } finally {
1196: System.setSecurityManager(null);
1197: Policy.setPolicy(ALLOW);
1198: }
1199: assertEquals(PERIOD_SIZE, ConverterManager.getInstance()
1200: .getPeriodConverters().length);
1201: }
1202:
1203: //-----------------------------------------------------------------------
1204: //-----------------------------------------------------------------------
1205: private static int INTERVAL_SIZE = 3;
1206:
1207: public void testGetIntervalConverter() {
1208: IntervalConverter c = ConverterManager.getInstance()
1209: .getIntervalConverter(new Interval(0L, 1000L));
1210: assertEquals(ReadableInterval.class, c.getSupportedType());
1211:
1212: c = ConverterManager.getInstance().getIntervalConverter("");
1213: assertEquals(String.class, c.getSupportedType());
1214:
1215: c = ConverterManager.getInstance().getIntervalConverter(null);
1216: assertEquals(null, c.getSupportedType());
1217:
1218: try {
1219: ConverterManager.getInstance().getIntervalConverter(
1220: Boolean.TRUE);
1221: fail();
1222: } catch (IllegalArgumentException ex) {
1223: }
1224: try {
1225: ConverterManager.getInstance().getIntervalConverter(
1226: new Long(0));
1227: fail();
1228: } catch (IllegalArgumentException ex) {
1229: }
1230: }
1231:
1232: public void testGetIntervalConverterRemovedNull() {
1233: try {
1234: ConverterManager.getInstance().removeIntervalConverter(
1235: NullConverter.INSTANCE);
1236: try {
1237: ConverterManager.getInstance().getIntervalConverter(
1238: null);
1239: fail();
1240: } catch (IllegalArgumentException ex) {
1241: }
1242: } finally {
1243: ConverterManager.getInstance().addIntervalConverter(
1244: NullConverter.INSTANCE);
1245: }
1246: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1247: .getIntervalConverters().length);
1248: }
1249:
1250: //-----------------------------------------------------------------------
1251: public void testGetIntervalConverters() {
1252: IntervalConverter[] array = ConverterManager.getInstance()
1253: .getIntervalConverters();
1254: assertEquals(INTERVAL_SIZE, array.length);
1255: }
1256:
1257: //-----------------------------------------------------------------------
1258: public void testAddIntervalConverter1() {
1259: IntervalConverter c = new IntervalConverter() {
1260: public boolean isReadableInterval(Object object,
1261: Chronology chrono) {
1262: return false;
1263: }
1264:
1265: public void setInto(ReadWritableInterval interval,
1266: Object object, Chronology chrono) {
1267: }
1268:
1269: public Class getSupportedType() {
1270: return Boolean.class;
1271: }
1272: };
1273: try {
1274: IntervalConverter removed = ConverterManager.getInstance()
1275: .addIntervalConverter(c);
1276: assertEquals(null, removed);
1277: assertEquals(Boolean.class, ConverterManager.getInstance()
1278: .getIntervalConverter(Boolean.TRUE)
1279: .getSupportedType());
1280: assertEquals(INTERVAL_SIZE + 1, ConverterManager
1281: .getInstance().getIntervalConverters().length);
1282: } finally {
1283: ConverterManager.getInstance().removeIntervalConverter(c);
1284: }
1285: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1286: .getIntervalConverters().length);
1287: }
1288:
1289: public void testAddIntervalConverter2() {
1290: IntervalConverter c = new IntervalConverter() {
1291: public boolean isReadableInterval(Object object,
1292: Chronology chrono) {
1293: return false;
1294: }
1295:
1296: public void setInto(ReadWritableInterval interval,
1297: Object object, Chronology chrono) {
1298: }
1299:
1300: public Class getSupportedType() {
1301: return String.class;
1302: }
1303: };
1304: try {
1305: IntervalConverter removed = ConverterManager.getInstance()
1306: .addIntervalConverter(c);
1307: assertEquals(StringConverter.INSTANCE, removed);
1308: assertEquals(String.class, ConverterManager.getInstance()
1309: .getIntervalConverter("").getSupportedType());
1310: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1311: .getIntervalConverters().length);
1312: } finally {
1313: ConverterManager.getInstance().addIntervalConverter(
1314: StringConverter.INSTANCE);
1315: }
1316: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1317: .getIntervalConverters().length);
1318: }
1319:
1320: public void testAddIntervalConverter3() {
1321: IntervalConverter removed = ConverterManager.getInstance()
1322: .addIntervalConverter(null);
1323: assertEquals(null, removed);
1324: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1325: .getIntervalConverters().length);
1326: }
1327:
1328: public void testAddIntervalConverterSecurity() {
1329: if (OLD_JDK) {
1330: return;
1331: }
1332: try {
1333: Policy.setPolicy(RESTRICT);
1334: System.setSecurityManager(new SecurityManager());
1335: ConverterManager.getInstance().addIntervalConverter(
1336: StringConverter.INSTANCE);
1337: fail();
1338: } catch (SecurityException ex) {
1339: // ok
1340: } finally {
1341: System.setSecurityManager(null);
1342: Policy.setPolicy(ALLOW);
1343: }
1344: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1345: .getIntervalConverters().length);
1346: }
1347:
1348: //-----------------------------------------------------------------------
1349: public void testRemoveIntervalConverter1() {
1350: try {
1351: IntervalConverter removed = ConverterManager.getInstance()
1352: .removeIntervalConverter(StringConverter.INSTANCE);
1353: assertEquals(StringConverter.INSTANCE, removed);
1354: assertEquals(INTERVAL_SIZE - 1, ConverterManager
1355: .getInstance().getIntervalConverters().length);
1356: } finally {
1357: ConverterManager.getInstance().addIntervalConverter(
1358: StringConverter.INSTANCE);
1359: }
1360: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1361: .getIntervalConverters().length);
1362: }
1363:
1364: public void testRemoveIntervalConverter2() {
1365: IntervalConverter c = new IntervalConverter() {
1366: public boolean isReadableInterval(Object object,
1367: Chronology chrono) {
1368: return false;
1369: }
1370:
1371: public void setInto(ReadWritableInterval interval,
1372: Object object, Chronology chrono) {
1373: }
1374:
1375: public Class getSupportedType() {
1376: return Boolean.class;
1377: }
1378: };
1379: IntervalConverter removed = ConverterManager.getInstance()
1380: .removeIntervalConverter(c);
1381: assertEquals(null, removed);
1382: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1383: .getIntervalConverters().length);
1384: }
1385:
1386: public void testRemoveIntervalConverter3() {
1387: IntervalConverter removed = ConverterManager.getInstance()
1388: .removeIntervalConverter(null);
1389: assertEquals(null, removed);
1390: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1391: .getIntervalConverters().length);
1392: }
1393:
1394: public void testRemoveIntervalConverterSecurity() {
1395: if (OLD_JDK) {
1396: return;
1397: }
1398: try {
1399: Policy.setPolicy(RESTRICT);
1400: System.setSecurityManager(new SecurityManager());
1401: ConverterManager.getInstance().removeIntervalConverter(
1402: StringConverter.INSTANCE);
1403: fail();
1404: } catch (SecurityException ex) {
1405: // ok
1406: } finally {
1407: System.setSecurityManager(null);
1408: Policy.setPolicy(ALLOW);
1409: }
1410: assertEquals(INTERVAL_SIZE, ConverterManager.getInstance()
1411: .getIntervalConverters().length);
1412: }
1413:
1414: //-----------------------------------------------------------------------
1415: public void testToString() {
1416: assertEquals(
1417: "ConverterManager[6 instant,7 partial,5 duration,5 period,3 interval]",
1418: ConverterManager.getInstance().toString());
1419: }
1420:
1421: }
|