wamblee.org Git - utils/blob - system/general/src/test/java/org/wamblee/system/core/DefaultInterfaceDescriptorTest.java

   1 /*
   2  * Copyright 2007 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.wamblee.system.core;
  17
  18 import junit.framework.TestCase;
  19
  20 import org.wamblee.system.core.DefaultProvidedInterface;
  21 import org.wamblee.system.core.DefaultRequiredInterface;
  22 import org.wamblee.system.core.ProvidedInterface;
  23 import org.wamblee.system.core.RequiredInterface;
  24
  25 import java.io.Serializable;
  26
  27
  28 /**
  29  * DOCUMENT ME!
  30  *
  31  * @author $author$
  32  * @version $Revision$
  33   */
  34 public class DefaultInterfaceDescriptorTest extends TestCase {
  35     /**
  36      * DOCUMENT ME!
  37      */
  38     public void testOneRequiredOneProvidedMatch() {
  39         ProvidedInterface provided = new DefaultProvidedInterface("name",
  40                 String.class);
  41         RequiredInterface required = new DefaultRequiredInterface("name",
  42                 String.class);
  43         assertTrue(required.implementedBy(provided));
  44     }
  45
  46     /**
  47      * DOCUMENT ME!
  48      */
  49     public void testOneRequiredOneProvidedMatchSubClass() {
  50         ProvidedInterface provided = new DefaultProvidedInterface("name",
  51                 Integer.class);
  52         RequiredInterface required = new DefaultRequiredInterface("name",
  53                 Number.class);
  54         assertTrue(required.implementedBy(provided));
  55     }
  56
  57     /**
  58      * DOCUMENT ME!
  59      */
  60     public void testOneRequiredOneProvidedNoMatch() {
  61         ProvidedInterface provided = new DefaultProvidedInterface("name",
  62                 String.class);
  63         RequiredInterface required = new DefaultRequiredInterface("name",
  64                 Number.class);
  65         assertFalse(required.implementedBy(provided));
  66     }
  67
  68     /**
  69      * DOCUMENT ME!
  70      */
  71     public void testOneRequiredMultipleProvidedMatch() {
  72         ProvidedInterface provided = new DefaultProvidedInterface("name",
  73                 new Class[] { String.class, Integer.class });
  74         RequiredInterface required = new DefaultRequiredInterface("name",
  75                 String.class);
  76         assertTrue(required.implementedBy(provided));
  77     }
  78
  79     /**
  80      * DOCUMENT ME!
  81      */
  82     public void testMultipleRequiredOneProvidedMatch() {
  83         ProvidedInterface provided = new DefaultProvidedInterface("name",
  84                 MyMultiple.class);
  85         RequiredInterface required = new DefaultRequiredInterface("name",
  86                 new Class[] { Runnable.class, Serializable.class });
  87         assertTrue(required.implementedBy(provided));
  88     }
  89
  90     /**
  91      * DOCUMENT ME!
  92      */
  93     public void testMultipleRequiredOneProvidedNoMatch() {
  94         ProvidedInterface provided = new DefaultProvidedInterface("name",
  95                 MyMultiple.class);
  96         RequiredInterface required = new DefaultRequiredInterface("name",
  97                 new Class[] { String.class, Runnable.class });
  98         assertFalse(required.implementedBy(provided));
  99     }
 100
 101     /**
 102      * DOCUMENT ME!
 103      */
 104     public void testMultipleRequiredMultipleProvidedMatch() {
 105         ProvidedInterface provided = new DefaultProvidedInterface("name",
 106                 new Class[] { Runnable.class, Serializable.class, String.class });
 107         RequiredInterface required = new DefaultRequiredInterface("name",
 108                 new Class[] { Runnable.class, Serializable.class });
 109         assertTrue(required.implementedBy(provided));
 110     }
 111
 112     /**
 113      * DOCUMENT ME!
 114      */
 115     public void testPrimitiveAndWrapperType() {
 116         RequiredInterface req1  = new DefaultRequiredInterface("req1", int.class);
 117         RequiredInterface req2  = new DefaultRequiredInterface("req1",
 118                 Integer.class);
 119         ProvidedInterface prov1 = new DefaultProvidedInterface("prov1",
 120                 int.class);
 121         ProvidedInterface prov2 = new DefaultProvidedInterface("prov2",
 122                 Integer.class);
 123         assertTrue(req1.implementedBy(prov1));
 124         assertTrue(req2.implementedBy(prov1));
 125         assertTrue(req1.implementedBy(prov2));
 126         assertTrue(req2.implementedBy(prov2));
 127     }
 128
 129     private static class MyMultiple implements Runnable, Serializable {
 130         @Override
 131         public void run() {
 132             // Empty
 133         }
 134     }
 135 }