Fixes #727 Use ByteBuddy to instrument classes instead Javassist: imp…

…lement suppress constructor

Fix code style issues

config/checkstyle/checkstyle.xml

@@ -102,7 +102,7 @@
       <property name="max" value="8"/>
     </module>
     <module name="AbbreviationAsWordInName">
-      <property name="allowedAbbreviationLength" value="5"/>
+      <property name="allowedAbbreviationLength" value="8"/>
     </module>
     <module name="PackageDeclaration">
       <property name="matchDirectoryStructure" value="false"/>

gradle/java-module.gradle

@@ -1,4 +1,5 @@
 repositories {
+    mavenLocal()
     mavenCentral()
     jcenter()
 }

gradle/release/fullJars.gradle

@@ -12,6 +12,7 @@ configure(fullJars){ project ->
     }
 
     repositories {
+        mavenLocal()
         mavenCentral()
         jcenter()
     }

powermock-core/src/main/java/org/powermock/core/MockGateway.java

@@ -113,6 +113,10 @@ public static Object constructorCall(Class<?> type, Object[] args, Class<?>[] si
         }
         return PROCEED;
     }
+
+    public static boolean suppressConstructorCall(Class<?> type, Object[] args, Class<?>[] sig) throws Throwable {
+        return constructorCall(type, args, sig) != PROCEED;
+    }
 
     /**
      * Tells PowerMock whether or not to mock

powermock-core/src/main/java/org/powermock/core/bytebuddy/ConditionalStateStackManipulation.java

@@ -0,0 +1,78 @@
+/*
+ *
+ *   Copyright 2017 the original author or authors.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+package org.powermock.core.bytebuddy;
+
+import net.bytebuddy.implementation.Implementation.Context;
+import net.bytebuddy.implementation.bytecode.StackManipulation;
+import net.bytebuddy.jar.asm.Label;
+import net.bytebuddy.jar.asm.MethodVisitor;
+import net.bytebuddy.jar.asm.Opcodes;
+
+public class ConditionalStateStackManipulation implements StackManipulation {
+
+
+    private final StackManipulation condition;
+    private final StackManipulation action;
+    private final StackManipulation otherwise;
+    private final Frame frame;
+
+    public ConditionalStateStackManipulation(final StackManipulation condition,
+                                             final StackManipulation action,
+                                             final StackManipulation otherwise,
+                                             final Frame frame) {
+
+        this.condition = condition;
+        this.action = action;
+        this.otherwise = otherwise;
+        this.frame = frame;
+    }
+
+    @Override
+    public boolean isValid() {
+        return true;
+    }
+
+    @Override
+    public Size apply(final MethodVisitor mv, final Context implementationContext) {
+
+        Size size = new Size(0, 0);
+
+        Label proceed = new Label();
+        Label exit = new Label();
+
+        size = size.aggregate(condition.apply(mv, implementationContext));
+
+        mv.visitJumpInsn(Opcodes.IFEQ, proceed);
+
+        size = size.aggregate(action.apply(mv, implementationContext));
+
+        mv.visitJumpInsn(Opcodes.GOTO, exit);
+
+        mv.visitLabel(proceed);
+        mv.visitFrame(Opcodes.F_FULL, frame.localSize(), frame.locals(), 0, null);
+
+        size = size.aggregate(otherwise.apply(mv, implementationContext));
+
+        mv.visitLabel(exit);
+
+        mv.visitFrame(Opcodes.F_FULL, 0, null, 0, null);
+
+        return size;
+    }
+}

powermock-core/src/main/java/org/powermock/core/bytebuddy/Frame.java

@@ -0,0 +1,143 @@
+/*
+ *
+ *   Copyright 2017 the original author or authors.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+package org.powermock.core.bytebuddy;
+
+
+import net.bytebuddy.description.method.ParameterDescription;
+import net.bytebuddy.description.method.ParameterDescription.InDefinedShape;
+import net.bytebuddy.description.method.ParameterList;
+import net.bytebuddy.description.type.TypeDescription.Generic;
+import net.bytebuddy.implementation.bytecode.StackSize;
+import net.bytebuddy.jar.asm.Opcodes;
+import net.bytebuddy.utility.CompoundList;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Frame {
+
+    public static Frame beforeConstructorCall(final Iterable<? extends ParameterDescription> constructorParameters) {
+        List<LocalVariable> locals = new ArrayList<LocalVariable>();
+
+        locals.add(LocalVariable.UNINITIALIZED_THIS);
+
+        int maxLocals = 1;
+
+        for (ParameterDescription sourceParameter : constructorParameters) {
+            Generic type = sourceParameter.getType();
+            locals.add(LocalVariable.from(type));
+            maxLocals += type.getStackSize().getSize();
+        }
+
+        return new Frame(locals);
+    }
+
+    private Deque<Object> stack;
+    private List<LocalVariable> locals;
+
+    public Frame(final List<LocalVariable> locals) {
+        this.locals = Collections.unmodifiableList(locals);
+        this.stack = new LinkedList<Object>();
+    }
+
+    public Frame addTopToLocals(final int count) {
+        List<LocalVariable> locals = new ArrayList<LocalVariable>();
+        for (int i = 0; i < count; i++) {
+            locals.add(LocalVariable.TOP);
+        }
+
+        return new Frame(
+                            CompoundList.of(this.locals, locals)
+        );
+    }
+
+    public Frame addLocalVariable(final LocalVariable localVariable) {
+        return new Frame(
+                            CompoundList.of(this.locals, localVariable)
+        );
+    }
+
+    public Frame addLocalVariables(final ParameterList<InDefinedShape> types) {
+
+        List<LocalVariable> frameLocals = new ArrayList<LocalVariable>();
+
+        for (ParameterDescription parameter : types) {
+            Generic type = parameter.getType();
+            frameLocals.add(LocalVariable.from(type));
+        }
+
+        return new Frame(CompoundList.of(this.locals, frameLocals));
+    }
+
+    public Object[] locals() {
+        Object[] frameLocals = new Object[this.locals.size()];
+        for (int i = 0; i < this.locals.size(); i++) {
+            frameLocals[i] = this.locals.get(i).getType();
+        }
+        return frameLocals;
+    }
+
+    public int localSize() {
+        return locals.size();
+    }
+
+    public int maxLocalVariableIndex() {
+        int localStackSize = 0;
+        for (LocalVariable localVariable : locals) {
+            localStackSize += localVariable.getStackSize().getSize();
+        }
+        return localStackSize;
+    }
+
+    public static class LocalVariable {
+        public static LocalVariable from(final Generic type) {
+            if (type.represents(double.class)) {
+                return DOUBLE;
+            } else {
+                return new LocalVariable(
+                    type.getTypeName().replace('.', '/'),
+                    type.getStackSize()
+                );
+            }
+        }
+
+        public static final LocalVariable UNINITIALIZED_THIS = new LocalVariable(Opcodes.UNINITIALIZED_THIS, StackSize.SINGLE);
+        public static final LocalVariable TOP = new LocalVariable(Opcodes.TOP, StackSize.SINGLE);
+        public static final LocalVariable DOUBLE = new LocalVariable(Opcodes.DOUBLE, StackSize.DOUBLE);
+
+        private final Object type;
+        private final StackSize stackSize;
+
+        private LocalVariable(final Object type, StackSize size) {
+            this.type = type;
+            this.stackSize = size;
+        }
+
+        public Object getType() {
+            return type;
+        }
+
+        public StackSize getStackSize() {
+            return stackSize;
+        }
+    }
+}

powermock-core/src/main/java/org/powermock/core/bytebuddy/MaxLocalsExtractor.java

@@ -0,0 +1,76 @@
+/*
+ *
+ *   Copyright 2017 the original author or authors.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+package org.powermock.core.bytebuddy;
+
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.jar.asm.ClassVisitor;
+import net.bytebuddy.jar.asm.MethodVisitor;
+import net.bytebuddy.jar.asm.Opcodes;
+
+public class MaxLocalsExtractor extends ClassVisitor {
+
+    private MethodMaxLocals methodMaxLocals;
+
+    public MaxLocalsExtractor() {
+        super(Opcodes.ASM5);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature,
+                                     final String[] exceptions) {
+        if (MethodDescription.CONSTRUCTOR_INTERNAL_NAME.equals(name)) {
+            methodMaxLocals = new MethodMaxLocals();
+            return new MaxLocalsMethodVisitor(name, desc, methodMaxLocals);
+        }
+        return super.visitMethod(access, name, desc, signature, exceptions);
+    }
+
+    public MethodMaxLocals getMethods() {
+        return methodMaxLocals;
+    }
+
+    private static class MaxLocalsMethodVisitor extends MethodVisitor {
+
+        private final String name;
+        private final String signature;
+        private final MethodMaxLocals methodMaxLocals;
+        private int maxLocals;
+
+        private MaxLocalsMethodVisitor(final String name, final String signature,
+                                       final MethodMaxLocals methodMaxLocals) {
+            super(Opcodes.ASM5);
+            this.name = name;
+            this.signature = signature;
+            this.methodMaxLocals = methodMaxLocals;
+        }
+
+        @Override
+        public void visitMaxs(final int maxStack, final int maxLocals) {
+            this.maxLocals = maxLocals;
+            super.visitMaxs(maxStack, maxLocals);
+        }
+
+        @Override
+        public void visitEnd() {
+            methodMaxLocals.add(name, signature, maxLocals);
+            super.visitEnd();
+        }
+    }
+
+}

powermock-core/src/main/java/org/powermock/core/bytebuddy/MethodMaxLocals.java

@@ -0,0 +1,44 @@
+/*
+ *
+ *   Copyright 2017 the original author or authors.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+package org.powermock.core.bytebuddy;
+
+import net.bytebuddy.description.method.MethodDescription;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class MethodMaxLocals {
+
+    private final Map<String, Integer> methodMaxLocals;
+
+    MethodMaxLocals() {
+        methodMaxLocals = new HashMap<String, Integer>();
+    }
+
+    public void add(String name, String signature, int maxLocals) {
+        methodMaxLocals.put(name + signature, maxLocals);
+    }
+
+    public int getMethodMaxLocal(final MethodDescription instrumentedMethod) {
+        final String key = instrumentedMethod.getInternalName() + instrumentedMethod.getDescriptor();
+        final Integer maxLocals = methodMaxLocals.get(key);
+        return maxLocals == null ? 0 : maxLocals;
+    }
+}