powermock/powermock

Features

• Java Unit Testing - Implements a specialized unit testing framework for Java that isolates code by mocking static methods and final classes.
• Bytecode Instrumentation Agents - Includes a runtime agent that injects bytecode transformations to modify system classes and bypass runtime environment locks.
• Runtime Instrumentation Agents - Injects bytecode transformations at runtime to modify system classes and bypass restricted environment locks.
• Bytecode Manipulation - Rewrites class bytes during loading to remove modifiers and intercept static or private method calls.
• Java Bytecode Manipulation - Provides advanced capabilities to modify compiled Java class bytes at runtime to override language restrictions and bypass encapsulation.
• Method Interception Proxies - Implements a mocking engine that reroutes method calls to a proxy handler to return predefined values.
• Constructor Interception - Intercepts the Java 'new' keyword to return mock instances instead of real objects during class instantiation.
• Mocking Frameworks - Provides a comprehensive Java mocking framework utilizing bytecode manipulation to isolate static methods, final classes, and private constructors.
• Partial Mocks - Implements test doubles that selectively execute original class logic while overriding specific methods.
• Private Member Mocks - Overrides private or final methods to verify internal behavior without altering source code visibility.
• Private Constructor Mocks - Bypasses private constructor restrictions to enable the creation of mock objects for classes with limited instantiation.
• Static Member Mocks - Uses bytecode instrumentation to mock static methods and object instances to isolate tests from real implementations.
• Private Method Stubs - Intercepts calls to private methods to isolate the unit under test from its internal dependencies.
• System Class Mocking - Intercepts calls to core runtime system classes and native methods typically locked by the JVM.
• Legacy Code Testing - Enables testing of old Java codebases by suppressing static initializers and intercepting internal object construction without source changes.
• Private Member Access - Provides utilities to retrieve or modify private fields and methods from external classes via reflection.
• Startup Agent Bootstrapping - Loads the project environment as a system agent to resolve classloading conflicts during JVM startup.
• Private Constructor Invocations - Creates instances of classes with private constructors by invoking them through reflection.
• Reflection-Based State Inspection - Uses language reflection to get or set private field values and verify object state.
• Reflection Utilities - Includes reflection-based utilities for invoking private methods and accessing internal object state.
• System Class Mocking - Simulates the behavior of core Java system classes and native methods typically locked by the JVM runtime.
• Encapsulation Bypasses - Uses reflection to access and modify private members of a class without changing source code visibility.
• Field Initialization Suppressions - Prevents specific member fields from being initialized during object instantiation.
• JUnit Rule Integrations - Provides specialized JUnit rules and runners to integrate advanced bytecode mocking into standard Java test suites.
• Member Field Resets - Restores member field values to their defaults after execution to ensure a clean state between tests.
• Method Executions Suppressions - Disables specific method calls or code blocks during tests to avoid side effects and external dependencies.
• Method Execution Suppressions - Blocks specific methods from executing and returns default values to bypass logic hindering unit tests.
• Initializer Suppressions - Prevents the execution of static initializers and constructors during object creation to avoid side effects.
• Construction Verification - Provides capabilities to verify that a specific class was instantiated with the expected arguments during test execution.
• Private Method Invocations - Provides the ability to execute and verify logic within private methods and fields using Java reflection.
• Signed Class Mocking - Bypasses signature verification to mock classes contained within signed archives.
• Final Member Mocks - Overrides final modifiers on classes and methods to control their behavior during test execution.
• Method Interception Spies - Creates spies of existing objects to mock specific methods while preserving the original behavior of others.
• Testing Frameworks - Mocks static methods, constructors, and private methods.

Star history