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.apache.juneau.commons.reflect.ElementFlag.*;
20  import static org.junit.jupiter.api.Assertions.*;
21  
22  import java.lang.reflect.Modifier;
23  
24  import org.apache.juneau.*;
25  import org.junit.jupiter.api.*;
26  
27  class ElementInfo_Test extends TestBase {
28  
29  	//-----------------------------------------------------------------------------------------------------------------
30  	// Test classes with various modifiers
31  	//-----------------------------------------------------------------------------------------------------------------
32  
33  	public static class PublicClass {
34  		public PublicClass() {}
35  		public void publicMethod() {}
36  		public int publicField;
37  	}
38  
39  	private static class PrivateClass {
40  		private PrivateClass() {}
41  		@SuppressWarnings("unused")
42  		private void privateMethod() {}
43  		@SuppressWarnings("unused")
44  		private int privateField;
45  	}
46  
47  	protected static class ProtectedClass {
48  		protected ProtectedClass() {}
49  		protected void protectedMethod() {}
50  		protected int protectedField;
51  	}
52  
53  	static class PackagePrivateClass {
54  		PackagePrivateClass() {}
55  		void packagePrivateMethod() {}
56  		int packagePrivateField;
57  	}
58  
59  	public static class StaticClass {
60  		public static void staticMethod() {}
61  		public static int staticField;
62  	}
63  
64  	public static class FinalClass {
65  		public final void finalMethod() {}
66  		public final int finalField = 0;
67  	}
68  
69  	public abstract static class AbstractClass {
70  		public abstract void abstractMethod();
71  	}
72  
73  	public interface InterfaceClass {
74  		void interfaceMethod();
75  	}
76  
77  	public static class SynchronizedClass {
78  		public synchronized void synchronizedMethod() {}
79  	}
80  
81  	public static class NativeClass {
82  		public native void nativeMethod();
83  	}
84  
85  	public static class StrictClass {
86  		public void strictMethod() {}
87  	}
88  
89  	public static class TransientClass {
90  		public transient int transientField;
91  	}
92  
93  	public static class VolatileClass {
94  		public volatile int volatileField;
95  	}
96  
97  	//-----------------------------------------------------------------------------------------------------------------
98  	// Helper methods
99  	//-----------------------------------------------------------------------------------------------------------------
100 
101 	private static ClassInfo getClassInfo(Class<?> c) {
102 		return ClassInfo.of(c);
103 	}
104 
105 	private static MethodInfo getMethod(Class<?> c, String name) {
106 		return ClassInfo.of(c).getPublicMethod(m -> m.hasName(name)).orElse(
107 			ClassInfo.of(c).getMethod(m -> m.hasName(name)).orElse(null)
108 		);
109 	}
110 
111 	@SuppressWarnings("unused")
112 	private static ConstructorInfo getConstructor(Class<?> c) {
113 		return ClassInfo.of(c).getPublicConstructor(cons -> cons.getParameterCount() == 0).orElse(
114 			ClassInfo.of(c).getDeclaredConstructor(cons -> cons.getParameterCount() == 0).orElse(null)
115 		);
116 	}
117 
118 	private static FieldInfo getField(Class<?> c, String name) {
119 		return ClassInfo.of(c).getPublicField(f -> f.hasName(name)).orElse(
120 			ClassInfo.of(c).getDeclaredField(f -> f.hasName(name)).orElse(null)
121 		);
122 	}
123 
124 	//====================================================================================================
125 	// getModifiers()
126 	//====================================================================================================
127 	@Test
128 	void a001_getModifiers() {
129 		var publicClass = getClassInfo(PublicClass.class);
130 		var modifiers = publicClass.getModifiers();
131 		assertTrue(Modifier.isPublic(modifiers));
132 		assertFalse(Modifier.isPrivate(modifiers));
133 		assertFalse(Modifier.isProtected(modifiers));
134 		// PublicClass is a static inner class, so it IS static
135 		assertTrue(Modifier.isStatic(modifiers));
136 		assertFalse(Modifier.isFinal(modifiers));
137 		assertFalse(Modifier.isAbstract(modifiers));
138 		assertFalse(Modifier.isInterface(modifiers));
139 	}
140 
141 	//====================================================================================================
142 	// is(ElementFlag)
143 	//====================================================================================================
144 	@Test
145 	void a002_is() {
146 		var publicClass = getClassInfo(PublicClass.class);
147 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
148 		var publicField = getField(PublicClass.class, "publicField");
149 		var privateClass = getClassInfo(PrivateClass.class);
150 		var staticMethod = getMethod(StaticClass.class, "staticMethod");
151 		var finalMethod = getMethod(FinalClass.class, "finalMethod");
152 		var abstractClass = getClassInfo(AbstractClass.class);
153 		var interfaceClass = getClassInfo(InterfaceClass.class);
154 		var synchronizedMethod = getMethod(SynchronizedClass.class, "synchronizedMethod");
155 		var nativeMethod = getMethod(NativeClass.class, "nativeMethod");
156 		var transientField = getField(TransientClass.class, "transientField");
157 		var volatileField = getField(VolatileClass.class, "volatileField");
158 
159 		// Public
160 		assertTrue(publicClass.is(PUBLIC));
161 		assertTrue(publicMethod.is(PUBLIC));
162 		assertTrue(publicField.is(PUBLIC));
163 		assertFalse(publicClass.is(NOT_PUBLIC));
164 		assertFalse(publicMethod.is(NOT_PUBLIC));
165 		assertFalse(publicField.is(NOT_PUBLIC));
166 
167 		// Private
168 		assertTrue(privateClass.is(PRIVATE));
169 		assertFalse(publicClass.is(PRIVATE));
170 		assertTrue(publicClass.is(NOT_PRIVATE));
171 		assertFalse(privateClass.is(NOT_PRIVATE));
172 
173 		// Protected
174 		var protectedClass = getClassInfo(ProtectedClass.class);
175 		assertTrue(protectedClass.is(PROTECTED));
176 		assertFalse(publicClass.is(PROTECTED));
177 		assertTrue(publicClass.is(NOT_PROTECTED));
178 		assertFalse(protectedClass.is(NOT_PROTECTED));
179 
180 		// Static
181 		assertTrue(staticMethod.is(STATIC));
182 		assertFalse(publicMethod.is(STATIC));
183 		assertTrue(publicMethod.is(NOT_STATIC));
184 		assertFalse(staticMethod.is(NOT_STATIC));
185 
186 		// Final
187 		assertTrue(finalMethod.is(FINAL));
188 		assertFalse(publicMethod.is(FINAL));
189 		assertTrue(publicMethod.is(NOT_FINAL));
190 		assertFalse(finalMethod.is(NOT_FINAL));
191 
192 		// Abstract
193 		assertTrue(abstractClass.is(ABSTRACT));
194 		assertFalse(publicClass.is(ABSTRACT));
195 		assertTrue(publicClass.is(NOT_ABSTRACT));
196 		assertFalse(abstractClass.is(NOT_ABSTRACT));
197 
198 		// Interface
199 		assertTrue(interfaceClass.is(INTERFACE));
200 		assertFalse(publicClass.is(INTERFACE));
201 
202 		// Synchronized
203 		assertTrue(synchronizedMethod.is(SYNCHRONIZED));
204 		assertFalse(publicMethod.is(SYNCHRONIZED));
205 		assertTrue(publicMethod.is(NOT_SYNCHRONIZED));
206 		assertFalse(synchronizedMethod.is(NOT_SYNCHRONIZED));
207 
208 		// Native
209 		assertTrue(nativeMethod.is(NATIVE));
210 		assertFalse(publicMethod.is(NATIVE));
211 		assertTrue(publicMethod.is(NOT_NATIVE));
212 		assertFalse(nativeMethod.is(NOT_NATIVE));
213 
214 		// Transient
215 		assertTrue(transientField.is(TRANSIENT));
216 		assertFalse(publicField.is(TRANSIENT));
217 		assertTrue(publicField.is(NOT_TRANSIENT));
218 		assertFalse(transientField.is(NOT_TRANSIENT));
219 
220 		// Volatile
221 		assertTrue(volatileField.is(VOLATILE));
222 		assertFalse(publicField.is(VOLATILE));
223 		assertTrue(publicField.is(NOT_VOLATILE));
224 		assertFalse(volatileField.is(NOT_VOLATILE));
225 	}
226 
227 	//====================================================================================================
228 	// isAbstract()
229 	//====================================================================================================
230 	@Test
231 	void a003_isAbstract() {
232 		var abstractClass = getClassInfo(AbstractClass.class);
233 		var abstractMethod = getMethod(AbstractClass.class, "abstractMethod");
234 		var publicClass = getClassInfo(PublicClass.class);
235 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
236 
237 		assertTrue(abstractClass.isAbstract());
238 		assertTrue(abstractMethod.isAbstract());
239 		assertFalse(publicClass.isAbstract());
240 		assertFalse(publicMethod.isAbstract());
241 	}
242 
243 	//====================================================================================================
244 	// isAll(ElementFlag...)
245 	//====================================================================================================
246 	@Test
247 	void a004_isAll() {
248 		var publicClass = getClassInfo(PublicClass.class);
249 		var staticMethod = getMethod(StaticClass.class, "staticMethod");
250 		var finalMethod = getMethod(FinalClass.class, "finalMethod");
251 
252 		// All flags match
253 		assertTrue(publicClass.isAll(PUBLIC, NOT_PRIVATE, NOT_PROTECTED));
254 		assertTrue(staticMethod.isAll(PUBLIC, STATIC));
255 
256 		// Not all flags match
257 		assertFalse(publicClass.isAll(PUBLIC, PRIVATE));
258 		assertFalse(staticMethod.isAll(PUBLIC, STATIC, FINAL));
259 		assertFalse(finalMethod.isAll(PUBLIC, STATIC));
260 
261 		// Empty flags array - allMatch on empty stream returns true (vacuous truth) (line 143)
262 		assertTrue(publicClass.isAll());
263 		assertTrue(staticMethod.isAll());
264 		
265 		// Single flag - ensures stream(flags).allMatch(this::is) is executed (line 143)
266 		assertTrue(publicClass.isAll(PUBLIC));
267 		assertFalse(publicClass.isAll(PRIVATE));
268 		assertTrue(staticMethod.isAll(STATIC));
269 		assertFalse(staticMethod.isAll(FINAL));
270 		
271 		// Multiple flags where first doesn't match (short-circuit) - line 143
272 		// allMatch short-circuits on first false, so this tests the short-circuit branch
273 		assertFalse(publicClass.isAll(PRIVATE, PUBLIC, NOT_PRIVATE));
274 		
275 		// Multiple flags where all match (full iteration) - line 143
276 		// allMatch iterates through all elements when all are true
277 		assertTrue(publicClass.isAll(PUBLIC, NOT_PRIVATE, NOT_PROTECTED, NOT_FINAL));
278 	}
279 
280 	//====================================================================================================
281 	// isAny(ElementFlag...)
282 	//====================================================================================================
283 	@Test
284 	void a005_isAny() {
285 		var publicClass = getClassInfo(PublicClass.class);
286 		var staticMethod = getMethod(StaticClass.class, "staticMethod");
287 		var finalMethod = getMethod(FinalClass.class, "finalMethod");
288 
289 		// At least one flag matches
290 		assertTrue(publicClass.isAny(PUBLIC, PRIVATE));
291 		assertTrue(staticMethod.isAny(PUBLIC, STATIC, FINAL));
292 		assertTrue(finalMethod.isAny(PUBLIC, STATIC, FINAL));
293 
294 		// No flags match
295 		assertFalse(publicClass.isAny(PRIVATE, PROTECTED));
296 		assertFalse(staticMethod.isAny(PRIVATE, FINAL));
297 
298 		// Empty flags array - anyMatch on empty stream returns false (line 157)
299 		assertFalse(publicClass.isAny(new ElementFlag[0]));
300 		assertFalse(staticMethod.isAny(new ElementFlag[0]));
301 		
302 		// Single flag - ensures stream(flags).anyMatch(this::is) is executed (line 157)
303 		assertTrue(publicClass.isAny(PUBLIC));
304 		assertFalse(publicClass.isAny(PRIVATE));
305 		assertTrue(staticMethod.isAny(STATIC));
306 		assertFalse(staticMethod.isAny(FINAL));
307 		
308 		// Multiple flags where first matches (short-circuit) - line 157
309 		// anyMatch short-circuits on first true, so this tests the short-circuit branch
310 		assertTrue(publicClass.isAny(PUBLIC, PRIVATE, PROTECTED));
311 		
312 		// Multiple flags where none match (full iteration) - line 157
313 		// anyMatch iterates through all elements when all are false
314 		assertFalse(publicClass.isAny(PRIVATE, PROTECTED, FINAL, ABSTRACT));
315 	}
316 
317 	//====================================================================================================
318 	// isFinal()
319 	//====================================================================================================
320 	@Test
321 	void a006_isFinal() {
322 		@SuppressWarnings("unused")
323 		var finalClass = getClassInfo(FinalClass.class);
324 		var finalMethod = getMethod(FinalClass.class, "finalMethod");
325 		var finalField = getField(FinalClass.class, "finalField");
326 		var publicClass = getClassInfo(PublicClass.class);
327 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
328 
329 		assertTrue(finalMethod.isFinal());
330 		assertTrue(finalField.isFinal());
331 		assertFalse(publicClass.isFinal());
332 		assertFalse(publicMethod.isFinal());
333 	}
334 
335 	//====================================================================================================
336 	// isInterface()
337 	//====================================================================================================
338 	@Test
339 	void a007_isInterface() {
340 		var interfaceClass = getClassInfo(InterfaceClass.class);
341 		var publicClass = getClassInfo(PublicClass.class);
342 
343 		assertTrue(interfaceClass.isInterface());
344 		assertFalse(publicClass.isInterface());
345 	}
346 
347 	//====================================================================================================
348 	// isNative()
349 	//====================================================================================================
350 	@Test
351 	void a008_isNative() {
352 		var nativeMethod = getMethod(NativeClass.class, "nativeMethod");
353 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
354 
355 		assertTrue(nativeMethod.isNative());
356 		assertFalse(publicMethod.isNative());
357 	}
358 
359 	//====================================================================================================
360 	// isNotAbstract()
361 	//====================================================================================================
362 	@Test
363 	void a009_isNotAbstract() {
364 		var abstractClass = getClassInfo(AbstractClass.class);
365 		var abstractMethod = getMethod(AbstractClass.class, "abstractMethod");
366 		var publicClass = getClassInfo(PublicClass.class);
367 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
368 
369 		assertFalse(abstractClass.isNotAbstract());
370 		assertFalse(abstractMethod.isNotAbstract());
371 		assertTrue(publicClass.isNotAbstract());
372 		assertTrue(publicMethod.isNotAbstract());
373 	}
374 
375 	//====================================================================================================
376 	// isNotFinal()
377 	//====================================================================================================
378 	@Test
379 	void a010_isNotFinal() {
380 		var finalMethod = getMethod(FinalClass.class, "finalMethod");
381 		var finalField = getField(FinalClass.class, "finalField");
382 		var publicClass = getClassInfo(PublicClass.class);
383 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
384 
385 		assertFalse(finalMethod.isNotFinal());
386 		assertFalse(finalField.isNotFinal());
387 		assertTrue(publicClass.isNotFinal());
388 		assertTrue(publicMethod.isNotFinal());
389 	}
390 
391 	//====================================================================================================
392 	// isNotInterface()
393 	//====================================================================================================
394 	@Test
395 	void a011_isNotInterface() {
396 		var interfaceClass = getClassInfo(InterfaceClass.class);
397 		var publicClass = getClassInfo(PublicClass.class);
398 
399 		assertFalse(interfaceClass.isNotInterface());
400 		assertTrue(publicClass.isNotInterface());
401 	}
402 
403 	//====================================================================================================
404 	// isNotNative()
405 	//====================================================================================================
406 	@Test
407 	void a012_isNotNative() {
408 		var nativeMethod = getMethod(NativeClass.class, "nativeMethod");
409 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
410 
411 		assertFalse(nativeMethod.isNotNative());
412 		assertTrue(publicMethod.isNotNative());
413 	}
414 
415 	//====================================================================================================
416 	// isNotPrivate()
417 	//====================================================================================================
418 	@Test
419 	void a013_isNotPrivate() {
420 		var privateClass = getClassInfo(PrivateClass.class);
421 		var publicClass = getClassInfo(PublicClass.class);
422 		var protectedClass = getClassInfo(ProtectedClass.class);
423 
424 		assertFalse(privateClass.isNotPrivate());
425 		assertTrue(publicClass.isNotPrivate());
426 		assertTrue(protectedClass.isNotPrivate());
427 	}
428 
429 	//====================================================================================================
430 	// isNotProtected()
431 	//====================================================================================================
432 	@Test
433 	void a014_isNotProtected() {
434 		var protectedClass = getClassInfo(ProtectedClass.class);
435 		var publicClass = getClassInfo(PublicClass.class);
436 		var privateClass = getClassInfo(PrivateClass.class);
437 
438 		assertFalse(protectedClass.isNotProtected());
439 		assertTrue(publicClass.isNotProtected());
440 		assertTrue(privateClass.isNotProtected());
441 	}
442 
443 	//====================================================================================================
444 	// isNotPublic()
445 	//====================================================================================================
446 	@Test
447 	void a015_isNotPublic() {
448 		var publicClass = getClassInfo(PublicClass.class);
449 		var privateClass = getClassInfo(PrivateClass.class);
450 		var protectedClass = getClassInfo(ProtectedClass.class);
451 
452 		assertFalse(publicClass.isNotPublic());
453 		assertTrue(privateClass.isNotPublic());
454 		assertTrue(protectedClass.isNotPublic());
455 	}
456 
457 	//====================================================================================================
458 	// isNotStatic()
459 	//====================================================================================================
460 	@Test
461 	void a016_isNotStatic() {
462 		var staticMethod = getMethod(StaticClass.class, "staticMethod");
463 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
464 		var staticField = getField(StaticClass.class, "staticField");
465 		var publicField = getField(PublicClass.class, "publicField");
466 
467 		assertFalse(staticMethod.isNotStatic());
468 		assertFalse(staticField.isNotStatic());
469 		assertTrue(publicMethod.isNotStatic());
470 		assertTrue(publicField.isNotStatic());
471 	}
472 
473 	//====================================================================================================
474 	// isNotSynchronized()
475 	//====================================================================================================
476 	@Test
477 	void a018_isNotSynchronized() {
478 		var synchronizedMethod = getMethod(SynchronizedClass.class, "synchronizedMethod");
479 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
480 
481 		assertFalse(synchronizedMethod.isNotSynchronized());
482 		assertTrue(publicMethod.isNotSynchronized());
483 	}
484 
485 	//====================================================================================================
486 	// isNotTransient()
487 	//====================================================================================================
488 	@Test
489 	void a019_isNotTransient() {
490 		var transientField = getField(TransientClass.class, "transientField");
491 		var publicField = getField(PublicClass.class, "publicField");
492 
493 		assertFalse(transientField.isNotTransient());
494 		assertTrue(publicField.isNotTransient());
495 	}
496 
497 	//====================================================================================================
498 	// isNotVolatile()
499 	//====================================================================================================
500 	@Test
501 	void a020_isNotVolatile() {
502 		var volatileField = getField(VolatileClass.class, "volatileField");
503 		var publicField = getField(PublicClass.class, "publicField");
504 
505 		assertFalse(volatileField.isNotVolatile());
506 		assertTrue(publicField.isNotVolatile());
507 	}
508 
509 	//====================================================================================================
510 	// isPrivate()
511 	//====================================================================================================
512 	@Test
513 	void a021_isPrivate() {
514 		var privateClass = getClassInfo(PrivateClass.class);
515 		var privateMethod = getMethod(PrivateClass.class, "privateMethod");
516 		var privateField = getField(PrivateClass.class, "privateField");
517 		var publicClass = getClassInfo(PublicClass.class);
518 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
519 
520 		assertTrue(privateClass.isPrivate());
521 		assertTrue(privateMethod.isPrivate());
522 		assertTrue(privateField.isPrivate());
523 		assertFalse(publicClass.isPrivate());
524 		assertFalse(publicMethod.isPrivate());
525 	}
526 
527 	//====================================================================================================
528 	// isProtected()
529 	//====================================================================================================
530 	@Test
531 	void a022_isProtected() {
532 		var protectedClass = getClassInfo(ProtectedClass.class);
533 		var protectedMethod = getMethod(ProtectedClass.class, "protectedMethod");
534 		var protectedField = getField(ProtectedClass.class, "protectedField");
535 		var publicClass = getClassInfo(PublicClass.class);
536 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
537 
538 		assertTrue(protectedClass.isProtected());
539 		assertTrue(protectedMethod.isProtected());
540 		assertTrue(protectedField.isProtected());
541 		assertFalse(publicClass.isProtected());
542 		assertFalse(publicMethod.isProtected());
543 	}
544 
545 	//====================================================================================================
546 	// isPublic()
547 	//====================================================================================================
548 	@Test
549 	void a023_isPublic() {
550 		var publicClass = getClassInfo(PublicClass.class);
551 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
552 		var publicField = getField(PublicClass.class, "publicField");
553 		var privateClass = getClassInfo(PrivateClass.class);
554 		var protectedClass = getClassInfo(ProtectedClass.class);
555 
556 		assertTrue(publicClass.isPublic());
557 		assertTrue(publicMethod.isPublic());
558 		assertTrue(publicField.isPublic());
559 		assertFalse(privateClass.isPublic());
560 		assertFalse(protectedClass.isPublic());
561 	}
562 
563 	//====================================================================================================
564 	// isStatic()
565 	//====================================================================================================
566 	@Test
567 	void a024_isStatic() {
568 		var staticMethod = getMethod(StaticClass.class, "staticMethod");
569 		var staticField = getField(StaticClass.class, "staticField");
570 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
571 		var publicField = getField(PublicClass.class, "publicField");
572 
573 		assertTrue(staticMethod.isStatic());
574 		assertTrue(staticField.isStatic());
575 		assertFalse(publicMethod.isStatic());
576 		assertFalse(publicField.isStatic());
577 	}
578 
579 
580 	//====================================================================================================
581 	// isSynchronized()
582 	//====================================================================================================
583 	@Test
584 	void a026_isSynchronized() {
585 		var synchronizedMethod = getMethod(SynchronizedClass.class, "synchronizedMethod");
586 		var publicMethod = getMethod(PublicClass.class, "publicMethod");
587 
588 		assertTrue(synchronizedMethod.isSynchronized());
589 		assertFalse(publicMethod.isSynchronized());
590 	}
591 
592 	//====================================================================================================
593 	// isTransient()
594 	//====================================================================================================
595 	@Test
596 	void a027_isTransient() {
597 		var transientField = getField(TransientClass.class, "transientField");
598 		var publicField = getField(PublicClass.class, "publicField");
599 
600 		assertTrue(transientField.isTransient());
601 		assertFalse(publicField.isTransient());
602 	}
603 
604 	//====================================================================================================
605 	// isVolatile()
606 	//====================================================================================================
607 	@Test
608 	void a028_isVolatile() {
609 		var volatileField = getField(VolatileClass.class, "volatileField");
610 		var publicField = getField(PublicClass.class, "publicField");
611 
612 		assertTrue(volatileField.isVolatile());
613 		assertFalse(publicField.isVolatile());
614 	}
615 }
616