wamblee.org Git - utils/blob - support/general/src/test/java/org/wamblee/reflection/ObjectTraversalTest.java

   1 /*
   2  * Copyright 2005-2010 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.reflection;
  17
  18 import static org.mockito.Matchers.*;
  19 import static org.mockito.Mockito.*;
  20
  21 import java.lang.reflect.Field;
  22 import java.lang.reflect.Method;
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.HashSet;
  26 import java.util.List;
  27 import java.util.Map;
  28 import java.util.Set;
  29 import java.util.logging.ConsoleHandler;
  30 import java.util.logging.Level;
  31 import java.util.logging.Logger;
  32
  33 import org.apache.derby.impl.sql.execute.OnceResultSet;
  34 import org.junit.Before;
  35 import org.junit.Test;
  36 import org.mockito.Mock;
  37 import org.mockito.MockitoAnnotations;
  38 import org.wamblee.reflection.ObjectTraversal.ObjectVisitor;
  39
  40 import static junit.framework.TestCase.*;
  41
  42 public class ObjectTraversalTest {
  43
  44     @Mock
  45     private ObjectVisitor visitor;
  46
  47     private ObjectTraversal traversal;
  48
  49     @Before
  50     public void setUp() {
  51         MockitoAnnotations.initMocks(this);
  52         traversal = new ObjectTraversal(visitor);
  53
  54         when(visitor.mustVisit(any(Class.class))).thenReturn(true);
  55         when(visitor.mustVisit(any(Field.class))).thenReturn(true);
  56         when(visitor.mustVisit(any(Method.class))).thenReturn(true);
  57
  58         when(visitor.visitPlainObject(any())).thenReturn(true);
  59         when(visitor.visitArray(any())).thenReturn(true);
  60         when(visitor.visitList(any(List.class))).thenReturn(true);
  61         when(visitor.visitMap(any(Map.class))).thenReturn(true);
  62         when(visitor.visitSet(any(Set.class))).thenReturn(true);
  63
  64         ObjectTraversal.LOGGER.setLevel(Level.FINEST);
  65         ConsoleHandler handler = new ConsoleHandler();
  66         handler.setLevel(Level.FINEST);
  67         ObjectTraversal.LOGGER.addHandler(handler);
  68     }
  69
  70     public static class X1 {
  71
  72     }
  73
  74     public static class X2 {
  75         private X1 x;
  76     }
  77
  78     @Test
  79     public void testTraverseFields() throws Exception {
  80         X2 x2 = new X2();
  81         X1 x1 = new X1();
  82         x2.x = x1;
  83         traversal.accept(x2);
  84         verify(visitor).mustVisit(X2.class);
  85         verify(visitor).mustVisit(X1.class);
  86         verify(visitor).mustVisit(eq(X2.class.getDeclaredField("x")));
  87         verify(visitor).visitPlainObject(same(x2));
  88         verify(visitor).visitPlainObject(same(x1));
  89         verifyNoMoreInteractions(visitor);
  90     }
  91
  92     public static class TraversalNonTraversedFields {
  93         private int x;
  94         private Object y = new Object();
  95     }
  96
  97     @Test
  98     public void testNonTraversedFields() throws Exception {
  99         TraversalNonTraversedFields obj = new TraversalNonTraversedFields();
 100         traversal.accept(obj);
 101         verify(visitor).mustVisit(TraversalNonTraversedFields.class);
 102         verify(visitor).mustVisit(
 103             eq(TraversalNonTraversedFields.class.getDeclaredField("x")));
 104         verify(visitor).mustVisit(
 105             eq(TraversalNonTraversedFields.class.getDeclaredField("y")));
 106         verify(visitor).visitPlainObject(same(obj));
 107     }
 108
 109     public static class X3 {
 110
 111     }
 112
 113     public static class X4 {
 114         public X3 getX3() {
 115             return new X3();
 116         }
 117     }
 118
 119     @Test
 120     public void testTraverseMethods() throws Exception {
 121         X4 x4 = new X4();
 122         traversal.accept(x4);
 123         verify(visitor).mustVisit(X4.class);
 124         verify(visitor).mustVisit(X3.class);
 125         verify(visitor).mustVisit(eq(X4.class.getDeclaredMethod("getX3")));
 126         verify(visitor).visitPlainObject(same(x4));
 127         verify(visitor).visitPlainObject(isA(X3.class));
 128         verifyNoMoreInteractions(visitor);
 129     }
 130
 131     @Test
 132     public void testTraverseList() {
 133         List list = new ArrayList();
 134         list.add(new X1());
 135         list.add(new X3());
 136         traversal.accept(list);
 137         verify(visitor).visitList(same(list));
 138         verify(visitor).visitPlainObject(isA(X1.class));
 139         verify(visitor).visitPlainObject(isA(X3.class));
 140     }
 141
 142     @Test
 143     public void testTraverseMap() {
 144         Map<String, Object> map = new HashMap<String, Object>();
 145         map.put("x1", new X1());
 146         map.put("x3", new X3());
 147         traversal.accept(map);
 148         verify(visitor).visitMap(same(map));
 149         verify(visitor).visitPlainObject(isA(X1.class));
 150         verify(visitor).visitPlainObject(isA(X3.class));
 151     }
 152
 153     @Test
 154     public void testTraverseSet() {
 155         Set set = new HashSet();
 156         set.add(new X1());
 157         set.add(new X3());
 158         traversal.accept(set);
 159         verify(visitor).visitSet(same(set));
 160         verify(visitor).visitPlainObject(isA(X1.class));
 161         verify(visitor).visitPlainObject(isA(X3.class));
 162     }
 163
 164     @Test
 165     public void testTraverseArray() {
 166         Object[] obj = new Object[2];
 167         obj[0] = new X1();
 168         obj[1] = new X3();
 169         traversal.accept(obj);
 170         verify(visitor).visitArray(same(obj));
 171         verify(visitor).visitPlainObject(isA(X1.class));
 172         verify(visitor).visitPlainObject(isA(X3.class));
 173     }
 174
 175     @Test
 176     public void testExcludeClasses() {
 177         X2 x2 = new X2();
 178         x2.x = new X1();
 179         when(visitor.mustVisit(X1.class)).thenReturn(false);
 180         traversal.accept(x2);
 181         verify(visitor).visitPlainObject(same(x2));
 182         verify(visitor, never()).visitPlainObject(same(x2.x));
 183     }
 184
 185     @Test
 186     public void testExcludeFields() {
 187         X2 x2 = new X2();
 188         x2.x = new X1();
 189         when(visitor.mustVisit(any(Field.class))).thenReturn(false);
 190         traversal.accept(x2);
 191         verify(visitor).visitPlainObject(same(x2));
 192         verify(visitor, never()).visitPlainObject(same(x2.x));
 193     }
 194
 195     @Test
 196     public void testExcludeMethods() {
 197         X4 x4 = new X4();
 198         when(visitor.mustVisit(any(Method.class))).thenReturn(false);
 199         traversal.accept(x4);
 200         verify(visitor).visitPlainObject(same(x4));
 201         verify(visitor, never()).visitPlainObject(isA(X3.class));
 202     }
 203
 204     public static class X5 {
 205         private X6 x6;
 206     }
 207
 208     public static class X6 {
 209         private X5 x5;
 210     }
 211
 212     @Test
 213     public void testCyclic() {
 214         X6 x6 = new X6();
 215         X5 x5 = new X5();
 216         x6.x5 = x5;
 217         x5.x6 = x6;
 218         traversal.accept(x6);
 219         verify(visitor).visitPlainObject(same(x6));
 220         verify(visitor).visitPlainObject(same(x5));
 221     }
 222
 223     @Test
 224     public void testCyclicList() {
 225         List list = new ArrayList();
 226         list.add(list);
 227         traversal.accept(list);
 228         verify(visitor, times(1)).visitList(same(list));
 229     }
 230
 231     @Test
 232     public void testCyclicMap() {
 233         Map map = new HashMap();
 234         map.put("x", map);
 235         traversal.accept(map);
 236         verify(visitor, times(1)).visitMap(same(map));
 237     }
 238
 239     @Test
 240     public void testCyclicSet() {
 241         Set set = new HashSet();
 242         set.add(set);
 243         traversal.accept(set);
 244         verify(visitor, times(1)).visitSet(same(set));
 245     }
 246
 247     @Test
 248     public void testCyclicArray() {
 249         Object[] obj = new Object[1];
 250         obj[0] = obj;
 251         traversal.accept(obj);
 252         verify(visitor, times(1)).visitArray(same(obj));
 253     }
 254
 255     @Test
 256     public void testVisitNull() {
 257         traversal.accept(null);
 258     }
 259
 260     @Test
 261     public void testExcludeFieldByReturningFalseInVisit() {
 262         X2 x2 = new X2();
 263         x2.x = new X1();
 264         when(visitor.visitPlainObject(any())).thenReturn(false);
 265         traversal.accept(x2);
 266         verify(visitor).visitPlainObject(same(x2));
 267         verify(visitor, never()).visitPlainObject(same(x2.x));
 268     }
 269
 270     @Test
 271     public void testTraverseListExcludeElements() {
 272         List list = new ArrayList();
 273         list.add(new X1());
 274         list.add(new X3());
 275         when(visitor.visitList(any(List.class))).thenReturn(false);
 276         traversal.accept(list);
 277         verify(visitor).visitList(same(list));
 278         verify(visitor, never()).visitPlainObject(any());
 279     }
 280
 281     @Test
 282     public void testTraverseMapExcludeElements() {
 283         Map<String, Object> map = new HashMap<String, Object>();
 284         map.put("x1", new X1());
 285         map.put("x3", new X3());
 286         when(visitor.visitMap(any(Map.class))).thenReturn(false);
 287         traversal.accept(map);
 288         verify(visitor).visitMap(same(map));
 289         verify(visitor, never()).visitPlainObject(any());
 290     }
 291
 292     @Test
 293     public void testTraverseSetExcludeElements() {
 294         Set set = new HashSet();
 295         set.add(new X1());
 296         set.add(new X3());
 297         when(visitor.visitSet(any(Set.class))).thenReturn(false);
 298
 299         traversal.accept(set);
 300         verify(visitor).visitSet(same(set));
 301         verify(visitor, never()).visitPlainObject(any());
 302     }
 303
 304     @Test
 305     public void testTraverseArrayExcludeElements() {
 306         Object[] obj = new Object[2];
 307         obj[0] = new X1();
 308         obj[1] = new X3();
 309         when(visitor.visitArray(any())).thenReturn(false);
 310
 311         traversal.accept(obj);
 312         verify(visitor).visitArray(same(obj));
 313         verify(visitor, never()).visitPlainObject(any());
 314     }
 315
 316 }