Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package mockito for openSUSE:Factory checked in at 2024-04-19 19:14:32 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/mockito (Old) and /work/SRC/openSUSE:Factory/.mockito.new.26366 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "mockito" Fri Apr 19 19:14:32 2024 rev:8 rq:1169149 version:5.11.0 Changes: -------- --- /work/SRC/openSUSE:Factory/mockito/mockito.changes 2024-02-22 20:58:49.299834134 +0100 +++ /work/SRC/openSUSE:Factory/.mockito.new.26366/mockito.changes 2024-04-19 19:17:44.507249053 +0200 @@ -1,0 +2,54 @@ +Fri Apr 19 07:18:58 UTC 2024 - Fridrich Strba <[email protected]> + +- Update to version 5.11.0 +- Changes of the 5.x line + * Mockito 5 is making core changes to ensure compatibility with + future JDK versions. + * Switch the Default MockMaker to mockito-inline (not applicable + to mockito-android) + + Mockito 2.7.6 introduced the mockito-inline mockmaker based on + the "inline bytecode" principle, offering compatibility + advantages over the subclass mockmaker. + + This change avoids JDK restrictions, such as violating module + boundaries and leaking subclass creation. + * Legitimate use cases for the subclass mockmaker + + scenarios where the inline mockmaker does not function, such + as on Graal VM's native image. + + Additionally, if avoiding mocking final classes, the subclass + mockmaker remains a viable option, although issues may arise + on JDK 17+. + + Mockito aims to support both mockmakers, allowing users to + choose based on their requirements. + * Update the Minimum Supported Java Version to 11 + + Mockito 4 supports Java 8 and above, but Mockito 5 raises the + minimum supported Java version to 11. + + Community member @reta contributed to this change. + + Users still on JDK 8 can continue using Mockito 4, with + minimal API differences between versions. + * New type() Method on ArgumentMatcher + + The ArgumentMatcher interface now includes a new type() method + to support varargs methods, addressing previous limitations. + + Users can now differentiate between matching calls with any + exact number of arguments or match any number of arguments. + + Mockito 5 provides a default implementation of the new method, + ensuring backward compatibility. + + No obligation for users to implement the new method; Mockito 5 + considers Void.type by default for varargs handling. + + ArgumentCaptor is now fully type-aware, enabling capturing + specific subclasses on a generic method. +- Removed patches: + * fix-bnd-config.patch + * fix-incompatible-types.patch + * fixup-ant-script.patch + * mockito-matcher.patch + * remove-hardcoded-source-target.patch + * setting-naming-policy.patch + + not needed by this version +- Added patches: + * keep-source-target-8.patch + + make the code again buildable with --release 8 + * use-unbundled-asm.patch + + adapt to our change of byte-buddy, where it does not bundle + asm, but uses objectweb-asm as external library + +------------------------------------------------------------------- Old: ---- fix-bnd-config.patch fix-incompatible-types.patch fixup-ant-script.patch mockito-1.10.19.tar.xz mockito-matcher.patch remove-hardcoded-source-target.patch setting-naming-policy.patch New: ---- aggregator.pom keep-source-target-8.patch mockito-5.11.0.tar.xz mockito-core-5.11.0.pom mockito-junit-jupiter-5.11.0.pom use-unbundled-asm.patch BETA DEBUG BEGIN: Old:- Removed patches: * fix-bnd-config.patch * fix-incompatible-types.patch Old: * fix-bnd-config.patch * fix-incompatible-types.patch * fixup-ant-script.patch Old: * fix-incompatible-types.patch * fixup-ant-script.patch * mockito-matcher.patch Old: * fixup-ant-script.patch * mockito-matcher.patch * remove-hardcoded-source-target.patch Old: * mockito-matcher.patch * remove-hardcoded-source-target.patch * setting-naming-policy.patch Old: * remove-hardcoded-source-target.patch * setting-naming-policy.patch + not needed by this version BETA DEBUG END: BETA DEBUG BEGIN: New:- Added patches: * keep-source-target-8.patch + make the code again buildable with --release 8 New: + make the code again buildable with --release 8 * use-unbundled-asm.patch + adapt to our change of byte-buddy, where it does not bundle BETA DEBUG END: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ mockito.spec ++++++ --- /var/tmp/diff_new_pack.TWDqYo/_old 2024-04-19 19:17:47.091344061 +0200 +++ /var/tmp/diff_new_pack.TWDqYo/_new 2024-04-19 19:17:47.111344796 +0200 @@ -17,38 +17,43 @@ Name: mockito -Version: 1.10.19 +Version: 5.11.0 Release: 0 Summary: A Java mocking framework License: MIT Group: Development/Libraries/Java URL: http://%{name}.org Source0: %{name}-%{version}.tar.xz -Patch0: fixup-ant-script.patch -Patch1: fix-bnd-config.patch -Patch2: %{name}-matcher.patch -# Workaround for NPE in setting NamingPolicy in cglib -Patch3: setting-naming-policy.patch -# because we have old objenesis -Patch4: fix-incompatible-types.patch -Patch5: remove-hardcoded-source-target.patch -BuildRequires: ant -BuildRequires: aqute-bnd -BuildRequires: cglib -BuildRequires: dos2unix +# build with maven instead of gradle +Source2: aggregator.pom +Source3: https://repo1.maven.org/maven2/org/mockito/mockito-core/%{version}/mockito-core-%{version}.pom +Source4: https://repo1.maven.org/maven2/org/mockito/mockito-junit-jupiter/%{version}/mockito-junit-jupiter-%{version}.pom +Patch0: use-unbundled-asm.patch +Patch1: keep-source-target-8.patch BuildRequires: fdupes -BuildRequires: hamcrest -BuildRequires: java-devel >= 1.8 -BuildRequires: javapackages-local >= 6 -BuildRequires: junit -BuildRequires: objenesis -BuildRequires: unzip +BuildRequires: maven-local +BuildRequires: mvn(junit:junit) +BuildRequires: mvn(net.bytebuddy:byte-buddy) +BuildRequires: mvn(net.bytebuddy:byte-buddy-agent) +BuildRequires: mvn(net.bytebuddy:byte-buddy-dep) +BuildRequires: mvn(org.apache.maven.plugins:maven-antrun-plugin) +BuildRequires: mvn(org.junit.jupiter:junit-jupiter-api) +BuildRequires: mvn(org.objenesis:objenesis) +BuildRequires: mvn(org.opentest4j:opentest4j) BuildArch: noarch %description Mockito is a mocking framework. It lets you write tests. Tests produce clean verification errors. +%package junit-jupiter +Summary: Mockito JUnit 5 support +Group: Development/Libraries/Java +Requires: %{name} = %{version}-%{release} + +%description junit-jupiter +Mockito JUnit 5 support. + %package javadoc Summary: Javadocs for %{name} Group: Documentation/HTML @@ -57,54 +62,88 @@ This package contains the API documentation for %{name}. %prep -%setup -q -dos2unix `find -name *.java` -%patch -P 0 -%patch -P 1 -%patch -P 2 -p1 -%patch -P 3 -p1 -%patch -P 4 -p1 -%patch -P 5 -p1 - -%pom_add_dep net.sf.cglib:cglib:3.1 maven/mockito-core.pom -find . -name "*.java" -exec sed -i "s|org\.%{name}\.cglib|net\.sf\.cglib|g" {} + -mkdir -p lib/compile lib/build lib/run lib/repackaged +%autosetup -p1 -%pom_xpath_remove 'target[@name="javadoc"]/copy' build.xml +cp %{SOURCE2} aggregator.pom +cp %{SOURCE3} pom.xml +cp %{SOURCE4} subprojects/junit-jupiter/pom.xml + +# Compatibility alias +%{mvn_alias} org.%{name}:%{name}-core org.%{name}:%{name}-all + +%pom_add_dep junit:junit +%pom_add_dep net.bytebuddy:byte-buddy-dep +%pom_remove_dep org.objenesis:objenesis +%pom_add_dep org.objenesis:objenesis +%pom_add_dep org.opentest4j:opentest4j + +%pom_remove_dep org.junit.jupiter:junit-jupiter-api subprojects/junit-jupiter +%pom_add_dep org.junit.jupiter:junit-jupiter-api subprojects/junit-jupiter + +mkdir -p src/main/resources/mockito-extensions +echo 'member-accessor-module' > src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor +echo 'mock-maker-subclass' > src/main/resources/mockito-extensions/org.mockito.plugins.MockMaker + +# see gradle/mockito-core/inline-mock.gradle +%pom_xpath_inject 'pom:project' ' +<build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-antrun-plugin</artifactId> + <version>any</version> + <executions> + <execution> + <phase>process-classes</phase> + <configuration> + <target> + <copy file="${project.build.outputDirectory}/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class" + tofile="${project.build.outputDirectory}/org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.raw"/> + </target> + </configuration> + <goals> + <goal>run</goal> + </goals> + </execution> + </executions> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-jar-plugin</artifactId> + <version>any</version> + <configuration> + <excludes> + <exclude>org/mockito/internal/creation/bytebuddy/inject/*.class</exclude> + </excludes> + </configuration> + </plugin> + </plugins> +</build> +' + +%{mvn_package} :aggregator __noinstall %build -build-jar-repository lib/compile objenesis cglib junit hamcrest/core -ant -Dant.build.javac.source=1.8 -Dant.build.javac.target=1.8 jar javadoc prepare.poms +%{mvn_build} -f -- \ + -Dproject.build.outputTimestamp=$(date -u -d @${SOURCE_DATE_EPOCH:-$(date +%%s)} +%%Y-%%m-%%dT%%H:%%M:%%SZ) \ +%if %{?pkg_vcmp:%pkg_vcmp java-devel >= 9}%{!?pkg_vcmp:0} + -Dmaven.compiler.release=8 \ +%endif + -Dmaven.compiler.source=8 -Dmaven.compiler.target=8 -Dsource=8 \ + -Dproject.build.sourceEncoding=UTF-8 -f aggregator.pom -echo "-reproducible: true" >> conf/%{name}-core.bnd -echo "-noextraheaders: true" >> conf/%{name}-core.bnd -echo "-snapshot: SNAPSHOT" >> conf/%{name}-core.bnd - -# Convert to OSGi bundle -bnd wrap \ - --version %{version} \ - --output target/%{name}-core-%{version}.bar \ - --properties conf/%{name}-core.bnd \ - target/%{name}-core-%{version}.jar -mv target/%{name}-core-%{version}.bar target/%{name}-core-%{version}.jar +%{mvn_package} org.mockito:mockito-junit-jupiter junit-jupiter %install -# jar -install -dm 0755 %{buildroot}%{_javadir}/%{name} -install -pm 0644 target/%{name}-core-%{version}.jar %{buildroot}%{_javadir}/%{name}/%{name}-core.jar -# pom -install -dm 0755 %{buildroot}%{_mavenpomdir}/%{name} -%{mvn_install_pom} target/%{name}-core.pom %{buildroot}%{_mavenpomdir}/%{name}/%{name}-core.pom -%add_maven_depmap %{name}/%{name}-core.pom %{name}/%{name}-core.jar -a org.%{name}:%{name}-all -# javadoc -install -dm 0755 %{buildroot}%{_javadocdir}/%{name} -cp -pr target/javadoc/* %{buildroot}%{_javadocdir}/%{name}/ +%mvn_install %fdupes -s %{buildroot}%{_javadocdir} %files -f .mfiles -%license LICENSE NOTICE +%license LICENSE +%doc README.md doc/design-docs/custom-argument-matching.md + +%files junit-jupiter -f .mfiles-junit-jupiter -%files javadoc -%{_javadocdir}/%{name} -%license LICENSE NOTICE +%files javadoc -f .mfiles-javadoc +%license LICENSE ++++++ _service ++++++ --- /var/tmp/diff_new_pack.TWDqYo/_old 2024-04-19 19:17:47.243349649 +0200 +++ /var/tmp/diff_new_pack.TWDqYo/_new 2024-04-19 19:17:47.243349649 +0200 @@ -2,16 +2,13 @@ <service name="tar_scm" mode="disabled"> <param name="scm">git</param> <param name="url">https://github.com/mockito/mockito.git</param> - <param name="revision">v1.10.19</param> - <param name="versionformat">1.10.19</param> - <param name="exclude">build.gradle</param> - <param name="exclude">cglib-and-asm</param> - <param name="exclude">lib/*</param> - <param name="exclude">doc</param> - <param name="exclude">gradle</param> - <param name="exclude">gradlew</param> - <param name="exclude">gradlew.bat</param> - <param name="exclude">javadoc</param> + <param name="revision">v5.11.0</param> + <param name="match-tag">v*</param> + <param name="versionformat">@PARENT_TAG@</param> + <param name="versionrewrite-pattern">v(.*)</param> + <param name="exclude">*gradle*</param> + <param name="exclude">**/*.gradle</param> + <param name="exclude">src/javadoc</param> </service> <service name="recompress" mode="disabled"> <param name="file">*.tar</param> ++++++ aggregator.pom ++++++ <?xml version="1.0" encoding="UTF-8"?> <project xmlns='http://maven.apache.org/POM/4.0.0' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd'> <modelVersion>4.0.0</modelVersion> <groupId>org.fedoraproject.xmvn.mockito</groupId> <artifactId>aggregator</artifactId> <version>any</version> <packaging>pom</packaging> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <modules> <module>.</module> <module>subprojects/junit-jupiter</module> </modules> </project> ++++++ keep-source-target-8.patch ++++++ --- a/src/main/java/org/mockito/internal/debugging/LocationImpl.java +++ b/src/main/java/org/mockito/internal/debugging/LocationImpl.java @@ -12,14 +12,12 @@ import org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleaner; import org.mockito.invocation.Location; import java.io.Serializable; -import java.lang.StackWalker.Option; -import java.lang.StackWalker.StackFrame; import java.util.Collections; +import java.util.Arrays; import java.util.List; import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Collectors; -import java.util.stream.Stream; class LocationImpl implements Location, Serializable { private static final long serialVersionUID = 2954388321980069195L; @@ -37,8 +35,6 @@ class LocationImpl implements Location, Serializable { */ private static final int BUFFER_SIZE = 16; - private static final StackWalker STACK_WALKER = stackWalker(); - private static final String PREFIX = "-> at "; private static final StackTraceCleaner CLEANER = @@ -51,7 +47,7 @@ class LocationImpl implements Location, Serializable { * per element). By assigning these Functions and Predicates to variables, we can * avoid the memory allocation. */ - private static final Function<StackFrame, StackFrameMetadata> toStackFrameMetadata = + private static final Function<StackTraceElement, StackFrameMetadata> toStackFrameMetadata = MetadataShim::new; private static final Predicate<StackFrameMetadata> cleanerIsIn = CLEANER::isIn; @@ -87,15 +83,14 @@ class LocationImpl implements Location, Serializable { } private static StackFrameMetadata getStackFrame(boolean isInline) { - return stackWalk( - stream -> - stream.map(toStackFrameMetadata) - .skip(FRAMES_TO_SKIP) - .filter(cleanerIsIn) - .skip(isInline ? 1 : 0) - .findFirst() - .orElseThrow( - () -> new MockitoException(noStackTraceFailureMessage()))); + StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace(); + return Arrays.stream(stackTraceElements) + .skip(FRAMES_TO_SKIP) + .map(toStackFrameMetadata) + .filter(cleanerIsIn) + .skip(isInline ? 1 : 0) + .findFirst() + .orElseThrow(() -> new MockitoException(noStackTraceFailureMessage())); } private static boolean usingDefaultStackTraceCleaner() { @@ -120,63 +115,48 @@ class LocationImpl implements Location, Serializable { * ensure there are no non-Mockito frames at the top of the stack trace. */ private static int framesToSkip() { - return stackWalk( - stream -> { - List<String> metadata = - stream.map(toStackFrameMetadata) - .map(StackFrameMetadata::getClassName) - .collect(Collectors.toList()); - return metadata.indexOf(LocationImpl.class.getName()); - }); - } - - private static <T> T stackWalk(Function<Stream<StackFrame>, T> function) { - return (T) STACK_WALKER.walk(function); - } - - private static StackWalker stackWalker() { - return StackWalker.getInstance( - Collections.singleton(Option.SHOW_REFLECT_FRAMES), BUFFER_SIZE); + List<String> stackTraceElements = Arrays.asList(Thread.currentThread().getStackTrace()).stream().map(x -> x.getClassName()).collect(Collectors.toList()); + return stackTraceElements.indexOf(LocationImpl.class.getName()) + 1; } private static final class MetadataShim implements StackFrameMetadata, Serializable { private static final long serialVersionUID = 8491903719411428648L; - private final StackFrame stackFrame; + private final StackTraceElement ste; - private MetadataShim(StackFrame stackFrame) { - this.stackFrame = stackFrame; + private MetadataShim(StackTraceElement ste) { + this.ste = ste; } @Override public String getClassName() { - return stackFrame.getClassName(); + return ste.getClassName(); } @Override public String getMethodName() { - return stackFrame.getMethodName(); + return ste.getMethodName(); } @Override public String getFileName() { - return stackFrame.getFileName(); + return ste.getFileName(); } @Override public int getLineNumber() { - return stackFrame.getLineNumber(); + return ste.getLineNumber(); } @Override public String toString() { - return stackFrame.toString(); + return ste.toString(); } /** * Ensure that this type remains serializable. */ private Object writeReplace() { - return new SerializableShim(stackFrame.toStackTraceElement()); + return new SerializableShim(ste); } } --- a/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java +++ b/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java @@ -54,7 +54,7 @@ public class ReturnsDeepStubs implements Answer<Object>, Serializable { MockCreationSettings<?> mockSettings = MockUtil.getMockSettings(invocation.getMock()); Class<?> rawType = returnTypeGenericMetadata.rawType(); - final var emptyValue = ReturnsEmptyValues.returnCommonEmptyValueFor(rawType); + final Object emptyValue = ReturnsEmptyValues.returnCommonEmptyValueFor(rawType); if (emptyValue != null) { return emptyValue; } --- a/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java +++ b/src/main/java/org/mockito/plugins/DoNotMockEnforcer.java @@ -57,7 +57,7 @@ public interface DoNotMockEnforcer extends DoNotMockEnforcerWithType { return null; } - private String recursiveCheckDoNotMockAnnotationForType(Class<?> type) { + default String recursiveCheckDoNotMockAnnotationForType(Class<?> type) { // Object and interfaces do not have a super class if (type == null) { return null; --- a/src/main/java/org/mockito/plugins/MockitoPlugins.java +++ b/src/main/java/org/mockito/plugins/MockitoPlugins.java @@ -43,7 +43,7 @@ public interface MockitoPlugins { * @since 2.10.0 * @deprecated Please use {@link #getMockMaker(String)} with {@link org.mockito.MockMakers#INLINE} instead. */ - @Deprecated(since = "5.6.0", forRemoval = true) + @Deprecated MockMaker getInlineMockMaker(); /** --- a/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java +++ b/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java @@ -171,12 +171,12 @@ public class MockitoExtension implements BeforeEachCallback, AfterEachCallback, do { annotation = findAnnotation(currentContext.getElement(), MockitoSettings.class); - if (currentContext.getParent().isEmpty()) { + if (currentContext.getParent() == null || !currentContext.getParent().isPresent()) { break; } currentContext = currentContext.getParent().get(); - } while (annotation.isEmpty() && currentContext != context.getRoot()); + } while ((annotation == null || !annotation.isPresent()) && currentContext != context.getRoot()); return annotation; } --- a/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CompositeParameterResolver.java +++ b/subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/resolver/CompositeParameterResolver.java @@ -9,6 +9,7 @@ import org.junit.jupiter.api.extension.ParameterContext; import org.junit.jupiter.api.extension.ParameterResolutionException; import org.junit.jupiter.api.extension.ParameterResolver; +import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -17,7 +18,7 @@ public class CompositeParameterResolver implements ParameterResolver { private final List<ParameterResolver> delegates; public CompositeParameterResolver(final ParameterResolver... delegates) { - this.delegates = List.of(delegates); + this.delegates = Arrays.asList(delegates); } @Override ++++++ mockito-1.10.19.tar.xz -> mockito-5.11.0.tar.xz ++++++ ++++ 167804 lines of diff (skipped) ++++++ mockito-core-5.11.0.pom ++++++ <?xml version="1.0" encoding="UTF-8"?> <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"; xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";> <modelVersion>4.0.0</modelVersion> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>5.11.0</version> <name>mockito-core</name> <description>Mockito mock objects library core API and implementation</description> <url>https://github.com/mockito/mockito</url> <licenses> <license> <name>MIT</name> <url>https://opensource.org/licenses/MIT</url> <distribution>repo</distribution> </license> </licenses> <developers> <developer> <id>mockitoguy</id> <name>Szczepan Faber</name> <url>https://github.com/mockitoguy</url> <roles> <role>Core developer</role> </roles> </developer> <developer> <id>bric3</id> <name>Brice Dutheil</name> <url>https://github.com/bric3</url> <roles> <role>Core developer</role> </roles> </developer> <developer> <id>raphw</id> <name>Rafael Winterhalter</name> <url>https://github.com/raphw</url> <roles> <role>Core developer</role> </roles> </developer> <developer> <id>TimvdLippe</id> <name>Tim van der Lippe</name> <url>https://github.com/TimvdLippe</url> <roles> <role>Core developer</role> </roles> </developer> </developers> <scm> <url>https://github.com/mockito/mockito.git</url> </scm> <issueManagement> <system>GitHub issues</system> <url>https://github.com/mockito/mockito/issues</url> </issueManagement> <ciManagement> <system>GH Actions</system> <url>https://github.com/mockito/mockito/actions</url> </ciManagement> <dependencies> <dependency> <groupId>net.bytebuddy</groupId> <artifactId>byte-buddy</artifactId> <version>1.14.12</version> <scope>compile</scope> </dependency> <dependency> <groupId>net.bytebuddy</groupId> <artifactId>byte-buddy-agent</artifactId> <version>1.14.12</version> <scope>compile</scope> </dependency> <dependency> <groupId>org.objenesis</groupId> <artifactId>objenesis</artifactId> <version>3.3</version> <scope>runtime</scope> </dependency> </dependencies> </project> ++++++ mockito-junit-jupiter-5.11.0.pom ++++++ <?xml version="1.0" encoding="UTF-8"?> <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"; xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";> <modelVersion>4.0.0</modelVersion> <groupId>org.mockito</groupId> <artifactId>mockito-junit-jupiter</artifactId> <version>5.11.0</version> <name>mockito-junit-jupiter</name> <description>Mockito JUnit 5 support</description> <url>https://github.com/mockito/mockito</url> <licenses> <license> <name>MIT</name> <url>https://opensource.org/licenses/MIT</url> <distribution>repo</distribution> </license> </licenses> <developers> <developer> <id>mockitoguy</id> <name>Szczepan Faber</name> <url>https://github.com/mockitoguy</url> <roles> <role>Core developer</role> </roles> </developer> <developer> <id>bric3</id> <name>Brice Dutheil</name> <url>https://github.com/bric3</url> <roles> <role>Core developer</role> </roles> </developer> <developer> <id>raphw</id> <name>Rafael Winterhalter</name> <url>https://github.com/raphw</url> <roles> <role>Core developer</role> </roles> </developer> <developer> <id>TimvdLippe</id> <name>Tim van der Lippe</name> <url>https://github.com/TimvdLippe</url> <roles> <role>Core developer</role> </roles> </developer> </developers> <scm> <url>https://github.com/mockito/mockito.git</url> </scm> <issueManagement> <system>GitHub issues</system> <url>https://github.com/mockito/mockito/issues</url> </issueManagement> <ciManagement> <system>GH Actions</system> <url>https://github.com/mockito/mockito/actions</url> </ciManagement> <dependencies> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>5.11.0</version> <scope>compile</scope> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.10.2</version> <scope>runtime</scope> </dependency> </dependencies> </project> ++++++ use-unbundled-asm.patch ++++++ diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java index 10b73c81a..5e2d8d2dc 100644 --- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java +++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java @@ -18,8 +18,8 @@ import net.bytebuddy.dynamic.ClassFileLocator; import net.bytebuddy.dynamic.scaffold.MethodGraph; import net.bytebuddy.dynamic.scaffold.TypeValidation; import net.bytebuddy.implementation.Implementation; -import net.bytebuddy.jar.asm.ClassVisitor; -import net.bytebuddy.jar.asm.MethodVisitor; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.MethodVisitor; import net.bytebuddy.matcher.ElementMatchers; import net.bytebuddy.pool.TypePool; import net.bytebuddy.utility.OpenedClassReader; diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java index 1490501ea..743a04f36 100644 --- a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java +++ b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java @@ -37,10 +37,10 @@ import net.bytebuddy.implementation.bind.annotation.Argument; import net.bytebuddy.implementation.bind.annotation.This; import net.bytebuddy.implementation.bytecode.StackSize; import net.bytebuddy.implementation.bytecode.assign.Assigner; -import net.bytebuddy.jar.asm.Label; -import net.bytebuddy.jar.asm.MethodVisitor; -import net.bytebuddy.jar.asm.Opcodes; -import net.bytebuddy.jar.asm.Type; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.Type; import net.bytebuddy.pool.TypePool; import net.bytebuddy.utility.OpenedClassReader; diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java index 93c8913ac..972753e78 100644 --- a/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java +++ b/src/test/java/org/mockito/internal/creation/bytebuddy/AbstractByteBuddyMockMakerTest.java @@ -21,6 +21,7 @@ import org.mockito.mock.SerializableMode; import org.mockito.plugins.MockMaker; import org.mockitoutil.ClassLoaders; import org.mockitoutil.SimpleSerializationUtil; +import org.objectweb.asm.ClassVisitor; import org.objenesis.ObjenesisStd; public abstract class AbstractByteBuddyMockMakerTest<MM extends MockMaker> @@ -126,7 +127,7 @@ public abstract class AbstractByteBuddyMockMakerTest<MM extends MockMaker> // given ClassLoader classpath_with_objenesis = ClassLoaders.excludingClassLoader() - .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, ObjenesisStd.class) + .withCodeSourceUrlOf(Mockito.class, ByteBuddy.class, ObjenesisStd.class, ClassVisitor.class) .withCodeSourceUrlOf(coverageTool()) .build(); diff --git a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java b/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java index f971893e4..63af9cd52 100644 --- a/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java +++ b/src/test/java/org/mockito/internal/junit/JUnitRuleTest.java @@ -8,6 +8,7 @@ import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mockingDetails; import static org.mockito.Mockito.when; +import org.junit.Ignore; import org.junit.Rule; import org.junit.Test; import org.mockito.Mock; @@ -42,6 +43,7 @@ public class JUnitRuleTest { @SuppressWarnings({"CheckReturnValue", "MockitoUsage"}) @Test + @Ignore public void does_not_check_invalid_mockito_usage_on_failure() throws Throwable { // This intended behavior is questionable // However, it was like that since the beginning of JUnit rule support diff --git a/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java b/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java index 7b156f0aa..d488e9628 100644 --- a/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java +++ b/src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java @@ -16,6 +16,7 @@ import org.junit.Test; import org.mockito.Mockito; import org.mockito.internal.configuration.plugins.Plugins; import org.mockitoutil.ClassLoaders; +import org.objectweb.asm.ClassVisitor; import org.objenesis.Objenesis; public class NoJUnitDependenciesTest { @@ -32,6 +33,7 @@ public class NoJUnitDependenciesTest { Matcher.class, ByteBuddy.class, ByteBuddyAgent.class, + ClassVisitor.class, Objenesis.class) .withCodeSourceUrlOf(coverageTool()) .without("junit", "org.junit", "org.opentest4j")
