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