View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.juneau.commons.reflect;
18  
19  import static org.junit.jupiter.api.Assertions.*;
20  
21  import java.lang.reflect.*;
22  
23  import org.apache.juneau.TestBase;
24  import org.junit.jupiter.api.*;
25  
26  class Visibility_Test extends TestBase {
27  
28  	//-----------------------------------------------------------------------------------------------------------------
29  	// Test classes with various visibility modifiers
30  	//-----------------------------------------------------------------------------------------------------------------
31  
32  	public static class PublicClass {
33  		public PublicClass() {}
34  		public void publicMethod() {}
35  		public int publicField;
36  	}
37  
38  	private static class PrivateClass {
39  		private PrivateClass() {}
40  		@SuppressWarnings("unused")
41  		private void privateMethod() {}
42  		@SuppressWarnings("unused")
43  		private int privateField;
44  	}
45  
46  	protected static class ProtectedClass {
47  		protected ProtectedClass() {}
48  		protected void protectedMethod() {}
49  		protected int protectedField;
50  	}
51  
52  	static class PackagePrivateClass {
53  		PackagePrivateClass() {}
54  		void packagePrivateMethod() {}
55  		int packagePrivateField;
56  	}
57  
58  	//-----------------------------------------------------------------------------------------------------------------
59  	// Helper methods
60  	//-----------------------------------------------------------------------------------------------------------------
61  
62  	private static Constructor<?> getConstructor(Class<?> c, Class<?>... paramTypes) {
63  		try {
64  			return c.getDeclaredConstructor(paramTypes);
65  		} catch (NoSuchMethodException e) {
66  			throw new RuntimeException(e);
67  		}
68  	}
69  
70  	private static Method getMethod(Class<?> c, String name, Class<?>... paramTypes) {
71  		try {
72  			return c.getDeclaredMethod(name, paramTypes);
73  		} catch (NoSuchMethodException e) {
74  			throw new RuntimeException(e);
75  		}
76  	}
77  
78  	private static Field getField(Class<?> c, String name) {
79  		try {
80  			return c.getDeclaredField(name);
81  		} catch (NoSuchFieldException e) {
82  			throw new RuntimeException(e);
83  		}
84  	}
85  
86  	//====================================================================================================
87  	// transform(Constructor<T>)
88  	//====================================================================================================
89  	@Test
90  	void a001_transform_constructor_null() throws Exception {
91  		assertThrows(IllegalArgumentException.class, () -> Visibility.PUBLIC.transform((Constructor<?>)null));
92  		assertThrows(IllegalArgumentException.class, () -> Visibility.PRIVATE.transform((Constructor<?>)null));
93  		assertThrows(IllegalArgumentException.class, () -> Visibility.NONE.transform((Constructor<?>)null));
94  	}
95  
96  	@Test
97  	void a002_transform_constructor_public() throws Exception {
98  		Constructor<?> publicCtor = getConstructor(PublicClass.class);
99  		Constructor<?> privateCtor = getConstructor(PrivateClass.class);
100 		Constructor<?> protectedCtor = getConstructor(ProtectedClass.class);
101 		Constructor<?> packageCtor = getConstructor(PackagePrivateClass.class);
102 
103 		// PUBLIC visibility - only makes public accessible, returns others as-is
104 		assertNotNull(Visibility.PUBLIC.transform(publicCtor));
105 		assertSame(privateCtor, Visibility.PUBLIC.transform(privateCtor));
106 		assertSame(protectedCtor, Visibility.PUBLIC.transform(protectedCtor));
107 		assertSame(packageCtor, Visibility.PUBLIC.transform(packageCtor));
108 
109 		// PROTECTED visibility - makes public and protected accessible
110 		assertNotNull(Visibility.PROTECTED.transform(publicCtor));
111 		assertSame(privateCtor, Visibility.PROTECTED.transform(privateCtor));
112 		assertNotNull(Visibility.PROTECTED.transform(protectedCtor));
113 		assertSame(packageCtor, Visibility.PROTECTED.transform(packageCtor));
114 
115 		// DEFAULT visibility - makes public, protected, and package accessible
116 		assertNotNull(Visibility.DEFAULT.transform(publicCtor));
117 		assertSame(privateCtor, Visibility.DEFAULT.transform(privateCtor));
118 		assertNotNull(Visibility.DEFAULT.transform(protectedCtor));
119 		assertNotNull(Visibility.DEFAULT.transform(packageCtor));
120 
121 		// PRIVATE visibility - makes all accessible
122 		assertNotNull(Visibility.PRIVATE.transform(publicCtor));
123 		assertNotNull(Visibility.PRIVATE.transform(privateCtor));
124 		assertNotNull(Visibility.PRIVATE.transform(protectedCtor));
125 		assertNotNull(Visibility.PRIVATE.transform(packageCtor));
126 
127 		// NONE visibility - doesn't make anything accessible, but returns as-is
128 		assertSame(publicCtor, Visibility.NONE.transform(publicCtor));
129 		assertSame(privateCtor, Visibility.NONE.transform(privateCtor));
130 		assertSame(protectedCtor, Visibility.NONE.transform(protectedCtor));
131 		assertSame(packageCtor, Visibility.NONE.transform(packageCtor));
132 	}
133 
134 	@Test
135 	void a003_transform_constructor_returnsSameInstance() throws Exception {
136 		Constructor<?> publicCtor = getConstructor(PublicClass.class);
137 		Constructor<?> result = Visibility.PUBLIC.transform(publicCtor);
138 		assertSame(publicCtor, result);
139 	}
140 
141 	//====================================================================================================
142 	// transform(Field)
143 	//====================================================================================================
144 	@Test
145 	void a004_transform_field_null() throws Exception {
146 		assertThrows(IllegalArgumentException.class, () -> Visibility.PUBLIC.transform((Field)null));
147 		assertThrows(IllegalArgumentException.class, () -> Visibility.PRIVATE.transform((Field)null));
148 		assertThrows(IllegalArgumentException.class, () -> Visibility.NONE.transform((Field)null));
149 	}
150 
151 	@Test
152 	void a005_transform_field_public() throws Exception {
153 		Field publicField = getField(PublicClass.class, "publicField");
154 		Field privateField = getField(PrivateClass.class, "privateField");
155 		Field protectedField = getField(ProtectedClass.class, "protectedField");
156 		Field packageField = getField(PackagePrivateClass.class, "packagePrivateField");
157 
158 		// PUBLIC visibility - only makes public accessible, returns others as-is
159 		assertNotNull(Visibility.PUBLIC.transform(publicField));
160 		assertSame(privateField, Visibility.PUBLIC.transform(privateField));
161 		assertSame(protectedField, Visibility.PUBLIC.transform(protectedField));
162 		assertSame(packageField, Visibility.PUBLIC.transform(packageField));
163 
164 		// PROTECTED visibility - makes public and protected accessible
165 		assertNotNull(Visibility.PROTECTED.transform(publicField));
166 		assertSame(privateField, Visibility.PROTECTED.transform(privateField));
167 		assertNotNull(Visibility.PROTECTED.transform(protectedField));
168 		assertSame(packageField, Visibility.PROTECTED.transform(packageField));
169 
170 		// DEFAULT visibility - makes public, protected, and package accessible
171 		assertNotNull(Visibility.DEFAULT.transform(publicField));
172 		assertSame(privateField, Visibility.DEFAULT.transform(privateField));
173 		assertNotNull(Visibility.DEFAULT.transform(protectedField));
174 		assertNotNull(Visibility.DEFAULT.transform(packageField));
175 
176 		// PRIVATE visibility - makes all accessible
177 		assertNotNull(Visibility.PRIVATE.transform(publicField));
178 		assertNotNull(Visibility.PRIVATE.transform(privateField));
179 		assertNotNull(Visibility.PRIVATE.transform(protectedField));
180 		assertNotNull(Visibility.PRIVATE.transform(packageField));
181 
182 		// NONE visibility - doesn't make anything accessible, but returns as-is
183 		assertSame(publicField, Visibility.NONE.transform(publicField));
184 		assertSame(privateField, Visibility.NONE.transform(privateField));
185 		assertSame(protectedField, Visibility.NONE.transform(protectedField));
186 		assertSame(packageField, Visibility.NONE.transform(packageField));
187 	}
188 
189 	@Test
190 	void a006_transform_field_returnsSameInstance() throws Exception {
191 		Field publicField = getField(PublicClass.class, "publicField");
192 		Field result = Visibility.PUBLIC.transform(publicField);
193 		assertSame(publicField, result);
194 	}
195 
196 	//====================================================================================================
197 	// transform(Method)
198 	//====================================================================================================
199 	@Test
200 	void a007_transform_method_null() throws Exception {
201 		assertThrows(IllegalArgumentException.class, () -> Visibility.PUBLIC.transform((Method)null));
202 		assertThrows(IllegalArgumentException.class, () -> Visibility.PRIVATE.transform((Method)null));
203 		assertThrows(IllegalArgumentException.class, () -> Visibility.NONE.transform((Method)null));
204 	}
205 
206 	@Test
207 	void a008_transform_method_public() throws Exception {
208 		Method publicMethod = getMethod(PublicClass.class, "publicMethod");
209 		Method privateMethod = getMethod(PrivateClass.class, "privateMethod");
210 		Method protectedMethod = getMethod(ProtectedClass.class, "protectedMethod");
211 		Method packageMethod = getMethod(PackagePrivateClass.class, "packagePrivateMethod");
212 
213 		// PUBLIC visibility - only makes public accessible, returns others as-is
214 		assertNotNull(Visibility.PUBLIC.transform(publicMethod));
215 		assertSame(privateMethod, Visibility.PUBLIC.transform(privateMethod));
216 		assertSame(protectedMethod, Visibility.PUBLIC.transform(protectedMethod));
217 		assertSame(packageMethod, Visibility.PUBLIC.transform(packageMethod));
218 
219 		// PROTECTED visibility - makes public and protected accessible
220 		assertNotNull(Visibility.PROTECTED.transform(publicMethod));
221 		assertSame(privateMethod, Visibility.PROTECTED.transform(privateMethod));
222 		assertNotNull(Visibility.PROTECTED.transform(protectedMethod));
223 		assertSame(packageMethod, Visibility.PROTECTED.transform(packageMethod));
224 
225 		// DEFAULT visibility - makes public, protected, and package accessible
226 		assertNotNull(Visibility.DEFAULT.transform(publicMethod));
227 		assertSame(privateMethod, Visibility.DEFAULT.transform(privateMethod));
228 		assertNotNull(Visibility.DEFAULT.transform(protectedMethod));
229 		assertNotNull(Visibility.DEFAULT.transform(packageMethod));
230 
231 		// PRIVATE visibility - makes all accessible
232 		assertNotNull(Visibility.PRIVATE.transform(publicMethod));
233 		assertNotNull(Visibility.PRIVATE.transform(privateMethod));
234 		assertNotNull(Visibility.PRIVATE.transform(protectedMethod));
235 		assertNotNull(Visibility.PRIVATE.transform(packageMethod));
236 
237 		// NONE visibility - doesn't make anything accessible, but returns as-is
238 		assertSame(publicMethod, Visibility.NONE.transform(publicMethod));
239 		assertSame(privateMethod, Visibility.NONE.transform(privateMethod));
240 		assertSame(protectedMethod, Visibility.NONE.transform(protectedMethod));
241 		assertSame(packageMethod, Visibility.NONE.transform(packageMethod));
242 	}
243 
244 	@Test
245 	void a009_transform_method_returnsSameInstance() throws Exception {
246 		Method publicMethod = getMethod(PublicClass.class, "publicMethod");
247 		Method result = Visibility.PUBLIC.transform(publicMethod);
248 		assertSame(publicMethod, result);
249 	}
250 }
251