001 /*****************************************************************************
002 * Copyright (C) PicoContainer Organization. All rights reserved. *
003 * ------------------------------------------------------------------------- *
004 * The software in this package is published under the terms of the BSD *
005 * style license a copy of which has been included with this distribution in *
006 * the LICENSE.txt file. *
007 * *
008 * Original code by Paul Hammant *
009 *****************************************************************************/
010
011 package org.picocontainer.classname;
012
013 import static junit.framework.Assert.assertEquals;
014 import static org.junit.Assert.assertNotNull;
015 import static org.junit.Assert.assertTrue;
016
017 import java.util.List;
018 import java.util.Properties;
019
020 import org.jmock.Mockery;
021 import org.jmock.integration.junit4.JMock;
022 import org.jmock.integration.junit4.JUnit4Mockery;
023 import org.junit.Test;
024 import org.junit.runner.RunWith;
025 import org.picocontainer.Characteristics;
026 import org.picocontainer.DefaultPicoContainer;
027 import org.picocontainer.MutablePicoContainer;
028 import org.picocontainer.PicoClassNotFoundException;
029 import org.picocontainer.PicoCompositionException;
030 import org.picocontainer.PicoContainer;
031 import org.picocontainer.behaviors.Caching;
032 import org.picocontainer.monitors.ConsoleComponentMonitor;
033 import org.picocontainer.tck.AbstractPicoContainerTest;
034
035 /**
036 * @author Paul Hammant
037 */
038 @RunWith(JMock.class)
039 public class DefaultClassLoadingPicoContainerTestCase extends AbstractPicoContainerTest {
040
041 private Mockery context = new JUnit4Mockery();
042
043
044 protected MutablePicoContainer createPicoContainer(PicoContainer parent) {
045 return new DefaultClassLoadingPicoContainer(this.getClass().getClassLoader(), new DefaultPicoContainer(new Caching(), parent));
046 }
047
048 protected Properties[] getProperties() {
049 return new Properties[] { Characteristics.NONE};
050 }
051
052 @Test public void testNamedChildContainerIsAccessible() {
053 StringBuffer sb = new StringBuffer();
054 final ClassLoadingPicoContainer parent = (ClassLoadingPicoContainer) createPicoContainer(null);
055 parent.addComponent(sb);
056 final ClassLoadingPicoContainer child = (ClassLoadingPicoContainer) parent.makeChildContainer("foo");
057 child.addComponent(LifeCycleMonitoring.class,LifeCycleMonitoring.class);
058 LifeCycleMonitoring o = (LifeCycleMonitoring) parent.getComponent((Object)("foo/*" + LifeCycleMonitoring.class.getName()));
059 assertNotNull(o);
060 }
061
062 @Test public void testNamedChildContainerIsAccessibleForStringKeys() {
063 StringBuffer sb = new StringBuffer();
064 final ClassLoadingPicoContainer parent = (ClassLoadingPicoContainer) createPicoContainer(null);
065 parent.addComponent(sb);
066 final MutablePicoContainer child = parent.makeChildContainer("foo");
067 child.addComponent("lcm",LifeCycleMonitoring.class);
068 Object o = parent.getComponent("foo/lcm");
069 assertNotNull(o);
070 assertTrue(sb.toString().indexOf("-instantiated") != -1);
071 }
072
073 @Test public void testNamedChildContainerIsAccessibleForClassKeys() {
074 StringBuffer sb = new StringBuffer();
075 final ClassLoadingPicoContainer parent = (ClassLoadingPicoContainer) createPicoContainer(null);
076 parent.addComponent(sb);
077 final MutablePicoContainer child = parent.makeChildContainer("foo");
078 child.addComponent(LifeCycleMonitoring.class,LifeCycleMonitoring.class);
079 Object o = parent.getComponent("foo/*" + LifeCycleMonitoring.class.getName());
080 assertNotNull(o);
081 assertTrue(sb.toString().indexOf("-instantiated") != -1);
082 }
083
084 @Test public void testMakeRemoveChildContainer() {
085 final ClassLoadingPicoContainer parent = (ClassLoadingPicoContainer) createPicoContainer(null);
086 parent.addComponent("java.lang.String", "This is a test");
087 MutablePicoContainer pico = parent.makeChildContainer();
088 // Verify they are indeed wired together.
089 assertNotNull(pico.getComponent("java.lang.String"));
090 boolean result = parent.removeChildContainer(pico);
091 assertTrue(result);
092 }
093
094 // test methods inherited. This container is otherwise fully compliant.
095 @Test public void testAcceptImplementsBreadthFirstStrategy() {
096 super.testAcceptImplementsBreadthFirstStrategy();
097 }
098
099 @Test(expected=IllegalStateException.class)
100 public void testSwapComponentMonitorWithNoComponentMonitorStrategyDelegateThrowsIllegalStateException() {
101 MutablePicoContainer delegate = context.mock(MutablePicoContainer.class);
102 //Delegate it twice for effect.
103 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer(new DefaultClassLoadingPicoContainer(delegate));
104 pico.changeMonitor(new ConsoleComponentMonitor());
105 }
106
107 @Test(expected=IllegalStateException.class)
108 public void testCurrentMonitorWithNoComponentMonitorStrategyDelegateThrowsIllegalStateException() {
109 Mockery context = new JUnit4Mockery();
110 MutablePicoContainer delegate = context.mock(MutablePicoContainer.class);
111 //Delegate it twice for effect.
112 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer(new DefaultClassLoadingPicoContainer(delegate));
113 pico.currentMonitor();
114 }
115
116 protected void addContainers(List expectedList) {
117 expectedList.add(DefaultClassLoadingPicoContainer.class);
118 expectedList.add(DefaultPicoContainer.class);
119 }
120
121
122 protected void addDefaultComponentFactories(List expectedList) {
123 expectedList.add(Caching.class);
124 }
125
126 @Test()
127 public void visitingClassesSiblingToAClassWithRegexSubsetWorksWithRecursive() {
128
129 final StringBuilder sb = new StringBuilder();
130 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer();
131 int found = pico.visit(new ClassName("org.picocontainer.DefaultPicoContainer"), ".*Container\\.class", true, new DefaultClassLoadingPicoContainer.ClassVisitor() {
132 public void classFound(Class clazz) {
133 sb.append(clazz.getName()).append("\n");
134 }
135 });
136 assertEquals("org.picocontainer.classname.ClassLoadingPicoContainer\n" +
137 "org.picocontainer.classname.DefaultClassLoadingPicoContainer$AsPropertiesPicoContainer\n" +
138 "org.picocontainer.classname.DefaultClassLoadingPicoContainer\n" +
139 "org.picocontainer.containers.AbstractDelegatingMutablePicoContainer\n" +
140 "org.picocontainer.containers.AbstractDelegatingPicoContainer\n" +
141 "org.picocontainer.containers.CommandLineArgumentsPicoContainer\n" +
142 "org.picocontainer.containers.CommandLinePicoContainer\n" +
143 "org.picocontainer.containers.CompositePicoContainer\n" +
144 "org.picocontainer.containers.EmptyPicoContainer\n" +
145 "org.picocontainer.containers.ImmutablePicoContainer\n" +
146 "org.picocontainer.containers.PropertiesPicoContainer\n" +
147 "org.picocontainer.containers.SystemPropertiesPicoContainer\n" +
148 "org.picocontainer.containers.TieringPicoContainer\n" +
149 "org.picocontainer.containers.TransientPicoContainer\n" +
150 "org.picocontainer.DefaultPicoContainer$AsPropertiesPicoContainer\n" +
151 "org.picocontainer.DefaultPicoContainer\n" +
152 "org.picocontainer.MutablePicoContainer\n" +
153 "org.picocontainer.PicoContainer\n",
154 sb.toString());
155 assertEquals(18, found);
156 }
157
158 @Test()
159 public void visitingClassesSiblingToAClassWithRegexSubsetWorksWithoutRecursive() {
160
161 final StringBuilder sb = new StringBuilder();
162 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer();
163 int found = pico.visit(new ClassName("org.picocontainer.DefaultPicoContainer"), ".*Container\\.class", false, new DefaultClassLoadingPicoContainer.ClassVisitor() {
164 public void classFound(Class clazz) {
165 sb.append(clazz.getName()).append("\n");
166 }
167 });
168 assertEquals("org.picocontainer.DefaultPicoContainer$AsPropertiesPicoContainer\n" +
169 "org.picocontainer.DefaultPicoContainer\n" +
170 "org.picocontainer.MutablePicoContainer\n" +
171 "org.picocontainer.PicoContainer\n",
172 sb.toString());
173 assertEquals(4, found);
174 }
175
176 @Test(expected = PicoClassNotFoundException.class)
177 public void visitingFailsIfBogusClass() {
178
179 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer();
180 pico.visit(new ClassName("org.picocontainer.BlahBlah"), ".*Container\\.class", false, new DefaultClassLoadingPicoContainer.ClassVisitor() {
181 public void classFound(Class clazz) {
182 }
183 });
184 }
185
186 @Test(expected = PicoCompositionException.class)
187 public void visitingFailsIfJDKClass() {
188 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer();
189 pico.visit(new ClassName("java.util.ArrayList"), ".*Container\\.class", false, new DefaultClassLoadingPicoContainer.ClassVisitor() {
190 public void classFound(Class clazz) {
191 }
192 });
193 }
194
195 @Test
196 public void visitingPassesIfClassInAJar() {
197
198 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer();
199 final StringBuilder sb = new StringBuilder();
200 int found = pico.visit(new ClassName("com.thoughtworks.xstream.XStream"), ".*m\\.class", false, new DefaultClassLoadingPicoContainer.ClassVisitor() {
201 public void classFound(Class clazz) {
202 sb.append(clazz.getName()).append("\n");
203 }
204 });
205 assertEquals("com.thoughtworks.xstream.XStream\n",
206 sb.toString());
207 assertEquals(1, found);
208 }
209
210 @Test
211 public void visitingPassesIfClassInAJarRecursively() {
212
213 DefaultClassLoadingPicoContainer pico = new DefaultClassLoadingPicoContainer();
214 final StringBuilder sb = new StringBuilder();
215 int found = pico.visit(new ClassName("com.thoughtworks.xstream.XStream"), ".*m\\.class", true, new DefaultClassLoadingPicoContainer.ClassVisitor() {
216 public void classFound(Class clazz) {
217 sb.append(clazz.getName()).append("\n");
218 }
219 });
220 assertEquals("com.thoughtworks.xstream.io.xml.xppdom.Xpp3Dom\n" +
221 "com.thoughtworks.xstream.core.util.PrioritizedList$PrioritizedItem\n" +
222 "com.thoughtworks.xstream.core.util.CustomObjectInputStream\n" +
223 "com.thoughtworks.xstream.core.util.CustomObjectOutputStream\n" +
224 "com.thoughtworks.xstream.XStream\n",
225 sb.toString());
226 assertEquals(5, found);
227 }
228
229
230
231 }