|
1
4 package com.tctest.spring.aop;
5
6 import org.springframework.aop.framework.ProxyFactoryBean;
7
8 import com.tc.test.TCTestCase;
9 import com.tcspring.FastAopProxy;
10
11
12 public class FastAopProxy_Test extends TCTestCase {
14 IMessageWriter target = null;
15 ProxyFactoryBean proxyFactoryBean = null;
16
17 Object  cglibProxied = null;
18 Object cglibProxied2 = null;
19
20 Object jdkDynamicProxied = null;
21 Object jdkDynamicProxied2 = null;
22
23 FastAopProxy fastProxy = null;
24
25
26 public FastAopProxy_Test() {
27 disableAllUntil("2008-09-18"); }
29
30 public void setUp() {
31 target = new MessageWriter();
32
33 proxyFactoryBean = new ProxyFactoryBean();
34 proxyFactoryBean.setFrozen(false);
35 proxyFactoryBean.setOptimize(true);
36 proxyFactoryBean.setTarget(target);
37 proxyFactoryBean.addAdvice(new SimpleBeforeAdvice());
38
39 cglibProxied = proxyFactoryBean.getObject();
40
41 proxyFactoryBean.setInterfaces(new Class [] {IMessageWriter.class });
42 proxyFactoryBean.setOptimize(false);
43 jdkDynamicProxied = proxyFactoryBean.getObject();
44
45
47 proxyFactoryBean = new ProxyFactoryBean();
48 proxyFactoryBean.setFrozen(false);
49 proxyFactoryBean.setOptimize(true);
50 proxyFactoryBean.setTarget(target);
51 proxyFactoryBean.addAdvice(new SimpleBeforeAdvice());
52
53 cglibProxied2 = proxyFactoryBean.getObject();
54
55 proxyFactoryBean.setInterfaces(new Class [] {IMessageWriter.class });
56 proxyFactoryBean.setOptimize(false);
57
58 jdkDynamicProxied2 = proxyFactoryBean.getObject();
59
60
62 fastProxy = new FastAopProxy(proxyFactoryBean);
63 }
64
65 public void testClassLoader() throws Exception {
66 assertTrue(cglibProxied instanceof MessageWriter);
67
68 assertTrue(jdkDynamicProxied instanceof IMessageWriter);
69 assertFalse(jdkDynamicProxied instanceof MessageWriter);
70
71 Object fastProxied1 = fastProxy.getProxy();
72 Object fastProxied2 = fastProxy.getProxy(target.getClass().getClassLoader());
73 Object fastProxied3 = fastProxy.getProxy(new MyClassLoader(target.getClass().getClassLoader()));
74
75 assertTrue(fastProxied1 instanceof IMessageWriter);
76 assertFalse(fastProxied1 instanceof MessageWriter);
77
78 assertTrue(fastProxied2 instanceof IMessageWriter);
79 assertFalse(fastProxied2 instanceof MessageWriter);
80
81 assertTrue(fastProxied3 instanceof IMessageWriter);
82 assertFalse(fastProxied3 instanceof MessageWriter);
83 }
84
85 public void testEquality() throws Exception {
87 assertFalse(jdkDynamicProxied.equals(jdkDynamicProxied2));
88
89 assertFalse(cglibProxied.equals(cglibProxied2));
90
91 Object fastProxied1 = fastProxy.getProxy();
92 assertFalse(fastProxied1.equals(fastProxy.getProxy()));
93 }
94
95 public void testBeforeAdvice() throws Exception {
96 Logger.log = null;
97 String cglibProxiedRv = ((MessageWriter)cglibProxied).writeMessage();
98 String cglibProxiedLog = Logger.log;
99 assertEquals("World", cglibProxiedRv);
100 assertTrue(cglibProxiedLog.indexOf("*EMPTY*") > -1 );
101
102 Logger.log = null;
103 String jdkDynamicProxiedRv = ((IMessageWriter)cglibProxied).writeMessage();
104 String jdkDynamicProxiedLog = Logger.log;
105 assertEquals("World", jdkDynamicProxiedRv);
106 assertTrue(jdkDynamicProxiedLog.indexOf("*EMPTY*") > -1);
107
108 Object fastProxied = fastProxy.getProxy();
109 Logger.log = null;
110 String fastProxiedRv = ((IMessageWriter)fastProxied).writeMessage();
111 String fastProxiedLog = Logger.log;
112 assertEquals("World", fastProxiedRv);
113 assertTrue("This is what we get: " + fastProxiedLog, fastProxiedLog.indexOf("*EMPTY*") > -1);
114 }
115
116 public void testNested1() {
117 ProxyFactoryBean factory = new ProxyFactoryBean();
118 factory.setFrozen(false);
119 factory.setOptimize(true);
120 factory.setInterfaces(new Class []{IMessageWriter.class});
121 factory.setTarget(cglibProxied);
122
123 FastAopProxy proxy = new FastAopProxy(factory);
124
125 Object nested = proxy.getProxy();
126
127 Logger.log = null;
128 String nestedRv = ((IMessageWriter)nested).writeMessage();
129 String nestedLog = Logger.log;
130 assertEquals("World", nestedRv);
131 }
132
133 public void testNested2() {
134 ProxyFactoryBean factory = new ProxyFactoryBean();
135 factory.setFrozen(false);
136 factory.setOptimize(true);
137 factory.setInterfaces(new Class []{IMessageWriter.class});
138 factory.setTarget(this.jdkDynamicProxied);
139
140 FastAopProxy proxy = new FastAopProxy(factory);
141
142 Object nested = proxy.getProxy();
143
144 Logger.log = null;
145 String nestedRv = ((IMessageWriter)nested).writeMessage();
146 String nestedLog = Logger.log;
147 assertEquals("World", nestedRv);
148 }
149
150 public void testNested3() {
151 ProxyFactoryBean factory = new ProxyFactoryBean();
152 factory.setFrozen(false);
153 factory.setOptimize(true);
154 factory.setInterfaces(new Class []{IMessageWriter.class});
155 factory.setTarget(fastProxy.getProxy());
156
157 FastAopProxy proxy = new FastAopProxy(factory);
158
159 Object nested = proxy.getProxy();
160
161 Logger.log = null;
162 String nestedRv = ((IMessageWriter)nested).writeMessage();
163 String nestedLog = Logger.log;
164 assertEquals("World", nestedRv);
165 }
166
167 public void testNullConfig() {
168 try {
169 this.fastProxy = new FastAopProxy(null);
170 fastProxy.getProxy();
171 fail("Shouldn't allow null interceptors");
172 } catch (Exception ex) {
173 ex.printStackTrace();
174 }
175 }
176
177 public void testNoTarget() {
178 proxyFactoryBean = new ProxyFactoryBean();
179 proxyFactoryBean.setFrozen(false);
180 proxyFactoryBean.setOptimize(true);
181 proxyFactoryBean.setInterfaces(new Class [] {IMessageWriter.class});
182 proxyFactoryBean.addAdvice(new SimpleBeforeAdvice());
183
184 try {
185 this.fastProxy = new FastAopProxy(proxyFactoryBean);
186 fastProxy.getProxy();
187 fail("Shouldn't allow null interceptors");
188 } catch (Exception ex) {
189 ex.printStackTrace();
190 }
191 }
192
193
194 private static class MyClassLoader extends ClassLoader {
195 public MyClassLoader(ClassLoader parent) {
196 super(parent);
197 }
198 }
199
200 }
201 |
Popular Tags |
Java API By Example, From Geeks To Geeks.