MentaContainer

Rev

Rev 92 | Rev 97 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 92 Rev 93
1
package org.mentacontainer.impl;
1
package org.mentacontainer.impl;
2
2
3
import junit.framework.Assert;
3
import junit.framework.Assert;
4
4
5
import org.junit.Test;
5
import org.junit.Test;
6
import org.mentacontainer.Container;
6
import org.mentacontainer.Container;
7
import org.mentacontainer.Factory;
7
import org.mentacontainer.Factory;
8
8
9
public class ClassFactoryTest {
9
public class ClassFactoryTest {
10
       
10
       
11
        private static class User {
11
        private static class User {
12
               
12
               
13
                private String username;
13
                private String username;
14
               
14
               
15
                public User() { }
15
                public User() { }
16
               
16
               
17
                public User(String username) {
17
                public User(String username) {
18
                        this.username = username;
18
                        this.username = username;
19
                }
19
                }
20
               
20
               
21
                public String getUsername() {
21
                public String getUsername() {
22
                        return username;
22
                        return username;
23
                }
23
                }
24
               
24
               
25
                public void setUsername(String username) {
25
                public void setUsername(String username) {
26
                        this.username = username;
26
                        this.username = username;
27
                }
27
                }
28
        }
28
        }
29
       
29
       
30
        @Test
30
        @Test
31
        public void testFactory() {
31
        public void testFactory() {
32
               
32
               
33
                Factory c1 = new ClassFactory(User.class).addInitValue("saoj");
-
 
-
 
33
                Container container = new MentaContainer();
34
               
34
               
35
                Factory c2 = new ClassFactory(User.class).addPropertyValue("username", "soliveira");
-
 
-
 
35
                Factory c1 = new ClassFactory(container, User.class).addInitValue("saoj");
-
 
36
               
-
 
37
                Factory c2 = new ClassFactory(container, User.class).addPropertyValue("username", "soliveira");
36
               
38
               
37
                User u1 = c1.getInstance();
39
                User u1 = c1.getInstance();
38
               
40
               
39
                User u2 = c2.getInstance();
41
                User u2 = c2.getInstance();
40
               
42
               
41
                Assert.assertTrue(u1 != u2);
43
                Assert.assertTrue(u1 != u2);
42
               
44
               
43
                Assert.assertTrue(!u1.getUsername().equals(u2.getUsername()));
45
                Assert.assertTrue(!u1.getUsername().equals(u2.getUsername()));
44
        }
46
        }
45
       
47
       
46
        private static class TestObj1 {
48
        private static class TestObj1 {
47
               
49
               
48
                String s;
50
                String s;
49
                int i;
51
                int i;
50
                long l;
52
                long l;
51
                User u;
53
                User u;
52
               
54
               
53
                public TestObj1(String s, int i, long l, User u) {
55
                public TestObj1(String s, int i, long l, User u) {
54
                        this.s = s;
56
                        this.s = s;
55
                        this.i = i;
57
                        this.i = i;
56
                        this.l = l;
58
                        this.l = l;
57
                        this.u = u;
59
                        this.u = u;
58
                }
60
                }
59
        }
61
        }
60
       
62
       
61
        @Test
63
        @Test
62
        public void testDependable1() {
64
        public void testDependable1() {
63
               
65
               
64
                Container c = new MentaContainer();
66
                Container c = new MentaContainer();
65
               
67
               
66
                c.ioc("myString", String.class).addInitValue("hello");
68
                c.ioc("myString", String.class).addInitValue("hello");
67
       
69
       
68
                Factory c1 = new ClassFactory(c, TestObj1.class).addInitDependency("myString").addInitValue(20).addInitValue(30000L)
70
                Factory c1 = new ClassFactory(c, TestObj1.class).addInitDependency("myString").addInitValue(20).addInitValue(30000L)
69
                                .addInitValue(new User("saoj"));
71
                                .addInitValue(new User("saoj"));
70
               
72
               
71
                TestObj1 o = c1.getInstance();
73
                TestObj1 o = c1.getInstance();
72
               
74
               
73
                Assert.assertEquals("hello", o.s);
75
                Assert.assertEquals("hello", o.s);
74
                Assert.assertEquals(20, o.i);
76
                Assert.assertEquals(20, o.i);
75
                Assert.assertEquals(30000L, o.l);
77
                Assert.assertEquals(30000L, o.l);
76
                Assert.assertEquals("saoj", o.u.getUsername());
78
                Assert.assertEquals("saoj", o.u.getUsername());
77
        }
79
        }
78
       
80
       
79
        private static class TestObj1_1 {
81
        private static class TestObj1_1 {
80
               
82
               
81
                String s;
83
                String s;
82
                int i;
84
                int i;
83
               
85
               
84
                public TestObj1_1() { }
86
                public TestObj1_1() { }
85
               
87
               
86
                public void setS(String s) { this.s = s; }
88
                public void setS(String s) { this.s = s; }
87
                public void setI(int i) { this.i = i; }
89
                public void setI(int i) { this.i = i; }
88
        }
90
        }
89
91
90
        @Test
92
        @Test
91
        public void testDependable2() {
93
        public void testDependable2() {
92
               
94
               
93
                Container c = new MentaContainer();
95
                Container c = new MentaContainer();
94
               
96
               
95
                c.ioc("myString", String.class).addInitValue("hello");
97
                c.ioc("myString", String.class).addInitValue("hello");
96
       
98
       
97
                Factory c1 = new ClassFactory(c, TestObj1_1.class).addPropertyDependency("s", "myString").addPropertyValue("i", 30);
99
                Factory c1 = new ClassFactory(c, TestObj1_1.class).addPropertyDependency("s", "myString").addPropertyValue("i", 30);
98
               
100
               
99
                TestObj1_1 o = c1.getInstance();
101
                TestObj1_1 o = c1.getInstance();
100
               
102
               
101
                Assert.assertEquals("hello", o.s);
103
                Assert.assertEquals("hello", o.s);
102
                Assert.assertEquals(30, o.i);
104
                Assert.assertEquals(30, o.i);
103
        }
105
        }
104
       
106
       
105
        private static class TestObj2 {
107
        private static class TestObj2 {
106
               
108
               
107
                int x;
109
                int x;
108
               
110
               
109
                public TestObj2() { }
111
                public TestObj2() { }
110
               
112
               
111
                public void setInteger(int x) {
113
                public void setInteger(int x) {
112
                        this.x = x;
114
                        this.x = x;
113
                }
115
                }
114
        }
116
        }
115
       
117
       
116
        @Test
118
        @Test
117
        public void testPrimitivePropertyValue1() {
119
        public void testPrimitivePropertyValue1() {
118
               
120
               
119
                Factory f = new ClassFactory(TestObj2.class).addPropertyValue("integer", 20);
-
 
-
 
121
                Container container = new MentaContainer();
-
 
122
               
-
 
123
                Factory f = new ClassFactory(container, TestObj2.class).addPropertyValue("integer", 20);
120
               
124
               
121
                TestObj2 o = f.getInstance();
125
                TestObj2 o = f.getInstance();
122
               
126
               
123
                Assert.assertEquals(20, o.x);
127
                Assert.assertEquals(20, o.x);
124
        }
128
        }
125
       
129
       
126
        @Test
130
        @Test
127
        public void testPrimitivePropertyValue2() {
131
        public void testPrimitivePropertyValue2() {
128
               
132
               
129
                Factory f = new ClassFactory(TestObj2.class).addPropertyValue("integer", new Integer(20));
-
 
-
 
133
                Container container = new MentaContainer();
-
 
134
               
-
 
135
                Factory f = new ClassFactory(container, TestObj2.class).addPropertyValue("integer", new Integer(20));
130
               
136
               
131
                TestObj2 o = f.getInstance();
137
                TestObj2 o = f.getInstance();
132
               
138
               
133
                Assert.assertEquals(20, o.x);
139
                Assert.assertEquals(20, o.x);
134
        }
140
        }
135
       
141
       
136
        private static class TestObj2_1 {
142
        private static class TestObj2_1 {
137
               
143
               
138
                int x;
144
                int x;
139
               
145
               
140
                public TestObj2_1() { }
146
                public TestObj2_1() { }
141
               
147
               
142
                public void setInteger(Integer x) {
148
                public void setInteger(Integer x) {
143
                        this.x = x;
149
                        this.x = x;
144
                }
150
                }
145
        }      
151
        }      
146
       
152
       
147
        @Test
153
        @Test
148
        public void testPrimitivePropertyValue3() {
154
        public void testPrimitivePropertyValue3() {
149
               
155
               
150
                Factory f = new ClassFactory(TestObj2_1.class).addPropertyValue("integer", 20);
-
 
-
 
156
                Container container = new MentaContainer();
-
 
157
               
-
 
158
                Factory f = new ClassFactory(container, TestObj2_1.class).addPropertyValue("integer", 20);
151
               
159
               
152
                TestObj2_1 o = f.getInstance();
160
                TestObj2_1 o = f.getInstance();
153
               
161
               
154
                Assert.assertEquals(20, o.x);
162
                Assert.assertEquals(20, o.x);
155
        }
163
        }
156
       
164
       
157
        @Test
165
        @Test
158
        public void testPrimitivePropertyValue4() {
166
        public void testPrimitivePropertyValue4() {
159
               
167
               
160
                Factory f = new ClassFactory(TestObj2_1.class).addPropertyValue("integer", new Integer(20));
-
 
-
 
168
                Container container = new MentaContainer();
-
 
169
               
-
 
170
                Factory f = new ClassFactory(container, TestObj2_1.class).addPropertyValue("integer", new Integer(20));
161
               
171
               
162
                TestObj2_1 o = f.getInstance();
172
                TestObj2_1 o = f.getInstance();
163
               
173
               
164
                Assert.assertEquals(20, o.x);
174
                Assert.assertEquals(20, o.x);
165
        }      
175
        }      
166
       
176
       
167
       
177
       
168
        private static class TestObj3 {
178
        private static class TestObj3 {
169
               
179
               
170
                int x;
180
                int x;
171
               
181
               
172
                public TestObj3(int x) {
182
                public TestObj3(int x) {
173
                        this.x = x;
183
                        this.x = x;
174
                }
184
                }
175
        }
185
        }
176
       
186
       
177
        @Test
187
        @Test
178
        public void testPrimitiveInitValue1() {
188
        public void testPrimitiveInitValue1() {
179
               
189
               
180
                Factory f = new ClassFactory(TestObj3.class).addInitValue(20);
-
 
-
 
190
                Container container = new MentaContainer();
-
 
191
               
-
 
192
                Factory f = new ClassFactory(container, TestObj3.class).addInitValue(20);
181
               
193
               
182
                TestObj3 o = f.getInstance();
194
                TestObj3 o = f.getInstance();
183
               
195
               
184
                Assert.assertEquals(20, o.x);
196
                Assert.assertEquals(20, o.x);
185
        }
197
        }
186
       
198
       
187
        private static class TestObj3_1 {
199
        private static class TestObj3_1 {
188
               
200
               
189
                int x;
201
                int x;
190
               
202
               
191
                public TestObj3_1(Integer x) {
203
                public TestObj3_1(Integer x) {
192
                        this.x = x;
204
                        this.x = x;
193
                }
205
                }
194
        }
206
        }
195
       
207
       
196
        @Test
208
        @Test
197
        public void testPrimitiveInitValue2() {
209
        public void testPrimitiveInitValue2() {
-
 
210
                               
-
 
211
                Container container = new MentaContainer();
198
               
212
               
199
                Factory f = new ClassFactory(TestObj3_1.class).addInitValue(20);
-
 
-
 
213
                Factory f = new ClassFactory(container, TestObj3_1.class).addInitValue(20);
200
               
214
               
201
                TestObj3_1 o = f.getInstance();
215
                TestObj3_1 o = f.getInstance();
202
               
216
               
203
                Assert.assertEquals(20, o.x);
217
                Assert.assertEquals(20, o.x);
204
        }
218
        }
205
       
219
       
206
        private static class TestObj3_2 {
220
        private static class TestObj3_2 {
207
               
221
               
208
                int x;
222
                int x;
209
                long l;
223
                long l;
210
               
224
               
211
                public TestObj3_2(Integer x, long l) {
225
                public TestObj3_2(Integer x, long l) {
212
                        this.x = x;
226
                        this.x = x;
213
                        this.l = l;
227
                        this.l = l;
214
                }
228
                }
215
        }
229
        }
216
       
230
       
217
        @Test
231
        @Test
218
        public void testPrimitiveInitValue3() {
232
        public void testPrimitiveInitValue3() {
219
               
233
               
220
                Factory f = new ClassFactory(TestObj3_2.class).addInitValue(20).addInitPrimitive(30L);
-
 
-
 
234
                Container container = new MentaContainer();
-
 
235
               
-
 
236
                Factory f = new ClassFactory(container, TestObj3_2.class).addInitValue(20).addInitPrimitive(30L);
221
               
237
               
222
                TestObj3_2 o = f.getInstance();
238
                TestObj3_2 o = f.getInstance();
223
               
239
               
224
                Assert.assertEquals(20, o.x);
240
                Assert.assertEquals(20, o.x);
225
                Assert.assertEquals(30L, o.l);
241
                Assert.assertEquals(30L, o.l);
226
        }      
242
        }      
227
       
243
       
228
        private static class TestObj4 {
244
        private static class TestObj4 {
229
               
245
               
230
                int x;
246
                int x;
231
                String s;
247
                String s;
232
                Long l1;
248
                Long l1;
233
                long l2;
249
                long l2;
234
               
250
               
235
                public TestObj4(int x, String s, Long l1, long l2) {
251
                public TestObj4(int x, String s, Long l1, long l2) {
236
                        this.x = x;
252
                        this.x = x;
237
                        this.s = s;
253
                        this.s = s;
238
                        this.l1 = l1;
254
                        this.l1 = l1;
239
                        this.l2 = l2;
255
                        this.l2 = l2;
240
                }
256
                }
241
        }
257
        }
242
       
258
       
243
        @Test
259
        @Test
244
        public void testMixInitValues() {
260
        public void testMixInitValues() {
245
               
261
               
246
                Factory f = new ClassFactory(TestObj4.class).addInitPrimitive(20).addInitValue("hello").addInitValue(20L).addInitPrimitive(20L);
-
 
-
 
262
                Container container = new MentaContainer();
-
 
263
               
-
 
264
                Factory f = new ClassFactory(container, TestObj4.class).addInitPrimitive(20).addInitValue("hello").addInitValue(20L).addInitPrimitive(20L);
247
               
265
               
248
                TestObj4 o = f.getInstance();
266
                TestObj4 o = f.getInstance();
249
               
267
               
250
                Assert.assertEquals(20, o.x);
268
                Assert.assertEquals(20, o.x);
251
                Assert.assertEquals("hello", o.s);
269
                Assert.assertEquals("hello", o.s);
252
                Assert.assertEquals(new Long(20), o.l1);
270
                Assert.assertEquals(new Long(20), o.l1);
253
                Assert.assertEquals(20, o.l2);
271
                Assert.assertEquals(20, o.l2);
254
        }
272
        }
255
}
273
}