Debian Codegraph @

src/test/java/org/jboss/modules/ref/ReferencesTestCase.java

raw
1 /*
2 * JBoss, Home of Professional Open Source.
3 * Copyright 2014 Red Hat, Inc., and individual contributors
4 * as indicated by the @author tags.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 package org.jboss.modules.ref;
20
21 import static org.jboss.modules.ref.util.Assert.assertReference;
22 import static org.junit.Assert.assertEquals;
23 import static org.junit.Assert.assertNull;
24 import static org.junit.Assert.assertSame;
25 import static org.junit.Assert.assertTrue;
26 import static org.junit.Assert.fail;
27
28 import java.lang.ref.ReferenceQueue;
29 import java.util.ArrayList;
30 import java.util.Collection;
31 import java.util.concurrent.TimeUnit;
32
33 import org.jboss.modules.ref.Reference.Type;
34 import org.jboss.modules.ref.References.ReaperThread;
35 import org.jboss.modules.ref.util.TestReaper;
36 import org.junit.Test;
37
38 /**
39 * Test for {@link References} class and internal classes.
40 *
41 * @author <a href="mailto:[email protected]">Flavia Rainone</a>
42 */
43 public class ReferencesTestCase {
44
45 @Test
46 public void nullReference() {
47 final Reference<?, ?> nullReference = References.getNullReference();
48 assertReference(nullReference, null, null, Type.NULL);
49 nullReference.clear();
50 assertReference(nullReference, null, null, Type.NULL);
51 assertEquals(nullReference, References.create(Type.NULL, null, null));
52 assertEquals(nullReference, References.create(Type.NULL, null, null, (Reaper<Object, Object>) null));
53 assertEquals(nullReference, References.create(Type.NULL, null, null, (ReferenceQueue<Object>) null));
54 }
55
56 @Test
57 public void createStrongReference() {
58 final Reference<String, String> reference = createReference(Type.STRONG);
59 assertTrue(reference instanceof StrongReference);
60 }
61
62 @Test
63 public void createSoftReference() {
64 final Reference<String, String> reference = createReference(Type.SOFT);
65 assertTrue(reference instanceof SoftReference);
66 }
67
68 @Test
69 public void createWeakReference() {
70 final Reference<String, String> reference = createReference(Type.WEAK);
71 assertTrue(reference instanceof WeakReference);
72 }
73
74 @Test
75 public void createIllegalPhantomReference() {
76 try {
77 References.create(Type.PHANTOM, "value", "attachment");
78 fail("IllegalArgumentException expected because of missing reaper/reference queue");
79 } catch (IllegalArgumentException e) {}
80 }
81
82 @Test
83 public void createStrongReferenceWithReaper() throws Exception {
84 final Object referent = new Object();
85 final Reference<Object, String> reference = References.create(Type.STRONG, referent, "attachment",
86 new TestReaper<Object, String>());
87 assertReference(reference, referent, "attachment", Type.STRONG);
88 assertTrue(reference instanceof StrongReference);
89 }
90
91 @Test
92 public void createSoftReferenceWithReaper() throws Exception {
93 final Reference<Object, String> reference = createReferenceWithReaper(Type.SOFT, false, false);
94 assertTrue(reference instanceof SoftReference);
95 }
96
97 @Test
98 public void createWeakReferenceWithReaper() throws Exception {
99 final Reference<Object, String> reference = createReferenceWithReaper(Type.WEAK, false, true);
100 assertTrue(reference instanceof WeakReference);
101 }
102
103 @Test
104 public void createPhantomReferenceWithReaper() throws Exception {
105 final Reference<Object, String> reference = createReferenceWithReaper(Type.PHANTOM, true, true);
106 assertTrue(reference instanceof PhantomReference);
107 }
108
109 @Test
110 public void createStrongReferenceWithQueue() throws Exception {
111 final Object referent = new Object();
112 final Reference<Object, String> reference = References.create(Type.STRONG, referent, "attachment", new ReferenceQueue<Object>());
113 assertReference(reference, referent, "attachment", Type.STRONG);
114 assertTrue(reference instanceof StrongReference);
115 }
116
117 @Test
118 public void createSoftReferenceWithQueue() throws Exception {
119 final Reference<?, ?> reference = createReferenceWithQueue(Type.SOFT, false, false);
120 assertTrue(reference instanceof SoftReference);
121 }
122
123 @Test
124 public void createWeakReferenceWithQueue() throws Exception {
125 final Reference<?, ?> reference = createReferenceWithQueue(Type.WEAK, false, true);
126 assertTrue(reference instanceof WeakReference);
127 }
128
129 @Test
130 public void createPhantomReferenceWithQueue() throws Exception {
131 final Reference<?, ?> reference = createReferenceWithQueue(Type.PHANTOM, true, true);
132 assertTrue(reference instanceof PhantomReference);
133 }
134
135 @Test
136 public void reapUnreapableReference() throws Exception {
137 Object referent = new Object();
138 final TestReaper<Object, Void> reaper = new TestReaper<Object, Void>();
139 final Reference<Object, Void> reference = new UnreapableWeakReference(referent);
140 assertReference(reference, referent, null, Type.WEAK);
141 referent = null;
142 System.gc();
143 assertNull(reaper.get(200, TimeUnit.MILLISECONDS));
144 }
145
146 @Test
147 public void failToReapReference() throws Exception {
148 final TestReaper<Object, Void> reaper = new FailToReap<Object, Void>();
149 Object referent = new Object();
150 final Reference<Object, Void> reference = new WeakReference<Object, Void>(referent, null, reaper);
151 assertReference(reference, referent, null, Type.WEAK, reaper);
152 referent = null;
153 System.gc();
154 assertNull(reaper.get(200, TimeUnit.MILLISECONDS));
155 }
156
157 private Reference<String, String> createReference(Type type) {
158 final Reference<String, String> reference = References.create(type, "value", "attachment");
159 assertReference(reference, "value", "attachment", type);
160 return reference;
161 }
162
163 private Reference<Object, String> createReferenceWithReaper(Type type, boolean expectedNullValue, boolean testReaper) throws Exception {
164 Object referent = new Object();
165 final TestReaper<Object, String> reaper = new TestReaper<Object, String>();
166 final Reference<Object, String> reference = References.create(type, referent, "attachment", reaper);
167 assertReference(reference, expectedNullValue? null: referent, "attachment", type, reaper);
168 if (testReaper) {
169 referent = null;
170 System.gc();
171 assertSame(reference, reaper.get());
172 }
173 return reference;
174 }
175
176 private Reference<Collection<Integer>, Object> createReferenceWithQueue(Type type, boolean expectedNullValue, boolean testQueue) throws Exception {
177 final Object referenceAttachment = new Object();
178 Collection<Integer> referent = new ArrayList<Integer>();
179 referent.add(Integer.valueOf(1));
180 referent.add(Integer.valueOf(11));
181 referent.add(Integer.valueOf(111));
182 final ReferenceQueue<Collection<Integer>> referenceQueue = new ReferenceQueue<Collection<Integer>>();
183 final Reference<Collection<Integer>, Object> reference = References.create(type, referent, referenceAttachment, referenceQueue);
184 assertReference(reference, expectedNullValue? null: referent, referenceAttachment, type, null);
185 if (testQueue) {
186 referent = null;
187 System.gc();
188 assertSame(reference, referenceQueue.remove(300));
189 }
190 return reference;
191 }
192
193 private static final class UnreapableWeakReference extends java.lang.ref.WeakReference<Object> implements Reference<Object, Void> {
194
195 UnreapableWeakReference(Object referent) {
196 super(referent, ReaperThread.REAPER_QUEUE);
197 }
198
199 @Override
200 public Void getAttachment() {
201 return null;
202 }
203
204 @Override
205 public Reference.Type getType() {
206 return Type.WEAK;
207 }
208 }
209
210 private static final class FailToReap<T, A> extends TestReaper<T, A> {
211 @Override
212 public void reap(Reference<T, A> reference) {
213 throw new RuntimeException("fail to reap");
214 }
215 }
216 }