Add additional test and assure lazy resolution of some modifier properties.

Author: raphw

.mvn/checksums.sha256

@@ -52,6 +52,7 @@ codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:0.0.6 1274279e722893d5566dbfeb79441
 codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:0.0.7 0f03b065a7f8d2084213b36d7f60eb9b051d37d52dedf0c7b942bb2ae6e3b643
 codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:0.0.8 046c716ee03b45d5cd0b801183cc8dff1f2bf7e854c097457c0fee7afbce0d73
 codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:0.0.9 3f7a5d593e0a56b1a5e69f0b0474d4fba5ea8d8cb0fe1d2952e71201cb65e20e
+codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:sources:0.0.10 170ead3613f036baf2e2142dc6385a5b2320df427f9892a8b3f5c58c54c23711
 codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:sources:0.0.2 681eb8c703ddd28797d7eaeb975ce3546068b8e49f5b47a841919689e7ca267f
 codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:sources:0.0.4 c76939fe1ecef6fe571d25ba2a3a7c708151152170083b27b01afe104283fa12
 codes.rafael.asmjdkbridge:asm-jdk-bridge:jar:sources:0.0.6 3fca530e91539b7a006fb194dbfd31d61e97e6d64bcce5366b68f96cf44bbca0

byte-buddy-dep/src/main/java/net/bytebuddy/description/type/TypeDescription.java

@@ -8602,6 +8602,26 @@ public int getModifiers() {
                     return delegate().getModifiers();
                 }
 
+                @Override
+                public boolean isAbstract() {
+                    return delegate().isAbstract();
+                }
+
+                @Override
+                public boolean isEnum() {
+                    return delegate().isEnum();
+                }
+
+                @Override
+                public boolean isInterface() {
+                    return delegate().isInterface();
+                }
+
+                @Override
+                public boolean isAnnotation() {
+                    return delegate().isAnnotation();
+                }
+
                 @Override
                 @MaybeNull
                 public String getGenericSignature() {

byte-buddy-dep/src/test/java/net/bytebuddy/pool/TypePoolDefaultWithLazyResolutionTypeDescriptionTest.java

@@ -7,15 +7,19 @@
 import net.bytebuddy.dynamic.scaffold.InstrumentedType;
 import net.bytebuddy.dynamic.scaffold.MethodGraph;
 import net.bytebuddy.dynamic.scaffold.TypeValidation;
+import net.bytebuddy.utility.AsmClassReader;
 import org.hamcrest.CoreMatchers;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
+import org.objectweb.asm.ClassVisitor;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
 
 import static net.bytebuddy.matcher.ElementMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -251,6 +255,66 @@ public void testSimpleName() throws Exception {
         assertThat(describe($DollarInName.class).getSimpleName(), CoreMatchers.is($DollarInName.class.getSimpleName()));
     }
 
+    @Test
+    public void testClassFileIsNotParsedForExtendedProperties() throws Exception {
+        if (lazinessMode == TypePool.Default.WithLazyResolution.LazinessMode.NAME) {
+            return;
+        }
+        TypeDescription typeDescription = new TypePool.Default.WithLazyResolution(new TypePool.CacheProvider.Simple(),
+                ClassFileLocator.ForClassLoader.of(NonGenericType.class.getClassLoader()),
+                TypePool.Default.ReaderMode.EXTENDED,
+                new AsmClassReader.Factory() {
+                    public AsmClassReader make(byte[] binaryRepresentation) {
+                        return make(Default.IMPLICIT.make(binaryRepresentation));
+                    }
+
+                    public AsmClassReader make(byte[] binaryRepresentation, boolean experimental) {
+                        return make(Default.IMPLICIT.make(binaryRepresentation, experimental));
+                    }
+
+                    private AsmClassReader make(final AsmClassReader delegate) {
+                        return new AsmClassReader() {
+                            @Override
+                            public <T> T unwrap(Class<T> type) {
+                                return delegate.unwrap(type);
+                            }
+
+                            @Override
+                            public int getModifiers() {
+                                return delegate.getModifiers();
+                            }
+
+                            @Override
+                            public String getInternalName() {
+                                return delegate.getInternalName();
+                            }
+
+                            @Override
+                            public String getSuperClassInternalName() {
+                                return delegate.getSuperClassInternalName();
+                            }
+
+                            @Override
+                            public List<String> getInterfaceInternalNames() {
+                                return delegate.getInterfaceInternalNames();
+                            }
+
+                            @Override
+                            public void accept(ClassVisitor classVisitor, int flags) {
+                                throw new AssertionError();
+                            }
+                        };
+                    }
+                },
+                lazinessMode).describe(NonGenericType.class.getName()).resolve();
+        assertThat(typeDescription.getSuperClass().asErasure().getName(), CoreMatchers.is(NonGenericType.class.getSuperclass().getName()));
+        assertThat(typeDescription.getInterfaces().get(0).asErasure().getName(), CoreMatchers.is(NonGenericType.class.getInterfaces()[0].getName()));
+        assertThat(typeDescription.isAbstract(), CoreMatchers.is(Modifier.isAbstract(NonGenericType.class.getModifiers())));
+        assertThat(typeDescription.isInterface(), CoreMatchers.is(Modifier.isInterface(NonGenericType.class.getModifiers())));
+        assertThat(typeDescription.isAnnotation(), CoreMatchers.is(Modifier.isInterface(NonGenericType.class.getModifiers())));
+        assertThat(typeDescription.isEnum(), CoreMatchers.is(NonGenericType.class.isEnum()));
+    }
+
     private static class SuperClass {
         /* empty */
     }