Datasets:

feedback-to-code

/

mozzarella

like 1

Follow

Feedback-2-Code 7

[ "keyword_issue_to_pr" ]

[ "I think we can push `2.1.0` next week since RC has been available for a little while now. Also I submitted a (random) PR to Google Guava and 850k+ tests did not fail :tada: https://github.com/google/guava/pull/2567\n", "Shall I publish a RC tomorrow after merging #646 ?\n", "-1 for merging #646 unless it's safe with unexpected system properties\n-1 for RC for #646. If this is the only bug / improvement, I suggest we push out 2.1.0 final, followed by 2.1.1 that contains the improvement. While I like the improvement, it does not strike me as something that needs another release candidate.\n\nGiven that we don't have more feedback to investigate, I suggest to set the final release to Monday. Good day to release :)\n", "I think we should merge #646 before releasing a final version. We already got several reported issues that were caused by old Java versions and I expect that quite a lot of people might not have updated their JDK in years.\n\nOtherthan that, I agree that we do not need a release candidate for this.\n", "Oh oops I indeed did not mean RC, but the final release :p\n\nSo lets merge #646 when the issue is fixed and then publish `2.1.0` on monday :tada:\n", "I will tweak the code before the end of the week-end, I was short on time these past two week.\n", "The final version needs to be exactly the same as the last RC. That's the idea of \"release candidates\" :)\n\nEssentially, the options are:\n\na) publish 2.1.0 final now, include the improvement in 2.1.1 (no rc needed, after 2.1.0 is out we won't be releasing candidates for 2.x versions)\nb) wait for fixes in the improvement, merge it, publish 2.1.0-rc-2, wait some time (for example, a day), publish 2.1.0 final\n\n@raphw says it's important to include the fix, so let's do option b)\n", "It is not strictly required for 1 very small bug fix to create a whole new RC with the accompanying waiting time. Other teams have also published their latest RC with just a couple of bug fixes immediately as final release, so I think we can safely release 2.1.0 with #646 on monday.\n", "The fact that other teams do it does not mean that it's right :)\n\nWe want to be in the position that we can always say that: \"the RC is exactly the final release\". This helps convincing teams to use RCs.\n\nOf course nothing can stop you from publishing final with any number of fixes you want. However, it is simply the matter of good practice to follow version conventions and avoid making exceptions for no good reason.\n\nPublishing final version with patches on top of last RC is sloppy. The reason one might want to do it is when the release process is manual / hard. It's not the case for Mockito, where entire pipeline is automated!!! :D\n", "I agree with you that we should **not** push this to the final release but I really think that we should merge #646 before going final. Therefore, I suggest a second release candidate instead of a release on Monday. Let's please do this right. Isn't this what RCs are for? Doing so, we can also merge #648.\n\nThe problem addressed by #646 was reported at least 6 times. Many developers do not even mean to run old Java versions but have some outdated JDK bundled with their IDE. This means that tests run using Maven but not in, for example, Eclipse, what is difficult to debug and will most likely cause frustration among some early adopters of Mockito 2. In the end, I have spent some hours myself to investigate reported issues of this origin. If we had thought of something like @bric3's solution earlier, I am sure we would have done this right away and I was very happy to see this PR. I am also sure this automatic debugging help will free us some time once Mockito 2 hits the mainstream and more people run into this problem.\n\nAs for #648, I think this can make quite a difference in how the Mockito 2 release is perceived in the public. A lot of people have already implemented their own stream-aware \"smart null\" answers or Java 8-adapters - thanks to the great Mockito API making this so easy - and most of our other changes are internal clean-ups and and do not really change user experience. With adding support for mocking final types and methods, we are delivering something new and exciting, something that people will speak about. Without such a feature, we are risking to suffer the Java 7-phenomenon where very few people bothered to update despite the significant changes made in the OpenJDK. In the end, to a user updating is a risk and additional work; so why bother if there is nothing in for you? In this perspective, Java 8 was an entirely different story. And _true_ final mocks do not really exist in the Java-space yet, in this respect we have built something that was never done before! I am sure people will want to try this feature out what hopefully motivates more folks to an upgrade.\n\nGiven that we have 2 PRs that only need to be merged with features that are both helping migration and adding some fuzz about the upcoming release, I am strictly against going for a final version on Monday. Let's pick this low hanging fruit. Also, from a marketing perspective, releasing Mockito 2.1 on Monday and Mockito 2.2-RC on Tuesday, I do not think this would sell well.\n\nI wish I had time to do all this before the RC was published but I was too busy during JavaZone and I had to catch up some sleep before getting everything I wanted ready. But now we have waited so long, let's delay the final version for just a little bit more. Isn't anticipation the greatest joy anyways? \n", "> The problem addressed by #646 was reported at least 6 times. \n\nI totally agree. Let's make java8 warning a part of 2.1.0. All I want is to follow good practices of versioning and RC.\n\n> releasing Mockito 2.1 on Monday and Mockito 2.2-RC on Tuesday, I do not think this would sell well.\n\nWe don't publish RCs for _compatible_ versions. We don't plan RCs for 2.2, 2.3, 2.12.32, they are compatible versions and don't need RCs.\n\n> And true final mocks do not really exist in the Java-space yet, in this respect we have built something that was never done before!\n\nLOVE IT!!!!\n\n> As for #648, I think this can make quite a difference in how the Mockito 2 release is perceived in the public.\n\nThat's really cool :) Caveats:\n- it's late\n- the feature is not ready (assuming the code is ok, documentation? release notes?)\n- the feature is a breaking change due to extra dependencies\n\nI'm not sure why you push so hard to include it in 2.1.0. You can spend more time on this feature, make it great, compatible, well documented, push it with 2.2.0 few weeks from now, include buzz, promo, etc. You will achieve **exactly** the same results community-wise. Actually, I think it is even better to spread good features over time to demonstrate that Mockito continually improves. Community will be adopting Mockito 2 slowly, it will take years. Some projects will stay on 1.10 forever :)\n\nI'm curious:\n- how much time is needed to make the feature is ready?\n- how much time is needed to make the feature backwards compatible?\n\n@raphw, I'm very happy you work on this and I totally admire your passion to improve Mockito. Let's build a plan and make it work. This feature is too late for 2.1.0. Last minute, unannounced big features, in the RC phase - this is just not a good idea. We've been planning the release for months, inline mocks never appeared on the checklists.\n\nLong story short, we don't need to block 2.1.0 to make this available in 2.x and make it an awesome, neat feature!!! :)\n", "As I said before, the feature is ready: it passes all of Mockito's unit tests when it is activated and we even added this to the Travis build to be constantly verified. At the same time, the feature guarantees to not break anything.\n\nI want to merge this now as there is nothing left to do, this is why the feature is a PR ready to be merged and not a private branch. If it is not included in 2.1, I can live with this but I find this a missed opportunity. From my perspective, this feature is good to go and I do not plan to spend more time on it, even if it is not included in 2.1. I can only improve it once people started using it and give me feedback.\n\nI already explained why I think it would be better to include it in 2.1 from a marketing perspective. Other than that, the feature can be added in 2.2 but in the meantime, it will just sit there with nothing changing; worst case some rebasements onto head.\n\nEffectively, what you suggests means therefore that we release 2.1.Final now and 2.2.Final in a few weeks (?). 2.2.Final will be the exact same jar as 2.1.Final would be with this feature merged. I simply do not see how this would improve anything.\n", "Usually following process is is good, but some time following guts is nice too. I second @raphw to include the mockmaker, it's opt-in. \n\nI agree final mock never appeared on the radar here, but the topic was discussed and investigated more than a year ago, by me and especially Rafael who, in the end, achieved this alone. That's a fantastic work @raphw !!!\n\nIncluding this is an opportunity. We already included incubating API before, I don't see why we shouldn't include it in 2.1.0 (and as such an 2.1.0-RC.x ) as well.\n", "Thank you guys challenging me and the good practices. We should be challenging one another and keep growing as technical leaders. Discussions like those are the core of collaborative software engineering. Let's enjoy them and never feel discouraged! I find you guys the best crowd I worked with in a while, and @raphw, you did pull off a feature nobody yet did in the history of mocking :)\n\nAbout the feature: it's too late to include it in the 2.1.0 final. It's great work and it must be included in Mockito. This feature is incompatible in the current form because of new dependencies. \n\nI will continue pushing Mockito team to follow decent engineering practices:\n- when RC is published, subsequent RCs are triggered for bugfixes required to get the release out\n- subsequent RCs are not used to ship new features, especially when they include breaking changes\n- no sudden big changes, midnight before major version release ;)\n- favoring incremental improvements, for better stability\n\nMockito is the product that has 2M users, it deserves thoughtful and rigorous following of decent engineering practices. Of course exceptions are necessary, but for good reasons!\n\n> Effectively, what you suggests means therefore that we release 2.1.Final now and 2.2.Final in a few weeks (?). 2.2.Final will be the exact same jar as 2.1.Final would be with this feature merged. I simply do not see how this would improve anything.\n\nWe can merge and publish version 2.2.0 even next day after the release, so long the feature is ready & compatible. I haven't reviewed the PR thoroughly yet, anyone else did? Does it have user-facing documentation (e.g. how can I opt-in for the feature, what can I expect?). Is it utterly and completely safe for default behavior?\n", "> Is it utterly and completely safe for default behavior?\n\n**YES**, it uses the plugin loader for that, people that want to try final class mocks will have to explicitly make a file in the folder `mockito-extensions`.\n\n> Does it have user-facing documentation (e.g. how can I opt-in for the feature, what can I expect?)\n\nSee [`Mockito` class](https://github.com/mockito/mockito/pull/648/files#diff-ddbc0d47e06a589778a6efe24c5d71d3R1220)\n\n> I haven't reviewed the PR thoroughly yet, anyone else did?\n\n**YES**, I did\n\n> - subsequent RCs are not used to ship new features, especially when they include breaking changes\n\nAdding a dependency is not a breaking change. However for other reasons I think mockito should avoid relying on that dependency. **EDIT :** manually shadowed.\n\n> - no sudden big changes, midnight before major version release ;)\n\nFor such a change, actually an opt-in feature, I think we should release another release candidate. (We will have another RC anyway due to the java version warning.)\n", "@bric3, shouting not needed :) Thank you for the answers! It's really helpful.\n\nThe documentation looks nice, I'll make some edits in the branch.\n\nAdding new dependency is backwards incompatible. I will write later why :)\n\nI'm +1 to including it in RC because:\n- I'm confident about the quality and documentation\n- It's an opt-in feature\n- New dependency is shadowed\n- The other new dependency (agent) is a part of ByteBuddy, so I'm willing to compromise the backwards compatibility of the RCs this time.\n\nI will write a comment to PR with few things I want to get done before it's merged.\n\nGreat work, thank you!\n", "Adding new dependency is a breaking change: https://www.linkedin.com/pulse/sofware-craftsmanship-adding-new-dependency-breaking-change-faber :)\n", "I don't think I fully agree with your article. In very technical terms, yes it is a breaking change. However, claiming that it breaks builds is imo a stretch in this particular case. The dependency is very small, has almost no new versions and looking at the release schedule, only 3 minor versions were available longer than a week. Therefore the likelihood of having a dependency conflict (even in minor range) is close to zero (if not zero). Therefore I think it is an exaggeration to claim it is something to worry about.\n\nI would also not like to point to your thoughtpiece in the documentation. I do acknowledge your point of view, but I simply do not share it. Therefore I would like to refrain from putting it in the official documentation, since that would indicate it is shared by the whole Mockito dev team.\n", "The article does not discuss the probability of failure. It simply describes facts. Change that can break clients is by definition \"incompatible\". The team can still decide to ship such change, as we are doing :)\n\nI respect your POV. Write your own article!\n\nI intend to link to the article. However, I would love to link to your article, too. Mockito needs more traction and publicity, strong opinions and public discussions is good for us all.\n\nI'm serious, write the article!\n", "@szczepiq \nI don't see a problem of adding a new dependency since the major version of mockito changed. Mockito v1.x has dependencies to hamcrest and objenesis whereas v2.x relies one byte-buddy and objenesis, so an other dependency don't make it worse. \n\nThe problem you describe in your article is IMO not the added dependency that breaks the build, that can also happen if a library updates to a new version of a dependency . I think the root cause is the fact that you client relies on library (read mockito) version that has no final/GA release. If they use non final version they should be aware of changes. For the same reason many teams have a policy that only allows to use final releases. \n", "I don't agree with these facts :\n\n> Adding new dependency is a breaking change\n> - New dependency is not present in corporate repo of one of your clients. His build breaks.\n\nThis argument completely disreagard dependency management tool like gradle or maven. Mockito is only distributed on bintray and maven central that are exactly made for getting those transitive dependencies.\n\n> - New dependency is not allowed in corporate repo of your client (for example, due to poor reputation or security concerns). The client cannot use the new version.\n\nWith such policies, the importing library update itself is subject to these restrictions, and therefore updates are not allowed anyway until reviews approves changes of the importing library. This will happen regardless of the dependency being an external jar or being shaded.\n\ne.g. license concerns won't be elimitated if the classes are just shaded.\n\n> - New dependency is already declared by the client, but with different, incompatible version. Conflict resolution picks up later version causing failures at runtime.\n> \n> Updating dependency could be a breaking change\n\nThis is indeed true and this is the only valid argument to me. Anyway the scope of this argument is limited because upgrading the importing library too can be in itself a breaking change (according to semver), e.g. mockito 2.x is incompatible with mockito 1.x.\nThis is indeed a problem with minor versions.\n\nUpdating a dependency is indeed something that could be breaking, but so could be the importing library.\n", "@bric3, you're right, my first example in the use case is invalid. Thanks for pointing this out, I'll update the article.\n\n@bric3, @ChristianSchwarz - you're right about the fact that major versions can carry breaking changes. However, including incompatible changes in subsequent release candidate is a poor engineering practice.\n\nRelease candidate by definition, is a software that is \"ready to release\" unless significant bugs are discovered. This means that N+1 release candidate should not have new features, big changes, and most importantly, incompatible changes. Consumers of release candidates need to be able to rely on this rule.\n\nThoughtful exceptions can always be made by the team, as we are doing :) I'll keep pushing for decent versioning practices. Thanks guys for feedback!!!\n", "@szczepiq not there's still two items in #123, I think they can be safely removed, as we won't remove the serialVersionUid, and unincubated API have either _hatched out_ or stil incubating.\n\nAlso on mockito javadoc there's link that point to an old website (like https://monkeyisland.pl/2009/01/13/subclass-and-override-vs-partial-mocking-vs-refactoring), I think we should only point to mockito wiki or github repo, not external website that can disappear anytime.\n", "Done. \n\n> I think we should only point to mockito wiki or github repo\n\n+1\n", "I think we can publish on monday. The release seems very stable and we have yet another successful upgrade, this time at RxJava: https://github.com/ReactiveX/RxJava/pull/4636\n", "+1. THANKS for great work :DDDD Pleasure doing projects together!!!\n\nGreat idea to migrate RxJava!\n", "Published, w00h00. Upgrade today :tada: \n" ]

[ "Why would this be abstract? It has a private constructor anyways.\n", "To keep it consistent, let's make these constant Strings too.\n", "Space after `if`?\n", "I would reverse this, to make the conditional equivalent to the name of the method. Very small nit though, but I had to think about it for a second :smile: \n", "It seems that these lines are untested. Are we able to come up with a test for this? E.g. why would we reorder these values.\n", "replace 'visible' with 'non-private'? Users might not know what 'visible' is :)\n", "AFAIR, StringJoiner always adds next line for each String argument. This means that if java is < 45, there will be extra EOLs. Perhaps it's fine, just wanted FYI.\n", "This is a fantastic improvement, very Mockito-style :D We always strive to make the exception messages better, even a notch better. In the long run all those small improvements create a compound effect. We'll have fantastic error handling, crisp and clear exception messages and happy users!!!\n", "FYI: Java 9 changes the standard version String and possibly other standard system properties. Let's make sure it works on Java 9 :)\n", "Let's make sure this is always safe, regardless of the content of the system properties. Those properties are mutable AFAIK, and/or might change/be different with future versions of java or perhaps even jvm/jdk vendor.\n\nOtherwise, love this PR :)\n", "Yes I wanted an extra empty line before platform information (if the runtime is a java 8 version below update 45)\n", "ok\n", "At the moment this shouldn't be a problem. the parsing targets Java 8 runtime\n\nhttp://openjdk.java.net/jeps/223\n", "Because they are wrong in the message ;) \nThe type to mock is not the class that the mockmaker created ;)\n", "yes i forgot that, I was a bit in hurry for this PR, and wanted to push on the remote ;)\nThis was still a work in progress ;)\n", "It's a usual practice to disallow instantiation.\n", "Yes true, but that is what the private constructor guarantees too right? But leaving it in is fine too :)\n" ]

"2016-09-22T08:33:22Z"

[ "epic" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGenerator.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGenerator.java", "src/main/java/org/mockito/internal/util/Platform.java" ]

[ "src/test/java/org/mockito/internal/util/PlatformTest.java" ]

"2016-09-17T15:57:32Z"

[ "keyword_pr_to_issue" ]

[ "Can be closed...\n" ]

[ "Why would this be abstract? It has a private constructor anyways.\n", "To keep it consistent, let's make these constant Strings too.\n", "Space after `if`?\n", "I would reverse this, to make the conditional equivalent to the name of the method. Very small nit though, but I had to think about it for a second :smile: \n", "It seems that these lines are untested. Are we able to come up with a test for this? E.g. why would we reorder these values.\n", "replace 'visible' with 'non-private'? Users might not know what 'visible' is :)\n", "AFAIR, StringJoiner always adds next line for each String argument. This means that if java is < 45, there will be extra EOLs. Perhaps it's fine, just wanted FYI.\n", "This is a fantastic improvement, very Mockito-style :D We always strive to make the exception messages better, even a notch better. In the long run all those small improvements create a compound effect. We'll have fantastic error handling, crisp and clear exception messages and happy users!!!\n", "FYI: Java 9 changes the standard version String and possibly other standard system properties. Let's make sure it works on Java 9 :)\n", "Let's make sure this is always safe, regardless of the content of the system properties. Those properties are mutable AFAIK, and/or might change/be different with future versions of java or perhaps even jvm/jdk vendor.\n\nOtherwise, love this PR :)\n", "Yes I wanted an extra empty line before platform information (if the runtime is a java 8 version below update 45)\n", "ok\n", "At the moment this shouldn't be a problem. the parsing targets Java 8 runtime\n\nhttp://openjdk.java.net/jeps/223\n", "Because they are wrong in the message ;) \nThe type to mock is not the class that the mockmaker created ;)\n", "yes i forgot that, I was a bit in hurry for this PR, and wanted to push on the remote ;)\nThis was still a work in progress ;)\n", "It's a usual practice to disallow instantiation.\n", "Yes true, but that is what the private constructor guarantees too right? But leaving it in is fine too :)\n" ]

"2016-09-22T08:33:22Z"

[ "enhancement" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGenerator.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/ByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/CachingMockBytecodeGenerator.java", "src/main/java/org/mockito/internal/util/Platform.java" ]

[ "src/test/java/org/mockito/internal/util/PlatformTest.java" ]

"2016-09-17T15:27:23Z"

[ "timestamp(timedelta=1.0, similarity=0.9526223644965176)", "keyword_pr_to_issue" ]

[]

[]

"2016-09-24T14:20:27Z"

[]

[ "build.gradle" ]

[ "build.gradle" ]

[]

"2016-09-24T09:34:15Z"

[ "timestamp(timedelta=1.0, similarity=0.8851382101039562)" ]

[ "PR? :)\n", "Check. See #654.\n" ]

[]

"2016-09-27T14:33:49Z"

[ "refactoring" ]

[ "src/main/java/org/mockito/internal/runners/StrictRunner.java", "src/main/java/org/mockito/internal/runners/util/FailureDetecter.java" ]

[ "src/main/java/org/mockito/internal/runners/StrictRunner.java", "src/main/java/org/mockito/internal/runners/util/FailureDetector.java" ]

[]

"2016-09-27T11:57:26Z"

[ "timestamp(timedelta=0.0, similarity=0.9690160524901865)" ]

[]

[]

"2016-09-27T16:15:03Z"

[]

[ "src/main/java/org/mockito/internal/junit/FriendlyExceptionMaker.java", "src/main/java/org/mockito/internal/junit/JUnitDetecter.java", "src/main/java/org/mockito/internal/junit/JUnitTool.java" ]

[ "src/main/java/org/mockito/internal/junit/FriendlyExceptionMaker.java", "src/main/java/org/mockito/internal/junit/JUnitDetector.java", "src/main/java/org/mockito/internal/junit/JUnitTool.java" ]

[]

"2016-09-27T16:09:54Z"

[ "timestamp(timedelta=0.0, similarity=0.9684891101898311)", "keyword_pr_to_issue" ]

[]

[]

"2016-09-30T05:15:15Z"

[]

[ "build.gradle", "gradle/wrapper/gradle-wrapper.properties", "gradlew", "gradlew.bat" ]

[ "build.gradle", "gradle/wrapper/gradle-wrapper.properties", "gradlew", "gradlew.bat" ]

[]

"2016-09-30T05:07:41Z"

[ "timestamp(timedelta=2.0, similarity=0.9517652425385589)" ]

[]

[ "`out` could be `StringBuilder` instead of just `String`.\n", "Formatting.\n", "`String.format()` to improve readability?\n", "Why not to mark it with `@Override` to force a deletion? AFAIR Mockito does not support Java 5 any longer.\n", "It would be nice to prefer AssertJ assertions over Junit they have a better API and allow chaining. Not a blocker to merge though.\n", "Actually it's the reverse `assertThat(value).isEqualTo(expected)`\n", "@szczepiq It seems to remain not fixed.\n" ]

"2016-10-17T04:07:32Z"

[ "new feature" ]

[ "src/main/java/org/mockito/MockingDetails.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/MockitoDebugger.java", "src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java", "src/main/java/org/mockito/internal/debugging/WarningsCollector.java", "src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java", "src/main/java/org/mockito/internal/util/DefaultMockingDetails.java", "src/main/java/org/mockito/stubbing/Stubbing.java" ]

[ "src/main/java/org/mockito/MockingDetails.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/MockitoDebugger.java", "src/main/java/org/mockito/internal/debugging/InvocationsPrinter.java", "src/main/java/org/mockito/internal/debugging/MockitoDebuggerImpl.java", "src/main/java/org/mockito/internal/debugging/WarningsCollector.java", "src/main/java/org/mockito/internal/invocation/UnusedStubsFinder.java", "src/main/java/org/mockito/internal/util/DefaultMockingDetails.java", "src/main/java/org/mockito/stubbing/Stubbing.java" ]

[ "src/test/java/org/mockito/internal/util/DefaultMockingDetailsTest.java", "src/test/java/org/mockitousage/debugging/InvocationsPrinterTest.java" ]

"2016-08-10T00:45:21Z"

[ "timestamp(timedelta=0.0, similarity=0.8775874955528284)" ]

[ "Given how Answer is supposed to be used it is a safe change to do. Plus, it is marked as @Incubating :)\n" ]

[]

"2016-10-24T10:31:38Z"

[ "bug" ]

[ "src/main/java/org/mockito/stubbing/Answer1.java", "src/main/java/org/mockito/stubbing/Answer2.java", "src/main/java/org/mockito/stubbing/Answer3.java", "src/main/java/org/mockito/stubbing/Answer4.java", "src/main/java/org/mockito/stubbing/Answer5.java", "src/main/java/org/mockito/stubbing/VoidAnswer1.java", "src/main/java/org/mockito/stubbing/VoidAnswer2.java", "src/main/java/org/mockito/stubbing/VoidAnswer3.java", "src/main/java/org/mockito/stubbing/VoidAnswer4.java", "src/main/java/org/mockito/stubbing/VoidAnswer5.java" ]

[ "src/main/java/org/mockito/stubbing/Answer1.java", "src/main/java/org/mockito/stubbing/Answer2.java", "src/main/java/org/mockito/stubbing/Answer3.java", "src/main/java/org/mockito/stubbing/Answer4.java", "src/main/java/org/mockito/stubbing/Answer5.java", "src/main/java/org/mockito/stubbing/VoidAnswer1.java", "src/main/java/org/mockito/stubbing/VoidAnswer2.java", "src/main/java/org/mockito/stubbing/VoidAnswer3.java", "src/main/java/org/mockito/stubbing/VoidAnswer4.java", "src/main/java/org/mockito/stubbing/VoidAnswer5.java" ]

[]

"2016-10-21T22:28:34Z"

[ "keyword_pr_to_issue" ]

[ "https://github.com/mockito/mockito/issues/384#issuecomment-243044175\n", "@szczepiq This is not the javadoc but I've mentioned a bit the runner in the what's new / migration guide in the wiki in the improvement section \n\nhttps://github.com/mockito/mockito/wiki/What%27s-new-in-Mockito-2\n", "Per https://github.com/mockito/mockito/issues/720#issuecomment-257087017 the message of `UnnecessaryStubbingException` should be improved to mention `MockitoJUnitRunner.Silent`.\n" ]

[]

"2016-11-14T05:07:55Z"

[ "docs" ]

[ "src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java", "src/main/java/org/mockito/internal/exceptions/Reporter.java" ]

[ "src/main/java/org/mockito/exceptions/misusing/UnnecessaryStubbingException.java", "src/main/java/org/mockito/internal/exceptions/Reporter.java" ]

[ "src/test/java/org/mockitousage/junitrunner/UnusedStubsExceptionMessageTest.java" ]

"2016-08-29T16:18:39Z"

[ "keyword_pr_to_issue" ]

[]

[ "This change does not work, see https://github.com/mockito/mockito/pull/760#issuecomment-261229080\n" ]

"2016-11-17T13:13:53Z"

[ "docs" ]

[ "build.gradle", "buildSrc/src/main/java/org/mockito/javadoc/JavadocExclude.java", "gradle/javadoc.gradle", "src/main/java/org/mockito/AdditionalAnswers.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/configuration/IMockitoConfiguration.java", "src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java" ]

[ "build.gradle", "gradle/javadoc.gradle", "src/main/java/org/mockito/AdditionalAnswers.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/configuration/IMockitoConfiguration.java", "src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java" ]

[ "subprojects/testng/testng.gradle" ]

"2016-11-17T05:52:17Z"

[ "keyword_issue_to_pr" ]

[ "Was fixed in #763" ]

[ "This change does not work, see https://github.com/mockito/mockito/pull/760#issuecomment-261229080\n" ]

"2016-11-17T13:13:53Z"

[ "docs" ]

[ "build.gradle", "buildSrc/src/main/java/org/mockito/javadoc/JavadocExclude.java", "gradle/javadoc.gradle", "src/main/java/org/mockito/AdditionalAnswers.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/configuration/IMockitoConfiguration.java", "src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java" ]

[ "build.gradle", "gradle/javadoc.gradle", "src/main/java/org/mockito/AdditionalAnswers.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/configuration/IMockitoConfiguration.java", "src/main/java/org/mockito/exceptions/stacktrace/StackTraceCleaner.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java" ]

[ "subprojects/testng/testng.gradle" ]

"2016-11-14T05:29:00Z"

[ "timestamp(timedelta=1.0, similarity=0.9228255909277773)" ]

[ "When mockito runs on Java 8 it already provide default answers for `Optional` / `Stream`", "I tested that before filing this issue; that's true for `Optional`, but not for `OptionalInt` and friends.", "Oh ok I read too fast the issue description. Sorry ;)\r\n\r\nlooking forward the PR.", "No worries :). PR filed: #782.", "NB: I opened this ticket before opening the PR only because the contribution guidelines [state](https://github.com/mockito/mockito/blob/release/2.x/.github/CONTRIBUTING.md) that at least one commit must be of the form `Fixes #id :`. But it seems a number of PRs (like the aforementioned #429) don't follow this guideline. Also, the guidelines indicate there should be a colon after the issue ID, but that rule seems to be followed \"almost never\". So what's your current view on this?", "@Stephan202 Sorry for the late reply, I'm in the middle of painful refactoring at work.\r\n\r\nWell this generally apply when there's a separate issue either because it's the same person, or because there's delay between the issue and the pull request, but you can propose a pull request that fixes an issue, that's ok, just as long as you describe properly the problem or motivate properly the change ;)" ]

[ "It just asks to simplify it with parameterized tests, e.g. with https://github.com/Pragmatists/JUnitParams/wiki/Quickstart . @Stephan202, would you dare to do it? ;)", "@szpak: I'm fine opening an extra PR, but I think the Mockito team should first decide on which parameterized test framework to use. The one you linked is an option, but JUnit also comes with built-in support for [`@RunWith(Theories.class)`](https://github.com/junit-team/junit4/wiki/Theories) and [`@RunWith(Parameterized.class)`](https://github.com/junit-team/junit4/wiki/parameterized-tests). There may be others, and it seems right now none of these approaches are used.\r\n\r\nAlternatively, the test duplication can be avoided as follows:\r\n```diff\r\ndiff --git a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java\r\nindex 480a9a1..ab9aad9 100644\r\n--- a/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java\r\n+++ b/src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java\r\n@@ -90,70 +90,32 @@ public class ReturnsEmptyValuesTest extends TestBase {\r\n \r\n @Test\r\n public void should_return_empty_Optional() throws Exception {\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.Stream\");\r\n-\r\n- //given\r\n- Object stream = mock(streamType);\r\n- Object optional = streamType.getMethod(\"findAny\").invoke(stream);\r\n- assertNotNull(optional);\r\n- assertFalse((Boolean) Class.forName(\"java.util.Optional\").getMethod(\"isPresent\").invoke(optional));\r\n-\r\n- Invocation findAny = this.getLastInvocation();\r\n-\r\n- //when\r\n- Object result = values.answer(findAny);\r\n-\r\n- //then\r\n- assertEquals(optional, result);\r\n+ verify_empty_Optional_is_returned(\"java.util.stream.Stream\", \"java.util.Optional\");\r\n }\r\n \r\n @Test\r\n public void should_return_empty_OptionalDouble() throws Exception {\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.DoubleStream\");\r\n-\r\n- //given\r\n- Object stream = mock(streamType);\r\n- Object optional = streamType.getMethod(\"findAny\").invoke(stream);\r\n- assertNotNull(optional);\r\n- assertFalse((Boolean) Class.forName(\"java.util.OptionalDouble\").getMethod(\"isPresent\").invoke(optional));\r\n-\r\n- Invocation findAny = this.getLastInvocation();\r\n-\r\n- //when\r\n- Object result = values.answer(findAny);\r\n-\r\n- //then\r\n- assertEquals(optional, result);\r\n+ verify_empty_Optional_is_returned(\"java.util.stream.DoubleStream\", \"java.util.OptionalDouble\");\r\n }\r\n \r\n @Test\r\n public void should_return_empty_OptionalInt() throws Exception {\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.IntStream\");\r\n-\r\n- //given\r\n- Object stream = mock(streamType);\r\n- Object optional = streamType.getMethod(\"findAny\").invoke(stream);\r\n- assertNotNull(optional);\r\n- assertFalse((Boolean) Class.forName(\"java.util.OptionalInt\").getMethod(\"isPresent\").invoke(optional));\r\n-\r\n- Invocation findAny = this.getLastInvocation();\r\n-\r\n- //when\r\n- Object result = values.answer(findAny);\r\n-\r\n- //then\r\n- assertEquals(optional, result);\r\n+ verify_empty_Optional_is_returned(\"java.util.stream.IntStream\", \"java.util.OptionalInt\");\r\n }\r\n \r\n @Test\r\n public void should_return_empty_OptionalLong() throws Exception {\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.LongStream\");\r\n+ verify_empty_Optional_is_returned(\"java.util.stream.LongStream\", \"java.util.OptionalLong\");\r\n+ }\r\n+\r\n+ private void verify_empty_Optional_is_returned(String streamFqcn, String optionalFqcn) throws Exception {\r\n+ Class<?> streamType = getClassOrSkipTest(streamFqcn);\r\n \r\n //given\r\n Object stream = mock(streamType);\r\n Object optional = streamType.getMethod(\"findAny\").invoke(stream);\r\n assertNotNull(optional);\r\n- assertFalse((Boolean) Class.forName(\"java.util.OptionalLong\").getMethod(\"isPresent\").invoke(optional));\r\n+ assertFalse((Boolean) Class.forName(optionalFqcn).getMethod(\"isPresent\").invoke(optional));\r\n \r\n Invocation findAny = this.getLastInvocation();\r\n \r\n@@ -166,54 +128,34 @@ public class ReturnsEmptyValuesTest extends TestBase {\r\n \r\n @Test\r\n public void should_return_empty_Stream() throws Exception {\r\n- // given\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.Stream\");\r\n-\r\n- // when\r\n- Object stream = values.returnValueFor(streamType);\r\n- long count = (Long) streamType.getMethod(\"count\").invoke(stream);\r\n-\r\n- // then\r\n- assertEquals(\"count of empty Stream\", 0L, count);\r\n+ verify_empty_Stream_is_returned(\"java.util.stream.Stream\");\r\n }\r\n \r\n @Test\r\n public void should_return_empty_DoubleStream() throws Exception {\r\n- // given\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.DoubleStream\");\r\n-\r\n- // when\r\n- Object stream = values.returnValueFor(streamType);\r\n- long count = (Long) streamType.getMethod(\"count\").invoke(stream);\r\n-\r\n- // then\r\n- assertEquals(\"count of empty DoubleStream\", 0L, count);\r\n+ verify_empty_Stream_is_returned(\"java.util.stream.DoubleStream\");\r\n }\r\n \r\n @Test\r\n public void should_return_empty_IntStream() throws Exception {\r\n- // given\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.IntStream\");\r\n-\r\n- // when\r\n- Object stream = values.returnValueFor(streamType);\r\n- long count = (Long) streamType.getMethod(\"count\").invoke(stream);\r\n-\r\n- // then\r\n- assertEquals(\"count of empty IntStream\", 0L, count);\r\n+ verify_empty_Stream_is_returned(\"java.util.stream.IntStream\");\r\n }\r\n \r\n @Test\r\n public void should_return_empty_LongStream() throws Exception {\r\n+ verify_empty_Stream_is_returned(\"java.util.stream.LongStream\");\r\n+ }\r\n+\r\n+ private void verify_empty_Stream_is_returned(String streamFqcn) throws Exception {\r\n // given\r\n- Class<?> streamType = getClassOrSkipTest(\"java.util.stream.LongStream\");\r\n+ Class<?> streamType = getClassOrSkipTest(streamFqcn);\r\n \r\n // when\r\n Object stream = values.returnValueFor(streamType);\r\n long count = (Long) streamType.getMethod(\"count\").invoke(stream);\r\n \r\n // then\r\n- assertEquals(\"count of empty LongStream\", 0L, count);\r\n+ assertEquals(\"count of empty \" + streamFqcn, 0L, count);\r\n }\r\n \r\n /**\r\n```\r\n", "I think that your proposed refactor is sufficient enough.", "It's a poor man's parameterized tests, but just for that case it is probably enough.\r\n\r\nBtw, I haven't used `Theories`, but `Parameterized` from JUnit is very verbose and limited. To define one parameterized test you need to sacrifice the whole class (you need to use fields and a constructor). There's no way to create more than one parameterized test in the same test class (which very often is very handy). JUnitParams is much more flexible (no to mentioned Spock brings it to the another level :) ).", "Alright, pending a decision on which framework to use, I opened PR #783 with the changes shown above.\r\n\r\n(Regarding Spock: my colleague @zshamrock gave a presentation/demo about that just last Thursday. It does look like a perfect fit for this sort of thing indeed.)", "Is this a breaking change?", "Well it's a behavioural change, so by definition one can write a test that passed prior but not afterwards. For this particular change that'd look something like the following:\r\n\r\n1. One has a class `C` with a method `m` returning `OptionalDouble`.\r\n2. One mocks `C`, producing an instance `c`.\r\n3. One fails to explicitly mock the behaviour of `c.m`.\r\n4. One uses `c` in some code that invokes `c.m` and relies on the result being `null`.\r\n\r\nI think the \"breakage\" in this case is acceptable for the following reasons:\r\n\r\n1. Since values of type `Optional*` should never be `null`, the failure points out a misuse of `Optional*`, and as such does the user a favour.\r\n2. If one insists on a \"nullable `Optional*`\", adding a simple mock statement in step 3 above clearly documents that contract, consistent with the [principle of least astonishment](https://en.wikipedia.org/wiki/Principle_of_least_astonishment).\r\n3. More generally, if a test crucially relies on a certain method's return value, then it's good practise to document this precondition explicitly.\r\n\r\nI feel the above arguments apply to `Stream*` as much as they do to `Optional*`, because a stream is a (proto) collection in some sense, and nullable collections are also decidedly an anti-pattern. WDYT?", "Your change is really good, it improves Mockito behavior for Java8!\r\n\r\nRegardless of the final decision whether to merge it or not, I find it disturbing that it wasn't discussed as a breaking change in this PR. @bric3, @TimvdLippe thoughts?", "To be honest, I had not realised this. Especially because I dont think someone relies on the previous null behavior.\r\n\r\nNonetheless we should have discussed this, good point.", "JUnitParams is fine, I have nothing against, let's go for it, test readability and maintainability is just as important as production code.", "Well my reasoning was fast : \r\n\r\n1. We forgot that in mockito 2, as a user I usually see that as a bug.\r\n2. The change is consistent with the goal of mockito 2 aka support java 8 best way.\r\n3. The change is breaking for users that uses primitive variant and that expect null for these stubs, which is not what those type are made for, so pretty rare.\r\n\r\nAll in a all this a reasonable change, that imo does not mean mockito should bump any version or postpone the change." ]

"2016-11-25T17:56:09Z"

[]

[ "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java", "src/main/java/org/mockito/internal/util/JavaEightUtil.java" ]

[ "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java", "src/main/java/org/mockito/internal/util/JavaEightUtil.java" ]

[ "src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java" ]

"2016-11-25T17:37:36Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8926900290820838)" ]

[ "Fantastic bug report: reproducible sample, clear motivation. Thanks! I'm looking at it now.\n", "I was able to repro this with a smaller example that does not use netty. It's a bug that needs to be fixed. Thank you for reporting!\n\n``` java\n@RunWith(MockitoJUnitRunner.class)\npublic class MockitoDeepStubsTest {\n\n private final ClassUnderTest classUnderTest = new ClassUnderTest();\n\n @Mock(answer = Answers.RETURNS_DEEP_STUBS) private ChannelFuture mockChannelFuture;\n\n @Test\n public void shouldAllowDeepStubsUnnecessaryStubbing() {\n classUnderTest.methodUnderTest(mockChannelFuture);\n }\n\n public static class ClassUnderTest {\n void methodUnderTest(ChannelFuture future) {\n future.getChannel().close();\n }\n }\n\n interface ChannelFuture {\n Channel getChannel();\n }\n\n interface Channel {\n void close();\n }\n}\n```\n", "@bschelberg, thank you for reporting! Stay tuned for Mockito 2.3.0 that will come with even better support for cleaner and easier to debug tests!" ]

[ "Could you add one more call after `getFoo()` to make sure it does not crash on a second invocation? Just to make sure and base on the original bug report.", "Absolutely, good idea.\r\n\r\n(My test does reproduce the incorrect the behavior)." ]

"2016-12-01T06:22:22Z"

[ "bug" ]

[ "src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java" ]

[ "src/main/java/org/mockito/internal/stubbing/InvocationContainerImpl.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsDeepStubs.java" ]

[ "src/test/java/org/mockitousage/junitrunner/DeepStubbingWithJUnitRunnerTest.java" ]

"2016-11-14T22:01:19Z"

[ "timestamp(timedelta=43.0, similarity=0.9208988661090468)" ]

[ "Release approaching ;)", "`0.7.8` has been released: https://github.com/jacoco/jacoco/issues/467#issuecomment-266305876", "Fixed by #798." ]

[]

"2016-12-12T21:10:32Z"

[ "java-9" ]

[ "gradle/coverage.gradle" ]

[ "gradle/coverage.gradle" ]

[]

"2016-12-01T23:22:33Z"

[ "keyword_issue_to_pr", "keyword_pr_to_issue" ]

[ "I think your second example has a typo, since there are no var args in the example", "thanks fixed", "Good catch!\r\nBy the way, the mock reference is both foo and mock", "While it is source and binary compatible, vararg method are different than plain old array method, reflection allows to distinguish that. The issue is in `ReturnsArgumentAt.returnedTypeOnSignature` where there's a special handling for varargs.", "I'm working on the fix (currently adding some unit tests)", "This should be fixed by #821" ]

[ "French comment? 😂 ", "spacing", "haha yes, I'm sick, so my brain had to think in french and slowly" ]

"2016-12-14T18:01:23Z"

[ "bug" ]

[ "src/main/java/org/mockito/AdditionalAnswers.java", "src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java" ]

[ "src/main/java/org/mockito/AdditionalAnswers.java", "src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java" ]

[ "src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java", "src/test/java/org/mockitousage/IMethods.java", "src/test/java/org/mockitousage/MethodsImpl.java" ]

"2016-12-14T14:40:38Z"

[ "keyword_pr_to_issue" ]

[ "As the question is answered in SO, you can negate matchers using `AdditionalMatchers.not()`.\r\n\r\nI think I can close this issue.", "OK... but this question highlights the fact that the online documentation and tutorials are not optional, they are essential ... and they are currently inadequate. People who are willing to learn shouldn't have to pose a question for such an obvious use case on SO.", "Hi,\r\n\r\nI closed the issue because it is about a feature request that is not valid since the feature is already present in a different form. Now documentation and tutorial is another thing.\r\n\r\n`AdditionalMatchers` is mentionned on the first line of the [ArgumentMatchers javadoc](https://static.javadoc.io/org.mockito/mockito-core/2.4.0/org/mockito/ArgumentMatchers.html). The Mockito javadoc gives plenty of code examples on the public API, which is already more than most javadoc in almost every project. \r\n\r\nI'm not saying it can't improved or we won't improve it, it can and we will! On the matter at hand those matchers can be promoted a bit more to enhance discoverability.\r\n\r\nRegarding tutorials I believe it is the responsibility of respective blog authors.\r\n\r\nIn the mean time pull requests are welcome, and the wiki can be edited by any benevolent soul.", "Also it seems I skipped the part on the `Pattern` class, reopening for the `matches(Pattern)` matcher.\r\n\r\n", "Oh... good. No really! The multi-line challenge has me foxed... indeed. :)", "The builds should propagate within an hour (note that badges or search.maven.org may not be up to date)", "Hi Brice... thanks for doing this so quickly. I have upgraded my gradle.build and got hold of your new build. But I am still having problems using \"not\" with this... if you have a moment maybe you might look at my new edit at [SO](http://stackoverflow.com/questions/41270738/mockito-argumentmatchers-doesnotmatch).", "It looks like an import issue, either for `not` or `matches`. I've tested it yesterday, when I added the API.", "Yes, you're right: it's an AssertJ confusion: Eclipse imported NotFilter.not() automatically. Apologies." ]

[]

"2016-12-22T13:50:01Z"

[ "enhancement" ]

[ "src/main/java/org/mockito/ArgumentMatchers.java", "src/main/java/org/mockito/internal/matchers/Matches.java" ]

[ "src/main/java/org/mockito/ArgumentMatchers.java", "src/main/java/org/mockito/internal/matchers/Matches.java" ]

[ "src/test/java/org/mockito/internal/matchers/MatchersToStringTest.java", "src/test/java/org/mockitousage/matchers/MatchersTest.java" ]

"2016-12-21T21:27:04Z"

[ "timestamp(timedelta=1.0, similarity=0.8883307402829964)" ]

[ "If the renaming is only needed when creating a distribution jar, you can customize the jar task with something like this:\r\n\r\n`jar {\r\n rename \"org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.class\", \"org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.raw\"\r\n}`\r\n\r\nIf you need to rename this file after compilation, you could use the `doLast` section of the `classes` task:\r\n\r\n`doLast {\r\n file(\"${buildDir}/main/org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.class\").renameTo(\"${buildDir}/main/org/mockito/internal/creation/bytebuddy/MockMethodDispatcher.raw\")\r\n}`", "I discovered the Robolectric ClassLoader issue as well while updating the Mockito mockmaker to ByteBuddy internally. My fix now has the correct class hierarchy, but it now fails to properly resolve the `MockMethodDispatcher`. Should we revert this change (and figure out a way to work with both the broken ClassLoader and the fixed version)?", "For now, I have patched the Robolectric ClassLoader to special case the class:\r\n\r\n```java\r\nString extension = className.equals(\"org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher\") ? \"raw\" : \"class\";\r\n String classFilename = className.replace('.', '/') + \".\" + extension;\r\n```\r\nHowever, this introduces a version complexity matrix. E.g.:\r\n\r\nbroken Robolectric works with current Mockito\r\nfixed Robolectric does not work with current Mockito\r\nfixed Robolectric + workaround works with current Mockito\r\n\r\nHow can we remove the workaround in Robolectric while at the same time remove the workaround in Mockito while adhering to SemVer in BOTH projects?", "Current thinking is (on Mockito build time) keep the `.class` and copying to `.raw`. Then we can update Mockito to just use `.class` and old Robolectric ignores `.raw`, while the new Robolectric uses the original `.class`." ]

[ "In order for this to work reliably, we need to also set one more task dependency on compileJava. Let me try to update the code in the branch...", "Above change makes the compiled classes directory contain both: the 'raw' and normal class. Is this what we want?", "Yes, for the time until packaging the jar. This is required to make IDEs work with Mockito which do otherwise claim that there is a class missing (experienced with IntellIJ). It does not hurt us as we know that our unit tests are run by a parent-first class loader where class loading works as expected. This is only an issue when dealing with parent-first loaders where the `.class` file must not exist." ]

"2016-12-26T15:08:05Z"

[ "android", "final-class-or-methods" ]

[ "build.gradle", "src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java" ]

[ "build.gradle", "gradle/mockito-core/inline-mock.gradle", "src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java" ]

[ "src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java", "src/test/java/org/mockito/internal/junit/JUnitRuleTest.java", "src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java" ]

"2016-12-26T12:25:45Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8665890352634279)" ]

[ "This is a bug in the user code. Yet Mockito should handle that gracefully.\r\n\r\nThanks for reporting." ]

[ "Actually I'd rather make the check in `ConditionalStackTraceFilter.filter()`. And if throwable is null, just return.", "Ok! already changed,please review. ", "Sorry it seems I was wrong. It seems that indeed your previous attempt was correct.\r\n\r\n```java\r\n if (t == null) {\r\n throw throwable;\r\n }\r\n```", "Ok, But I don't know why the build is failing?\r\n\r\n> Execution failed for task ':assertEnvVariables'.\r\n> Please export 'GH_TOKEN' env variable first. Expression: java.lang.System.env[it]. Values: it = GH_TOKEN", "Yes I'm sure your change is correct, it's something else.", "Discarding this comment as it requires to rewrite `filter` a bit more." ]

"2017-01-04T14:16:26Z"

[ "bug" ]

[ "src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java" ]

[ "src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java" ]

[ "src/test/java/org/mockitousage/bugs/NPEWhenCustomExceptionStackTraceReturnNullTest.java" ]

"2017-01-03T08:29:31Z"

[ "timestamp(timedelta=50952.0, similarity=0.9218907831467025)" ]

[ "@TimvdLippe should this issue be closed now that the PR is merged, or should this fix be backported to the 2.x branch too?", "@mureinik Oh right it was to the wrong branch 😭 That's my mistake. I will backport it manually" ]

[]

"2017-01-12T20:38:56Z"

[]

[ "src/main/java/org/mockito/ArgumentMatchers.java" ]

[ "src/main/java/org/mockito/ArgumentMatchers.java" ]

[]

"2017-01-12T20:35:12Z"

[ "timestamp(timedelta=42649.0, similarity=0.9349826054048819)" ]

[]

[]

"2017-01-14T09:11:11Z"

[ "java-9" ]

[ "build.gradle", "gradle/mockito-core/osgi.gradle" ]

[ "build.gradle", "gradle/mockito-core/osgi.gradle" ]

[]

"2017-01-13T15:05:44Z"

[ "keyword_pr_to_issue" ]

[ "I think the easiest solution is to not assert the GH_TOKEN if the build is a pull request", "Can't we just disable the checks if the repo is not mockito/mockito ?", "Pull requests always have `mockito/mockito` as repository?", "No only ours, external contributors have a fork. Since the GH_TOKEN assertion don't fail for our pull request I think this is safe assumption.", "@szczepiq could you make this high priority on your list? Failing builds discourages external developers from publishing their work" ]

[]

"2017-01-15T18:57:07Z"

[ "bug", "continuous integration" ]

[ "gradle/root/release.gradle" ]

[ "gradle/root/release.gradle" ]

[]

"2017-01-06T14:41:43Z"

[ "timestamp(timedelta=0.0, similarity=0.9349826054048819)" ]

[]

[]

"2017-01-15T20:51:27Z"

[ "java-9" ]

[ "build.gradle", "gradle/mockito-core/osgi.gradle" ]

[ "build.gradle", "gradle/mockito-core/osgi.gradle" ]

[]

"2017-01-13T15:05:44Z"

[ "timestamp(timedelta=0.0, similarity=0.9721334097970477)", "keyword_pr_to_issue" ]

[ "I am going to submit a Pull Request, adding an additional clarification with code example in the docs." ]

[ "I'd rephrase to : \r\n\r\n```\r\n<strong>Warning</strong> : if instead of chaining {@code .thenReturn()} calls, multiple stubbing with same matchers or arguments are used then each stubbing will override the previous one :\r\n```", "Sure, sounds much better. I'm going to update the PR to this." ]

"2017-01-20T15:51:46Z"

[ "docs" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2017-01-20T15:42:19Z"

[ "keyword_pr_to_issue" ]

[ "Do you mean argument matcher or mock return values?", "I mean default return value of a mock.", "Here is a quick fix, sadly I can't push throu the firewall.\r\n\r\n```java\r\nif (type.isArray()) {\r\n Class<?> componentType = type.getComponentType();\r\n return Array.newInstance(componentType, 0);\r\n}\r\n```\r\n\r\nneeds to added to [ReturnsEmptyValues::returnValueFor(Class)](https://github.com/mockito/mockito/blob/release/2.x/src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java#L79).", "Seems like String has also no empty return value.", "Yes the fix is quite easy. I haven't pushed it yet. I'm focused on the selection of the Devoxx France CFP right now.\r\n\r\n`String` was discussed, at some point but most people felt `null` was a sane default even for `String`.", "Please consider backwards compatibility when implementing the fix. Thanks!\r\n", "That's indeed a good point, I'm hesitating. Since mockito returns non null collections, it seems a consistent to return a non null array by default too.\r\n\r\nIf merging this one in mockito 2, that may break tests that rely on the default behavior only.\r\nThat requires at the very least a minor version bumb. I'm quite enclined to get it right in mockito 2, but it could it wait for mockito 3.\r\n\r\n", "While cleaning stuff, just noticed there's a `ReturnsMoreEmptyValues` that already do that.\r\n\r\nHowever it does more things than simply retuning non emtpy arrays. It returns empty strings too.", "Nice catch! ReturnsMoreEmptyValues was intended to replace ReturnEmptyValues in the next major version of Mockito. However, it was deprioritized and/or forgotten and we never got to do it.\r\n\r\nIncluding this change in Mockito 2 will potentially break tests. The failure may not be easy to debug / understand (sudden change of behavior of test). Such changes should only be included in major version update and well documented. Given our strong desire for compatibility, let's include it in Mockito 3. I suggest we also review other empty / default return values in Mockito 3.", "@szczepiq Yes in the end I only pushed the change to target master in #897 " ]

[ "If this class now only returns an emptry String, why don't we remove this class and move the empty string to `ReturnsEmptyValues`?", "Actually I don't think that's part of this PR. And I find that returning empty string instead of `null` more debattable (hence a separate PR).", "Oh nice! It's good to take advantage of Java8!", "Fantastic! Less code to maintain.", "I like the idea to condense the tests into 2 methods.", "As general feedback, not particularly to this PR, I'm +1 to returning empty String. We can poll more feedback from the community. Empty String seems like a better default, avoiding potential NPE. The idea behind the defaults is to return the most sensible value if the user does not care about the mock.", "@szczepiq Let's create another PR for default Strings, it'll be easier to track for end users as it will appear in the changelog." ]

"2017-01-21T13:48:22Z"

[ "enhancement", "in progress" ]

[ "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java", "src/main/java/org/mockito/internal/util/JavaEightUtil.java" ]

[ "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValues.java", "src/main/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValues.java" ]

[ "src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java", "src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsEmptyValuesTest.java", "src/test/java/org/mockito/internal/stubbing/defaultanswers/ReturnsMoreEmptyValuesTest.java" ]

"2017-01-11T15:48:36Z"

[ "keyword_pr_to_issue" ]

[ "I don't see what you mean I have no problem for that : \r\n\r\n* https://static.javadoc.io/org.mockito/mockito-core/2.3.0/org/mockito/Mockito.html#40\r\n* https://static.javadoc.io/org.mockito/mockito-core/2.3.0/org/mockito/Mockito.html#strict_mockito", "At first it seems to be working, but the actual issue is that the first link of @bric3 does work, but the second does not. The problem is that the headers have the second link, so they must be updated to use numbers instead." ]

[]

"2017-01-23T14:39:51Z"

[ "docs" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2016-12-13T07:14:18Z"

[ "keyword_pr_to_issue" ]

[ "@raphw thanks for merging the PR that fast! Would you mind reopening this ticket? There are more classes that can be refactored that way, I would like to extend the list.\n", "Big :+1: for me btw, but please keep the pull requests managable and as small as possible. Preferably refactoring 1 method at a time. That way it is a lot easier to review.\n", "I agree, there is nothing wrong with multiple PRs, the quick merge is a reaction to an easy overview (and being stuck at an Ukrainian airport without access to the Eurocup).\n", "There are still two unit tests failing, could you have a look @ChristianSchwarz - I just had a quick look and there are two unit tests failing which seems related to the way you refactored the previous stubbing of the `Reporter`.\n\nI should have checked more thoroughly before merging, hopefully you can fix the problem soon. Alternatively, I will just rollback the one commit (the first one is good) and we can reapply the patch once you fixed the two unit tests. Thank you, really, this was great clean-up.\n", "I fixed the one test error. I push it tonight.\n\nPS: I also fixed a bug in the stack trace cleaner. Not a biggy but please do not `@Ignore` tests. Especially in big commits, it is easy to miss that single annotation.\n", "@raphw Which test(s) is/are failing? I will fix it asap! Too bad that some test fail on a regulare base, is it possible to ignore them in the ide only?\n", "You can see the build output here: https://travis-ci.org/mockito/mockito#L254-L269\n\nI advise you to run the tests with `./gradlew build`. This should work.\n", "@TimvdLippe know what you mean! The next PR's include only one refactored class at a time.\n", "I have it all fixed on local but I did not have access to wifi without 22 blocked. Will commit soon.\n", "@raphw can you please reopen this issue \n", "Sorry, GitHub automatically closes issues that reference a PR.\n", "@ChristianSchwarz If a commit contains a comment like \"Fixes #426\" the mentioned issue is automatically closed by github.\n", "@PascalSchumacher Good to know! I will leave it out for the upcoming PR's. Thanks!\n", "Now that we are pulling in static methods, I would like to propose a new (linter) rule. To make it easier to read a file, I would like that all methods invoked in the current class are referenced with `this.` (and `super.` for that matter). Therefore if we see `this.verify`, we know it is in the current class and the same object, whereas `verify` references a static method in this class, or an imported static method. Do you agree @mockito/developers ?\n", "> I would like that all methods invoked in the current class are referenced with this. (and super. for that matter).\n\nTo me it feels like unnecessary/duplicate code cause `this` is implicit. Adding `this.` before every instance call would create a lot more text and would IMHO reduce readability. E.g.:\n\n`this.doSometing(this.withPrivateMethod())` vs. `doSomething(withPrivateMethod())`\n\n> Therefore if we see this.verify, we know it is in the current class and the same object, whereas verify references a static method in this class, or an imported static method.\n\nAn other option avoid ambiguity is to qualify static methods via its class name. This way you can also distinguish which verify(..) is called ( `MockitoCore.verify(..)` / `Mocktio.verify(..)`) , which is not an easy task when a static import is used.\n", "I'm not coding too much in Mockito ATM (hopefully now after SpringOne conference I'll have more time) but I fully agree with @ChristianSchwarz . IMO the best solution is to: \n- omit `this` before method calls. \n- if necessary provide the class for static method call\n", "Respectful -1\n\nI like when the class formally declares collaborators instead of calling out to static methods. This makes it easy to reason about the code. I don't need to read every line of code in the class to find out external couplings realized via static methods. I can see the couplings via fields, I can easily query how the field variable is used, etc. Another use case is when we discover missing/incorrect unit test coverage (or we do some larger refactorings) and we cannot easily write tests because code is too procedural.\n\nThe benefits for converting to static utilities have minimal significance to me. Yet, there is a downside I care about (e.g. maintainability of procedural code, static methods that consume static methods, that consume static methods...).\n\nHence, I down vote this sort of changes. Going down this path, all stateless classes in Mockito would become static utilities :)\n\nYou can get +1's from other maintainers and have your changes merged - I'm not here to block your changes but to give honest feedback. I see merit in arguments for static utilities. They do not outweigh the cost in my opinion.\n", "I'm mitigated about this as well. I understand well that mockito creates garbage, but they are short lived and **most probably** won't go in the old generation especially in the test phase. Yet the faster the tests are the more developers will run them, it **may** have impacts on big projects. Also design wise I don't like much static methods too.\n\nHowever I don't totally agree with the above points : \n\n> I don't need to read every line of code in the class to find out external couplings realized via static methods. I can see the couplings via fields, I can easily query how the field variable is used, etc.\n\nCoupling appears also in the import section ; static methods are visible there. And modern IDE usually highlight this. IntelliJ even have a warning if import section is too big, just as there's warning if there's too many fields. This point should not be the reason to avoid static methods.\n\n> maintainability of procedural code, static methods that consume static methods, that consume static methods...\n\nHaving instance methods does not protect again procedural code.\n\n---\n\nI believe there's middle ground there : \n- Mockito project contains a lot of small utility stateless objects that are supporting mockito features, these are usually collections tools, reflection tools, those could are good candidate for static methods. Objects like `FieldSetter`, `FieldCopier`, `LenientCopyTool` could be nice candidate for static methods\n- Mockito features could be backed by object instances. Objects like `MockitoCore`, `MockCreationValidator`, `ArgumentMatchingTool` are candidate to stay objects.\n", "Exactly the middle ground described by Brice is my motivation for merging most of the PRs. This is also the reason I have not yet merged the MockitoCore PR for this exact reason.\n\nIf an object is not a attribute or parameter, but an internal creation and immediately dismissed, I value a pure function more.\n", "Thought: when we switch to Java 8, we can use interfaces with default\nmethods. The switch from static utility to interface is very easy now (just\na couple of text replaces, no method reference modifications).\n\nOn Fri, 12 Aug 2016, 17:23 Brice Dutheil, notifications@github.com wrote:\n\n> I'm mitigated about this as well. I understand well that mockito creates\n> garbage, but they are short lived and _most probably_ won't go in the old\n> generation especially in the test phase. Yet the faster the tests are the\n> more developers will run them, it _may_ have impacts on big projects.\n> Also design wise I don't like much static methods too.\n> \n> However I don't totally agree with the above points :\n> \n> I don't need to read every line of code in the class to find out external\n> couplings realized via static methods. I can see the couplings via fields,\n> I can easily query how the field variable is used, etc.\n> \n> Coupling appears also in the import section ; static methods are visible\n> there. And modern IDE usually highlight this. IntelliJ even have a warning\n> if import section is too big, just as there's warning if there's too many\n> fields. This point should not be the reason to avoid static methods.\n> \n> maintainability of procedural code, static methods that consume static\n> methods, that consume static methods...\n> \n> ## Having instance methods does not protect again procedural code.\n> \n> I believe there's middle ground there :\n> \n> -\n> \n> Mockito project contains a lot of small utility stateless objects that\n> are supporting mockito features, these are usually collections tools,\n> reflection tools, those could are good candidate for static methods.\n> Objects like FieldSetter, FieldCopier, LenientCopyTool could be nice\n> candidate for static methods\n> -\n> \n> Mockito features could be backed by object instances. Objects like\n> MockitoCore, MockCreationValidator, ArgumentMatchingTool are candidate\n> to stay objects.\n> \n> —\n> You are receiving this because you modified the open/close state.\n> Reply to this email directly, view it on GitHub\n> https://github.com/mockito/mockito/issues/426#issuecomment-239476519,\n> or mute the thread\n> https://github.com/notifications/unsubscribe-auth/AFrDb6QVlVesWgPAhurimgSUPQTRcTZSks5qfJALgaJpZM4IzjKm\n> .\n", "This feels like a misuse of the default methods.\n", "I think you mean static-methods in interfaces here? Default-methods require an instance to be called on.\nAnyway I don't think that it is a good idea. It would a result in an interface that is not intended to be implemented or extended and only serves as container for utility methods. IMHO a class with private constructor is the best construct to do this.\n", "> > Thought: when we switch to Java 8, we can use interfaces with default\n> > methods.\n> \n> Default-methods require an instance to be called on.\n\nI was thinking exactly that, default methods in the interface plus instance (either as a separate file or as a singleton declared within the interface).\n", "@ChristianSchwarz What do you think to continue the work here with the middle ground described [here](https://github.com/mockito/mockito/issues/426#issuecomment-239476519) ?\n", "I am attempting to refactor the MatcherBinder class to a static utility class and am having trouble refactoring the following from MockHandlerImplTest.java: `\r\nhandler.matchersBinder = new MatchersBinder() {\r\n public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, Invocation invocation) {\r\n throw new InvalidUseOfMatchersException();\r\n }\r\n}; `\r\nHow can I maintain the abstract class definition when I am not able to create an object of MatcherBinder?\r\n\r\nAny help is appreciated! ", "Let's close this ticket. Refactorings can be done as needed as we work with the code." ]

[]

"2017-01-26T12:17:39Z"

[]

[ "src/main/java/org/mockito/internal/verification/Calls.java", "src/main/java/org/mockito/internal/verification/Times.java", "src/main/java/org/mockito/internal/verification/checkers/NonGreedyNumberOfInvocationsInOrderChecker.java", "src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java", "src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderChecker.java" ]

[ "src/main/java/org/mockito/internal/verification/Calls.java", "src/main/java/org/mockito/internal/verification/Times.java", "src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java" ]

[ "src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java", "src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java" ]

"2016-06-11T13:23:18Z"

[ "keyword_pr_to_issue" ]

[ "I have to push the code style decided a few months ago, maybe gradle can generate a section with the mockito style for IDEA (and eclipse and netbeans)", "Absolutely great idea. Perhaps it's worth waiting for Mockito3 before we do that to avoid merging problems?" ]

[ "Don't we also need the dev dependency for checkstyle?", "Not sure what you mean by this. Could you please elaborate?\r\n", "@TimvdLippe, we don't need any extra dependency. checkstyle plugin is a part of Gradle distribution. Good question!", "@mureinik, do we need separate checker configurations per submodule? I'd rather us have a single consistent checkstyle rule for all java code.", "Can you write a bit of xml comment here that we added the validation to make the git blame / git diff workflows easier? I suspect this rule can be annoying to engineers when the builds start failing (including me ;). It's nice to see the reminder in the code why we decided to apply those rules.", "@szczepiq I tried to reduce the scope of the change as much as possible, but you're right - this is a bad idea, and we should use one conf file for the entire project. I'll update the PR.", "@szczepiq will do, thanks for the idea.", "Is it necessary to have a stylesheet ?", "It makes searching for errors a lot easier. Else it would be thousands of rows with 0 information", "Yup, what @TimvdLippe said. Actually, he authored this style sheet and asked me to include it in the patch." ]

"2017-02-05T21:37:13Z"

[ "refactoring" ]

[ "build.gradle", "gradle/java-library.gradle", "src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java" ]

[ "build.gradle", "config/checkstyle/checkstyle.xml", "config/checkstyle/checkstyle.xsl", "gradle/java-library.gradle", "src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java" ]

[ "src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java", "src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java", "src/test/java/org/mockitousage/IMethods.java" ]

"2017-01-23T10:23:07Z"

[ "keyword_pr_to_issue" ]

[]

[ "Spacing around `=`", "Very nice! Thank you for updating the documentation diligently." ]

"2017-02-06T12:43:14Z"

[]

[ "src/main/java/org/mockito/internal/stubbing/StubberImpl.java", "src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java", "src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java" ]

[ "src/main/java/org/mockito/internal/stubbing/StubberImpl.java", "src/main/java/org/mockito/internal/stubbing/answers/DoesNothing.java", "src/main/java/org/mockito/internal/stubbing/answers/InvocationInfo.java" ]

[ "src/test/java/org/mockito/internal/junit/UnusedStubbingsTest.java", "src/test/java/org/mockito/internal/stubbing/answers/DoesNothingTest.java", "src/test/java/org/mockito/internal/stubbing/answers/InvocationInfoTest.java", "src/test/java/org/mockitousage/IMethods.java", "src/test/java/org/mockitousage/MethodsImpl.java", "src/test/java/org/mockitoutil/TestBase.java" ]

"2017-02-03T18:42:17Z"

[ "timestamp(timedelta=0.0, similarity=0.8756630753506662)", "keyword_pr_to_issue" ]

[ "I tried to add in previous Open JDK 8 (102) but the option is not recognized\r\n\r\n```\r\noption.addStringOption('--allow-script-in-comments')\r\noption.addStringOption('-allow-script-in-comments')\r\noption.addStringOption('allow-script-in-comments')\r\n```\r\n\r\nI'll try later with the same JDK (121)", "Could it be related to #787 ?", "I will also take another look at the service-worker thing, as it does not appear to work with javadoc.io. If I can't fix it (after exams :wink: ) then I will simply revert it.", ";)\r\n\r\nContiuous improvements", "From the release notes: http://www.oracle.com/technetwork/java/javase/8u121-relnotes-3315208.html\r\n\r\n> The javadoc tool will now reject any occurrences of JavaScript code in the javadoc documentation comments and command-line options, unless the command-line option, --allow-script-in-comments is specified.\r\n> \r\n> With the --allow-script-in-comments option, the javadoc tool will preserve JavaScript code in documentation comments and command-line options. An error will be given by the javadoc tool if JavaScript code is found and the command-line option is not set.\r\n> JDK-8138725 (not public)" ]

[ "Thank you for fixing the problem and documenting it diligently!" ]

"2017-02-06T14:34:05Z"

[ "java-8", "continuous integration" ]

[ "gradle/mockito-core/javadoc.gradle" ]

[ "gradle/mockito-core/javadoc.gradle" ]

[]

"2017-01-20T15:07:48Z"

[ "timestamp(timedelta=0.0, similarity=0.9999999999999999)", "keyword_pr_to_issue" ]

[ "> mock(DM.class, withSettings().useDefaultMethods())\n\nI like that. 'spyDefaultMethods'?\n\nBTW. What's better/more intuitive default for default methods? real method invocation or empty/unstubbed value?\n", "I think that depends on the mocked type. I'd say :\n- interface => use default methods by default\n- concrete => I'm not sure I'd rather not make those default\n\n`spyDefaultMethod` is wrong because the primary objective is not to spy them.\n", "So potentially this is Mockito 3 backwards incompatible change (when changing defaults). Thanks for bringing this up!\n", "For this thing only this could be potntially backward incompatible. Yet for this thing only I'm not yet sure we should change the default between 2.x and 3.x whatever the introduction or not of `useDefaultMethods` in `2.x`. \n\nI'm a bit undecided at that moment. I may have a better opinion when the code is actually done. \n\nRight now the code base of mockito 2.x runs Java6 so we don't have Java 8 tests, Mockito 3 (master) is Java 8 and we'll introduce Java 8 specific tests.\n", "Makes perfect sense.\n\nWe already have code in 2.x that detects java 8. Up to you how to push that further ;)\n", "If starting from scratch, I couldn't think of a use case that'd benefit from stubbing the default methods by default.\r\n\r\nBut maybe that use case does exist, or at least for backward compatibility it's too late to change?\r\n\r\nEither way, I propose we do not need to add a default Answer or anything to mock(). \r\n\r\nDefault methods in interfaces are much like concrete methods in abstract classes. `spy(AnAbstractClass.class)` today already _by default_ invokes concrete methods unless they are explicitly stubbed. It seems natural to me that we just relax the restriction on `spy(SomeInterface.class)` to accept interface as a parameter instead of throwing illegal usage exception as it does today.\r\n", "@fluentfuture Can you elaborate on that : \r\n\r\n> It seems natural to me that we just relax the restriction on `spy(SomeInterface.class)` to accept interface as a parameter instead of throwing illegal usage exception as it does today.\r\n\r\nYes backward compatiblity is a primary concern. Yet if the change makes sense and doesn't impact users in a bad way it can be discussed.\r\nAlso maybe we could backport behavior and API from master to release/2x.", "Sure.\r\n\r\nToday, if java.util.Consumer were an abstract class defined as:\r\n\r\n```java\r\npublic abstract class Consumer<T> {\r\n public Consumer<T> andThen(Consumer<? super T> that) {\r\n return v -> {accept(v); that.accept(v);};\r\n }\r\n\r\n public abstract void accept(T value);\r\n}\r\n```\r\n\r\nI can `@Spy` it to have `andThen()` called by default:\r\n```java\r\n@Spy private final Consumer<String> consumer1;\r\n@Spy private final Consumer<String> consumer2;\r\n\r\n@Test public void testCompose() {\r\n consumer1.andThen(consumer2).accept(\"hi\");\r\n verify(consumer1).accept(\"hi\");\r\n verify(consumer2).accept(\"hi\");\r\n}\r\n```\r\n\r\nIt doesn't work with Consumer being interface with `andThen()` being an equivalent default method:\r\n\r\n```java\r\npublic interface Consumer<T> {\r\n default Consumer<T> andThen(Consumer<? super T> that) {\r\n return v -> {accept(v); that.accept(v);};\r\n }\r\n\r\n void accept(T value);\r\n}\r\n```\r\n\r\nBut that is just because we are having a validation that rejects spy(Consumer.class). That validation can be removed because it doesn't hurt even if you spy(AnInterface.class) and even if that interface has no default method, because it will just work the same way as mock(AnInterface.class).\r\n\r\nHere's a [commit](https://github.com/fluentfuture/mockito/commit/afdd5ebc32de38d098c517bda32c83e194371574) in my fork that removes the validation and the above test passes.\r\n\r\n\r\nBy the way, I retract my suggestion to make `mock(AnInterface.class)` to call default methods, because then it would break the symmetry with `mock(AnEquivalentAbstractClass.class)`, which can be surprising.", "Ah I see.\r\n\r\nImho spying an interface `spy(Interface.class)` is wrong, even when there's default methods, it doesn't feel like a a spy. As spy have more meaning to spy concrete code.\r\n\r\nInstead mocking an interface `mock(Interface.class)` to call default methods only seems ok. And maybe backward compatible. Although I would like opt-in/out mechanism.\r\nBut mocking an abstract class `mock(AnEquivalentAbstractClass.class)` should never call concrete code.", "I agree that the spy() name is kinda misleading for the behavior of \"mock only abstract methods\".\r\n\r\nI originally proposed fake() or other names but spy() was chosen none-the-less.\r\n\r\nI don't defend the spy() name but it's what we have, so there may be some value to consistency.\r\n\r\n", "`spy` is a specialized mock that seems to _speak_ for everyone, maybe `fake` can be another compelling specilization.\r\n\r\nAt this moment not sure if we will, but maybe in the future.", "Here's how I found peace with the spy() name:\r\n\r\nYes it calls the non-abstract methods, which isn't spying (more like fake). But it also allows you to explicitly stub them with `when()` or to `verify()` them, so in that sense, it can still be called a spy.", "Regarding \"interface\" vs. \"abstract class\", I personally think we should try not to be picky about the difference.\r\n\r\nSome project scoped or company scoped APIs out there aren't designed to be implemented/subclassed directly by users. For these APIs, going from an abstract class to interface or vice versa is reserved as an implementation detail change.\r\n\r\nThe worst that should happen with changing abstract class to interface is that a handful of direct subclasses break compilation and need to be fixed to use the \"implements\" keyword.\r\n\r\nIt'd be a much bigger burden if all the sudden a lot of tests that used to spy() on the abstract class fail just because of the abstract -> interface change.\r\n\r\nSpecifically, now with Java 8, I'd expect some abstract classes to become interfaces with default methods because the only reason they were abstract classes in the first place was to be able to have some default methods (for fluent chaining and stuff).", "Interesting feedback. I still have mixed feeling about relaxing spy to allow an interface.\r\nI'll sleep on it, and think about it as your migration use case is legitimate.\r\n\r\nAnd anyway this address only a part of the original issue.", "@bric3 Can you explain which part isn't addressed in the original issue, assuming we put aside the mock() vs. spy() naming difference?", "@fluentfuture I meant regarding configurability of stubbing default method for a mock, not a spy.\r\n\r\nYet the use cases discussed above are defintely additional scenario to account for when we will implement the stuff.", "@bric3 Are you okay with allowing @Spy on interfaces? If so, I'll send a PR.", "@fluentfuture yes. I have worked on it in #906. But I won't have a computer near me for a week still.", "Great discussion. \r\n\r\n+1 to allow spying on interfaces\r\n-1 to adding new public API method like 'fake' - it would make the api more complicated just for the sake of a single use case\r\n+ 0.5 to changing the default behavior of Mockito 3 to 'spy' interface defender methods by default. This way it is the most intuitive behavior users expect. See https://github.com/mockito/mockito/issues/940", "I attempted to update the ticket description to reflect the outcome of the discussion. Feel free to change if needed.", "If I were going to add another method I would call it `stub` based on [Martin Fowler's article describing the 3]( https://martinfowler.com/articles/mocksArentStubs.html).\r\n\r\nSeems like `@Incubating Mockito.spy( Class<?> clazz )` more or less does what I expect. Ultimately finding that behavior though required quite a bit of research.\r\n\r\nWhether or not adding `Mockito.stub( Class<?> clazz )` method would be worth it I can't say because I don't feel like I'm familiar enough with the underlying implementation/behavior to know how different `mock` and `spy` are. If those are just configuration differences then it's probably worth it, if there's more to it, maybe not. If `stub` could `CALL_REAL_METHODS`, but only work for `abstract` and `interface` and not be able to do `verify` that would make it different from a `spy`, imo.\r\n\r\nEither way, more docs seem necessary. I might try to put those together for #940 ", "I somehow missed this ticket. \r\n\r\nMockito should imho follow the idea of defender methods and allow API-evolution without breaking client code/test. I other words if a class under test evolves and calls defender methods on a mocked interface the tests should not fail or should not be rewritten by replacing `@Mock` with `@Spy` or setting up special mocking settings like `withSettings().useDefaultMethods()`.\r\n\r\nI think it is possibe to rewrite the `mock(..)` implementation to generate stubbed calls to default methods without special mock settings. \r\n\r\n```java\r\npublic <T> T mock(Class<T> type){\r\n T mock=MOCKITO_CORE.mock(type);\r\n if (!typeToMock.isInterface())\r\n return mock;\r\n\r\n for (Method method : typeToMock.getDeclaredMethods()) {\r\n if (method.isDefault()) {\r\n doCallRealMethod().when(mock);\r\n callWithAnyMatchers(mock, method);\r\n }\r\n }\r\n return mock;\r\n}\r\n\r\nprivate static void callWithAnyMatchers(Object mock, Method method) {\r\n Class<?>[] parameterTypes = method.getParameterTypes();\r\n List<Object> defaultValues = new ArrayList<Object>();\r\n for (Class<?> type : parameterTypes) {\r\n defaultValues.add(Mockito.any(type));\r\n }\r\n \r\n try {\r\n method.invoke(mock, defaultValues.toArray());\r\n } catch (Exception e) {\r\n throw new MockitoException(e.getMessage(), e);\r\n }\r\n}\r\n\r\n\r\n```\r\nThis way clients can redefine the defender stubbings like overriding it in an implementation. \r\n\r\n@bric3 \r\n@szczepiq \r\n@fluentfuture \r\nWhat do you think?\r\n\r\n\r\n", "Is it any different from API-evolution of abstract classes?\r\n\r\nIn template-method pattern, if the SUT calls an abstract method, and then later evolves to call a default method that indirectly calls the abstract method, the exact same problem can happen, no?\r\n\r\nThis kind of evolution has always been possible. And it's not clear to me that the user always means to only stub/verify the abstract method. Sometimes the user may just want to stub/verify the method directly called, abstract or not.\r\n\r\nIt seems to me not the mocking framework's responsibility to guess the user's intention. Instead, if the user wants to stub/verify the direct method invocation, use `@Mock;` while if the user wants to stub/verify abstract methods, use `@Spy`.\r\n\r\n", "> Is it any different from API-evolution of abstract classes?\r\n>\r\n>In template-method pattern, if the SUT calls an abstract method, and then later evolves to call a default method that indirectly calls the abstract method, the exact same problem can happen, no?\r\n\r\nI agree if you see it like that they are pretty equal.\r\n\r\nI want to avoid that `@Spy` is misused to stub in the first place. The word \"spying\" implies that there is something to spy on (the SUT), but for interfaces the \"spying\" make no sense we would spy on a mocked interface. \r\n\r\n>It seems to me not the mocking framework's responsibility to guess the user's intention. \r\n\r\nI agree here too! What about a littel helper that create stubbings that call the real default method: `Mockito.delegateDefaultMethodsToReal(mockedInterface)`\r\n", "I still suggest `stub` as the method name for that per previous reasons cited", "Did a bit of archeology. #106 has a discussion both about the API and the naming.\r\n\r\nIn that thread I argued against `spy`: \"All the use cases I know of for partial mocking don't need spying\". \r\n\r\nAt the time \"stub\" wasn't suggested but now I think about it, it seems to make sense.\r\n\r\nAlthough, changing it may mean to introduce a new `@Stub` annotation, and deprecate `@Spy AbstractClass`, if we are willing to consider the ship not sailed yet.", "Interesting discussion! Thank you for all suggestions.\r\n\r\n>the tests should not fail or should not be rewritten by replacing @Mock with @Spy or setting up special mocking settings like withSettings().useDefaultMethods().\r\n\r\nYou are right. Ideally the tests only fail when a bug is introduced.\r\n\r\nI have a feeling the discussion is getting broader and I am not sure if still discusses the issue reported :) My immediate reaction to new `@Stub` interface and potential deprecation of `@Spy` is -1 because I don't see clear value. However, please formulate a separate ticket with the use case, code samples, and the team will for sure review it!\r\n\r\nComing back to the original issue: relaxing spy annotation for interfaces is useful for spying on interfaces with default methods. The use case is reasonable and team is +1 to the change. Do we have new data / use cases that indicate that this change inappropriate?" ]

[ "Nice! Thank you for updating the test!", "Nice and clean! Thank you!" ]

"2017-02-12T21:29:48Z"

[ "new feature", "java-8", "noteworthy", "please contribute" ]

[ "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java" ]

[ "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/internal/configuration/SpyAnnotationEngine.java" ]

[ "src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java", "src/test/java/org/mockitousage/annotation/WrongSetOfAnnotationsTest.java", "src/test/java/org/mockitousage/constructor/CreatingMocksWithConstructorTest.java" ]

"2016-10-07T09:29:53Z"

[ "timestamp(timedelta=0.0, similarity=0.9276498021435603)", "keyword_pr_to_issue" ]

[]

[ "I'll also add : \r\n\r\n```\r\ncharset=utf-8\r\n```\r\n\r\n", "I've met in some placed that option disabled for markdown files:\r\n\r\n```\r\n[*.md]\r\ntrim_trailing_whitespace = false\r\n```\r\n\r\nHowever, I'm not sure if it was a copy-paste from one source or there is a valid use case where new whitespace in a markdown files is required.", "yup, for Eclipse guys on Windows.", "We can always improve this file.\r\n\r\nRegarding the specific change for md files, I don't think trailing spaces should be an issue." ]

"2017-02-25T15:34:04Z"

[]

[ ".github/CONTRIBUTING.md" ]

[ ".editorconfig", ".github/CONTRIBUTING.md" ]

[]

"2017-02-21T20:27:00Z"

[ "timestamp(timedelta=0.0, similarity=0.9999999999999998)" ]

[ "That seems like a reasonable issue. Looking forward to your pull request @paulduffin !", "Should I make the change in release/2.x?\n\nOn 8 March 2017 at 12:57, Tim van der Lippe <notifications@github.com>\nwrote:\n\n> That seems like a reasonable issue. Looking forward to your pull request\n> @paulduffin <https://github.com/paulduffin> !\n>\n> —\n> You are receiving this because you were mentioned.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/mockito/mockito/issues/982#issuecomment-285033757>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AEtcQ-KnL90mWa9jxuLBhEsA8QmxpSJzks5rjqXXgaJpZM4MWrIj>\n> .\n>\n", "Yes please :)", "Done." ]

[]

"2017-03-08T16:38:10Z"

[ "bug", "1.* incompatible" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMaker.java", "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java" ]

[ "src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java" ]

"2017-03-08T11:30:26Z"

[ "timestamp(timedelta=0.0, similarity=0.931699655929002)" ]

[]

[]

"2017-03-10T09:54:11Z"

[ "please contribute" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2017-03-07T13:46:15Z"

[ "keyword_pr_to_issue" ]

[ "This was fixed in #989" ]

[ "Let's add a `@deprecated since 3.0.0` here, so we don't accidently remove it in the wrong version (which we did previously)", "Since we deprecate the method anyways, is this test really required?", "This still needs a `@since`", "I would rather not name it with `2`. Probably better as `should_remove_all_interactions_verify_no_interactions()`", "Same here", "Same here", "Same here", "Same here", "Same here", "Same here", "@ffissore We should avoid this catch block by calling `MockUtil.isMock(..)`" ]

"2017-03-21T08:43:15Z"

[ "2.* incompatible", "feedback-needed" ]

[ "src/main/java/org/mockito/BDDMockito.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/internal/MockitoCore.java", "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/verification/VerificationModeFactory.java" ]

[ "src/main/java/org/mockito/BDDMockito.java", "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/internal/MockitoCore.java", "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/verification/NoInteractions.java", "src/main/java/org/mockito/internal/verification/VerificationModeFactory.java" ]

[ "src/test/java/org/mockito/MockitoTest.java", "src/test/java/org/mockito/internal/InvalidStateDetectionTest.java", "src/test/java/org/mockito/internal/verification/NoInteractionsTest.java", "src/test/java/org/mockitousage/basicapi/ResetTest.java", "src/test/java/org/mockitousage/customization/BDDMockitoTest.java", "src/test/java/org/mockitousage/misuse/InvalidUsageTest.java", "src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java", "src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java", "src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java", "src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java", "src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java", "src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/ResetMocksInParentTestClassTooTest.java" ]

"2017-03-16T04:44:21Z"

[ "keyword_pr_to_issue" ]

[ "Waiting for review / merge: https://github.com/mockito/mockito-release-tools/pull/103", "Fix seems fine to me. Have not executed it locally though.", "I don't know if this is related, but the release process currently [fails](https://travis-ci.org/mockito/mockito/jobs/230865593#L796) with:\r\n> remote: Invalid username or password.\r\n\r\non a git push.", "It is sadly unrelated. It seems that @szczepiq password was reset for some reason :sob: ", "There is something weird going on with GitHub auth tokens. They seem to be expiring or something. I've tested locally a new token, updated Travis configuration and restarted Travis Job. We'll see if it helps.", "It was fixed!" ]

[]

"2017-05-01T01:17:25Z"

[ "continuous integration" ]

[ "gradle.properties" ]

[ "gradle.properties" ]

[]

"2017-04-30T17:50:35Z"

[ "keyword_pr_to_issue" ]

[ "@troig Mockito checks if the argument type is compatible with the return type to make a misuse ot the API as soon as posible visible. In this case the argument-type Object is inferred from the generic type T, due to type erasure. Since Object is not a subtype of String Mockito throws the exception you see.\r\n\r\nSolution: The issue can by fixed by inferring the argument-type of the actual argument-instance.\r\n In case the argument-type is a primitive or the arg is null Mockito must fallback and use the type provided by method signature. \r\n\r\nI have a solution ~~that currently doesn't work due to regressions introduced with #1032 (vararg-expansion is broken)~~.\r\n", "Thanks @ChristianSchwarz for you quick answer!" ]

[]

"2017-05-10T11:47:32Z"

[]

[ "src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java" ]

[ "src/main/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAt.java" ]

[ "src/test/java/org/mockito/internal/stubbing/answers/ReturnsArgumentAtTest.java", "src/test/java/org/mockitousage/IMethods.java", "src/test/java/org/mockitousage/MethodsImpl.java" ]

"2017-05-05T13:31:05Z"

[ "keyword_pr_to_issue" ]

[ "What would you consider to be the correct behaviour here? At a push I might propose a slight change in naming to \"TooFewActualInvocations\" but the core behaviour is the same.\r\n\r\nYour example is confusing because your \"atLeast(2)\" verification is on .add(\"five times\"), which suggests five invocations of add() with that String, but there are no invocations with that String.\r\n\r\nWhat do you expect to see here?", "I think the expectation is that the code works when it is copy pasted to IDE and executed. Why don't we fix it by changing \"five times\" to \"three times\"? Do you want to contribute? Please do! :)", "Oh wait, I see now. It's a problem with [the documentation](http://static.javadoc.io/org.mockito/mockito-core/2.8.9/org/mockito/Mockito.html#4). Sure thing, I can update that no problem.", "Thanks folks. " ]

[]

"2017-05-26T07:51:19Z"

[ "docs", "please contribute" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2017-05-18T00:46:16Z"

[ "keyword_pr_to_issue" ]

[ "No, I haven't seen anything like that before. There were no changes in .travis.yml and I have no idea what one of the jobs is missing. Probably (I hope) it will be automatically fixed by the next commit. It may be good to report it to Travis.", "Just merged another PR, will see how many child jobs Travis triggers this time :)", "Another instance of this problem. I've contacted Travis CI support, put you guys on cc.", "Commented on the ticket in Travis issue tracker (https://github.com/travis-ci/travis-ci/issues/4681#issuecomment-306102865). Here's the message from Travis CI support:\r\n\r\n```\r\nThanks for reaching out and I'm sorry for this change in behavior.\r\n\r\nThis is the result of a change we released 3 days ago and it's detailed here: https://github.com/travis-ci/travis-ci/issues/4681. In brief, if you have no matrix expansion on the top level, and there is at least one job defined in `matrix.include`, the top level job is no longer included in the build matrix.\r\n\r\nYou should be able to get your old build configuration back by adding the following under `matrix.include`:\r\n\r\n\r\nmatrix:\r\n include:\r\n - jdk: oraclejdk7\r\n - jdk: oraclejdk7\r\n env: SKIP_RELEASE=true MOCK_MAKER=mock-maker-inline\r\n ⋮\r\n```\r\n\r\nI'm trying it now ;)" ]

[]

"2017-06-05T04:58:17Z"

[ "bug", "continuous integration" ]

[ ".travis.yml" ]

[ ".travis.yml" ]

[]

"2017-06-01T17:03:21Z"

[ "timestamp(timedelta=1.0, similarity=0.8727445117873299)" ]

[ "If the implementation is clean and generic, I would be in favor of it", "@szpak For what version is that feature planned (Or has it been already released)?" ]

[]

"2017-06-12T22:22:38Z"

[ "new feature", "noteworthy" ]

[ "src/main/java/org/mockito/AdditionalAnswers.java" ]

[ "src/main/java/org/mockito/AdditionalAnswers.java", "src/main/java/org/mockito/internal/stubbing/answers/AnswersWithDelay.java" ]

[ "src/test/java/org/mockito/internal/stubbing/answers/AnswersWithDelayTest.java", "src/test/java/org/mockitousage/stubbing/StubbingWithAdditionalAnswersTest.java" ]

"2017-06-08T15:22:57Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8675876474461881)" ]

[ "I think we need to set a property on our project, looking at the line above in the Travis build you linked: \r\n```\r\nproject property 'maven-central-release' exists: false\r\n```", "Looking! Thank you for reporting!", "Great bug report guys! It was very easy to nail down the issue!", "Please review / merge: https://github.com/mockito/mockito/pull/1129", "Worked perfectly - https://repo1.maven.org/maven2/org/mockito/mockito-core/2.8.47/" ]

[ "👍 " ]

"2017-06-15T14:35:35Z"

[ "question", "continuous integration" ]

[ "gradle/shipkit.gradle" ]

[ "gradle/shipkit.gradle" ]

[]

"2017-06-14T09:56:30Z"

[ "timestamp(timedelta=131388.0, similarity=0.8609656881228989)", "keyword_pr_to_issue" ]

[ "This should be fixed now." ]

[]

"2017-07-06T18:21:49Z"

[ "bug", "continuous integration" ]

[ "gradle.properties" ]

[ "gradle.properties" ]

[]

"2017-07-06T17:56:32Z"

[ "keyword_pr_to_issue" ]

[ "I am going to fix this. \r\n\r\nThrowsExceptionClass must simply implement ValidableAnswer...\r\n\r\n\r\n\r\n", "Thank you for reporting. Indeed it is a bug." ]

[ "Missing the ewuals here", "Missing equals here", "Missing equals here", "Can you give me some more infos? We expect the instance to be thrown that was passed to the stubbing, right?", "Lets better use: `exception.expect(sameInstance(expected));`", "Sorry, this one is correct. I misread" ]

"2017-08-12T11:57:33Z"

[]

[ "src/main/java/org/mockito/internal/stubbing/BaseStubbing.java", "src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java", "src/main/java/org/mockito/internal/stubbing/StubberImpl.java", "src/main/java/org/mockito/internal/stubbing/answers/ThrowsExceptionClass.java" ]

[ "src/main/java/org/mockito/internal/stubbing/BaseStubbing.java", "src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java", "src/main/java/org/mockito/internal/stubbing/StubberImpl.java" ]

[ "src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java" ]

"2017-08-03T13:49:41Z"

[ "keyword_pr_to_issue" ]

[ "This was fixed in #1184" ]

[]

"2017-09-04T21:39:42Z"

[ "continuous integration" ]

[ ".travis.yml" ]

[ ".travis.yml" ]

[]

"2017-09-01T16:00:09Z"

[ "timestamp(timedelta=2.0, similarity=0.8418935844654968)" ]

[ "If we can make this work on JDK6-8, I am all for it. If you can, please submit a PR that we can review :)", "This change is compatible with JDK6-8, because you only add an entry to `MANIFEST.mf` file. Older Java versions simply ignore it, and JDK9 uses it as a stable automatic module name (instead of generating it from JAR archive name).\r\n\r\nIf you drop the support for older JDKs somewhere in the future, you can create a true module with the same name and the change will be invisible to JDK9 modular applications:\r\n\r\n```java\r\nmodule org.mockito {\r\n requires ...;\r\n}\r\n```\r\n\r\nPR -> I'd love to, but I'm tracking the Jigsaw support in more projects and I'm afraid I don't have enough time to update them all. So I will see." ]

[]

"2017-10-04T16:23:03Z"

[ "java-9", "please contribute" ]

[ "gradle/mockito-core/osgi.gradle" ]

[ "gradle/mockito-core/osgi.gradle" ]

[]

"2017-09-24T15:16:58Z"

[ "timestamp(timedelta=165622.0, similarity=0.8636678635689894)" ]

[ "What's more even using the old Silent `@RunWith(org.mockito.runners.MockitoJUnitRunner.Silent.class)` still causes `UnnecessaryStubbingException`. The new one (`@RunWith(org.mockito.junit.MockitoJUnitRunner.Silent.class)`) has to be used to keep test passing.", "https://github.com/mockito/mockito/blob/e10c5409e460c3ecd6b2ef9513a0b3802351d85f/src/main/java/org/mockito/runners/MockitoJUnitRunner.java#L29-L31\r\n\r\nIt seems we have to change the call to this instead: https://github.com/mockito/mockito/blob/e10c5409e460c3ecd6b2ef9513a0b3802351d85f/src/main/java/org/mockito/junit/MockitoJUnitRunner.java#L107\r\n\r\nI submitted #1226 to discuss this change in behavior. I think it is an oversight when we deprecated the runner in the old package.", "It's a bug. Thank you for reporting!\r\n\r\nThe previous runner: ```org.mockito.runners.MockitoJUnitRunner``` should behave exactly the same as the new runner: ```org.mockito.junit.MockitoJUnitRunner```", "I started reviewing @TimvdLippe PR and I came to conclusion that it the current behavior works as designed.\r\n\r\n - the change of strictness of the runner was an intentional incompatible change in 2.0 release\r\n - the deprecation of the runner was a compatible change done after 2.0. Deprecated runner does not intend to help migration.\r\n - the current behavior of the code (unless I'm mistaken) is that deprecated runner behaves as the new runner which is what we want.\r\n\r\nI hope above clarifies the situation :) Please reopen if needed!" ]

[ "Curious why changing the public modifier?\r\n\r\nI suspect that this change may not be binary compatible in case somebody extends the runner.", "The code works as designed (https://github.com/mockito/mockito/issues/1212#issuecomment-340266646).\r\n\r\nIf you want to keep the PR I suggest that we add a unit test that uses deprecated runner so that we preserve and document this behavior." ]

"2017-10-27T13:12:40Z"

[ "question", "wontfix", "strictness" ]

[ "src/main/java/org/mockito/junit/MockitoJUnitRunner.java", "src/main/java/org/mockito/runners/MockitoJUnitRunner.java" ]

[ "src/main/java/org/mockito/junit/MockitoJUnitRunner.java", "src/main/java/org/mockito/runners/MockitoJUnitRunner.java" ]

[]

"2017-10-19T13:23:38Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8800423002840884)" ]

[ "That seems fine to me. Please submit a pull request :smile: " ]

[ "Shouldn't it be RetentionPolicy.RUNTIME? Annotations with RetentionPolicy.CLASS are not preserved for the vm runtime execution, which is what I assume Findbugs needs.", "Since this annotation is on our core public API methods, can you add a paragraph describing what this annotation means for the end users, written in a way that even a newbie would understand :)", "Let's add \"since\" Javadoc tag", "Actually, I think we should make this package-protected. It's not intended to be used by Mockito users", "I don't think so, it seems to work in AssertJ: https://github.com/karlicoss/assertj-core/blob/master/src/main/java/org/assertj/core/util/CheckReturnValue.java", "If you make it package-protected we won't be able to use this annotation on our public types that reside is subpackages.", "ok :)" ]

"2017-10-27T13:38:24Z"

[]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/CheckReturnValue.java", "src/main/java/org/mockito/Mockito.java" ]

[]

"2017-06-16T09:01:04Z"

[ "timestamp(timedelta=0.0, similarity=0.9091651390028943)", "keyword_pr_to_issue" ]

[]

[ "Maybe it would be better to iterate over subprojects and depend on \"test\" task (by a type or by a name) and use that list to generate also files to include (istead of looking for `*.exec` file)?\r\n\r\nIt would be even less fragile to have an optional exclusions for specific modules if needed.", "Do we really need it to be defined in every module separately? Maybe you could use the list of subprojects (I proposed above) to do it in a more generic way?", "I tried to make that work, but ran into problems. First of all, not every subproject has this test task. Therefore, I had to somehow filter the correct project. However, if you do something like below Gradle will throw an exception:\r\n\r\n```groovy\r\nsubprojects {\r\n if (it.getTaskByName('test')\r\n dependsOn \"${it.path}:test\"\r\n}\r\n```\r\n\r\nMy Groovy is lackluster and I just couldn't get this to work.", "Yes, because only this task will generate the correct `*.exec` files in `build/` which then have to be picked up by the root project. If you have a better solution, feel free to push to this PR!", "I will try to tune that tomorrow. Stay tuned.", "I'm curious why we need to specify the tool version. Can you get rid of the version and see if it works? If we bump Gradle, we generally want the best jacoco version that works with given Gradle version. Let's try if we can rely on the default.\r\n\r\nNot blocking for this PR.", "Does this work? I suspect we can run into problems because we cannot guarantee that at this point subproject has any source sets (the sequence / order in which Gradle configures projects).", "I looked at the current \"mockitoCoverage\" implementation and I think that the change is a bit more involved. For example, we should also include ```classDirectories``` from the subprojects.", "Let's avoid code duplication. I'm sure @szpak will figure this out.", "Let's avoid hardcoding the test task names and coupling with subprojects. \r\n\r\nSomething like that should work (please note that I have not tested it :):\r\n\r\n```Gradle\r\ntask mockitoCoverage(...)\r\n\r\nallprojects {\r\n plugins.withId(\"java\") {\r\n apply plugin: \"jacoco\"\r\n //configure jacoco version, etc.\r\n\r\n mockitoCoverage.dependsOn \"test\"\r\n //configure other parts of jacoco plugin or the mockitoCoverage task\r\n }\r\n}\r\n```", "Gradle usually has outdated version of JaCoCo by default (see https://github.com/gradle/gradle/commit/987d86f36a05b9090ab498dfbe77fe3dbc0f8e39 - 6 months after the release of 0.7.9 - thanks to the PR from the JaCoCo committer). In addition Mockito tended (in the past) to do not use the newest Gradle version.\r\nTherefore, it's redundant right now, but it can be needed once 0.7.10 is released. As a result, having it just one place would be probably enough to be able to uncomment one line in `coverage.gradle`.", "Sure, if not I will ask the Gradle 1.x core developer for help :).\r\n\r\nWiP.", "It was more tricky and took much more time that I expected... I did it in 3 somehow different ways and in the end I left the simplest version (with one file gathering all coverage data). Feel free to comment and to enhance.", "@mockitoguy Do you have a good idea how to get rid of it without changing the main Gradle configuration in Mockito to much?\r\n\r\nSubtasks doesn't have `Test` tasks enhances automatically due to the applying order.", "Not sure. I don't fully see the problem with ordering.", "It looks somewhat confusing that \"allprojects\" section is within the body of the \"mockitoCoverage\" task configuration.", "Let's get rid of \"for client\" - I don't even know what it means :)", "Does it actually generate html and xml? In the past the task could only generate only one kind of report.", "Is this line needed?", "It's caused by the fact that the root project in Mockito is not an empty parent project, but mockito-core in fact (which also generates coverage data).", "According [documentation](https://docs.gradle.org/current/userguide/jacoco_plugin.html#sec:jacoco_specific_task_configuration):\r\n> The JaCoCo plugin adds a JacocoTaskExtension extension to all tasks of type Test. This extension allows the configuration of the JaCoCo specific properties of the test task.\r\n\r\nIt doesn't happen for subprojects here. I needed to call \"applyTo\" manually. I didn't see it in multiprojects with \"normal\" empty parent/root project.", "Yes, it is (it's enabled in the configuration)\r\n.\r\nFor me the HTML link is enough. I don't know why the the link do XML was introduced. @TimvdLippe do you remember?", "Rather yes. There is:\r\n```\r\ndependencies {\r\n testCompile \"org.mockito:mockito-core:$version\"\r\n testCompile project(path: ':', configuration: 'testUtil')\r\n testCompile libraries.junit4\r\n testCompile libraries.assertj\r\n}\r\n```\r\nin that file below.", "That is used by CodeCov afaik", "Yes, but do they use also a link displayed in the console? :)", "Oh in that manner. I doubt it, but does it harm by reporting it?", "Should we also take into account the Kotlin projects, as they are also generating coverage?", "The groovy/kotlin plugins applies the `java` plugin under the hood.", "Ah okay :+1: " ]

"2017-10-27T14:14:32Z"

[ "enhancement", "kotlin", "please contribute" ]

[ "gradle/root/coverage.gradle", "subprojects/extTest/extTest.gradle", "subprojects/kotlinTest/kotlinTest.gradle" ]

[ "gradle/root/coverage.gradle", "subprojects/extTest/extTest.gradle", "subprojects/kotlinTest/kotlinTest.gradle" ]

[]

"2017-05-05T12:38:36Z"

[ "timestamp(timedelta=0.0, similarity=0.969590801230008)", "keyword_pr_to_issue" ]

[ "Think it makes sense to add a check since we have it. Without it, the project will just always be inconsistent.", "Absolutely +1. Thank you!" ]

[ "Coudn't we apply it automatically to all projects that apply Java plugin? Similar way it is done with JaCoCo - to do not miss another module once added.", "Uh, yeah maybe. Not a Gradle expert, but I can give it a shot tomorrow!", "Done. Please take a look :+1: ", "Do we use that plugin to handle any other type of files than `.java` and `.groovy` (`.kt`?)? If not, maybe it would be good to narrow the scope to only submodules with code? It can be achieved the same way as with the coverage: `plugins.withId(\"java\") { ... }`.", "Yes also any configuration or extra files. We can limit to Java projects, but I would rather check that all our files comply. Apparently we were missing quite some in total and the more we can catch, the better. WDYT?", "If it's also for non source code files I'm ok with `allprojects` unconditionally." ]

"2017-11-03T12:23:46Z"

[]

[ "build.gradle", "config/checkstyle/checkstyle.xml", "doc/licenses/HEADER.txt", "gradle/mockito-core/license.gradle", "src/main/java/org/mockito/CheckReturnValue.java", "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java", "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java", "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java" ]

[ "build.gradle", "config/checkstyle/checkstyle.xml", "config/checkstyle/java.header", "doc/licenses/HEADER.txt", "gradle/license.gradle", "src/main/java/org/mockito/CheckReturnValue.java", "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidByteBuddyMockMaker.java", "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidLoadingStrategy.java", "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java" ]

[ "src/test/java/org/mockitousage/bugs/GenericsMockitoAnnotationsTest.java", "src/test/java/org/mockitousage/verification/VerificationAfterDelayTest.java", "subprojects/extTest/src/test/java/org/mockitousage/plugins/stacktrace/MyStackTraceCleanerProvider.java", "subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/MyMockMaker.java", "subprojects/extTest/src/test/java/org/mockitousage/plugins/switcher/MyPluginSwitch.java", "subprojects/inline/src/test/java/org/mockitoinline/FinalClassMockingTest.java", "subprojects/inline/src/test/java/org/mockitoinline/PluginTest.java", "subprojects/inline/src/test/java/org/mockitoinline/StubbingLocationTest.java", "subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/FunctionTest.kt", "subprojects/kotlinTest/src/test/kotlin/org/mockito/kotlin/SuspendTest.kt", "subprojects/testng/src/main/java/org/mockito/testng/MockitoAfterTestNGMethod.java", "subprojects/testng/src/main/java/org/mockito/testng/MockitoBeforeTestNGMethod.java", "subprojects/testng/src/main/java/org/mockito/testng/MockitoTestNGListener.java", "subprojects/testng/src/test/java/org/mockitousage/testng/AnnotatedFieldsShouldBeInitializedByMockitoTestNGListenerTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/CaptorAnnotatedFieldShouldBeClearedTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/ConfigurationMethodTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/DontResetMocksIfNoListenerTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/EnsureMocksAreInitializedBeforeBeforeClassMethodTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/InitializeChildTestWhenParentHasListenerTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/MockFieldsShouldBeResetBetweenTestMethodsTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/ParentTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/ResetMocksInParentTestClassTooTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/SomeType.java", "subprojects/testng/src/test/java/org/mockitousage/testng/TestWithoutListenerShouldNotInitializeAnnotatedFieldsTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/FailingOnPurposeBecauseIncorrectAnnotationUsage.java", "subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/FailingOnPurposeBecauseIncorrectStubbingSyntax.java", "subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/FailingOnPurposeBecauseWrongStubbingSyntaxInConfigurationMethod.java", "subprojects/testng/src/test/java/org/mockitousage/testng/failuretests/TestNGShouldFailWhenMockitoListenerFailsTest.java", "subprojects/testng/src/test/java/org/mockitousage/testng/utils/FailureRecordingListener.java", "subprojects/testng/src/test/resources/mockito-testng.xml" ]

"2017-11-02T15:10:19Z"

[ "keyword_pr_to_issue" ]

[ "I'm observing a similar issue. Only happens with `mockito-inline`. Don't have time right now to distill the affected tests into a minimal reproduction case. Maybe @raphw has a hunch.", "Alright, decided to look for a minimal reproduction case after all. This is what I came up with:\r\n```java\r\npackage com.example\r\n\r\nimport static org.mockito.ArgumentMatchers.eq;\r\nimport static org.mockito.Mockito.spy;\r\nimport static org.mockito.Mockito.verify;\r\n\r\nimport org.testng.annotations.Test;\r\n\r\npublic final class MockitoIssue1254Test {\r\n @Test\r\n public void test() {\r\n Dummy d = spy(new Dummy());\r\n d.foo();\r\n verify(d).bar(eq(\"baz\"));\r\n }\r\n\r\n static class Dummy {\r\n public void foo() {\r\n bar(\"baz\");\r\n }\r\n\r\n // Also fails if public.\r\n void bar(String s) {}\r\n }\r\n}\r\n```\r\n\r\nCauses:\r\n```\r\nWanted but not invoked:\r\ndummy.bar(\"baz\");\r\n-> at com.example.MockitoIssue1254Test$Dummy.bar(MockitoIssue1254Test.java:23)\r\n\r\nHowever, there was exactly 1 interaction with this mock:\r\ndummy.foo();\r\n-> at com.example.MockitoIssue1254Test.test(MockitoIssue1254Test.java:13)\r\n```\r\n\r\nThis test does pass with Mockito 2.11.0. It also passes with Mockito 2.12.0, provided `mockito-inline` is disabled.", "Probably another error in the logic for self-invocation detection. I will have a look!", "Ok, this was just me forgetting how my implementation intially worked. I fixed it locally and will push a fix soon.", "Same for mocked methods on Spy. On 2.12.0 real method is called.", "When is this going to be on Maven Central?", "We could trigger a new release, @TimvdLippe, would you find some time?", "Yeah I can try it tomorrow :)\n\nOp di 5 dec. 2017 om 20:55 schreef Rafael Winterhalter <\nnotifications@github.com>:\n\n> We could trigger a new release, @TimvdLippe\n> <https://github.com/timvdlippe>, would you find some time?\n>\n> —\n> You are receiving this because you were mentioned.\n>\n>\n> Reply to this email directly, view it on GitHub\n> <https://github.com/mockito/mockito/issues/1254#issuecomment-349422044>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AFrDb3sUMqw_c_exn9HiMDi5ls1QmDHdks5s9Z_LgaJpZM4QZVVK>\n> .\n>\n", "Version 2.13.0 should be published and available soon in Maven Central!\r\n\r\nP.S. @mockitoguy the `[ci maven-central-release]` was working flawlessly :tada: ", "Danke! Bedankt! Many thanks!", "Can confirm that finally our suite of 13+ K Kotlin tests work after fixing #1183 and this one ✨ Thanks!", ">P.S. @mockitoguy the [ci maven-central-release] was working flawlessly 🎉\r\n\r\nAwesome! Thank you for pushing out the version!" ]

[ "With the issue fixed, this comment is no longer true. Would leave it out to avoid head-scratching.", "Indeed, poorly copy-pasted. Thanks.", "Can you add a code comment explaining why we need this? Please make it thorough, it would be great to share understanding! :)", "Can we make the message more actionable? Is there anything the user can do? File a ticket?", "Nice test coverage!\r\n\r\nI'm wondering if we should rather put the inline tests in main mockito codebase. The use cases should work for every Mockito mock maker, inline or not. We do run all our tests with inline mock as far as I remember.", "Do we? I would not recall that. If so, yes, we should probably move the class.", "It is my library, I can add a method to get hold of the object. But I think we are safe here as we shade the code, no real danger here.", "Added a comment.", "Nevermind, we do of course inline it and can therefore change the code.", "^ The comment is still there ;)." ]

"2017-11-13T21:30:41Z"

[ "bug" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java", "src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java", "src/main/java/org/mockito/internal/util/concurrent/WeakConcurrentMap.java" ]

[ "subprojects/inline/src/test/java/org/mockitoinline/RecursionTest.java", "subprojects/inline/src/test/java/org/mockitoinline/SuperCallTest.java" ]

"2017-11-10T10:07:26Z"

[ "keyword_pr_to_issue" ]

[ "It seems to me as if you are defining circular class loading hierarchies. With Mockito 2, we are applying more fine grained locking to improve concurrency. The difference is displayed in the stack trace where `findOrInsert` aquires a lock for the class loader of the mock class before creating a mock. The previous solution always aquired a global lock what made it impossible to create to mock classes concurrently.\r\n\r\nThe relevant part:\r\n\r\n```\r\nat java.lang.ClassLoader.loadClass(ClassLoader.java:404)\r\n- waiting to lock <0x00000007959e4a78> (a sbt.classpath.ClasspathUtilities$$anon$1)\r\nat java.lang.ClassLoader.loadClass(ClassLoader.java:411)\r\n- locked <0x0000000795a868e8> (a sbt.classpath.ClasspathFilter)\r\n\t\r\nat java.lang.ClassLoader.loadClass(ClassLoader.java:404)\r\n- waiting to lock <0x0000000795a868e8> (a sbt.classpath.ClasspathFilter)\r\nat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:161)\r\n- locked <0x00000007959e4a78> (a sbt.classpath.ClasspathUtilities$$anon$1)\r\n```\r\n\r\nHow can it be that `sbt.classpath.ClasspathFilter` delegates to `sbt.classpath.ClasspathUtilities$$anon$1` where the latter apparently also reqires locking the former? Class loaders should only be used in strict hierarchies.", "So both Maps are abstract, I'll try mocking concrete implementations. That might have caused the classloaders to kick in. I try to rewrite some of the tests to use specific implementations instead of abstract classes, but for i.e. ImmutableMap that's gonna be difficult as far as I can see.\r\n\r\nedit:\r\nSwitched to a concrete Map, just deadlocks somewhere else now, while mocking a Finagle Service[Request, Response] and a simple trait, same locks as before though.\r\n\r\n```\r\nFound one Java-level deadlock:\r\n=============================\r\n\"Timer-0\":\r\n waiting to lock monitor 0x00007f4d08002a48 (object 0x00000000c2857fb8, a sbt.classpath.ClasspathUtilities$$anon$1),\r\n which is held by \"pool-9-thread-6-ScalaTest-running-BRequestFilterSpec\"\r\n\"pool-9-thread-6-ScalaTest-running-BRequestFilterSpec\":\r\n waiting to lock monitor 0x00007f4d34003f08 (object 0x00000000c2857f60, a sbt.classpath.ClasspathFilter),\r\n which is held by \"pool-9-thread-7-ScalaTest-running-JFilterSpec\"\r\n\"pool-9-thread-7-ScalaTest-running-JFilterSpec\":\r\n waiting to lock monitor 0x00007f4d08002a48 (object 0x00000000c2857fb8, a sbt.classpath.ClasspathUtilities$$anon$1),\r\n which is held by \"pool-9-thread-6-ScalaTest-running-BRequestFilterSpec\"\r\n```", "I've run into this same problem recently as well and my jstack was identical to the OP's. I've started playing around with the mockito versions and I'm not sure if this helps, but using mockito 2.6.6 in my tests didn't result in a deadlock, while using 2.6.7+ did result in deadlock.", "Maybe we need to add a property that can be enabled to avoid the more fine-grained locking for the type cache. I would still like to know what is causing this as I even stress-tested the cache lock but I cannot reproduce the locking.\r\n\r\nIs there any project that I can build that reliably reproduces this?", "I'm not sure if it's the same problem but I got similar deadlock after specs2 update:\r\n```\r\n17:57:32 \tat java.lang.ClassLoader.loadClass(ClassLoader.java:404)\r\n17:57:32 \t- waiting to lock <0x00000000d7fda228> (a java.lang.Object)\r\n17:57:32 \tat sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)\r\n17:57:32 \tat java.lang.ClassLoader.loadClass(ClassLoader.java:357)\r\n17:57:32 \tat java.lang.Class.getDeclaredMethods0(Native Method)\r\n17:57:32 \tat java.lang.Class.privateGetDeclaredMethods(Class.java:2701)\r\n17:57:32 \tat java.lang.Class.getDeclaredMethods(Class.java:1975)\r\n17:57:32 \tat net.bytebuddy.description.method.MethodList$ForLoadedMethods.<init>(MethodList.java:90)\r\n17:57:32 \tat net.bytebuddy.description.type.TypeDescription$ForLoadedType.getDeclaredMethods(TypeDescription.java:7232)\r\n17:57:32 \tat net.bytebuddy.description.type.TypeDescription$Generic$OfNonGenericType.getDeclaredMethods(TypeDescription.java:3349)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.doAnalyze(MethodGraph.java:576)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.analyze(MethodGraph.java:537)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.doAnalyze(MethodGraph.java:573)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$Default.compile(MethodGraph.java:508)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.MethodGraph$Compiler$AbstractBase.compile(MethodGraph.java:408)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.MethodRegistry$Default.prepare(MethodRegistry.java:418)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:162)\r\n17:57:32 \tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:155)\r\n17:57:32 \tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase.make(DynamicType.java:2560)\r\n17:57:32 \tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase$Delegator.make(DynamicType.java:2662)\r\n17:57:32 \tat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:94)\r\n17:57:32 \tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n17:57:32 \tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n17:57:32 \tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:138)\r\n17:57:32 \tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:346)\r\n17:57:32 \tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:161)\r\n17:57:32 \t- locked <0x0000000080591100> (a sun.misc.Launcher$AppClassLoader)\r\n17:57:32 \tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:355)\r\n17:57:32 \tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n17:57:32 \tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n17:57:32 \tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n17:57:32 \tat org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25)\r\n17:57:32 \tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n17:57:32 \tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:63)\r\n17:57:32 \tat org.mockito.Mockito.mock(Mockito.java:1729)\r\n17:57:32 \tat org.mockito.Mockito.mock(Mockito.java:1642)\r\n17:57:32 \tat org.specs2.mock.MockitoMocker$class.mock(MockitoMocker.scala:21)\r\n17:57:32 \tat org.specs2.mock.mockito.TheMockitoMocker$$anon$1.mock(TheMockitoMocker.scala:8)\r\n17:57:32 \tat org.specs2.mock.mockito.MocksCreation$class.mock(MocksCreation.scala:18)\r\n```", "@raphw \r\n> Is there any project that I can build that reliably reproduces this?\r\n\r\nThis seems to be happening for every travis build for https://github.com/lucidsoftware/xtract\r\n\r\nHowever, it doesn't happen when I build locally.\r\n\r\nI was able to reproduce by building it in the travisci/ci-garnet:packer-1512502276-986baf0 docker image. Which is how I was able to get a thread dump and figure out that this is a likely cause.\r\n\r\nNow that I have identified what the problem probably is, I'll try to fix future builds, but a commit id that is broken is 1939ab6798c974e4238439d04ba54a71ece5c31c.\r\n\r\nFrom the thread dump, I think the applicable code is:\r\n\r\n```scala\r\n private class PureXmlReader[T](result: T) extends XmlReader[T] {\r\n def read(elem: scala.xml.NodeSeq): ParseResult[T] = ParseSuccess(result)\r\n }\r\n\r\n private class PartialSuccessXmlReader[T](result: T, errors: Seq[ParseError]) extends XmlReader[T] {\r\n def read(elem: scala.xml.NodeSeq): ParseResult[T] = PartialParseSuccess(result, errors)\r\n }\r\n\r\n def successXmlReader[T](result: T): XmlReader[T] =\r\n spy(new PureXmlReader(result))\r\n\r\n def partialSuccessXmlReader[T](result: T, errors: Seq[ParseError]): XmlReader[T] =\r\n spy(new PartialSuccessXmlReader[T](result, errors))\r\n```\r\n\r\nIt seems successXmlReader and partialSuccessXmlReader are being called simultaneously, and creating the spies concurrently results in a deadlock. The fact that both PureXmlReader and PartialSuccessXmlReader extend XmlReader is suspicious.\r\n\r\nI can give you the full thread dump if you want, but it is pretty similar to the original post.", "In my case I had to fix it by adding `sequential` to the Specification to preven examples from being executed in parallel.", "Hey guys, we're planning to merge the fix soon. Thank you for patience and reporting another use case here!" ]

[ "@raphw, can we lock always using BOOTSTRAP_LOCK?\r\n\r\nIn JVM that runs tests, we have one instance of BOOTSTRAP_LOCK and (typically) one instance of the classloader. If using classloader is a performance tweak, do we have an evidence how much value it adds? Also, the lock is only used for \"new\" classes (not yet in cache). I am not convinced using \"classloader\" as monitor adds value.\r\n\r\nIt is a best practice to always use internal objects as synchronization monitors (private final Object). This way, nobody else will use that object for monitoring and we're safe from deadlocks.\r\n\r\nI'm not a fan of adding a system property to control this. It does not help with user experience because the user is impacted by a hanging build. After some googling, the user might be able to find an answer or he needs to reach out to us to learn about the property. But then what - he needs to remember to use the property in codebases that are exposed to this problem? Also, a system property is yet another method to configure Mockito - let's limit the various ways Mockito can be configured.\r\n\r\nHope you don't mind me complaining :) I'm super grateful you debugged this issue and offered a solution! For Mockito, it's best if we keep things simple, add new configuration options only when we really need to, and strive for great user experience." ]

"2017-11-13T21:31:29Z"

[]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/TypeCachingBytecodeGenerator.java" ]

[]

"2017-05-03T22:52:41Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.9041043942633712)" ]

[ "Yes, it is by design.\r\n\r\n\"Strict stubs\" are not \"strict mocks\", e.g. we detect unused or incorrectly declared stubs but we don't force the user to verify all interactions.\r\n\r\nIf above is not clear in the documentation, can you suggest and update to the Javadoc that would make this clear? Perhaps on Strictness type or on Strictness.STRICT_STUBS enum value.", "Are there any plans for `Strict mocks` where the above would be detected?", ">Are there any plans for Strict mocks where the above would be detected?\r\n\r\nYes, we should start supporting strict mocks. I gave a talk at Devoxx conference in San Jose in March and I collected even more feedback for offering strict mocks as an alternative. We have a ticket open at #649 on this but so far we didn't accumulate enough energy to get started on this.\r\n\r\nYou motivated me to start working on this. I'll commit to produce a design spec for #649 so that it is ready to work on by an eager contributor. How does it sound? :)", "> I gave a talk at Devoxx conference in San Jose in March and I collected even more feedback for offering strict mocks as an alternative.\r\n\r\nThat's also where I learned from the `MockitoRule` and the different options. Thanks for that!\r\n\r\n> How does it sound? :)\r\n\r\nAwesome.\r\n\r\nI'd also very much prefer something along the lines of:\r\n `Mockito.enableStrictMode();`\r\n\r\nWhere you opt in for strict modes by default and then maybe can opt out for particular mocks.\r\n\r\nDo you plan to integrate the above static method call into the MockitoRule so that you can maybe do something like:\r\n`@Rule public final MockitoRule mockitoRule = MockitoJUnit.rule().strictness(STRICT_MOCKS);` that has the behavior of `STRICT_STUBS` and strict mocking?\r\n", "The design spec is ready at #1097. Do you want to contribute? :)", "I'm definitely interested. I might have some time. Would it also be okay to start with a POC and from there go and implement out all of the details? ", ">Would it also be okay to start with a POC and from there go and implement out all of the details?\r\n\r\nAbsolutely! Feel free to submit PR with a POC for early review.", "`release/2.x` is the correct branch to do so, right?", "Yes please :)\nOp ma 29 mei 2017 om 18:14 schreef Niklas Baudy <notifications@github.com>:\n\n> release/2.x is the correct branch to do so, right?\n>\n> —\n> You are receiving this because you are subscribed to this thread.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/mockito/mockito/issues/1086#issuecomment-304694849>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AFrDb9S1OMV6VFvnHQkIS66COktib-yMks5r-u7ngaJpZM4NcKVl>\n> .\n>\n" ]

[]

"2017-12-27T09:52:28Z"

[ "docs", "please contribute" ]

[ "src/main/java/org/mockito/quality/Strictness.java" ]

[ "src/main/java/org/mockito/quality/Strictness.java" ]

[]

"2017-05-16T08:34:02Z"

[ "keyword_pr_to_issue" ]

[]

[ "Nit: no need to add `final` here", "done" ]

"2018-02-06T22:58:21Z"

[]

[ "src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java", "src/main/java/org/mockito/internal/invocation/RealMethod.java", "src/main/java/org/mockito/invocation/InvocationFactory.java", "version.properties" ]

[ "src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java", "src/main/java/org/mockito/internal/invocation/RealMethod.java", "src/main/java/org/mockito/invocation/InvocationFactory.java", "version.properties" ]

[ "src/test/java/org/mockito/InvocationFactoryTest.java", "src/test/java/org/mockito/StaticMockingExperimentTest.java" ]

"2018-02-06T21:31:53Z"

[ "keyword_pr_to_issue" ]

[ "Good idea. Do you want to submit a PR?", "@mockitoguy I can work on it.\r\nAlso, to make it consistent I would suggest to extend the message to include all the invocations for other cases. As example for `TooLittleActualInvocations`.", "Submitted PR #1319 " ]

[ "Not sure if it follows the convention since the `*` was used before and `java.*` imports were listed below.", "`invocations` → `locations`?", "Indentation might have changed.", "`infocation` → `location`?", "`allLocations` → `locations`? At this point it not entirely consistent with other calls if I understand correctly.", "Same thing with imports as above.", "As I can see the import layouts that was used before violates the conventions that are described here: https://github.com/mockito/mockito/blob/release/2.x/.github/CONTRIBUTING.md#coding-style\r\nShould I revert it or is it better to follow the conventions that are in the guide?", "Here the imports also violates the described import layout", "Done", "Done", "Done", "Done", "Let's put this assert in a separate test" ]

"2018-02-21T13:34:58Z"

[ "please contribute" ]

[ "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/invocation/InvocationsFinder.java", "src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java", "src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java" ]

[ "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/invocation/InvocationsFinder.java", "src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java", "src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java" ]

[ "src/test/java/org/mockito/internal/invocation/InvocationsFinderTest.java", "src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java", "src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java" ]

"2018-02-16T07:53:37Z"

[ "keyword_pr_to_issue" ]

[ "Fantastic analysis, thank you! Do you want to take a stab at fixing it?\r\n\r\n(ping @raphw, original author of the this mock maker).", "I will have a look. Great analysis indeed. We will have to weakly reference any mock instance stored in Mockito. This is a straight forwars fi, I hope.", "I will do it once I have time. (The kid, you k ow.)", "I saw two problems we need to keep in mind:\r\n- How to weak references interact with serializability\r\n- We have to be vigilant to prevent premature cleaning up of the mock. Is there any possible case where we can gain access to the the invocations / handler without a reference to the mock?", "I uploaded a fix proposal as fb37a2e even though\r\n- I don't like that we use different kind of invocations for some tests\r\n- The tests pass and I think I serialize properly, but I am not 100% sure as I never dealt with serialization before", "Hey guys! I was reviewing @moltmann's PR and I'm wondering what are the alternative options to solve the problem. Can we attach a state to the mock object so that MockMakers can do their magic without keeping weak maps of all mocks? @raphw, thoughts?", "Unfortunately, I do not think that there is an alternative to weak references.\r\n\r\nThe Java instrumentation API allows the retransformation of Java byte code, it does not allow changing the shape of a class, e.g. adding fields. Naturally, the dispatcher would be placed in such a field such that the life time of a dispatcher would be implicitly bound to the mock instance. But since we cannot add this field, we have to place the instance outside of it such that we have to use weak references to reach the same effect.\r\n\r\nTherefore, I fear that this is the only way to go. ", "Thank you for explanation!\r\n\r\nOne alternative/supplemental option is to make the lifecycle of mocks more formal. For example, JUnit rule / runner / mockito session can inform the mock maker that \"we're done with mock x\".", "@mockitoguy If you can make this work, great. I see my mockmaker to be used to a legacy test suites though as they want to just mock one final method and not create a new test suite. Some older suites might not use junit or any other fancy feature.\r\n\r\nHence I would like to find a solution that does not require any changes outside of mockito.", "@mockitoguy Is there any further change you want to c0ad83a?" ]

[]

"2018-02-21T17:35:28Z"

[]

[ "gradle/java-library.gradle", "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java", "src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java", "src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java", "subprojects/inline/inline.gradle", "version.properties" ]

[ "gradle/java-library.gradle", "src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java", "src/main/java/org/mockito/internal/invocation/DefaultInvocationFactory.java", "src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java", "src/main/java/org/mockito/internal/invocation/mockref/MockReference.java", "src/main/java/org/mockito/internal/invocation/mockref/MockStrongReference.java", "src/main/java/org/mockito/internal/invocation/mockref/MockWeakReference.java", "subprojects/inline/inline.gradle", "version.properties" ]

[ "src/test/java/org/mockito/internal/invocation/InvocationBuilder.java", "src/test/java/org/mockito/internal/invocation/mockref/MockWeakReferenceTest.java", "src/test/java/org/mockitoutil/TestBase.java", "subprojects/inline/src/test/java/org/mockitoinline/StressTest.java" ]

"2018-02-15T23:19:06Z"

[ "timestamp(timedelta=5.0, similarity=0.8825254719575555)" ]

[]

[ "This is the current behavior, correct? E.g. your PR did not change it?", "This comment explains what the code does but does not explain why (which is the point of code comments). Unfortunately, I don't know either :) I think it was a judgement call years ago and we will stick to it to keep compatibility. Thank you for cleaning up the TODO and adding test coverage.", "This looks like a change in behavior. What is driving this? We are very careful when making changes in behavior that can cause issues when migrating to newer version of Mockito.", "Thanks!", "This exception message is not consistent with how we handle exceptions. Take a look at a Reporter class. Typically we throw an exception that is or derives from MockitoException. The message needs to be very clean, actionable to the end user. I suggest to create a high level unit test that demonstrates this use case from the standpoint of the end user. Run this test, observe the exception, would a newbie Mockito understand the exception message and was able to resolve the problem quickly?", "I see, thank you! Now I think the TODO was added because it's strange when a _user_ passes a null varargs argument:\r\n```java\r\nthenReturn(\"foo\", (String []) null);\r\n// instead of \r\nthenReturn(\"foo\", (String) null);\r\n```\r\nIf that null array comes from somewhere else (e.g., a method `nextInvocationsArguments`), that almost always a programming error that must be fixed (we can't say if a user really means `{ null }`, or `{}`, or if that's an error).\r\n\r\nWill Mockito stick with this decision in 2.x only, or in 3+ too? Will you consider changing that in the next releases? In the latter case I'd keep a TODO, but expand it with explanation _and_ a reference to an issue.", "This one is tricky, as it must not occur because of an _external_ precondition that _Mockito_ first validates this answer. If this precondition is met (i.e., Mockito never calls `answer` if `validateFor` fails), it will never fire. Therefore, I can't think of how to yield this exception through _public_ API.\r\n\r\nI've checked on 2.x with the following test, `answer` throws an NPE:\r\n\r\n```java\r\n @Test\r\n public void should_not_answer_null_throwable() throws Throwable {\r\n try {\r\n // Shall #validateFor first!\r\n new ThrowsException(null).answer(new InvocationBuilder().toInvocation());\r\n Assertions.fail(\"Should have raised NPE\");\r\n } catch (NullPointerException expected) {}\r\n }\r\n```\r\n\r\nI see such alternatives:\r\n1. Keep an implicit null check. I believe it's not OK because this check is performed on the object state, and not on a user-supplied argument.\r\n2. Add an explicit null check, throw NPE with description.\r\n3. Add an explicit null check, throw IllegalStateException with description.\r\n4. Add an explicit null check, report in a more user-friendly format.\r\n5. Add a `validateFor` check in `answer`. It will _definetely_ catch when validateFor isn't called, but is redundant in case when Mockito always validates this answer (= adheres to the Answer+ValidableAnswer contract).\r\n\r\nI'd say (5) is the safest one, but you make the same check twice (externally in the framework code + internally in the class itself). I can't say how expensive that is, or shall we trust the rest of the framework here, what do you think?\r\n\r\nIt seems `Reporter` is used to supply user-facing exceptions, but this one shall never occur in correct Mockito implementation. How do you report _internal_ errors?", "Exactly, I've added to confirm that.", "I considered how to clarify that in the case when any argument is null, we abort the stubbing.\r\n\r\nIt doesn't change _observable_ behavior, because `thenThrow(Class<? extends Throwable> throwableType)` does the same if null is passed (that was extracted in `abortNullExceptionType`).\r\n\r\nIf any code is added in `thenThrow(Class<? extends Throwable> throwableType)` _[before](https://github.com/mockito/mockito/pull/1324/files/84332358ad08f225c9bb293e5200792046d57ed7#diff-01345510e64bc217eb06fbf16e77739dR58)_ a null check, the behavior will become different.\r\n", "If you think it's worth it, I'd do the same to [`thenThrow(Throwable.. throwables)`](https://github.com/mockito/mockito/pull/1324/files/84332358ad08f225c9bb293e5200792046d57ed7#diff-01345510e64bc217eb06fbf16e77739dR43).", "Unless there is a strong reason not to, I plan to keep the code as is. Nobody complained about it. There is risk that the change will be incompatible. It's better to focus Mockito 3 on more interesting features!\r\n\r\nThank you for pointing this out and attempting to clear up the TODO!", "Oh I see now, thank you for clarification!\r\n\r\nI don't see the value of this change. We are adding one extra method and creating small code duplication.", "Oh, you're right, the user will never see it when using the public API. I missed that.\r\n\r\nIf this is only internal, IllegalStateException is perfect.", "I'd rather keep the assignment for backwards compatibility. I made this change and will push it back to your pull request. Can you contribute a test that preserves this behavior?", "Can you contribute a fix that makes it fail early when null passed via constructor? This would be cleaner (earlier feedback).", "Oh, that's unexpected, thank you for adding a clarifying comment!\r\n\r\nI think I'll add a couple of tests:\r\n- The one that prevents the change I did.\r\n- The one that verifies we get the throwable returned from `fillInStackTrace` in subsequent invocations.", "What's interesting is that the custom exception from #866 breaks the [Throwable#fillInStackTrace contract](https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html#fillInStackTrace--): this method shall always return `this`, never `null` or a reference to another throwable.\r\n", "I actually did it locally earlier, and got failures in some integration tests. It seems the constructor has to allow null throwable so that we don't get UnfinishedStubbingException (I certainly can't say if that shall or can be fixed). Here is an example of failing test output:\r\n```\r\norg.mockitousage.stubbing.StubbingWithThrowablesTest > shouldNotAllowSettingNullThrowable FAILED\r\n java.lang.AssertionError: \r\n Expected: (an instance of org.mockito.exceptions.base.MockitoException and exception with message a string containing \"Cannot stub with null throwable\")\r\n but: an instance of org.mockito.exceptions.base.MockitoException <org.junit.internal.runners.model.MultipleFailureException: There were 2 errors:\r\n org.mockito.exceptions.base.MockitoException(\r\n Cannot stub with null throwable!)\r\n org.mockito.exceptions.misusing.UnfinishedStubbingException(\r\n Unfinished stubbing detected here:\r\n -> at org.mockitousage.stubbing.StubbingWithThrowablesTest.shouldNotAllowSettingNullThrowable(StubbingWithThrowablesTest.java:154)\r\n\r\n E.g. thenReturn() may be missing.\r\n Examples of correct stubbing:\r\n when(mock.isOk()).thenReturn(true);\r\n when(mock.isOk()).thenThrow(exception);\r\n doThrow(exception).when(mock).someVoidMethod();\r\n Hints:\r\n 1. missing thenReturn()\r\n 2. you are trying to stub a final method, which is not supported\r\n 3: you are stubbing the behaviour of another mock inside before 'thenReturn' instruction if completed\r\n )> is a org.junit.internal.runners.model.MultipleFailureException\r\n Stacktrace was: org.junit.internal.runners.model.MultipleFailureException: There were 2 errors:\r\n org.mockito.exceptions.base.MockitoException(\r\n Cannot stub with null throwable!)\r\n org.mockito.exceptions.misusing.UnfinishedStubbingException(\r\n Unfinished stubbing detected here:\r\n -> at org.mockitousage.stubbing.StubbingWithThrowablesTest.shouldNotAllowSettingNullThrowable(StubbingWithThrowablesTest.java:154)\r\n\r\n E.g. thenReturn() may be missing.\r\n Examples of correct stubbing:\r\n when(mock.isOk()).thenReturn(true);\r\n when(mock.isOk()).thenThrow(exception);\r\n doThrow(exception).when(mock).someVoidMethod();\r\n Hints:\r\n 1. missing thenReturn()\r\n 2. you are trying to stub a final method, which is not supported\r\n 3: you are stubbing the behaviour of another mock inside before 'thenReturn' instruction if completed\r\n )\r\n at org.junit.runners.model.MultipleFailureException.assertEmpty(MultipleFailureException.java:67)\r\n at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:39)\r\n at org.junit.rules.ExpectedException$ExpectedExceptionStatement.evaluate(ExpectedException.java:239)\r\n at org.junit.rules.RunRules.evaluate(RunRules.java:20)\r\n at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\r\n at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)\r\n at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)\r\n at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\n at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\n at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\n at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\n at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\n at org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\n at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.runTestClass(JUnitTestClassExecuter.java:114)\r\n at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.execute(JUnitTestClassExecuter.java:57)\r\n at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassProcessor.processTestClass(JUnitTestClassProcessor.java:66)\r\n at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:51)\r\n at sun.reflect.GeneratedMethodAccessor60.invoke(Unknown Source)\r\n at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n at java.lang.reflect.Method.invoke(Method.java:498)\r\n at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)\r\n at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)\r\n at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32)\r\n at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93)\r\n at com.sun.proxy.$Proxy1.processTestClass(Unknown Source)\r\n at org.gradle.api.internal.tasks.testing.worker.TestWorker.processTestClass(TestWorker.java:108)\r\n at sun.reflect.GeneratedMethodAccessor59.invoke(Unknown Source)\r\n at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n at java.lang.reflect.Method.invoke(Method.java:498)\r\n at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)\r\n at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)\r\n at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:146)\r\n at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:128)\r\n at org.gradle.internal.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:404)\r\n at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63)\r\n at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:46)\r\n at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\r\n at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\r\n at org.gradle.internal.concurrent.ThreadFactoryImpl$ManagedThreadRunnable.run(ThreadFactoryImpl.java:55)\r\n at java.lang.Thread.run(Thread.java:748)\r\n\r\n```", "Isn't it already tested in NPEWhenCustomExceptionStackTraceReturnNullTest?", "I like this test. Can you check if we have top level integration tests for those use cases? I did a quick search and I think we have some gaps.\r\n\r\nI'm wondering if top level tests under 'org.mockitousage.*' packages aren't better to verify and document this behavior. ThrowsExceptionTest is becoming big and complicated and it does seem to repeat the coverage of the other tests. Thoughts?", "It is, shall I remove this unit test or expand the IT in `NPEWhenCustomExceptionStackTraceReturnNullTest`?", "There is a similar integration test: `org.mockitousage.stubbing.StubbingConsecutiveAnswersTest#should_throw_consecutively`\r\n\r\nShall I remove this one?", "As this test passed, the code \r\n```\r\nthrowable.fillInStackTrace();\r\nfilter.filter(throwable);\r\nthrow throwable;\r\n```\r\ndidn't break #866 , did it?", "Shan't we add a comment that these implementations of `fillInStackTrace` are totally incorrect -- they violate the method contract? Any Throwable implementation must always return a reference to `this` from `fillInStackTrace`.", "Go ahead! I wanted to preserve current behavior in a test.", "Why `linkplain` here instead of `link`?" ]

"2018-02-23T19:00:21Z"

[]

[ "src/main/java/org/mockito/internal/stubbing/BaseStubbing.java", "src/main/java/org/mockito/internal/stubbing/StubberImpl.java", "src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java" ]

[ "src/main/java/org/mockito/internal/stubbing/BaseStubbing.java", "src/main/java/org/mockito/internal/stubbing/StubberImpl.java", "src/main/java/org/mockito/internal/stubbing/answers/ThrowsException.java" ]

[ "src/test/java/org/mockito/internal/stubbing/answers/ThrowsExceptionTest.java", "src/test/java/org/mockitousage/bugs/FillInStackTraceScenariosTest.java", "src/test/java/org/mockitousage/stubbing/StubbingConsecutiveAnswersTest.java", "src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java" ]

"2018-02-23T18:55:25Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=6.0, similarity=0.8442294612501725)" ]

[]

[]

"2018-03-01T17:51:44Z"

[]

[ "src/main/java/org/mockito/internal/debugging/LocationImpl.java" ]

[ "src/main/java/org/mockito/internal/debugging/LocationImpl.java" ]

[]

"2018-03-01T17:49:29Z"

[ "timestamp(timedelta=0.0, similarity=0.9362691284832727)", "keyword_issue_to_pr", "keyword_pr_to_issue" ]

[ "Hm that seems really weird. Could you please post the implementation of `TacticalStation` and `SpaceShip` (although I am assuming they are simple POJO's?)", "(Oh never mind, I missed the small link at the end of the example to https://github.com/szpak/code-examples-and-poc/tree/mockito2junit5-bug/mockito2-junit5/src/main/java/info/solidsoft/blog/mockito/junit5 )", "@szpak Please see https://github.com/mockito/mockito/blob/5e9a3c62fc1ca4cf12d5d19580613f418cebc895/subprojects/junit-jupiter/src/test/java/org/mockitousage/InjectMocksTest.java for a working test. I could make these tests fail with adding `final` to the field declaration, so that is what is going wrong. Removing `final` makes the tests pass.\r\n\r\nWhat I do not understand is how this could work with JUnit 4, as we have not changed any of that code. We are completely reusing all of that logic.", "It also works with `final` if `MockitoAnnotations.initMocks(this);` is used. Therefore, I would suspect the way how it is triggered/executed in JUnit 5 extension.", "@TimvdLippe @szpak I have debugged this issue a bit. Here is what I found: it does look like the problem is with triggering the same logic from `MockitoExtension.class`. \r\nThe root cause of the problem is that `beforeEach` creates two `testInstances` of the same test class for each test. \r\nLooks like method `collectParentTestInstances` is adding the same testInstance to the list of test instances.\r\nI can try to work on this issue if no one is assigned to is already.\r\n", "PRs appreciated!\n\nOn Mon, 26 Mar 2018, 10:55 Serge Bishyr, <notifications@github.com> wrote:\n\n> @TimvdLippe <https://github.com/TimvdLippe> @szpak\n> <https://github.com/szpak> I have debugged this issue a bit. Here is what\n> I found: it does look like the problem is with triggering the same logic\n> from MockitoExtension.class.\n> The root cause of the problem is that beforeEach creates two testInstances\n> of the same test class for each test.\n> Looks like method collectParentTestInstances is adding the same\n> testInstance to the list of test instances.\n> I can try to work on this issue if no one is assigned to is already.\n>\n> —\n> You are receiving this because you were mentioned.\n>\n>\n> Reply to this email directly, view it on GitHub\n> <https://github.com/mockito/mockito/issues/1346#issuecomment-376094135>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AFrDb9w69sJERNCP5FZJXPrwdq0ltsI9ks5tiK0ZgaJpZM4S6Huw>\n> .\n>\n", "Have added PR #1349 with the fix for the issue", "It works flawlessly. Thanks @SeriyBg!\r\n\r\n@TimvdLippe As this bug can impact all those people preferring a constructor injection, what do you thing about releasing the new minor version (e.g. after #1350 is hopefully merged :) ) to Maven Central?", "@szpak Yes after #1350 we will probably publish a new version. You can however already use the latest version from Bintray", "I know Tim that I can, but JUnit 5 support is a notable feature and having it working correctly in the latest non-development version (available in Maven Central) seems very sensible for me. Great, that we agree on releasing a new stable (but IHMO still 2.17.x) version soon.", "I'm seeing this same bug when using `SpringExtension.class` along with `MockitoExtension.class`:\r\n\r\n```\r\n@ExtendWith({MockitoExtension.class, SpringExtension.class})\r\npublic class InjectMocksTest {\r\n static class TacticalStation {}\r\n\r\n static class SpaceShip {\r\n private final TacticalStation tacticalStation;\r\n\r\n public SpaceShip(final TacticalStation tacticalStation) {\r\n this.tacticalStation = tacticalStation;\r\n }\r\n\r\n public TacticalStation getTacticalStation() {\r\n return tacticalStation;\r\n }\r\n }\r\n\r\n @InjectMocks\r\n private SpaceShip spaceShip;\r\n\r\n @Mock\r\n private TacticalStation tacticalStation;\r\n\r\n @Test\r\n public void shouldInjectMocks() {\r\n assertThat(tacticalStation).isNotNull();\r\n assertThat(spaceShip.getTacticalStation()).isEqualTo(tacticalStation);\r\n //Bug ↑ - different mocks are use in @Mock and @InjectMock\r\n }\r\n}\r\n```\r\n\r\nThis is using Mockito 3.1.0, JUnit 5.6.0, and Spring Boot 5.3.0.RELEASE.", "> I'm seeing this same bug when using `SpringExtension.class` along with `MockitoExtension.class`:\r\n> \r\n> ```\r\n> @ExtendWith({MockitoExtension.class, SpringExtension.class})\r\n> public class InjectMocksTest {\r\n> static class TacticalStation {}\r\n> \r\n> static class SpaceShip {\r\n> private final TacticalStation tacticalStation;\r\n> \r\n> public SpaceShip(final TacticalStation tacticalStation) {\r\n> this.tacticalStation = tacticalStation;\r\n> }\r\n> \r\n> public TacticalStation getTacticalStation() {\r\n> return tacticalStation;\r\n> }\r\n> }\r\n> \r\n> @InjectMocks\r\n> private SpaceShip spaceShip;\r\n> \r\n> @Mock\r\n> private TacticalStation tacticalStation;\r\n> \r\n> @Test\r\n> public void shouldInjectMocks() {\r\n> assertThat(tacticalStation).isNotNull();\r\n> assertThat(spaceShip.getTacticalStation()).isEqualTo(tacticalStation);\r\n> //Bug ↑ - different mocks are use in @Mock and @InjectMock\r\n> }\r\n> }\r\n> ```\r\n> \r\n> This is using Mockito 3.1.0, JUnit 5.6.0, and Spring Boot 5.3.0.RELEASE.\r\n\r\nYes I am also facing this issue. Mine is also exactly the same scenario. Below are my dependencies,\r\norg.junit.jupiter:junit-jupiter-engine:5.6.0\r\norg.springframework.boot:spring-boot-starter:2.2.6.RELEASE\r\norg.springframework.boot:spring-boot-starter-test:2.2.6.RELEASE\r\norg.mockito:mockito-junit-jupiter:3.1.0" ]

[ "Lets use `isSame` here, as we literally want this object to be there.", "Good catch, have changed it. Thanks!", "I have amended the previous commit as it's a simple and small change" ]

"2018-03-26T09:44:50Z"

[ "bug", "injection", "junit5" ]

[ "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "subprojects/junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java" ]

"2018-03-25T12:31:24Z"

[ "timestamp(timedelta=0.0, similarity=0.8727645311881962)", "keyword_issue_to_pr", "keyword_pr_to_issue" ]

[ "I am 👍 for this feature with the following use case:\r\n\r\nInitialization of local variable mocks. Previously this would be `Mock<Generic> mock = mock(Mock.class)`. However, this loses the type-signature of `Generic`. With parameter mocks, we can do `@Mock Mock<Generic> mock` and still maintain the generic type signature.", "I should also note that I haven't personally used parameter resolution the way it's shown above. Our team generally either injects the mock object at the class level and configures it in ``@BeforeEach`` **OR** we inject the mock object in the test method and configure it at the top of the test method's block.", "Yes agreed. Rather than some \"magic\" shared by methods, I think a generics-type-safe replacement for local mock initialization is a lot better.", "I just edited the description of this issue to include a link to the sample ``MockitoExtension`` (I had intended to provide that reference originally). I don't know if I'd refer to the the methods sharing the parameter instance as \"magic\" but without looking at the code it certainly isn't clear that the parameters are the shared if the types and names match. I definitely think that there are use-cases for this technique and the use of ``ExtensionContext.Store`` is a great way to provide references to objects from different methods. My main concern is that when there is a name collision and the types match, you might end up with behavior that's really hard to understand (without knowing how the underlying extension works).\r\n\r\nI'm not sure I'm a fan of the syntax you described above as it seems more redundant than ``@Mock MyWeirdThing myWeirdMock`` - I'm guessing I'm misunderstanding your intention (I get the erasure part).", "In Junit 4, local mock initialization would be \r\n\r\n```java\r\nclass Test {\r\n @Test\r\n public void test() {\r\n Mock<String> mock = Mockito.mock(Mock.class);\r\n }\r\n class Mock<T> {}\r\n}\r\n```\r\nThis would issue a warning saying that the generic type of `String` is not correctly created by `Mockito.mock`. (Even though we know that our mocks will work)\r\n\r\nWith this feature, in JUnit 5, we can have:\r\n\r\n```java\r\nclass Test {\r\n @Test\r\n public void test(@Mock Mock<String> mock) {\r\n }\r\n class Mock<T> {}\r\n}\r\n```\r\nAnd the compiler will not warn any longer.", "I don't remember ever seeing that warning - Perhaps because I've always used the Mockito runner or rule?", "Correct. You do not get that warning when using the runner. But then you have mocks that are used in every single test. This targets the use case where you need 1 extra mock in only 1 testcase.", "And if the ``MockitoExtension`` is the JUnit 5 replacement for the runner or rule, why wouldn't those warnings also be suppressed?", "Because the point of Mock initialization is different. JUnit 4 only supported for attributes. We are now talking about method parameters. Hopefully when I implement this logic, it is more clear to you 😄 ", "I'm not trying to be argumentative ... but as a pretty heavy user of the prototype ``MockitoExtension`` in the https://github.com/junit-team/junit5-samples project we'd have a lot of tests to update with this syntax. We'll also need to make sure the example in the users guide and (if they're kept) the code in the junit-samples project matches the official implementation. At this point I should probably let junit-team (I wish I could use a mention here) coordinate that with you.\r\n\r\n@sbrannen @marcphilipp @sormuras", "Looking at the source of https://github.com/junit-team/junit5-samples/blob/7bf40178345d5ca837579c8ddb8c025401a98788/junit5-mockito-extension/src/main/java/com/example/mockito/MockitoExtension.java I think we should be fine. I will let you know when the PR is open so that you can test that out.\r\n\r\nOne note: the Mockito team was not involved with the development of the prototype, but I think we will approach very similar capabilities.", "I was looking at https://github.com/junit-team/junit5-samples/blob/master/junit5-mockito-extension/src/test/java/com/example/mockito/MockitoExtensionWithNestedTests.java because it's got a bunch of use cases including test-local mocks and the \"magic\" you referred to above. Thinking though the syntax change you're describing, I'll assume that the tests would still run but with the same warning?\r\n\r\nI do realize that the Mockito team didn't produce the prototype and it would be unrealistic to think that you should be permanently limited by it architecturally. I did however think that the syntax \"proposed\" by the prototype was consistent with the field injection that already existed in Mockito. I'm going to assume that what is produced as the official extension will be well integrated and well maintained - and I never complain about stable tooling!", "Opened #1350 with a proposal implementation.", "Okay, to write down the reason I think mock sharing by parameter is not a good idea:\r\n\r\nFirst of all, there is a lot of duplicate code. For every test method, you need to list the mocks, which results in duplicate. Rather, using fields for these mocks removes the duplication.\r\n\r\nSecondly, by relying on fields, the compiler will complain when you make a typo (or change a type). With parameters, you rely on the name (String-based) and the type declared. Both are not compiler safe.\r\n\r\nLastly, because you can rely on fields, refactoring is a lot easier, as IDE's support renaming by field. This is not possible for parameters.\r\n\r\nFor these 3 reasons, I see field mock sharing superior to parameter mock sharing and am therefore against introducing this logic in the parameter resolution.", "> For these 3 reasons, I see field mock sharing superior to parameter mock sharing and am therefore against introducing this logic in the parameter resolution.\r\n\r\nI totally understand the rationale. 👍 ", "What about support for `@Spy` and `@Captor`? Should new issues be created, or can it be part of this one?", "`@Spy` makes no sense, as it requires a concrete instance. `@Captor` could be done. Let's discuss that in a different issue :+1: as this issue has been resolved.", "My memory was incorrect, as #1350 has NOT been merged yet.", ">`@Spy` makes no sense\r\n\r\nYou are completely right 😄.\r\n\r\nI've created #1382 for adding support for `@Captor`", "There's `Mockito.spy(Class)` which would work for a method parameter.", "@marcphilipp Ah, yes I see now. Not sure how useful that actually is, as I only learned today we expose that API 😂 " ]

[]

"2018-03-26T13:38:17Z"

[ "junit5" ]

[ "gradle/dependencies.gradle", "src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "gradle/dependencies.gradle", "src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "subprojects/junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java" ]

"2018-03-25T21:08:04Z"

[ "keyword_issue_to_pr" ]

[ "Hm that seems really weird. Could you please post the implementation of `TacticalStation` and `SpaceShip` (although I am assuming they are simple POJO's?)", "(Oh never mind, I missed the small link at the end of the example to https://github.com/szpak/code-examples-and-poc/tree/mockito2junit5-bug/mockito2-junit5/src/main/java/info/solidsoft/blog/mockito/junit5 )", "@szpak Please see https://github.com/mockito/mockito/blob/5e9a3c62fc1ca4cf12d5d19580613f418cebc895/subprojects/junit-jupiter/src/test/java/org/mockitousage/InjectMocksTest.java for a working test. I could make these tests fail with adding `final` to the field declaration, so that is what is going wrong. Removing `final` makes the tests pass.\r\n\r\nWhat I do not understand is how this could work with JUnit 4, as we have not changed any of that code. We are completely reusing all of that logic.", "It also works with `final` if `MockitoAnnotations.initMocks(this);` is used. Therefore, I would suspect the way how it is triggered/executed in JUnit 5 extension.", "@TimvdLippe @szpak I have debugged this issue a bit. Here is what I found: it does look like the problem is with triggering the same logic from `MockitoExtension.class`. \r\nThe root cause of the problem is that `beforeEach` creates two `testInstances` of the same test class for each test. \r\nLooks like method `collectParentTestInstances` is adding the same testInstance to the list of test instances.\r\nI can try to work on this issue if no one is assigned to is already.\r\n", "PRs appreciated!\n\nOn Mon, 26 Mar 2018, 10:55 Serge Bishyr, <notifications@github.com> wrote:\n\n> @TimvdLippe <https://github.com/TimvdLippe> @szpak\n> <https://github.com/szpak> I have debugged this issue a bit. Here is what\n> I found: it does look like the problem is with triggering the same logic\n> from MockitoExtension.class.\n> The root cause of the problem is that beforeEach creates two testInstances\n> of the same test class for each test.\n> Looks like method collectParentTestInstances is adding the same\n> testInstance to the list of test instances.\n> I can try to work on this issue if no one is assigned to is already.\n>\n> —\n> You are receiving this because you were mentioned.\n>\n>\n> Reply to this email directly, view it on GitHub\n> <https://github.com/mockito/mockito/issues/1346#issuecomment-376094135>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AFrDb9w69sJERNCP5FZJXPrwdq0ltsI9ks5tiK0ZgaJpZM4S6Huw>\n> .\n>\n", "Have added PR #1349 with the fix for the issue", "It works flawlessly. Thanks @SeriyBg!\r\n\r\n@TimvdLippe As this bug can impact all those people preferring a constructor injection, what do you thing about releasing the new minor version (e.g. after #1350 is hopefully merged :) ) to Maven Central?", "@szpak Yes after #1350 we will probably publish a new version. You can however already use the latest version from Bintray", "I know Tim that I can, but JUnit 5 support is a notable feature and having it working correctly in the latest non-development version (available in Maven Central) seems very sensible for me. Great, that we agree on releasing a new stable (but IHMO still 2.17.x) version soon.", "I'm seeing this same bug when using `SpringExtension.class` along with `MockitoExtension.class`:\r\n\r\n```\r\n@ExtendWith({MockitoExtension.class, SpringExtension.class})\r\npublic class InjectMocksTest {\r\n static class TacticalStation {}\r\n\r\n static class SpaceShip {\r\n private final TacticalStation tacticalStation;\r\n\r\n public SpaceShip(final TacticalStation tacticalStation) {\r\n this.tacticalStation = tacticalStation;\r\n }\r\n\r\n public TacticalStation getTacticalStation() {\r\n return tacticalStation;\r\n }\r\n }\r\n\r\n @InjectMocks\r\n private SpaceShip spaceShip;\r\n\r\n @Mock\r\n private TacticalStation tacticalStation;\r\n\r\n @Test\r\n public void shouldInjectMocks() {\r\n assertThat(tacticalStation).isNotNull();\r\n assertThat(spaceShip.getTacticalStation()).isEqualTo(tacticalStation);\r\n //Bug ↑ - different mocks are use in @Mock and @InjectMock\r\n }\r\n}\r\n```\r\n\r\nThis is using Mockito 3.1.0, JUnit 5.6.0, and Spring Boot 5.3.0.RELEASE.", "> I'm seeing this same bug when using `SpringExtension.class` along with `MockitoExtension.class`:\r\n> \r\n> ```\r\n> @ExtendWith({MockitoExtension.class, SpringExtension.class})\r\n> public class InjectMocksTest {\r\n> static class TacticalStation {}\r\n> \r\n> static class SpaceShip {\r\n> private final TacticalStation tacticalStation;\r\n> \r\n> public SpaceShip(final TacticalStation tacticalStation) {\r\n> this.tacticalStation = tacticalStation;\r\n> }\r\n> \r\n> public TacticalStation getTacticalStation() {\r\n> return tacticalStation;\r\n> }\r\n> }\r\n> \r\n> @InjectMocks\r\n> private SpaceShip spaceShip;\r\n> \r\n> @Mock\r\n> private TacticalStation tacticalStation;\r\n> \r\n> @Test\r\n> public void shouldInjectMocks() {\r\n> assertThat(tacticalStation).isNotNull();\r\n> assertThat(spaceShip.getTacticalStation()).isEqualTo(tacticalStation);\r\n> //Bug ↑ - different mocks are use in @Mock and @InjectMock\r\n> }\r\n> }\r\n> ```\r\n> \r\n> This is using Mockito 3.1.0, JUnit 5.6.0, and Spring Boot 5.3.0.RELEASE.\r\n\r\nYes I am also facing this issue. Mine is also exactly the same scenario. Below are my dependencies,\r\norg.junit.jupiter:junit-jupiter-engine:5.6.0\r\norg.springframework.boot:spring-boot-starter:2.2.6.RELEASE\r\norg.springframework.boot:spring-boot-starter-test:2.2.6.RELEASE\r\norg.mockito:mockito-junit-jupiter:3.1.0" ]

[]

"2018-03-26T13:38:17Z"

[ "bug", "injection", "junit5" ]

[ "gradle/dependencies.gradle", "src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "gradle/dependencies.gradle", "src/main/java/org/mockito/internal/configuration/MockAnnotationProcessor.java", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "subprojects/junit-jupiter/src/test/java/org/mockitousage/JunitJupiterTest.java" ]

"2018-03-25T12:31:24Z"

[ "timestamp(timedelta=2.0, similarity=0.8688001584516274)" ]

[]

[]

"2018-05-13T21:56:54Z"

[]

[ "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java", "src/main/java/org/mockito/internal/verification/VerificationModeFactory.java", "src/main/java/org/mockito/internal/verification/VerificationWrapper.java", "src/main/java/org/mockito/verification/VerificationAfterDelay.java" ]

[ "src/main/java/org/mockito/Mockito.java", "src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java", "src/main/java/org/mockito/internal/verification/VerificationModeFactory.java", "src/main/java/org/mockito/internal/verification/VerificationWrapper.java", "src/main/java/org/mockito/verification/VerificationAfterDelay.java" ]

[ "src/test/java/org/concurrentmockito/ThreadVerifiesContinuouslyInteractingMockTest.java", "src/test/java/org/mockitousage/stubbing/DeepStubbingTest.java", "src/test/java/org/mockitousage/verification/AtMostXVerificationTest.java" ]

"2018-05-13T21:23:03Z"

[ "keyword_pr_to_issue" ]

[]

[]

"2018-05-17T09:26:34Z"

[ "junit5" ]

[ "settings.gradle", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "settings.gradle", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java", "subprojects/junitJupiterExtensionTest/junitJupiterExtensionTest.gradle" ]

[ "subprojects/junitJupiterExtensionTest/src/test/java/org/mockitousage/NoExtendsTest.java", "subprojects/junitJupiterExtensionTest/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension", "subprojects/junitJupiterExtensionTest/src/test/resources/junit-platform.properties" ]

"2018-05-17T09:25:55Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=5.0, similarity=0.8708289949970366)" ]

[]

[]

"2018-06-06T16:33:06Z"

[]

[ "src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java", "src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java" ]

[ "src/main/java/org/mockito/internal/hamcrest/HamcrestArgumentMatcher.java", "src/main/java/org/mockito/internal/invocation/MatcherApplicationStrategy.java" ]

[ "src/test/java/org/mockito/internal/invocation/MatcherApplicationStrategyTest.java" ]

"2018-06-06T16:29:09Z"

[ "timestamp(timedelta=0.0, similarity=0.8555848687526292)", "keyword_pr_to_issue" ]

[ "asm 6.2 alone does not fix this, neither does upgrading to latest bytebuddy help here.\r\nThe combination of asm 6.2, latest bytebuddy, a minor code change in mockito and setting `-Dnet.bytebuddy.experimental=true` helps here.", "mockito-core-2.21.0.jar \t\r\nbyte-buddy-1.8.15.jar\r\n\r\nwith org.mockito.plugins.MockMaker \"mock-maker-inline\" the fix is not working with java 1.8_172 and java 11-ea+24.\r\n\r\nwithout \"mock-maker-inline\" it works\r\n\r\norg.mockito.exceptions.base.MockitoException: \r\nMockito cannot mock this class: interface de.espirit.or.schema.EntityType.\r\n\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 1.8\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 25.172-b11\r\nJVM name : Java HotSpot(TM) 64-Bit Server VM\r\nJVM version : 1.8.0_172-b11\r\nJVM info : mixed mode\r\nOS name : Mac OS X\r\nOS version : 10.13.6\r\n\r\n\r\nYou are seeing this disclaimer because Mockito is configured to create inlined mocks.\r\nYou can learn about inline mocks and their limitations under item #39 of the Mockito class javadoc.\r\n\r\nUnderlying exception : org.mockito.exceptions.base.MockitoException: Could not modify all classes [interface de.espirit.or.schema.EntityType, interface java.io.Serializable]\r\n\r\n\tat de.espirit.firstspirit.access.editor.TestEntityAssociate.beforeEach(TestEntityAssociate.java:27)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.lang.reflect.Method.invoke(Method.java:498)\r\n\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\r\n\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\r\n\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)\r\n\tat org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:24)\r\n\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)\r\n\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\n\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\n\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\n\tat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\n\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\n\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\n\tat org.junit.runner.JUnitCore.run(JUnitCore.java:137)\r\n\tat com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)\r\n\tat com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)\r\nCaused by: org.mockito.exceptions.base.MockitoException: Could not modify all classes [interface de.espirit.or.schema.EntityType, interface java.io.Serializable]\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:137)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:344)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:159)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:353)\r\n\t... 23 more\r\nCaused by: java.lang.IllegalStateException: \r\nByte Buddy could not instrument all classes within the mock's type hierarchy\r\n\r\nThis problem should never occur for javac-compiled classes. This problem has been observed for classes that are:\r\n - Compiled by older versions of scalac\r\n - Classes that are part of the Android distribution\r\n\tat org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.triggerRetransformation(InlineBytecodeGenerator.java:164)\r\n\tat org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.mockClass(InlineBytecodeGenerator.java:141)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:137)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:344)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:159)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:353)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n\tat org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker.createMockType(InlineByteBuddyMockMaker.java:200)\r\n\tat org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker.createMock(InlineByteBuddyMockMaker.java:181)\r\n\tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n\tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:69)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1895)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1804)\r\n\t... 23 more\r\nCaused by: java.lang.NoSuchFieldError: ASM_API\r\n\tat org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator$ParameterWritingVisitorWrapper$ParameterAddingClassVisitor.<init>(InlineBytecodeGenerator.java:251)\r\n\tat org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator$ParameterWritingVisitorWrapper$ParameterAddingClassVisitor.<init>(InlineBytecodeGenerator.java:246)\r\n\tat org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator$ParameterWritingVisitorWrapper.wrap(InlineBytecodeGenerator.java:242)\r\n\tat net.bytebuddy.asm.AsmVisitorWrapper$Compound.wrap(AsmVisitorWrapper.java:645)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default$ForInlining$RedefinitionClassVisitor.visit(TypeWriter.java:3672)\r\n\tat net.bytebuddy.jar.asm.ClassReader.accept(ClassReader.java:492)\r\n\tat net.bytebuddy.jar.asm.ClassReader.accept(ClassReader.java:355)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default$ForInlining.create(TypeWriter.java:2915)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default.make(TypeWriter.java:1634)\r\n\tat net.bytebuddy.dynamic.scaffold.inline.RedefinitionDynamicTypeBuilder.make(RedefinitionDynamicTypeBuilder.java:171)\r\n\tat net.bytebuddy.dynamic.scaffold.inline.AbstractInliningDynamicTypeBuilder.make(AbstractInliningDynamicTypeBuilder.java:92)\r\n\tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase.make(DynamicType.java:2669)\r\n\tat org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.transform(InlineBytecodeGenerator.java:215)\r\n\tat sun.instrument.TransformerManager.transform(TransformerManager.java:188)\r\n\tat sun.instrument.InstrumentationImpl.transform(InstrumentationImpl.java:428)\r\n\tat sun.instrument.InstrumentationImpl.retransformClasses0(Native Method)\r\n\tat sun.instrument.InstrumentationImpl.retransformClasses(InstrumentationImpl.java:144)\r\n\tat org.mockito.internal.creation.bytebuddy.InlineBytecodeGenerator.triggerRetransformation(InlineBytecodeGenerator.java:161)\r\n\t... 37 more", "We are experiencing the same error with Java 11 and inline mocks.", "Having similar issue with mockito and Java 11. Unable to mock any class/interface, do we need implement any method for class loading,since defineclass method removed in Java11 ? I even edited my java.policy for assertion exception.\r\nhttps://dzone.com/articles/jdk-11-and-proxies-in-a-world-past-sunmiscunsafe\r\nhttp://hg.openjdk.java.net/jdk9/hs/jdk/rev/0d2ab72ba600\r\nmockito -2.21.0,\r\nbytebuddy-1.8.15\r\n\r\nBelow is the exception:\r\norg.mockito.exceptions.base.MockitoException: \r\n\r\nMockito cannot mock this class: class com.xxx.xxx.toolkit.config.Configuration.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 11\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 11-ea+26\r\nJVM name : Java HotSpot(TM) 64-Bit Server VM\r\nJVM version : 11-ea+26\r\nJVM info : mixed mode\r\nOS name : Mac OS X\r\nOS version : 10.13.4\r\n\r\n\r\nUnderlying exception : java.lang.IllegalStateException: Error invoking java.lang.invoke.MethodHandles$Lookup#defineClass\r\nCaused by: java.lang.IllegalStateException: Error invoking java.lang.invoke.MethodHandles$Lookup#defineClass\r\nCaused by: java.security.AccessControlException: access denied (\"java.lang.RuntimePermission\" \"defineClass\")\r\n", "Same problem here...", "Seeing a related error:\r\n```\r\norg.mockito.exceptions.base.MockitoException: \r\nMockito cannot mock this class: interface cloud.cosmin.checklister.repo.ListRepo.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 11\r\nJVM vendor name : AdoptOpenJDK\r\nJVM vendor version : 11.0.1+13\r\nJVM name : OpenJDK 64-Bit Server VM\r\nJVM version : 11.0.1+13\r\nJVM info : mixed mode\r\nOS name : Linux\r\nOS version : 4.15.0-39-generic\r\n\r\n\r\nUnderlying exception : java.lang.UnsupportedOperationException: Cannot define class using reflection\r\n\tat cloud.cosmin.checklister.rest.ListControllerTest.setUp(ListControllerTest.java:37)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\r\n\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\r\n\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)\r\n\tat org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:24)\r\n\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)\r\n\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\n\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\n\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\n\tat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\n\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\n\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\n\tat org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.runTestClass(JUnitTestClassExecutor.java:106)\r\n\tat org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.execute(JUnitTestClassExecutor.java:58)\r\n\tat org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.execute(JUnitTestClassExecutor.java:38)\r\n\tat org.gradle.api.internal.tasks.testing.junit.AbstractJUnitTestClassProcessor.processTestClass(AbstractJUnitTestClassProcessor.java:66)\r\n\tat org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:51)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n\tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)\r\n\tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)\r\n\tat org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32)\r\n\tat org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93)\r\n\tat com.sun.proxy.$Proxy2.processTestClass(Unknown Source)\r\n\tat org.gradle.api.internal.tasks.testing.worker.TestWorker.processTestClass(TestWorker.java:117)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n\tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)\r\n\tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)\r\n\tat org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:155)\r\n\tat org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:137)\r\n\tat org.gradle.internal.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:404)\r\n\tat org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63)\r\n\tat org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:46)\r\n\tat java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)\r\n\tat java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)\r\n\tat org.gradle.internal.concurrent.ThreadFactoryImpl$ManagedThreadRunnable.run(ThreadFactoryImpl.java:55)\r\n\tat java.base/java.lang.Thread.run(Thread.java:834)\r\nCaused by: java.lang.UnsupportedOperationException: Cannot define class using reflection\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Unavailable.defineClass(ClassInjector.java:821)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection.inject(ClassInjector.java:185)\r\n\tat net.bytebuddy.dynamic.loading.ClassLoadingStrategy$Default$InjectionDispatcher.load(ClassLoadingStrategy.java:187)\r\n\tat net.bytebuddy.dynamic.TypeResolutionStrategy$Passive.initialize(TypeResolutionStrategy.java:79)\r\n\tat net.bytebuddy.dynamic.DynamicType$Default$Unloaded.load(DynamicType.java:4457)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:121)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:138)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:346)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:161)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:355)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n\tat org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25)\r\n\tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n\tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:65)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1855)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:36)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16)\r\n\tat org.mockito.internal.configuration.IndependentAnnotationEngine.createMockFor(IndependentAnnotationEngine.java:38)\r\n\tat org.mockito.internal.configuration.IndependentAnnotationEngine.process(IndependentAnnotationEngine.java:62)\r\n\tat org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:57)\r\n\tat org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:41)\r\n\tat org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:69)\r\n\t... 48 more\r\nCaused by: java.lang.IllegalStateException: Could not find sun.misc.Unsafe\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingUnsafe$Dispatcher$Disabled.initialize(ClassInjector.java:1366)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingUnsafe.inject(ClassInjector.java:1202)\r\n\tat net.bytebuddy.dynamic.loading.ClassLoadingStrategy$ForUnsafeInjection.load(ClassLoadingStrategy.java:458)\r\n\tat net.bytebuddy.dynamic.TypeResolutionStrategy$Passive.initialize(TypeResolutionStrategy.java:79)\r\n\tat net.bytebuddy.dynamic.DynamicType$Default$Unloaded.load(DynamicType.java:4457)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$Indirect.make(ClassInjector.java:684)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$CreationAction.run(ClassInjector.java:302)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection$Dispatcher$CreationAction.run(ClassInjector.java:290)\r\n\tat java.base/java.security.AccessController.doPrivileged(Native Method)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingReflection.<clinit>(ClassInjector.java:70)\r\n\tat net.bytebuddy.dynamic.loading.ClassLoadingStrategy$Default$InjectionDispatcher.load(ClassLoadingStrategy.java:184)\r\n\t... 71 more\r\nCaused by: java.lang.NoSuchMethodException: sun.misc.Unsafe.defineClass(java.lang.String, [B, int, int, java.lang.ClassLoader, java.security.ProtectionDomain)\r\n\tat java.base/java.lang.Class.getMethod(Class.java:2109)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingUnsafe$Dispatcher$CreationAction.run(ClassInjector.java:1269)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingUnsafe$Dispatcher$CreationAction.run(ClassInjector.java:1257)\r\n\tat java.base/java.security.AccessController.doPrivileged(Native Method)\r\n\tat net.bytebuddy.dynamic.loading.ClassInjector$UsingUnsafe.<clinit>(ClassInjector.java:1136)\r\n\t... 80 more\r\n```", "@cstroe Are you sure that you don't have some older byte-buddy version on the classpath?\r\n\r\n(of course I assume that use you the latest version of Mockito and Byte Buddy provided by it).", "@szpak Your intuition is correct. I am using Spring Boot version `2.0.5.RELEASE`, and it is using an older version of the Mockito library. In order to use the newest Mockito, I had to change my Gradle config:\r\n```\r\n testCompile('org.springframework.boot:spring-boot-starter-test') {\r\n exclude group: \"org.mockito\", module: \"mockito-core\"\r\n }\r\n testCompile(\"org.mockito:mockito-core:2.23.4\")\r\n```\r\n\r\nThat fixed my errors. Thank you for the help.", "Great to hear.\r\n\r\nBtw, Spring Boot provides also an easier way to override dependency [versions](https://docs.spring.io/platform/docs/Cairo-BUILD-SNAPSHOT/reference/html/getting-started-overriding-versions.html). Here, overriding Mockito would be enough.\r\n\r\nBtw, AFAIR only Spring Boot 2.1 declared Java 11 compatibility. Therefore, you may want to upgrade to prevent further surprises :).", "> testCompile('org.springframework.boot:spring-boot-starter-test') {\r\n> exclude group: \"org.mockito\", module: \"mockito-core\"\r\n> }\r\n> testCompile(\"org.mockito:mockito-core:2.23.4\")\r\n\r\nthis works like a charm, Thank You!", "> \r\n> \r\n> > testCompile('org.springframework.boot:spring-boot-starter-test') {\r\n> > exclude group: \"org.mockito\", module: \"mockito-core\"\r\n> > }\r\n> > testCompile(\"org.mockito:mockito-core:2.23.4\")\r\n> \r\n> this works like a charm, Thank You!\r\n\r\nAnyone has an idea how to do this in pom.xml?", "@JiDarwish It's basic maven dependency management ;)\r\n\r\n```xml\r\n<dependency>\r\n <groupId>org.springframework.boot</groupId>\r\n <artifactId>spring-boot-starter-test</artifactId>\r\n <scope>test</test>\r\n <exclusions>\r\n <exclusion>\r\n <groupId>org.mockito</groupId>\r\n <artifactId>mockito-core</artifactId>\r\n </exclusion>\r\n </exclustions>\r\n</dependency>\r\n<dependency>\r\n <groupId>org.mockito</groupId>\r\n <artifactId>mockito-core</artifactId>\r\n <version>2.23.4</version>\r\n <scope>test</scope>\r\n</dependency>\r\n```", "@bric3 I did exactly the same, still didn't help :-(\r\n\r\n> Java : 11\r\n> JVM vendor name : Oracle Corporation\r\n> JVM vendor version : 11.0.2+9\r\n> JVM name : OpenJDK 64-Bit Server VM\r\n> JVM version : 11.0.2+9\r\n> JVM info : mixed mode\r\n> OS name : Mac OS X\r\n> OS version : 10.14.4", "Ok, adding bytebuddy dep. on top of that helped!", "> @JiDarwish It's basic maven dependency management ;)\r\n> \r\n> ```\r\n> <dependency>\r\n> <groupId>org.springframework.boot</groupId>\r\n> <artifactId>spring-boot-starter-test</artifactId>\r\n> <scope>test</test>\r\n> <exclusions>\r\n> <exclusion>\r\n> <groupId>org.mockito</groupId>\r\n> <artifactId>mockito-core</artifactId>\r\n> </exclusion>\r\n> </exclustions>\r\n> </dependency>\r\n> <dependency>\r\n> <groupId>org.mockito</groupId>\r\n> <artifactId>mockito-core</artifactId>\r\n> <version>2.23.4</version>\r\n> <scope>test</scope>\r\n> </dependency>\r\n> ```\r\n\r\nIf your project extend `spring-boot-starter-parent` you might just add : \r\n```\r\n\t<properties>\r\n\t\t<mockito.version>2.23.4</mockito.version>\r\n\t</properties>\r\n```\r\n\r\nIn your Maven file. " ]

[]

"2018-07-10T12:04:36Z"

[ "java-11" ]

[ "gradle/dependencies.gradle", "src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java" ]

[ "gradle/dependencies.gradle", "src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java" ]

[]

"2018-07-02T11:12:56Z"

[ "keyword_issue_to_pr" ]

[ "Interesting. Thanks for the bug report.\r\n\r\nI noticed a change in serialization in the release notes (http://www.oracle.com/technetwork/java/javase/8u181-relnotes-4479407.html) yesterday.\r\n\r\n> core-libs/java.io:serialization\r\n> ➜ Better stack walking\r\n> New access checks have been added during the object creation phase of deserialization. This should not affect ordinary uses of deserialization. However, reflective frameworks that make use of JDK-internal APIs may be impacted. The new checks can be disabled if necessary by setting the system property jdk.disableSerialConstructorChecks to the value \"true\". This must be done by adding the argument -Djdk.disableSerialConstructorChecks=true to the Java command line.\r\n>\r\n> JDK-8197925 (not public)\r\n\r\nI'll verify that asap.\r\n\r\n\r\n-- Brice\r\nMisplet on my phone\r\n\r\n\r\n", "I'm looking into it right now. Thank you for reporting!\r\n\r\nOur JDK10 build has been exposed: https://travis-ci.org/mockito/mockito/jobs/405198762", "I confirm that disabling the constructor checks works. Running the tests with the following properties make them pass. \r\n\r\n```diff\r\ndiff --git i/build.gradle w/build.gradle\r\nindex b47d86bbf..da61d692e 100644\r\n--- i/build.gradle\r\n+++ w/build.gradle\r\n@@ -91,6 +91,10 @@ task wrapper(type: Wrapper) {\r\n gradleVersion = '4.7'\r\n }\r\n\r\n+test {\r\n+ systemProperty \"jdk.disableSerialConstructorChecks\", \"true\"\r\n+}\r\n+\r\n //Posting Build scans to https://scans.gradle.com\r\n buildScan {\r\n licenseAgreementUrl = 'https://gradle.com/terms-of-service'\r\n```\r\n\r\nIt seems that remove the `Any` constructor did the trick. \r\n\r\n```diff\r\ndiff --git i/src/main/java/org/mockito/internal/matchers/Any.java w/src/main/java/org/mockito/internal/matchers/Any.java\r\nindex f9f0069bd..ad4cca35a 100644\r\n--- i/src/main/java/org/mockito/internal/matchers/Any.java\r\n+++ w/src/main/java/org/mockito/internal/matchers/Any.java\r\n@@ -13,8 +13,8 @@ public class Any implements ArgumentMatcher<Object>, VarargMatcher ,Serializable\r\n\r\n public static final Any ANY = new Any();\r\n\r\n- private Any() {\r\n- }\r\n+ // private Any() {\r\n+ // }\r\n\r\n public boolean matches(Object actual) {\r\n return true;\r\n```\r\n\r\nHowever I suspect that user tests relying on mocks of an object with private no-arg constructor that is serialized using `ObjectInputStream` maybe have to declare this system property. Although it seems like an edgy case.", "Created PR to fix this problem: #1433", "Fixed on master :tada:", "@mockitoguy can you make a patch release to maven central for this?", "@TimvdLippe the fix in #1433 only affects mockito's build\r\n\r\nMockito users will see the same errors in their build if they are in the same conditions.", "@mockitoguy \r\nif you take a look at other classes in matchers directory, eg. Contains.java.\r\nthey have similar problem. there's no accessible non-arg constructor\r\n\r\nmockito UT doesn't try to serialize them. \r\n" ]

[]

"2018-07-18T13:34:04Z"

[ "bug", "java-8", "java-10", "build" ]

[ "src/main/java/org/mockito/internal/matchers/Any.java" ]

[ "src/main/java/org/mockito/internal/matchers/Any.java" ]

[]

"2018-07-18T01:44:11Z"

[ "timestamp(timedelta=40740.0, similarity=0.8866171351360362)" ]

[ "Thank you for contribution!" ]

[]

"2018-07-21T16:47:04Z"

[ "docs" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2018-07-21T12:43:51Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=162048.0, similarity=0.8437745467741583)" ]

[ "It's a bug. Thank you for reporting!", "@epeee, can you take a look at this?", "Upstream bug in Shipkit: https://github.com/mockito/shipkit/issues/741", "@mockitoguy sorry, I was busy yesterday. \r\nI can have a look at the upstream bug in shipkit tomorrow.", "Not sure if it is related but the `2.20.1` is available in JCenter but not in Maven Central.", "There is some delay. Bintray log shows that the sync was successful. Let's wait until the end of the day.\r\n\r\nThanks for checking!", "OSS repo has the right artifacts so I think it's just a delay before it's searchable in central. Proof - [pom.xml](https://oss.sonatype.org/service/local/artifact/maven/redirect?r=releases&g=org.mockito&a=mockito-inline&v=2.20.1&e=pom) in the Sonatype OSS 'release' repo.\r\n\r\nLet's keep the ticket open until we add tests for the artifacts. @ming13, do you want to contribute a test that would verify artifact IDs? This should be a form of a Gradle task.", "The issue is fixed in 2.20.1. I've added tests to prevent the issue in the future.\r\n\r\nThanks again for reporting!!!" ]

[]

"2018-07-26T03:39:08Z"

[]

[ "build.gradle", "doc/release-notes/official.md", "gradle/java-library.gradle" ]

[ "build.gradle", "doc/release-notes/official.md", "gradle/java-library.gradle" ]

[]

"2018-07-25T08:09:20Z"

[ "keyword_issue_to_pr" ]

[ "This is probably broken by https://github.com/mockito/mockito/commit/28fa11092b55595727eb3c40059a5f632f3f29cc Could you revert the Bytebuddy version and see if that fixes it?", "Sure thing, @TimvdLippe - I'm not 100% sure on the best way to go about that, though. Any pointers on how to most easily pull down and point to the correct artifacts? I've got it cloned, but am not sure which gradle projects represent the `core` and `android` artifacts.\r\n\r\n(I'm assuming that `subprojects/android` is likely `mockito-android - but just trying to include the root project in my app gives a gradle error, making me suspect I'm doing this wrong)", "You should be able to pin the version of ByteBuddy to a specific version in your `pom.xml` or Gradle file. No need to clone this repository :smile: ", "So this is fixed as of #1525 ?", "> So this is fixed as of #1525 ? \r\n\r\nDoesn't look so. `mockito-android 2.23.0` and `bytebuddy 1.9.3` fails with exception. same mockito and `bytebuddy 1.8.10` works for me ", "Use 2.23.4", "> Use 2.23.4\r\n\r\nHow should it fix the issue?\r\n\r\n```\r\n+--- org.mockito:mockito-android:2.23.4\r\n| +--- org.mockito:mockito-core:2.23.4\r\n| | +--- net.bytebuddy:byte-buddy:1.9.3\r\n| | +--- net.bytebuddy:byte-buddy-agent:1.9.3\r\n| | \\--- org.objenesis:objenesis:2.6\r\n| \\--- net.bytebuddy:byte-buddy-android:1.9.3\r\n| +--- net.bytebuddy:byte-buddy:1.9.3\r\n| \\--- com.jakewharton.android.repackaged:dalvik-dx:1\r\n| \\--- com.jakewharton.android.repackaged:libcore-dex:2\r\n```\r\nFails, but \r\n```\r\n+--- org.mockito:mockito-android:2.23.4\r\n| +--- org.mockito:mockito-core:2.23.4\r\n| | +--- net.bytebuddy:byte-buddy:1.9.3 -> 1.8.10\r\n| | +--- net.bytebuddy:byte-buddy-agent:1.9.3 -> 1.8.10\r\n| | \\--- org.objenesis:objenesis:2.6\r\n| \\--- net.bytebuddy:byte-buddy-android:1.9.3 -> 1.8.10\r\n| +--- net.bytebuddy:byte-buddy:1.8.10\r\n| \\--- com.jakewharton.android.repackaged:dalvik-dx:1\r\n| \\--- com.jakewharton.android.repackaged:libcore-dex:2\r\n```\r\nworks. What am I missing?", "@plastiv \r\n\r\nCheck the answer from: https://stackoverflow.com/a/51891596/8034839 \r\n\r\nTry to use the version 2.18.3\r\n\r\n```\r\ntestImplementation 'org.mockito:mockito-core:2.18.3'\r\nandroidTestImplementation 'org.mockito:mockito-android:2.18.3'\r\n```\r\n", "Hmm - it doesn't seem to be working for me, even with a forced ByteBuddy. Here's a code snippet from my build.gradle to force this:\r\n\r\n```\r\nconfigurations.all {\r\n resolutionStrategy {\r\n force 'net.bytebuddy:byte-buddy:1.8.10'\r\n force 'net.bytebuddy:byte-buddy-agent:1.8.10'\r\n }\r\n}\r\n```\r\n\r\nAnd you can see in my dependencies:\r\n```\r\n+--- org.mockito:mockito-android:2.23.4\r\n| +--- org.mockito:mockito-core:2.23.4\r\n| | +--- net.bytebuddy:byte-buddy:1.9.3 -> 1.8.10\r\n| | +--- net.bytebuddy:byte-buddy-agent:1.9.3 -> 1.8.10\r\n| | \\--- org.objenesis:objenesis:2.6\r\n| \\--- net.bytebuddy:byte-buddy-android:1.9.3\r\n| +--- net.bytebuddy:byte-buddy:1.9.3 -> 1.8.10\r\n| \\--- com.jakewharton.android.repackaged:dalvik-dx:1\r\n| \\--- com.jakewharton.android.repackaged:libcore-dex:2\r\n```\r\n\r\nAny further ideas what might be causing this?", "@tmtrademarked Try also downgrading `net.bytebuddy:byte-buddy-android:1.8.10`", "Well, I feel silly now. That should have been obvious. Thanks! That does in fact fix the problem.", "It looks like this may be fixed in the newest byte-buddy versions. Unpinning my byte buddy and updating to Mockito 2.24.0 (which brings in byte-buddy 1.9.7) seems to fix the problem on my builds!", "Glad to hear! Closing per above comment." ]

[ "Version 3.0.1 requires Java 8. If this is an issue, we need to keep using the older version.", "I reverted this change." ]

"2018-10-30T06:42:01Z"

[ "android" ]

[ "gradle/dependencies.gradle" ]

[ "gradle/dependencies.gradle" ]

[]

"2018-10-05T19:31:53Z"

[ "timestamp(timedelta=1.0, similarity=0.8680414470106933)" ]

[ "Great investigation! Do you have a suggestion on how to resolve this?", "Tried different approaches. I believe I found one solution that works well. Created a PR." ]

[]

"2018-11-24T17:50:01Z"

[]

[ "src/main/java/org/mockito/internal/stubbing/BaseStubbing.java", "src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java", "src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java", "subprojects/inline/inline.gradle" ]

[ "src/main/java/org/mockito/internal/stubbing/BaseStubbing.java", "src/main/java/org/mockito/internal/stubbing/ConsecutiveStubbing.java", "src/main/java/org/mockito/internal/stubbing/OngoingStubbingImpl.java", "subprojects/inline/inline.gradle" ]

[ "subprojects/inline/src/test/java/org/mockitoinline/OneLinerStubStressTest.java" ]

"2018-11-22T22:32:39Z"

[ "timestamp(timedelta=1.0, similarity=0.9250358639836104)" ]

[]

[ "Great! We don't want local cache on CI.", "Why do we need this setting or the next one? Can we rely on Gradle's defaults?", "good question, let's rely on defaults for now and adjust them if needed later on." ]

"2018-11-26T21:02:18Z"

[ "please contribute", "build" ]

[ ".gitignore", "gradle.properties", "settings.gradle" ]

[ ".gitignore", "gradle.properties", "settings.gradle" ]

[]

"2018-11-26T17:06:16Z"

[ "timestamp(timedelta=0.0, similarity=0.8578591718360361)", "keyword_pr_to_issue" ]

[ "A fix (if this **is** an issue) might be simple:\r\n\r\n```\r\nIndex: src/main/java/org/mockito/internal/stubbing/StubberImpl.java\r\nIDEA additional info:\r\nSubsystem: com.intellij.openapi.diff.impl.patch.CharsetEP\r\n<+>UTF-8\r\n===================================================================\r\n--- src/main/java/org/mockito/internal/stubbing/StubberImpl.java\t(revision 11e28796ecd89470ca50632e0fe9b2e4260e323a)\r\n+++ src/main/java/org/mockito/internal/stubbing/StubberImpl.java\t(date 1532965613000)\r\n@@ -93,6 +93,9 @@\r\n } catch (RuntimeException instantiationError) {\r\n mockingProgress().reset();\r\n throw instantiationError;\r\n+ } catch (InstantiationError instantiationError) {\r\n+ mockingProgress().reset();\r\n+ throw instantiationError;\r\n }\r\n return doThrow(e);\r\n }\r\n```", "@dmitry-timofeev, do you want to take a stab at it? Please provide top level test that demonstrates the problem, too. It would be really helpful. Thank you!", "Hi @mockitoguy , thank you for having a look. I'm a little busy at work, therefore I won't be able to in the coming weeks.", "That's fair, we will try find time to work on this. Thank you for reporting!" ]

[]

"2018-11-27T16:56:06Z"

[ "bug" ]

[ "src/main/java/org/mockito/internal/stubbing/StubberImpl.java" ]

[ "src/main/java/org/mockito/internal/stubbing/StubberImpl.java" ]

[ "src/test/java/org/mockitousage/stubbing/StubbingWithBadThrowablesTest.java", "subprojects/junit-jupiter/src/test/java/org/mockitousage/UninstantiableThrowableTest.java" ]

"2018-10-09T18:09:07Z"

[ "timestamp(timedelta=9.0, similarity=0.9413523180519786)" ]

[]

[]

"2018-11-28T23:07:03Z"

[ "build" ]

[ "src/main/java/org/mockito/internal/junit/ExceptionFactory.java" ]

[ "src/main/java/org/mockito/internal/junit/ExceptionFactory.java" ]

[]

"2018-11-28T22:58:55Z"

[ "timestamp(timedelta=8.0, similarity=0.8412190641305102)" ]

[ "Given that @brachi-wernick opened a PR for this and it appears that we never commented on this issue: I don't think we should allow this. You should use the real Function in all cases, as a spy of the function would just delegate to the actual function.\r\n\r\nTherefore I am inclined to close this issue and corresponding PR. @mockito/core any opinion on this one?", "@TimvdLippe just let me know for next time. Should i solve issues only after you commented on them?", "Yes please. Sorry for not getting to this issue sooner. We should have commented :cry: Your help is still appreciated though, so feel free to sent more PRs! Issues tagged with \"Please contribute\" are definitely open for community PRs: https://github.com/mockito/mockito/issues?q=is%3Aissue+is%3Aopen+label%3A%22please+contribute%22", "Closing per https://github.com/mockito/mockito/issues/1068#issuecomment-446266057", "@TimvdLippe sorry for commenting on a closed issue, but can you reconsider reopening it? We might have missed the point of spying on a lambda. I don't think the idea would be to stub the methods or something like that, but to verify their recorded information. For instance, this becomes extremely useful when we want to test callbacks, and we only care if the lambda was called, how many times, which arguments, etc.\r\n\r\nSimilar libraries in other languages have this feature since verifying is the most useful part of a `spy()`. A good example is [Sinon.JS](https://sinonjs.org), in which we even find an example of this usage in the documentation: https://sinonjs.org/releases/v13/spies/\r\n\r\nI found myself in this same situation while improving some tests on a library of my authoring called [Maybe](https://github.com/JoseLion/maybe). Here's the gist of the use case 🙂 \r\n```java\r\n@Test void runs_the_effect_callback() {\r\n final Consumer<IOException> effectSpy = spy(error -> { });\r\n\r\n Maybe.fromSupplier(throwingOp).doOnError(IOException.class, effectSpy);\r\n\r\n verify(effectSpy, times(1)).accept(FAIL_EXCEPTION);\r\n}\r\n```\r\n\r\nAs you can see, the test only cares to verify if the `effect` callback was invoked once with the specific argument. I think there's no other way of doing this with Mockito, and since spying to the lambda will fail, I'm using @danwallach's workaround for now. \r\n\r\nI hope you find this helpful in improving Mockito 🙂 \r\n\r\nCheers!" ]

[]

"2018-12-11T16:16:03Z"

[]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/test/java/org/mockito/MockitoTest.java" ]

"2017-05-04T13:31:59Z"

[ "keyword_issue_to_pr" ]

[ "I suppose it's worth noting that in the (hopefully) very short term, adding this class in the appropriate package is a simple workaround if you don't want to generalize setting the suggested property:\r\n\r\n```java\r\npackage android.support.test;\r\n\r\nimport android.content.Context;\r\n\r\npublic class InstrumentationRegistry {\r\n public static Context getTargetContext() {\r\n return androidx.test.InstrumentationRegistry.getTargetContext();\r\n }\r\n}\r\n```", "I did this in the class where I got this error and it fixed the problem for me. \r\n\r\n`static {\r\n System.setProperty(\"org.mockito.android.target\", ApplicationProvider.getApplicationContext().getCacheDir().getPath()); \r\n}`", "This should be fixed in #1583" ]

[ "Can you refactor the common part into a method so that only the String is different? That makes maintaining this piece of code a bit easier.", "done" ]

"2019-01-08T18:19:56Z"

[ "android" ]

[ "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java" ]

[ "subprojects/android/src/main/java/org/mockito/android/internal/creation/AndroidTempFileLocator.java" ]

[]

"2018-08-10T21:51:10Z"

[ "keyword_pr_to_issue" ]

[ "@raphw FYI" ]

[]

"2019-01-09T16:11:43Z"

[]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java" ]

[]

"2019-01-09T11:37:11Z"

[ "timestamp(timedelta=0.0, similarity=0.9093045693735561)", "keyword_pr_to_issue" ]

[]

[]

"2019-01-10T12:19:16Z"

[ "injection" ]

[ "src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java" ]

[ "src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java" ]

[]

"2019-01-10T12:16:12Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8999167219580725)" ]

[ "My machine is still on JVM 11.0.1. Going to have to go through Travis this time around to debug this issue..." ]

[]

"2019-01-28T17:25:20Z"

[ "java-11", "build" ]

[ "build.gradle" ]

[ "build.gradle" ]

[]

"2019-01-19T14:46:33Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8977929713305419)" ]

[ "Suspiciously, the type is again in the `java.util` package. That leads me to believe any type definitive in there can't be mocked.", "> That leads me to believe any type definitive in there can't be mocked.\r\n\r\nUsing `2.24.0`. It works with the older version.", "The package should not be an issue, but I'll check. ", "There is a dot missing after the package name....", "Haha well spotted! Might be a simple String concatenation typo.", "This is probably the mistake: https://github.com/mockito/mockito/blob/00cc06b387c3af8aaaed3a14fcb38df7d69db6c1/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java#L101\r\n\r\nShould be:\r\n\r\n```java\r\n typeName = InjectionBase.class.getPackage().getName() +\".\" + features.mockedType.getSimpleName();\r\n```", "Yes, very much.\r\n\r\nCan it be that we don't have a test case for mocking a 'java.' type?\r\n\r\nAre yoilu on your machine? I'll fix it next week otherwise. ", "Sadly not. I can work on it tomorrow as well. Luckily we have a test suite now 🎉 ", "Or if @sormuras is available to make that PR, that would be amazing as well 😄 Our tests are specified in https://github.com/mockito/mockito/blob/f11705be91ee3545bc006908b34425f1fc359898/subprojects/module-test/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java", "Great, Tim!\r\n\r\nAny plans to sync current release to Maven Central, soon? 2.24.0 is the latest one that was uploaded: http://central.maven.org/maven2/org/mockito/mockito-core/maven-metadata.xml", "I wanted to do so, but I first wanted to get some other issues resolved with @raphw Hopefully we can get to that next week. (but seems like we hit a JDK bug 🎉 )", "Mockito 2.24.5 should be available on Maven central later today.", "Looks good on 12: https://travis-ci.org/junit-team/junit5/jobs/495011557" ]

[]

"2019-02-11T15:27:29Z"

[ "java-12" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java" ]

[ "src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java", "subprojects/module-test/src/test/java/org/mockito/moduletest/ModuleHandlingTest.java" ]

"2019-02-10T16:09:00Z"

[ "keyword_pr_to_issue" ]

[ "We have observed similar things before. It seems like a mock is something keeping a hard reference to a listener. @TimvdLippe Do you remember me mentioning to having observed this some times? Were you working with the listener parts originally?", "Yes I recall that discussion. The listener parts were introduced by @mockitoguy. I have run into this problem myself from time to time and have not figured out where it goes wrong. These listeners should not even be considered when serializing mocks." ]

[]

"2019-02-12T23:00:27Z"

[]

[ "src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java" ]

[ "src/main/java/org/mockito/internal/junit/DefaultStubbingLookupListener.java" ]

[ "src/test/java/org/mockitousage/serialization/StrictStubsSerializableTest.java" ]

"2019-02-12T21:47:14Z"

[ "timestamp(timedelta=6.0, similarity=0.853894488049074)" ]

[]

[]

"2019-02-28T02:45:54Z"

[]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2019-02-28T02:35:41Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=8.0, similarity=0.9119012286113053)" ]

[ "Update: I found that the lazy verification works properly when you use `VerificationCollector` directly. However, if you try and use it as a JUnit rule that's when this bug manifests.\r\n\r\nI have updated `VerificationCollectorImplTest` to properly test for this situation and fail as appropriate. I will have a quick look and see if it is an easy fix; otherwise I may submit a PR with the test only and leave a more experienced hand to fix it.", "Another update: I have gotten to the root of this problem.\r\n\r\n>I found that the lazy verification works properly when you use VerificationCollector directly. However, if you try and use it as a JUnit rule that's when this bug manifests.\r\n\r\nThis wasn't quite correct. The distinguishing feature wasn't the JUnit rule, but if you do a verification for an invocation that tries to match on an argument while running under JUnit.\r\n\r\nThere is code in `org.mockito.internal.junit.ExceptionFactory` that checks to see if JUnit is on the classpath - if so, then it will throw `org.mockito.exceptions.verification.junit.ArgumentsAreDifferent` rather than `org.mockito.exceptions.verification.ArgumentsAreDifferent`. The JUnit version inherits from `junit.framework.ComparisonFailure` whereas the basic version inherits from `org.mockito.exceptions.base.MockitoAssertionError`.\r\n\r\nIt seems that the purpose of this is to help JUnit-aware GUIs to produce more helpful diagnostic output. This makes sense (although it would make more sense to derive from a more-up-to-date version of `ComparisonFailure` if it is available, like `org.junit.ComparisonFailure` - perhaps this could be the subject of a different issue/PR). However, because it is not a subclass of `MockitoAssertionError`, it skips out of the try/catch in `VerificationCollectorImpl` (see https://github.com/mockito/mockito/blob/b745b5d48e9c110fa419fd007b3159ff612b8643/src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java#L92).\r\n\r\nThere are two possible solutions:\r\n\r\n1. Add another `catch()` to catch `ComparisonFailure` as well.\r\n2. Broaden the catch for `MockitoAssertionError` to a common superclass (like `AssertionError`).\r\n\r\nThe second probably has more generic appeal and would future-proof the solution if other types of argument comparison were used (eg, a custom argument matcher). I will submit a PR for this shortly." ]

[]

"2019-03-04T03:52:22Z"

[]

[ "src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java" ]

[ "src/main/java/org/mockito/internal/junit/VerificationCollectorImpl.java" ]

[ "src/test/java/org/mockitousage/junitrule/VerificationCollectorImplTest.java" ]

"2019-03-03T23:45:20Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8876214866028436)" ]

[ "For more information see the error-prone bugpattern: https://errorprone.info/bugpattern/TypeParameterUnusedInFormals", "@mockitoguy WDYT? I think it makes sense to have a simple API for local assignments or in return statements, but we would still need the Class to be explicit.", "Looking...", "Good idea! Few suggestions:\r\n - document clearly the use case in the new method (compact, readable tests / one-liner invocations).\r\n - add NotExtensible annotation to InvocationOnMock\r\n\r\nNice catch.\r\n", "Awesome, thanks for the quick response! Will open a PR today :smile: ", "Instead of using the reintroduced `getArgument<T>(int, Class<T>)`, IIUC the issue described above can also be solved as follows:\r\n```java\r\ninvocation.<Runnable>getArgument(0).run()\r\n```\r\nThat's admittedly less obvious, but does keep the API smaller. Has this been considered?", "While that does work as well, I think consistency with the old API as well as the readability of the former vs the latter would still lead me to conclude that reintroducing is the appropriate solution." ]

[]

"2019-03-04T15:13:15Z"

[]

[ "src/main/java/org/mockito/MockSettings.java", "src/main/java/org/mockito/MockitoFramework.java", "src/main/java/org/mockito/MockitoSession.java", "src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java", "src/main/java/org/mockito/invocation/InvocationOnMock.java", "src/main/java/org/mockito/session/MockitoSessionBuilder.java", "src/main/java/org/mockito/session/MockitoSessionLogger.java" ]

[ "src/main/java/org/mockito/MockSettings.java", "src/main/java/org/mockito/MockitoFramework.java", "src/main/java/org/mockito/MockitoSession.java", "src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java", "src/main/java/org/mockito/invocation/InvocationOnMock.java", "src/main/java/org/mockito/session/MockitoSessionBuilder.java", "src/main/java/org/mockito/session/MockitoSessionLogger.java" ]

[]

"2019-02-05T16:53:30Z"

[ "keyword_pr_to_issue" ]

[ "@TimvdLippe it looks like we fixed this one in https://github.com/mockito/shipkit/pull/782.\r\nI can do some local testing and provide a PR for this one soon (shipkit version update).", "Thanks for that @epeee Looking forward to that PR.", "Thank you guys!" ]

[]

"2019-03-04T17:36:20Z"

[]

[ "build.gradle", "version.properties" ]

[ "build.gradle", "version.properties" ]

[]

"2019-03-04T15:12:41Z"

[ "keyword_pr_to_issue" ]

[]

[ "What is the reasoning for making this protected? It is an internal class, so it should not be subclassed.", "I don't see these being used anywhere else. Moreover, they are not on the interface `Invocation`. If we were to add them, they have to be on the interface.", "I currently need to extend it to replace the InvocationMatcher, so I made it protected just in case, but I'm happy to leave it private if you prefer so", "I'm calling it from mockito-scala, should I add it to the interface then?", "We cannot do it. It's leaking internal API via a public API.", ">should I add it to the interface then?\r\n\r\nPlease no. MockReference is an internal type and we should not leak it from a public interface.", "@TimvdLippe, I'm ok with changing private method to protected on an internal type so that mockito-scala integration is easier in the short term. @bbonanno is aware that we don't guarantee compatibility for internal API in the long term.", "This is good! We can add this method to the public API because it returns a public type.", "Can you add \"since\" tag because it's a new public API?", "Can you add a note that the method converts each argument using ArgumentMatchers.eq() or AdditionalMatchers.arryEq() and that it is used internally for the purposes of human-readable invocation printing.\r\n\r\nI don't want users to confuse this new method with the MatchableInvocation.getMatchers() method.", ":)", "Can you use Javadoc link? Thank you :)", "Ups, sorry about that" ]

"2019-03-16T20:12:52Z"

[]

[ "src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java", "src/main/java/org/mockito/internal/invocation/InvocationMatcher.java", "src/main/java/org/mockito/internal/reporting/PrintSettings.java", "src/main/java/org/mockito/invocation/Invocation.java" ]

[ "src/main/java/org/mockito/internal/invocation/InterceptedInvocation.java", "src/main/java/org/mockito/internal/invocation/InvocationMatcher.java", "src/main/java/org/mockito/internal/reporting/PrintSettings.java", "src/main/java/org/mockito/invocation/Invocation.java" ]

[ "src/test/java/org/mockito/internal/invocation/InvocationBuilder.java", "src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java" ]

"2019-03-16T20:11:36Z"

[ "timestamp(timedelta=0.0, similarity=0.9492359482839157)" ]

[ "Changing the exception type is an incompatible change in a strict sense. However, we need to be able to improve the framework by tweaking the exceptions if needed. We always strive to be compatible. There are no known legit use cases why our users would want to catch & handle specific Mockito exceptions. It's OK to change the type of ArgumentsAreDifferent exception.", "I'm happy to take this on, per your request. The hardest part was the question of whether/how to handle backward compatibility. Should have a PR submitted by Monday.", "> The hardest part was the question of whether/how to handle backward compatibility\r\n\r\nWe are OK with this incompatible change (see my other comment). Thanks for taking this on!!!\r\n\r\n" ]

[ "We will get to that when we switch to Java 1.8. Let's remove these comments for now.", "Done.", "Great! \"compileOnly\" is exactly the way to go!", "Let's just say \"JUnit\", instead of \"JUnit 3\" in the javadocs. It will be less confusing.", "Let's change \"JUnit 3\" -> \"Junit\" in all new javadoc", "Can you confirm one thing for me? This import needs to change because test runtime classpath inherits opentest4j from \"compileOnly\"?", "Yes. This was the \"imperfect\" behaviour I was referring to. Even though it's only using the JUnit 4 runner, it finds OpenTest4J on the classpath and uses it.", "Will do. This is a hangover from the earlier prototype which also supported `org.junit.ComparisonFailure` as well as `junit.framework.ComparisonFailure`.", "As above.", "I started to implement this change and had a rethink. Merely saying \"...if JUnit is on the class path...\" is inaccurate. Specifically, `junit.framework.ComparisonFailure` must be on the classpath, which is included in JUnit 3 & 4 but not 5. So the current implementation will not throw a ComparisonFailure if JUnit 5 is on the classpath but JUnit 3/4 is not.", "Thanks!", "Thanks!", "OK" ]

"2019-03-18T09:19:25Z"

[]

[ "build.gradle", "gradle/dependencies.gradle", "gradle/mockito-core/osgi.gradle", "src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java", "src/main/java/org/mockito/exceptions/verification/junit/package-info.java", "src/main/java/org/mockito/internal/junit/ExceptionFactory.java" ]

[ "build.gradle", "gradle/dependencies.gradle", "gradle/mockito-core/osgi.gradle", "src/main/java/org/mockito/exceptions/verification/ArgumentsAreDifferent.java", "src/main/java/org/mockito/exceptions/verification/junit/package-info.java", "src/main/java/org/mockito/exceptions/verification/opentest4j/ArgumentsAreDifferent.java", "src/main/java/org/mockito/exceptions/verification/opentest4j/package-info.java", "src/main/java/org/mockito/internal/junit/ExceptionFactory.java" ]

[ "src/test/java/org/mockito/StaticMockingExperimentTest.java", "src/test/java/org/mockito/internal/junit/ExceptionFactoryTest.java", "src/test/java/org/mockito/internal/verification/VerificationOverTimeImplTest.java", "src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java", "src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java", "src/test/java/org/mockitointegration/NoJUnitDependenciesTest.java", "src/test/java/org/mockitousage/basicapi/UsingVarargsTest.java", "src/test/java/org/mockitousage/matchers/CustomMatcherDoesYieldCCETest.java", "src/test/java/org/mockitousage/matchers/HamcrestMatchersTest.java", "src/test/java/org/mockitousage/matchers/MatchersTest.java", "src/test/java/org/mockitousage/matchers/MoreMatchersTest.java", "src/test/java/org/mockitousage/matchers/ReflectionMatchersTest.java", "src/test/java/org/mockitousage/matchers/VarargsTest.java", "src/test/java/org/mockitousage/stacktrace/ClickableStackTracesTest.java", "src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java", "src/test/java/org/mockitousage/verification/BasicVerificationTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java", "src/test/java/org/mockitousage/verification/PrintingVerboseTypesWithArgumentsTest.java", "src/test/java/org/mockitousage/verification/VerificationUsingMatchersTest.java" ]

"2019-03-15T19:15:17Z"

[ "keyword_pr_to_issue", "timestamp(timedelta=0.0, similarity=0.8940422539486178)" ]

[]

[ "I think the JUnit dependency should be kept at 4.12, we should avoid depending on a beta version.", "Shall we keep a lower target, to allow benefit for older platforms ?", "ErrorProne must run on Java 8: https://errorprone.info/docs/installation\r\n\r\nEdit: Although we could bump the target compatibility, I would rather not deal with that.", "The checker API requires 4.13 sadly. However, I will revert it to just run 4.13 for the tests on this project. 4.13 will be released next week.", "OK that makes sense ;)", "OK waiting for junit 4.13 then", "I'm OK shipping with 4.13 beta because this new jar is completely decoupled from other jars. Hope that helps!" ]

"2019-03-18T15:13:04Z"

[ "enhancement", "new feature" ]

[ "gradle/dependencies.gradle", "gradle/root/java-compatibility-check.gradle", "settings.gradle" ]

[ "gradle/dependencies.gradle", "gradle/root/java-compatibility-check.gradle", "settings.gradle", "subprojects/errorprone/errorprone.gradle", "subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensible.java" ]

[ "subprojects/errorprone/src/test/java/org/mockito/errorprone/bugpatterns/MockitoNotExtensibleTest.java" ]

"2019-03-18T14:47:55Z"

[ "keyword_pr_to_issue" ]

[ "I am also getting the same error. Reverting back to `2.23.+` fixes the issue.", "Seems like you are loading the wrong version of ByteBuddy. What version are\nyou using?\n\nOn Mon, 4 Feb 2019, 10:49 Taher, <notifications@github.com> wrote:\n\n> I am also getting the same error. Reverting back to 2.23.+ fixes the\n> issue.\n>\n> —\n> You are receiving this because you are subscribed to this thread.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/mockito/mockito/issues/1606#issuecomment-460203942>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AFrDb00_6nD1ZzQkmmEe6lbYHNFnz_8Yks5vKBBTgaJpZM4ag8uJ>\n> .\n>\n", "Hi Tim,\r\n\r\nThe ByteBuddy version I use is 1.9.3", "That version is too low. Mockito depends on ByteBuddy 1.9.7: https://github.com/mockito/mockito/blob/aacacb156166b54b7eba3dfe03dd7bacda54c8d8/gradle/dependencies.gradle#L7 Also shown in the pom: http://central.maven.org/maven2/org/mockito/mockito-core/2.24.0/mockito-core-2.24.0.pom It seems like your project setup does not correctly resolve dependency mismatches.", "Had the same issue even though we never set bytebuddy as dependency somewhere.\r\nSetting bytebuddy dependency explicitly at gradle fixed it for me.", "Adding bytebuddy as a dependency did fix the problem. I would think Gradle manages this dependency himself.\r\n\r\nAnyway, thanks for the help! ", "I had to add byte-buddy as well as an explicit dependency to our project. Is it valid behaviour to use byte-buddy during runtime, even though it's specified as just a compile-time dependency of mockito?", "Same error with the same versions of mockito and byte-buddy, but adding it explicitly doesn't solve the issue. The only difference is that I use Maven instead of Gradle.", "I would reopen this as an actual bug since 2.23.0 version doesn't have this issue and the lib should handle gracefully its own dependencies like this one.", "Since quite some people have the same issue, i've reopened the issue.", "Same issue here. Same goes for 2.25.0.\r\n\r\nReverting to 2.23.0 solves the problem.", "Could anyone produce a repository that shows the issue?", "I am preparing a repo that shows the issue (it may take a couple of days), but if both mockito and selenium are used in a single pom.xml, selenium 3.141.59's dependency on byte-buddy 1.8.15 causes that version of byte-buddy to be used instead of the version required by mockito.", "I am not sure what we on the Mockito team can do about that. If Maven resolves to a dependency that does not satisfy the constraints we declare in our pom, that seems like an issue of Maven. We need at least ByteBuddy 1.9.7. If a different dependency requires a lower version, I think you need to resolve that in your `pom.xml` by explicitly declaring the version of ByteBuddy.\r\n\r\nPer https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Dependency_Scope I am not sure what other scope is more appropriate over `compile`. We need ByteBuddy during compilation to define our MockMaker and therefore we also need to use it when running any test.", "As explained in my issue #1671 we have the same problem (sorry for the duplicate, I hadn't seen this one).\r\nAfter investigation, it seems that we have 2 ByteBuddy.\r\nThe first one is from hibernate-core-5.4.1 and is released byte-buddy 1.9.5\r\nThe second one is from mockito-core-2.25.1 and is released byte-buddy 1.9.7\r\n\r\nFor some reasons, it's the byte-buddy 1.9.5 from hibernate dependency that is used by mockito.\r\n\r\nBy exluding byte-buddy from hibernate dependency, we can fix the problem, but I'm not sure that we will not have any side effect on hibernate :-/\r\n\r\n```\r\n<dependency>\r\n\t<groupId>org.hibernate</groupId>\r\n\t<artifactId>hibernate-core</artifactId>\r\n\t<version>5.4.1</version>\r\n\t<exclusions>\r\n\t\t<exclusion>\r\n\t\t\t<artifactId>byte-buddy</artifactId>\r\n\t\t\t<groupId>net.bytebuddy</groupId>\r\n\t\t</exclusion>\r\n\t</exclusions>\r\n</dependency>\r\n```\r\n\r\n", "Good catch, @marcam. If you go to https://mvnrepository.com/artifact/org.hibernate/hibernate-core/5.4.1.Final you can check that Hibernate will work well with any version until 1.9.10 (see update column in the dependencies table). So you can safely add the exclusion or include a new dependency in Maven to make clear what version you really want to use (my approach)", "Thank you @borjapenman \r\nHibernate 5.4.2 is just released this morning with bytebuddy 1.9.10 and solves the problem without doing any exeption :-)\r\nmockito uses now the 1.9.10 instead of 1.9.7\r\n\r\n\r\n", "@TimvdLippe, @raphw, shall we bump bytebuddy in Mockito? I'm curious: if it is a good time to start shadowing bytebuddy just like had in the past with cglib. This ticket is an evidence of the impact to our users when bytebuddy versions don't agree.", "I dont bumping the version is going to help. The dependency mechanisms in Maven and Gradle are fundamentally working against us.\r\n\r\nI think shadowing is a good alternative. We should carefully evaluate the downsides, but to me it seems like the best option we have available.", "I don't think shadowing is a good alternative as this forces Mockito updates when updating to a new Java version rather the polling the newest Byte Buddy. \r\n\r\nThose resolution breakages are unfortunate but should be rare as we do not often require new APIs in Mockito. ", "I also don't like the idea with shadowing, especially as bute-buddy is (usually ;) ) backward compatible withing sane versioning scheme.\r\nGradle should use the higher version by default. Maven seems to use a different approach.\r\n\r\nRegarding dependency bumping, @mockitoguy could you please consider adding a Dependabot app from the GitHub [marketplace](https://github.com/marketplace/dependabot/) (just for the mockito repository) to do it for us automatically (via PRs)? See the sample generated [PRs](https://github.com/szpak/mockito/pulls) in my fork. The configuration itself was merged in #1600.", "OK, thank you for consideration! Let's avoid shadowing.\r\n\r\n@szpak, I'll check dependabot!", "Based on the Twitter discussion we had with Maven + Gradle, I will perform an investigation in all possible options. Hopefully I can finish that next week, but not sure when.\r\n\r\nThe TLDR is that the \"closest wins\" mechanism by Maven results in the usage of a version of ByteBuddy that is too old. We can specify our ByteBuddy version differently with `[1.2.3,)`, but I am not sure if that has unexpected side-effects. That's what I want to investigate.", "> Based on the Twitter discussion we had with Maven + Gradle, I will perform an investigation in all possible options\r\n\r\nIf Hibernate wants 1.9.10 and mockito-core wants 1.9.7, and those versions are not compatible, then I'm not sure what you want the build system to do. It won't be resolved automatically. Our options:\r\n\r\n a) shadowing\r\n b) mockito-core bumps to 1.9.10\r\n c) hibernate downgrades to 1.9.7\r\n d) we tell customers to downgrade/force to 1.9.7 and _hope_ that hibernate will work\r\n\r\nSome of those options are clearly not viable.", "Opened https://github.com/mockito/mockito/pull/1673", "> If Hibernate wants 1.9.10 and mockito-core wants 1.9.7, and those versions are not compatible, then I'm not sure what you want the build system to do. It won't be resolved automatically.\r\n\r\nBut the versions are compatible. We can simple use 1.9.10 and make them both work. That's because ByteBuddy follows semver (afaik).", "Yes, Byte Buddy follows semver. I had some hickups in the past, but given the libraries spread, I think the amount of incidents was minimal.\r\n\r\nThe reason I dislike the shadowing approach is that this would mean that any library should shadow all dependencies to avoid any possible conflict. This is a problem that should be solved in dependency resolution.", "I keep getting the same error i.e \r\n\"Mockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\"\r\n\r\nI have updated my gradle dependencies to match :\r\n\r\nhttps://mvnrepository.com/artifact/org.mockito/mockito-core/2.25.0\r\n\r\nmockito : \"2.25.0\"\r\nmockito-core : \"2.25.0\"\r\n\r\nI dont need bytebuddy dependency but added it to override any old dependencies\r\nbyte-buddy : 1.9.11\r\nbyte-buddy-agent : 1.9.11\r\n\r\nCan someone suggest , what am I doing wrong ?", "> But the versions are compatible\r\n\r\nOh, then I misread this ticket. So I don't know what the problem is :)", "We are getting this when attempting to upgrade Spring Boot 2.0.x to 2.1.x.\r\n\r\nspring-boot-dependencies specifies the version for ByteBuddy and Mockito:\r\n\r\nSpring Boot 2.0:\r\n```xml\r\n<byte-buddy.version>1.7.11</byte-buddy.version>\r\n<mockito.version>2.15.0</mockito.version>\r\n```\r\n\r\nSpring Boot 2.1:\r\n```xml\r\n<byte-buddy.version>1.9.10</byte-buddy.version>\r\n<mockito.version>2.23.4</mockito.version>\r\n```\r\n\r\nWe are using ``spy`` on a real class and it is fully public and non-final.\r\n\r\nAny version of Mockito newer than 2.15.0 seems to cause this. 2.16.0 uses byte-buddy 1.9.10. Any idea on what I can look for?", "@efenderbosch Are you sure ByteBuddy is not loaded transitively through a different dependency?", "Yes, running ``mvn dependency:tree`` only shows 1.7.11 or 1.9.10 and only through Mockito.\r\n\r\nWe are still running Java 8, if that matters. Need Pact to update (4.x is currently in beta) so we can upgrade to 11. Was there a change in Mockito 2.16+ or ByteBuddy 1.8+ that doesn't work w/ Java 8?", "> 1.7.11\r\n\r\nThat version is too low and probably leads to the tests loading the wrong version of ByteBuddy. Could you specify ByteBuddy as a dependency in your root pom to use the correct version?\r\n\r\n> Was there a change in Mockito 2.16+ or ByteBuddy 1.8+ that doesn't work w/ Java 8?\r\n\r\nNo, Mockito should work just fine on Java 8", "ByteBuddy 1.7.11 and Mockito 2.15.0 *work*, though. Anything after that uses ByteBuddy 1.9.10+ and fails.\r\n\r\nedit:\r\nok specified\r\n```xml\r\n<mockito.version>2.15.0</mockito.version>\r\n<byte-buddy.version>1.7.11</byte-buddy.version>\r\n```\r\nin our parent pom and it still fails. I'm very confused now.\r\n\r\n``mvn dependency:tree`` shows this:\r\n\r\n```\r\n[INFO] | +- org.mockito:mockito-core:jar:2.15.0:test\r\n[INFO] | | +- net.bytebuddy:byte-buddy:jar:1.7.11:provided\r\n[INFO] | | \\- net.bytebuddy:byte-buddy-agent:jar:1.7.11:test\r\n```\r\n\r\nwith no other versions of Mockito or ByteBuddy. ", "Ok, I think I figured it out. The problem seems to be ``default`` methods on interfaces.\r\n\r\nThe class I'm spying implements ``com.github.benmanes.caffeine.cache.CacheLoader``\r\n\r\nIf my concrete class overrides the ``default`` methods, then my test runs successfully.", "@efenderbosch Please open a new issue (or PR if you can :smile: ) to triage your problem there.", "@efenderbosch This was strange. Can you create a small reproduction of the issue?", "I tried w/ a clean project and can't reproduce it. Gave up on Spring Boot 2.1 for now. Tried 2.0.9 (from 2.0.8) and got the same issue. So I'm pretty stumped as to what is going on. At this point, we are fine w/ just overriding default methods on the couple classes that we need to mock/spy.", "My colleague run into the same issue after recent upgrade to\r\n'mockito-core', version: '2.25.0'\r\n'powermock-api-mockito2', version: '2.0.0'\r\n'powermock-module-junit4', version: '2.0.0'. \r\n\r\nDowngrading mockito-core to 2.23.0 helped to solve it. Strangely, it happens only running tests individually from IDEA, but they work fine running via Gradle script. Also, I was not able to reproduce it on my machine, though we have very similar environment setups.\r\n\r\nError message:\r\n\r\norg.mockito.exceptions.base.MockitoException:\r\nMockito cannot mock this class: class com.fasterxml.jackson.databind.ObjectMapper.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\nJava : 1.8\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 25.191-b12\r\nJVM name : Java HotSpot(TM) 64-Bit Server VM\r\nJVM version : 1.8.0_191-b12\r\nJVM info : mixed mode\r\nOS name : Windows 10\r\nOS version : 10.0\r\n\r\nUnderlying exception : java.lang.IllegalArgumentException: Could not create type", "Hi I have the same problem. I am migrating from java 8 to java 11. I have updated Mockito to 2.23.0 \r\n\r\n`[INFO] +- org.mockito:mockito-core:jar:2.23.0:compile`\r\n\r\nI have also included byte-buddy as a dependency \r\n```\r\n[INFO] +- net.bytebuddy:byte-buddy:jar:1.9.7:compile\r\n[INFO] +- net.bytebuddy:byte-buddy-agent:jar:1.9.7:compile\r\n\r\n```\r\nI have checked that byte-buddy is not loaded transitively through a different dependency. I can't understand what the issue is.", "Do you have a stack trace? There can be other errors causing this message.", "@raphw The stack trace is almost the same as others. Here you go\r\n```\r\norg.mockito.exceptions.base.MockitoException: \r\n\r\nMockito cannot mock this class: class javax.ws.rs.core.Response.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 11\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 11.0.2+9-LTS\r\nJVM name : Java HotSpot(TM) 64-Bit Server VM\r\nJVM version : 11.0.2+9-LTS\r\nJVM info : mixed mode\r\nOS name : Linux\r\nOS version : 4.9.125-linuxkit\r\n\r\nUnderlying exception : java.lang.IllegalStateException: Error invoking java.lang.reflect.Method#getAnnotatedReturnType\r\n```", "@MoodyMudit It's unlikely that is the full stacktrace. Could you post the full stacktrace please?", "It still shows the error with *Error invoking java.lang.reflect.Method#getAnnotatedReturnType*. Seems like a problem with your mocked class.", "@TimvdLippe @raphw I was able to solve this issue. I noticed that java 11 does not contain the JAXB APIs. So I included them as dependencies in pom.\r\n\r\n```\r\n<dependency>\r\n <groupId>javax.xml.bind</groupId>\r\n <artifactId>jaxb-api</artifactId>\r\n <version>2.2.11</version>\r\n</dependency>\r\n<dependency>\r\n <groupId>com.sun.xml.bind</groupId>\r\n <artifactId>jaxb-core</artifactId>\r\n <version>2.2.11</version>\r\n</dependency>\r\n<dependency>\r\n <groupId>com.sun.xml.bind</groupId>\r\n <artifactId>jaxb-impl</artifactId>\r\n <version>2.2.11</version>\r\n</dependency>\r\n<dependency>\r\n <groupId>javax.activation</groupId>\r\n <artifactId>activation</artifactId>\r\n <version>1.1.1</version>\r\n</dependency>\r\n```\r\nThanks for your help.", "> 嗨，\r\n> \r\n> 从版本2.24.0开始，我收到错误“Mockito只能模拟非私有和非最终类。”。回到Mockito 2.23.4解决了这个问题。\r\n> \r\n> **堆栈跟踪**\r\n> `Underlying exception : java.lang.IllegalArgumentException: Could not create type at nl.tkp.ddw.pensioenaangifte.test.model.unittesten.AanleveringFilteringStepDefinitions.setup(AanleveringFilteringStepDefinitions.java:43) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at cucumber.runtime.Utils$1.call(Utils.java:26) at cucumber.runtime.Timeout.timeout(Timeout.java:16) at cucumber.runtime.Utils.invoke(Utils.java:20) at cucumber.runtime.java.JavaHookDefinition.execute(JavaHookDefinition.java:60) at cucumber.runner.HookDefinitionMatch.runStep(HookDefinitionMatch.java:16) at cucumber.runner.TestStep.executeStep(TestStep.java:63) at cucumber.runner.TestStep.run(TestStep.java:49) at cucumber.runner.TestCase.run(TestCase.java:40) at cucumber.runner.Runner.runPickle(Runner.java:40) at cucumber.runtime.junit.PickleRunners$NoStepDescriptions.run(PickleRunners.java:146) at cucumber.runtime.junit.FeatureRunner.runChild(FeatureRunner.java:68) at cucumber.runtime.junit.FeatureRunner.runChild(FeatureRunner.java:23) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) at org.junit.runners.ParentRunner.run(ParentRunner.java:363) at cucumber.runtime.junit.FeatureRunner.run(FeatureRunner.java:73) at cucumber.api.junit.Cucumber.runChild(Cucumber.java:124) at cucumber.api.junit.Cucumber.runChild(Cucumber.java:65) at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) at cucumber.api.junit.Cucumber$1.evaluate(Cucumber.java:133) at org.junit.runners.ParentRunner.run(ParentRunner.java:363) at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.runTestClass(JUnitTestClassExecutor.java:110) at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.execute(JUnitTestClassExecutor.java:58) at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.execute(JUnitTestClassExecutor.java:38) at org.gradle.api.internal.tasks.testing.junit.AbstractJUnitTestClassProcessor.processTestClass(AbstractJUnitTestClassProcessor.java:62) at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:51) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35) at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24) at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32) at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93) at com.sun.proxy.$Proxy2.processTestClass(Unknown Source) at org.gradle.api.internal.tasks.testing.worker.TestWorker.processTestClass(TestWorker.java:118) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35) at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24) at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:175) at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:157) at org.gradle.internal.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:404) at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63) at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:46) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) at org.gradle.internal.concurrent.ThreadFactoryImpl$ManagedThreadRunnable.run(ThreadFactoryImpl.java:55) at java.lang.Thread.run(Thread.java:748) Caused by: java.lang.IllegalArgumentException: Could not create type at net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:154) at net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365) at net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174) at net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376) at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32) at org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71) at org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42) at org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25) at org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35) at org.mockito.internal.MockitoCore.mock(MockitoCore.java:62) at org.mockito.Mockito.mock(Mockito.java:1896) at org.mockito.internal.configuration.MockAnnotationProcessor.processAnnotationForMock(MockAnnotationProcessor.java:44) at org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:19) at org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16) at org.mockito.internal.configuration.IndependentAnnotationEngine.createMockFor(IndependentAnnotationEngine.java:38) at org.mockito.internal.configuration.IndependentAnnotationEngine.process(IndependentAnnotationEngine.java:62) at org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:49) at org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:41) at org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:69) ... 63 more Caused by: java.lang.NoSuchMethodError: net.bytebuddy.dynamic.loading.MultipleParentClassLoader$Builder.appendMostSpecific(Ljava/util/Collection;)Lnet/bytebuddy/dynamic/loading/MultipleParentClassLoader$Builder; at org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:83) at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37) at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34) at net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152) ... 81 more`\r\n> \r\n> **Versioninfo**\r\n> Java：1.8 \r\n> JVM供应商名称：Oracle Corporation \r\n> JVM供应商版本：25.191-b12 \r\n> JVM名称：Java HotSpot（TM）64位服务器VM \r\n> JVM版本：1.8.0_191-b12 \r\n> JVM信息：混合模式\r\n> 操作系统名称：Mac OS X \r\n> OS版本：10.13.6 \r\n> Mockito-core：2.24.0\r\n\r\n我也遇到了 快点修复", "I have the same problem with 2.27.0, reverting back to 2.23.4 works.\r\n\r\n> Interface that Mockito is unable to mock\r\n\r\n```java\r\n\r\nimport java.util.Set;\r\n\r\nimport br.com.senior.platform.authorization.UserNotificationPriority;\r\nimport br.com.senior.platform.authorization.model.ResourceIntegration;\r\n\r\npublic interface NotifyResourceIntegration {\r\n\r\n boolean notifyOnError(Set<ResourceIntegration> allResources, Throwable ex, String tenant);\r\n\r\n void notifyUser(UserNotificationPriority priority, String content, String tenant);\r\n}\r\n```\r\n\r\n> Full stack trace\r\n\r\n\r\n```\r\norg.mockito.exceptions.base.MockitoException: \r\nMockito cannot mock this class: interface br.com.senior.platform.authorization.service.notification.NotifyResourceIntegration.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 11\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 11.0.2+9\r\nJVM name : OpenJDK 64-Bit Server VM\r\nJVM version : 11.0.2+9\r\nJVM info : mixed mode\r\nOS name : Windows 10\r\nOS version : 10.0\r\n\r\n\r\nUnderlying exception : java.lang.IllegalArgumentException: Could not create type\r\n\r\n\tat br.com.senior.platform.authorization.service.notification.NotifyServiceImplTest.setUp(NotifyServiceImplTest.java:38)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\r\n\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\r\n\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)\r\n\tat org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:24)\r\n\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)\r\n\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\n\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\n\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\n\tat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\n\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\n\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\n\tat org.junit.runner.JUnitCore.run(JUnitCore.java:137)\r\n\tat com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)\r\n\tat com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)\r\nCaused by: java.lang.IllegalArgumentException: Could not create type\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:154)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n\tat org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25)\r\n\tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n\tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:62)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1907)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.processAnnotationForMock(MockAnnotationProcessor.java:44)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:19)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16)\r\n\tat org.mockito.internal.configuration.IndependentAnnotationEngine.createMockFor(IndependentAnnotationEngine.java:38)\r\n\tat org.mockito.internal.configuration.IndependentAnnotationEngine.process(IndependentAnnotationEngine.java:62)\r\n\tat org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:49)\r\n\tat org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:41)\r\n\tat org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:69)\r\n\t... 23 more\r\nCaused by: java.lang.NoSuchMethodError: net.bytebuddy.dynamic.loading.MultipleParentClassLoader$Builder.appendMostSpecific(Ljava/util/Collection;)Lnet/bytebuddy/dynamic/loading/MultipleParentClassLoader$Builder;\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:83)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152)\r\n\t... 41 more\r\n\r\n```", "@luankevinferreira You are loading a too-old version of ByteBuddy. Check the version you are using and upgrade it to the one compatible with the version specified in the Mockito pom.", "> My colleague run into the same issue after recent upgrade to\r\n> 'mockito-core', version: '2.25.0'\r\n> 'powermock-api-mockito2', version: '2.0.0'\r\n> 'powermock-module-junit4', version: '2.0.0'.\r\n> \r\n> Downgrading mockito-core to 2.23.0 helped to solve it. Strangely, it happens only running tests individually from IDEA, but they work fine running via Gradle script. Also, I was not able to reproduce it on my machine, though we have very similar environment setups.\r\n> \r\n> Error message:\r\n> \r\n> org.mockito.exceptions.base.MockitoException:\r\n> Mockito cannot mock this class: class com.fasterxml.jackson.databind.ObjectMapper.\r\n> \r\n> Mockito can only mock non-private & non-final classes.\r\n> If you're not sure why you're getting this error, please report to the mailing list.\r\n> \r\n> Java : 1.8\r\n> JVM vendor name : Oracle Corporation\r\n> JVM vendor version : 25.191-b12\r\n> JVM name : Java HotSpot(TM) 64-Bit Server VM\r\n> JVM version : 1.8.0_191-b12\r\n> JVM info : mixed mode\r\n> OS name : Windows 10\r\n> OS version : 10.0\r\n> \r\n> Underlying exception : java.lang.IllegalArgumentException: Could not create type\r\n\r\nI actually encountered this same issue today. What caused the problem for me was a dependency combination misconfiguration: I have a config \"compile\" that takes Hibernate-osgi 2.5.17Final, which depends on byte-buddy 1.6.14. I have a config \"test\" that takes mockito 2.27.0, which depends on byte-buddy 1.9.10. When running my unittests from my IDE, it properly combined those dependencies including version management, but when I ran it from an Ant script, I had to manually merge these 2 configurations into a class Path. I put the compile config first, which meant the Byte-Buddy of Hibernate was used by Mockito instead of the one Mockito had to use. We considered putting the test config first, but that would actually mean we would test with a different version of ByteBuddy than we use in the main configuration.\r\n\r\nupgrading Hibernate would currently be too involved, but we are planning to do so later for Java 11 support. For now, we're downgrading Mockito.", "\r\nI am getting the below error when using Mockito. Is it related to this issue?\r\n\r\n```\r\nCaused by: java.lang.NoClassDefFoundError: javax/xml/bind/annotation/adapters/XmlAdapter\r\n [junit] \tat java.base/java.lang.Class.getDeclaringClass0(Native Method)\r\n [junit] \tat java.base/java.lang.Class.getEnclosingClass(Class.java:1518)\r\n [junit] \tat java.base/java.lang.reflect.Executable.getAnnotatedReturnType0(Executable.java:642)\r\n [junit] \tat java.base/java.lang.reflect.Method.getAnnotatedReturnType(Method.java:721)\r\n [junit] \tat java.base/jdk.internal.reflect.GeneratedMethodAccessor18.invoke(Unknown Source)\r\n [junit] \tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n [junit] \tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedReturnType.resolve(TypeDescription.java:2928)\r\n```", "@karthickpdy Unrelated. Is javax.xml.bind on the classpath? If you're on jdk >= 11 JAXB is removed from the JDK.", "Seems like an annotation is loaded during instrumentation that is indeed missing on the class path.\r\n\r\nIf you just try to load this class where the mock is created, is the same exception thrown?", "Seeing following with 2.23.0 / OpenJDK Runtime Environment 18.9 (build 11.0.2+9), works fine with Java 8.\r\norg.mockito:mockito-core:2.23.0\r\n net.bytebuddy:byte-buddy:1.9.0\r\n net.bytebuddy:byte-buddy-agent:1.9.0\r\n org.objenesis:objenesis:2.6\r\n\r\n> \r\n\r\n> org.mockito.exceptions.base.MockitoException: \r\n> Mockito cannot mock this class: class javax.ws.rs.core.Response.\r\n> \r\n> Mockito can only mock non-private & non-final classes.\r\n> If you're not sure why you're getting this error, please report to the mailing list.\r\n> \r\n> \r\n> Java : 11\r\n> JVM vendor name : Oracle Corporation\r\n> JVM vendor version : 11.0.2+9\r\n> JVM name : OpenJDK 64-Bit Server VM\r\n> JVM version : 11.0.2+9\r\n> JVM info : mixed mode\r\n> OS name : Windows 10\r\n> OS version : 10.0\r\n> \r\n> \r\n> Underlying exception : java.lang.IllegalStateException: Error invoking java.lang.reflect.Method#getAnnotatedReturnType\r\n> \tat com.MyTest.setup(MyTest.java:72)\r\n> \tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n> \tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n> \tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n> \tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n> \tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\r\n> \tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\r\n> \tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)\r\n> \tat org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:24)\r\n> \tat org.junit.rules.ExpectedException$ExpectedExceptionStatement.evaluate(ExpectedException.java:239)\r\n> \tat org.junit.rules.RunRules.evaluate(RunRules.java:20)\r\n> \tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\r\n> \tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)\r\n> \tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)\r\n> \tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\n> \tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\n> \tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\n> \tat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\n> \tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\n> \tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\n> \tat org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.runTestClass(JUnitTestClassExecutor.java:110)\r\n> \tat org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.execute(JUnitTestClassExecutor.java:58)\r\n> \tat org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecutor.execute(JUnitTestClassExecutor.java:38)\r\n> \tat org.gradle.api.internal.tasks.testing.junit.AbstractJUnitTestClassProcessor.processTestClass(AbstractJUnitTestClassProcessor.java:62)\r\n> \tat org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:51)\r\n> \tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n> \tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n> \tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n> \tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n> \tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)\r\n> \tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)\r\n> \tat org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32)\r\n> \tat org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93)\r\n> \tat com.sun.proxy.$Proxy2.processTestClass(Unknown Source)\r\n> \tat org.gradle.api.internal.tasks.testing.worker.TestWorker.processTestClass(TestWorker.java:118)\r\n> \tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n> \tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n> \tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n> \tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n> \tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)\r\n> \tat org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)\r\n> \tat org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:175)\r\n> \tat org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:157)\r\n> \tat org.gradle.internal.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:404)\r\n> \tat org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63)\r\n> \tat org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:46)\r\n> \tat java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)\r\n> \tat java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)\r\n> \tat org.gradle.internal.concurrent.ThreadFactoryImpl$ManagedThreadRunnable.run(ThreadFactoryImpl.java:55)\r\n> \tat java.base/java.lang.Thread.run(Thread.java:834)\r\n> Caused by: java.lang.IllegalStateException: Error invoking java.lang.reflect.Method#getAnnotatedReturnType\r\n> \tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedReturnType.resolve(TypeDescription.java:2932)\r\n> \tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Delegator.asList(TypeDescription.java:3186)\r\n> \tat net.bytebuddy.description.type.TypeDescription$Generic$OfNonGenericType$ForLoadedType.getDeclaredAnnotations(TypeDescription.java:3872)\r\n> \tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.apply(AnnotationAppender.java:669)\r\n> \tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.onNonGenericType(AnnotationAppender.java:650)\r\n> \tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.onNonGenericType(AnnotationAppender.java:353)\r\n> \tat net.bytebuddy.description.type.TypeDescription$Generic$OfNonGenericType.accept(TypeDescription.java:3662)\r\n> \tat net.bytebuddy.implementation.attribute.MethodAttributeAppender$ForInstrumentedMethod.apply(MethodAttributeAppender.java:181)\r\n> \tat net.bytebuddy.implementation.attribute.MethodAttributeAppender$Compound.apply(MethodAttributeAppender.java:449)\r\n> \tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod$WithBody.applyAttributes(TypeWriter.java:691)\r\n> \tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod$WithBody.applyBody(TypeWriter.java:681)\r\n> \tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod.apply(TypeWriter.java:590)\r\n> \tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default$ForCreation.create(TypeWriter.java:5114)\r\n> \tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default.make(TypeWriter.java:1915)\r\n> \tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:197)\r\n> \tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:174)\r\n> \tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase.make(DynamicType.java:3376)\r\n> \tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase$Delegator.make(DynamicType.java:3565)\r\n> \tat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:128)\r\n> \tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n> \tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n> \tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:137)\r\n> \tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:350)\r\n> \tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:159)\r\n> \tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:361)\r\n> \tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n> \tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n> \tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n> \tat org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25)\r\n> \tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n> \tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:69)\r\n> \tat org.mockito.Mockito.mock(Mockito.java:1895)\r\n> \tat org.mockito.internal.configuration.MockAnnotationProcessor.processAnnotationForMock(MockAnnotationProcessor.java:41)\r\n> \tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:19)\r\n> \tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16)\r\n> \tat org.mockito.internal.configuration.IndependentAnnotationEngine.createMockFor(IndependentAnnotationEngine.java:38)\r\n> \tat org.mockito.internal.configuration.IndependentAnnotationEngine.process(IndependentAnnotationEngine.java:62)\r\n> \tat org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:57)\r\n> \tat org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:41)\r\n> \tat org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:69)\r\n> \t... 50 more\r\n> Caused by: java.lang.NoClassDefFoundError: javax/xml/bind/annotation/adapters/XmlAdapter\r\n> \tat java.base/java.lang.Class.getDeclaringClass0(Native Method)\r\n> \tat java.base/java.lang.Class.getEnclosingClass(Class.java:1518)\r\n> \tat java.base/sun.reflect.annotation.AnnotatedTypeFactory.nestingForType(AnnotatedTypeFactory.java:96)\r\n> \tat java.base/sun.reflect.annotation.TypeAnnotationParser.buildAnnotatedType(TypeAnnotationParser.java:79)\r\n> \tat java.base/java.lang.reflect.Executable.getAnnotatedReturnType0(Executable.java:642)\r\n> \tat java.base/java.lang.reflect.Method.getAnnotatedReturnType(Method.java:721)\r\n> \tat java.base/jdk.internal.reflect.GeneratedMethodAccessor23.invoke(Unknown Source)\r\n> \tat java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n> \tat java.base/java.lang.reflect.Method.invoke(Method.java:566)\r\n> \tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedReturnType.resolve(TypeDescription.java:2928)\r\n> \t... 89 more\r\n> `", "> As explained in my issue #1671 we have the same problem (sorry for the duplicate, I hadn't seen this one).\r\n> After investigation, it seems that we have 2 ByteBuddy.\r\n> The first one is from hibernate-core-5.4.1 and is released byte-buddy 1.9.5\r\n> The second one is from mockito-core-2.25.1 and is released byte-buddy 1.9.7\r\n> \r\n> For some reasons, it's the byte-buddy 1.9.5 from hibernate dependency that is used by mockito.\r\n> \r\n> By exluding byte-buddy from hibernate dependency, we can fix the problem, but I'm not sure that we will not have any side effect on hibernate :-/\r\n> \r\n> ```\r\n> <dependency>\r\n> \t<groupId>org.hibernate</groupId>\r\n> \t<artifactId>hibernate-core</artifactId>\r\n> \t<version>5.4.1</version>\r\n> \t<exclusions>\r\n> \t\t<exclusion>\r\n> \t\t\t<artifactId>byte-buddy</artifactId>\r\n> \t\t\t<groupId>net.bytebuddy</groupId>\r\n> \t\t</exclusion>\r\n> \t</exclusions>\r\n> </dependency>\r\n> ```\r\n\r\nThis worked for me. I added `byte-buddy` and `byte-buddy-agent` dependencies to my pom file in the version **1.9.7**.\r\n\r\nIt was like the following:\r\n\r\n```\r\n <dependency>\r\n\t\t\t<groupId>net.bytebuddy</groupId>\r\n\t\t\t<artifactId>byte-buddy</artifactId>\r\n\t\t\t<version>1.9.7</version>\r\n\t\t\t<scope>test</scope>\r\n\t\t</dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>net.bytebuddy</groupId>\r\n\t\t\t<artifactId>byte-buddy-agent</artifactId>\r\n\t\t\t<version>1.9.7</version>\r\n\t\t\t<scope>test</scope>\r\n\t\t</dependency>\r\n```\r\n\r\nAlso, I excluded those dependencies in `hibernate-core` and `hibernate-entitymanager` because those dependencies contains the `byte-buddy` and `byte-buddy-agent` in a prior version.", "In **Eclipse** make sure to add as external library byte buddy. Ctrl + right click on project > Java Build Path > Libraries > Add external JARS > byte-buddy-1.**.*.jar\r\nThis worked for me if you want to debug your Junit tests in Eclipse", "I am still getting this issue with Mockito `3.0.0` (and `mockito-android`) when running Android instrumentation tests:\r\n\r\n```\r\norg.mockito.exceptions.base.MockitoException:\r\nMockito cannot mock this class: class com.(...)._MyClass_.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\nIMPORTANT INFORMATION FOR ANDROID USERS:\r\n\r\nThe regular Byte Buddy mock makers cannot generate code on an Android VM!\r\nTo resolve this, please use the 'mockito-android' dependency for your application:\r\nhttp://search.maven.org/#search%7Cga%7C1%7Ca%3A%22mockito-android%22%20g%3A%22org.mockito%22\r\n\r\nJava : 0.9\r\nJVM vendor name : The Android Project\r\nJVM vendor version : 2.1.0\r\nJVM name : Dalvik\r\nJVM version : 0.9\r\nJVM info : null\r\nOS name : Linux\r\nOS version : 3.18.71-g7dfaee7f928\r\n\r\n\r\nUnderlying exception : java.lang.IllegalArgumentException: Could not create type\r\nat _com.(...).MyTest_.setUp(MyTest.java:44)\r\nat java.lang.reflect.Method.invoke(Native Method)\r\nat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\r\n(...)\r\nat org.junit.runner.JUnitCore.run(JUnitCore.java:115)\r\nat androidx.test.internal.runner.TestExecutor.execute(TestExecutor.java:56)\r\nat androidx.test.runner.AndroidJUnitRunner.onStart(AndroidJUnitRunner.java:392)\r\nat android.app.Instrumentation$InstrumentationThread.run(Instrumentation.java:2074)\r\nCaused by: java.lang.IllegalArgumentException: Could not create type\r\nat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:154)\r\nat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365)\r\nat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174)\r\nat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376)\r\nat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\nat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\nat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\nat org.mockito.android.internal.creation.AndroidByteBuddyMockMaker.createMock(AndroidByteBuddyMockMaker.java:39)\r\nat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\nat org.mockito.internal.MockitoCore.mock(MockitoCore.java:63)\r\nat org.mockito.Mockito.mock(Mockito.java:1908)\r\nat org.mockito.internal.configuration.MockAnnotationProcessor.processAnnotationForMock(MockAnnotationProcessor.java:44)\r\nat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:19)\r\nat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16)\r\nat org.mockito.internal.configuration.IndependentAnnotationEngine.createMockFor(IndependentAnnotationEngine.java:38)\r\nat org.mockito.internal.configuration.IndependentAnnotationEngine.process(IndependentAnnotationEngine.java:62)\r\nat org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:49)\r\nat org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:41)\r\nat org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:69)\r\n... 30 more\r\nCaused by: java.lang.NoSuchFieldError: No instance field targetApiLevel of type I in class Lcom/android/dx/dex/DexOptions; or its superclasses (declaration of 'com.android.dx.dex.DexOptions' appears in /data/app/com.teamwork.projects.data.test-WeFv56g4F9J4rFDV8asMpg==/base.apk)\r\nat net.bytebuddy.android.AndroidClassLoadingStrategy$DexProcessor$ForSdkCompiler.makeDefault(AndroidClassLoadingStrategy.java:216)\r\nat net.bytebuddy.android.AndroidClassLoadingStrategy$Injecting.<init>(AndroidClassLoadingStrategy.java:387)\r\nat org.mockito.android.internal.creation.AndroidLoadingStrategy.resolveStrategy(AndroidLoadingStrategy.java:39)\r\nat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:173)\r\nat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\nat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\nat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152)\r\n... 48 more\r\n```", "What dex compiler did you bundle with Android here? Seems like the API is not compatible.", "I'm using Studio 3.5 and Gradle build tools 3.5.0, so it's using D8 by default I guess.", "Getting this on `mockito-android:3.1.0` (instrumented tests) especially on `release` build, on `debug` it works fine.\r\n```\r\n classpath 'com.android.tools.build:gradle:3.5.0'\r\n\r\nandroid {\r\n buildTypes {\r\n buildToolsVersion \"28.0.3\"\r\n release {\r\n minifyEnabled false\r\n``` ", "I'm seeing a similar error running Mockito 3.10.0 or 2.23.4, it doesn't make a difference. I've tried running on an Android 10 phone, as well as on a emulator sdk 27\r\n\r\n```\r\norg.mockito.exceptions.base.MockitoException:\r\nMockito cannot mock this class: class android.content.Context.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\n\r\nIMPORTANT INFORMATION FOR ANDROID USERS:\r\n\r\nThe regular Byte Buddy mock makers cannot generate code on an Android VM!\r\nTo resolve this, please use the 'mockito-android' dependency for your application:\r\nhttp://search.maven.org/#search%7Cga%7C1%7Ca%3A%22mockito-android%22%20g%3A%22org.mockito%22\r\n\r\nJava : 0.9\r\nJVM vendor name : The Android Project\r\nJVM vendor version : 2.1.0\r\nJVM name : Dalvik\r\nJVM version : 0.9\r\nJVM info : null\r\nOS name : Linux\r\nOS version : 3.18.91+\r\n\r\n\r\nUnderlying exception : java.lang.IllegalArgumentException: Could not create type\r\nat com.mycomp.android.sdk.core.driver.ble.nordic.MyTest.<init>(MyTest.kt:301)\r\nat java.lang.reflect.Constructor.newInstance0(Native Method)\r\nat java.lang.reflect.Constructor.newInstance(Constructor.java:334)\r\nat org.junit.runners.BlockJUnit4ClassRunner.createTest(BlockJUnit4ClassRunner.java:217)\r\nat org.junit.runners.BlockJUnit4ClassRunner$1.runReflectiveCall(BlockJUnit4ClassRunner.java:266)\r\nat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\r\nat org.junit.runners.BlockJUnit4ClassRunner.methodBlock(BlockJUnit4ClassRunner.java:263)\r\nat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)\r\nat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)\r\nat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\nat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\nat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\nat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\nat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\nat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\nat androidx.test.ext.junit.runners.AndroidJUnit4.run(AndroidJUnit4.java:104)\r\nat org.junit.runners.Suite.runChild(Suite.java:128)\r\nat org.junit.runners.Suite.runChild(Suite.java:27)\r\nat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\nat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\nat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\nat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\nat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\nat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\nat org.junit.runner.JUnitCore.run(JUnitCore.java:137)\r\nat org.junit.runner.JUnitCore.run(JUnitCore.java:115)\r\nat androidx.test.internal.runner.TestExecutor.execute(TestExecutor.java:56)\r\nat androidx.test.runner.AndroidJUnitRunner.onStart(AndroidJUnitRunner.java:388)\r\nat android.app.Instrumentation$InstrumentationThread.run(Instrumentation.java:2075)\r\nCaused by: java.lang.IllegalArgumentException: Could not create type\r\nat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:154)\r\nat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365)\r\nat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174)\r\nat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376)\r\nat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\nat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\nat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\nat org.mockito.android.internal.creation.AndroidByteBuddyMockMaker.createMock(AndroidByteBuddyMockMaker.java:39)\r\nat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\nat org.mockito.internal.MockitoCore.mock(MockitoCore.java:63)\r\nat org.mockito.Mockito.mock(Mockito.java:1908)\r\n... 29 more\r\nCaused by: java.lang.NoSuchFieldError: No instance field targetApiLevel of type I in class Lcom/android/dx/dex/DexOptions; or its superclasses (declaration of 'com.android.dx.dex.DexOptions' appears in /data/app/com.mycomp.android.sdk.test-akjnnaFvI2s0R5IuilGDvg==/base.apk)\r\nat net.bytebuddy.android.AndroidClassLoadingStrategy$DexProcessor$ForSdkCompiler.makeDefault(AndroidClassLoadingStrategy.java:216)\r\nat net.bytebuddy.android.AndroidClassLoadingStrategy$Injecting.<init>(AndroidClassLoadingStrategy.java:387)\r\nat org.mockito.android.internal.creation.AndroidLoadingStrategy.resolveStrategy(AndroidLoadingStrategy.java:39)\r\nat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:173)\r\nat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\nat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\nat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152)\r\n... 39 more\r\n```\r\n\r\nTo provide more context, this happens after adding MockK Android (https://mockk.io/ANDROID.html). The only suspicious dependency I see is `dexmaker:2.21.0`. I've forced it to use dexmaker:2.25.0, which upgrades to mockito 2.25.0, but still no luck\r\n\r\n", "Android has been changing its APIs in a non-compatible manner again, this causes these problems. I would have to look into supporting newer API versions in the DEX compiler. If you are also using MOCKK, I assume that the problem is the dexmaker version, you are very likely on the right track.", "if anyone is still getting the error in spring-boot project, it could be because spring provides its version of byte-buddy. \r\nadding `<byte-buddy.version>1.9.7</byte-buddy.version>` will tell maven to use the newer version.", "> I am still getting this issue with Mockito `3.0.0` (and `mockito-android`) when running Android instrumentation tests:\r\n> \r\n> ```\r\n> org.mockito.exceptions.base.MockitoException:\r\n> Mockito cannot mock this class: class com.(...)._MyClass_.\r\n> \r\n> Mockito can only mock non-private & non-final classes.\r\n> If you're not sure why you're getting this error, please report to the mailing list.\r\n> \r\n> IMPORTANT INFORMATION FOR ANDROID USERS:\r\n> \r\n> The regular Byte Buddy mock makers cannot generate code on an Android VM!\r\n> To resolve this, please use the 'mockito-android' dependency for your application:\r\n> http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22mockito-android%22%20g%3A%22org.mockito%22\r\n> \r\n> Java : 0.9\r\n> JVM vendor name : The Android Project\r\n> JVM vendor version : 2.1.0\r\n> JVM name : Dalvik\r\n> JVM version : 0.9\r\n> JVM info : null\r\n> OS name : Linux\r\n> OS version : 3.18.71-g7dfaee7f928\r\n> \r\n> \r\n> Underlying exception : java.lang.IllegalArgumentException: Could not create type\r\n> at _com.(...).MyTest_.setUp(MyTest.java:44)\r\n> at java.lang.reflect.Method.invoke(Native Method)\r\n> at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\r\n> (...)\r\n> at org.junit.runner.JUnitCore.run(JUnitCore.java:115)\r\n> at androidx.test.internal.runner.TestExecutor.execute(TestExecutor.java:56)\r\n> at androidx.test.runner.AndroidJUnitRunner.onStart(AndroidJUnitRunner.java:392)\r\n> at android.app.Instrumentation$InstrumentationThread.run(Instrumentation.java:2074)\r\n> Caused by: java.lang.IllegalArgumentException: Could not create type\r\n> at net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:154)\r\n> at net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365)\r\n> at net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174)\r\n> at net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376)\r\n> at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n> at org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n> at org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n> at org.mockito.android.internal.creation.AndroidByteBuddyMockMaker.createMock(AndroidByteBuddyMockMaker.java:39)\r\n> at org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n> at org.mockito.internal.MockitoCore.mock(MockitoCore.java:63)\r\n> at org.mockito.Mockito.mock(Mockito.java:1908)\r\n> at org.mockito.internal.configuration.MockAnnotationProcessor.processAnnotationForMock(MockAnnotationProcessor.java:44)\r\n> at org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:19)\r\n> at org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16)\r\n> at org.mockito.internal.configuration.IndependentAnnotationEngine.createMockFor(IndependentAnnotationEngine.java:38)\r\n> at org.mockito.internal.configuration.IndependentAnnotationEngine.process(IndependentAnnotationEngine.java:62)\r\n> at org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:49)\r\n> at org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:41)\r\n> at org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:69)\r\n> ... 30 more\r\n> Caused by: java.lang.NoSuchFieldError: No instance field targetApiLevel of type I in class Lcom/android/dx/dex/DexOptions; or its superclasses (declaration of 'com.android.dx.dex.DexOptions' appears in /data/app/com.teamwork.projects.data.test-WeFv56g4F9J4rFDV8asMpg==/base.apk)\r\n> at net.bytebuddy.android.AndroidClassLoadingStrategy$DexProcessor$ForSdkCompiler.makeDefault(AndroidClassLoadingStrategy.java:216)\r\n> at net.bytebuddy.android.AndroidClassLoadingStrategy$Injecting.<init>(AndroidClassLoadingStrategy.java:387)\r\n> at org.mockito.android.internal.creation.AndroidLoadingStrategy.resolveStrategy(AndroidLoadingStrategy.java:39)\r\n> at org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:173)\r\n> at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n> at org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n> at net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152)\r\n> ... 48 more\r\n> ```\r\n\r\nGetting same exception for Unit test cases.\r\nMockito - 3.1.0\r\nPowermock - 2.0.4\r\n\r\nYou are able to solve this issue. if yes please give us the solution.", "Try using the newest version of Byte Buddy explicitly. I recently adjusted the code to work with Android's newer API versions.", "> Try using the newest version of Byte Buddy explicitly. I recently adjusted the code to work with Android's newer API versions.\r\n\r\nTried but no luck\r\n\r\nHere is the log\r\n\r\n\r\n```\r\norg.mockito.exceptions.base.MockitoException: \r\nMockito cannot mock this class: class android.content.Context.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 1.8\r\nJVM vendor name : JetBrains s.r.o\r\nJVM vendor version : 25.202-b49-5587405\r\nJVM name : OpenJDK 64-Bit Server VM\r\nJVM version : 1.8.0_202-release-1483-b49-5587405\r\nJVM info : mixed mode\r\nOS name : Mac OS X\r\nOS version : 10.14.6\r\n\r\n\r\nUnderlying exception : java.lang.IllegalStateException: Error invoking java.lang.reflect.Executable#getAnnotatedExceptionTypes\r\n\r\n\tat org.junit.internal.runners.TestMethod.invoke(TestMethod.java:68)\r\n\tat org.junit.internal.runners.MethodRoadie$2.run(MethodRoadie.java:89)\r\n\tat org.junit.internal.runners.MethodRoadie.runBeforesThenTestThenAfters(MethodRoadie.java:97)\r\n\tat org.junit.internal.runners.MethodRoadie.runTest(MethodRoadie.java:87)\r\n\tat org.junit.internal.runners.MethodRoadie.run(MethodRoadie.java:50)\r\n\tat org.junit.internal.runners.ClassRoadie.runUnprotected(ClassRoadie.java:34)\r\n\tat org.junit.internal.runners.ClassRoadie.runProtected(ClassRoadie.java:44)\r\n\tat org.junit.runner.JUnitCore.run(JUnitCore.java:137)\r\n\tat com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)\r\n\tat com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)\r\nCaused by: java.lang.IllegalStateException: Error invoking java.lang.reflect.Executable#getAnnotatedExceptionTypes\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedExceptionType.resolve(TypeDescription.java:3029)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Delegator.asList(TypeDescription.java:3201)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$OfNonGenericType$ForLoadedType.getDeclaredAnnotations(TypeDescription.java:3887)\r\n\tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.apply(AnnotationAppender.java:690)\r\n\tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.onNonGenericType(AnnotationAppender.java:671)\r\n\tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.onNonGenericType(AnnotationAppender.java:374)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$OfNonGenericType.accept(TypeDescription.java:3677)\r\n\tat net.bytebuddy.implementation.attribute.MethodAttributeAppender$ForInstrumentedMethod.apply(MethodAttributeAppender.java:218)\r\n\tat net.bytebuddy.implementation.attribute.MethodAttributeAppender$Compound.apply(MethodAttributeAppender.java:484)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod$WithBody.applyAttributes(TypeWriter.java:706)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod$WithBody.applyBody(TypeWriter.java:696)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod.apply(TypeWriter.java:605)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default$ForCreation.create(TypeWriter.java:5133)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default.make(TypeWriter.java:1933)\r\n\tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:225)\r\n\tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:198)\r\n\tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase.make(DynamicType.java:3404)\r\n\tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase$Delegator.make(DynamicType.java:3600)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:172)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n\tat org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25)\r\n\tat org.powermock.api.mockito.mockmaker.PowerMockMaker.createMock(PowerMockMaker.java:41)\r\n\tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n\tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:63)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1908)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1817)\r\n\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.lang.reflect.Method.invoke(Method.java:498)\r\n\tat org.junit.internal.runners.TestMethod.invoke(TestMethod.java:68)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$PowerMockJUnit44MethodRunner.runTestMethod(PowerMockJUnit44RunnerDelegateImpl.java:326)\r\n\tat org.junit.internal.runners.MethodRoadie$2.run(MethodRoadie.java:89)\r\n\tat org.junit.internal.runners.MethodRoadie.runBeforesThenTestThenAfters(MethodRoadie.java:97)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$PowerMockJUnit44MethodRunner.executeTest(PowerMockJUnit44RunnerDelegateImpl.java:310)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.executeTestInSuper(PowerMockJUnit47RunnerDelegateImpl.java:131)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.access$100(PowerMockJUnit47RunnerDelegateImpl.java:59)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner$TestExecutorStatement.evaluate(PowerMockJUnit47RunnerDelegateImpl.java:147)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.evaluateStatement(PowerMockJUnit47RunnerDelegateImpl.java:107)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.executeTest(PowerMockJUnit47RunnerDelegateImpl.java:82)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$PowerMockJUnit44MethodRunner.runBeforesThenTestThenAfters(PowerMockJUnit44RunnerDelegateImpl.java:298)\r\n\tat org.junit.internal.runners.MethodRoadie.runTest(MethodRoadie.java:87)\r\n\tat org.junit.internal.runners.MethodRoadie.run(MethodRoadie.java:50)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.invokeTestMethod(PowerMockJUnit44RunnerDelegateImpl.java:218)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.runMethods(PowerMockJUnit44RunnerDelegateImpl.java:160)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$1.run(PowerMockJUnit44RunnerDelegateImpl.java:134)\r\n\tat org.junit.internal.runners.ClassRoadie.runUnprotected(ClassRoadie.java:34)\r\n\tat org.junit.internal.runners.ClassRoadie.runProtected(ClassRoadie.java:44)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.run(PowerMockJUnit44RunnerDelegateImpl.java:136)\r\n\tat org.powermock.modules.junit4.common.internal.impl.JUnit4TestSuiteChunkerImpl.run(JUnit4TestSuiteChunkerImpl.java:117)\r\n\tat org.powermock.modules.junit4.common.internal.impl.AbstractCommonPowerMockRunner.run(AbstractCommonPowerMockRunner.java:57)\r\n\tat org.powermock.modules.junit4.PowerMockRunner.run(PowerMockRunner.java:59)\r\n\t... 5 more\r\nCaused by: java.lang.NoClassDefFoundError: android/content/IntentSender$FinishedDispatcher\r\n\tat java.lang.Class.getDeclaringClass0(Native Method)\r\n\tat java.lang.Class.getDeclaringClass(Class.java:1235)\r\n\tat java.lang.Class.getEnclosingClass(Class.java:1277)\r\n\tat sun.reflect.annotation.AnnotatedTypeFactory.addNesting(AnnotatedTypeFactory.java:96)\r\n\tat sun.reflect.annotation.AnnotatedTypeFactory.buildAnnotatedType(AnnotatedTypeFactory.java:65)\r\n\tat sun.reflect.annotation.TypeAnnotationParser.buildAnnotatedTypes(TypeAnnotationParser.java:158)\r\n\tat java.lang.reflect.Executable.getAnnotatedExceptionTypes(Executable.java:718)\r\n\tat sun.reflect.GeneratedMethodAccessor44.invoke(Unknown Source)\r\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.lang.reflect.Method.invoke(Method.java:498)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedExceptionType.resolve(TypeDescription.java:3025)\r\n\t... 65 more\r\n```", "Are there any updates on this?\r\nI've tried with Mockito `3.2.4`, any possible combination of Byte Buddy versions and excluding it from other testing libraries that use it, no luck.\r\nStill can't run instrumentation tests if I'm using MockK > `1.9` in the same module.", "I think I may have found the culprit: the newer Dexmaker version MockK is using.\r\nI've managed to get rid of the issue in my project with the latest version of the two libs by doing this:\r\n\r\n```\r\nandroidTestImplementation(\"org.mockito:mockito-android:3.2.4\")\r\nandroidTestImplementation(\"io.mockk:mockk-android:1.9.3\") {\r\n exclude module: 'dexmaker'\r\n}\r\nandroidTestImplementation \"com.linkedin.dexmaker:dexmaker:2.12.1\" // newer versions break Mockito\r\n```", "Hi all, I have a similar problem. I have the error around trying to mock an interface that utilizes JDBI 2. I've tried various combinations of mockito-core around 2.23.* and 2.24.* and manually setting the byte-buddy version. I currently have 2.23.4 and byte buddy 1.9.11\r\n\r\nI'll include the error and some of the dependency tree. Any ideas?\r\n```\r\norg.mockito.exceptions.base.MockitoException: \r\nMockito cannot mock this class: interface com.groupon.da.aesservice.jdbi.CustomerDbi.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 1.8\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 25.172-b11\r\nJVM name : Java HotSpot(TM) 64-Bit Server VM\r\nJVM version : 1.8.0_172-b11\r\nJVM info : mixed mode\r\nOS name : Mac OS X\r\nOS version : 10.14.6\r\n\r\n\r\nUnderlying exception : java.lang.IllegalArgumentException: Could not create type\r\n\r\n\tat org.mockito.internal.runners.DefaultInternalRunner$1.withBefores(DefaultInternalRunner.java:39)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.methodBlock(BlockJUnit4ClassRunner.java:276)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)\r\n\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)\r\n\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\r\n\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\r\n\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\r\n\tat org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)\r\n\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\r\n\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\r\n\tat org.mockito.internal.runners.DefaultInternalRunner$1.run(DefaultInternalRunner.java:79)\r\n\tat org.mockito.internal.runners.DefaultInternalRunner.run(DefaultInternalRunner.java:85)\r\n\tat org.mockito.internal.runners.StrictRunner.run(StrictRunner.java:39)\r\n\tat org.mockito.junit.MockitoJUnitRunner.run(MockitoJUnitRunner.java:163)\r\n\tat org.junit.runner.JUnitCore.run(JUnitCore.java:137)\r\n\tat com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)\r\n\tat com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)\r\n\tat com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)\r\nCaused by: java.lang.IllegalArgumentException: Could not create type\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:154)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n\tat org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25)\r\n\tat org.powermock.api.mockito.mockmaker.PowerMockMaker.createMock(PowerMockMaker.java:41)\r\n\tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n\tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:69)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1896)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.processAnnotationForMock(MockAnnotationProcessor.java:44)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:19)\r\n\tat org.mockito.internal.configuration.MockAnnotationProcessor.process(MockAnnotationProcessor.java:16)\r\n\tat org.mockito.internal.configuration.IndependentAnnotationEngine.createMockFor(IndependentAnnotationEngine.java:38)\r\n\tat org.mockito.internal.configuration.IndependentAnnotationEngine.process(IndependentAnnotationEngine.java:62)\r\n\tat org.mockito.internal.configuration.InjectingAnnotationEngine.processIndependentAnnotations(InjectingAnnotationEngine.java:57)\r\n\tat org.mockito.internal.configuration.InjectingAnnotationEngine.process(InjectingAnnotationEngine.java:41)\r\n\tat org.mockito.MockitoAnnotations.initMocks(MockitoAnnotations.java:69)\r\n\t... 19 more\r\nCaused by: java.lang.annotation.AnnotationFormatError: Invalid default: public abstract java.lang.Class org.skife.jdbi.v2.sqlobject.stringtemplate.UseStringTemplate3StatementLocator.errorListener()\r\n\tat java.lang.reflect.Method.getDefaultValue(Method.java:612)\r\n\tat sun.reflect.annotation.AnnotationType.<init>(AnnotationType.java:132)\r\n\tat sun.reflect.annotation.AnnotationType.getInstance(AnnotationType.java:85)\r\n\tat sun.reflect.annotation.AnnotationParser.parseAnnotation2(AnnotationParser.java:266)\r\n\tat sun.reflect.annotation.AnnotationParser.parseAnnotations2(AnnotationParser.java:120)\r\n\tat sun.reflect.annotation.AnnotationParser.parseAnnotations(AnnotationParser.java:72)\r\n\tat java.lang.Class.createAnnotationData(Class.java:3521)\r\n\tat java.lang.Class.annotationData(Class.java:3510)\r\n\tat java.lang.Class.getAnnotations(Class.java:3446)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:85)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152)\r\n\t... 38 more\r\n```\r\n\r\nPartial Dependency tree (lines with *byte* and *mock*)\r\n```\r\n[INFO] {myProject}\r\n[INFO] +- net.bytebuddy:byte-buddy-agent:jar:1.9.11:test\r\n[INFO] +- net.bytebuddy:byte-buddy:jar:1.9.11:test\r\n[INFO] +- org.mockito:mockito-core:jar:2.23.4:test\r\n[INFO] | \\- org.objenesis:objenesis:jar:3.0.1:test\r\n[INFO] +- org.powermock:powermock-module-junit4:jar:2.0.2:test\r\n[INFO] | +- org.powermock:powermock-module-junit4-common:jar:2.0.2:test\r\n[INFO] | \\- org.hamcrest:hamcrest-core:jar:1.3:test\r\n[INFO] +- org.powermock:powermock-api-mockito2:jar:2.0.2:test\r\n[INFO] | \\- org.powermock:powermock-api-support:jar:2.0.2:test\r\n[INFO] +- org.powermock:powermock-core:jar:2.0.2:test\r\n[INFO] | +- org.powermock:powermock-reflect:jar:2.0.2:test\r\n[INFO] | \\- org.javassist:javassist:jar:3.24.1-GA:compile\r\n```", "\r\n\r\n\r\n> I think I may have found the culprit: the newer Dexmaker version MockK is using.\r\n> I've managed to get rid of the issue in my project with the latest version of the two libs by doing this:\r\n> \r\n> ```\r\n> androidTestImplementation(\"org.mockito:mockito-android:3.2.4\")\r\n> androidTestImplementation(\"io.mockk:mockk-android:1.9.3\") {\r\n> exclude module: 'dexmaker'\r\n> }\r\n> androidTestImplementation \"com.linkedin.dexmaker:dexmaker:2.12.1\" // newer versions break Mockito\r\n> ```\r\n\r\nThank you very much.\r\n\r\nresolutionStrategy {\r\n force(\"com.linkedin.dexmaker:dexmaker:2.12.1\")\r\n}", "You don't need to exclude or declare the dexmaker dependency. The resolutionStrategy part works just fine", "Started getting this on Android after updating to Kotlin 1.4.0 with Mockito 3.5.2:\r\n\r\n```\r\nMockito cannot mock this class: class android.content.Context.\r\n\r\nJava : 11\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 11.0.8+10\r\nJVM name : OpenJDK 64-Bit Server VM\r\nJVM version : 11.0.8+10\r\nJVM info : mixed mode\r\nOS name : Linux\r\nOS version : 4.15.0-1077-aws\r\n``` \r\n\r\nI'm not using Mockk anywhere, dexmaker isn't part of my dependencies tree and everything was working perfectly fine before updating the language. All tests are running against Android API 28, so pretty sure this isn't \"Android changing its APIs in a non-compatible manner\" as was previously mentioned.", "Is there no stack trace or anything? We had some quick bug fixes right after release. Could you try out the version just released?\r\n\r\nAlso, can you try to downgrade the implicit Objenesis dependency? It seems to break a lot of Android things due to its use of `MethodHandle`s.", "Thanks @raphw. I managed to isolate the issue. It seems CircleCI updated their JVM version to 11.0.8 without letting anyone know, and that caused several issues including this. Upgrading to Mockito's latest version and then instructing CircleCI to use JVM 8 fixes it.", "Hey @raphw, I am having the same issue. Can you please let me know how you instruct CircleCI to use JVM 8? I can't seem to find how to do it.", "I don't use CircleCI but @mradzinski can maybe help you out.", "Oh I am sorry @raphw, I tagged the wrong person. I meant to tag @mradzinski. However I updated the `mockito` libraries (we use `mockito-android` and `mockito-kotlin`) to the latest versions and our tests worked fine once again, I didn't have to mess with the CircleCI configuration. Thank you!", "Hi All,\r\n\r\nI'm also seeing this error while mocking \r\n@Mock\r\nprivate KafkaFactory mockKafkaFactory;\r\n\r\njava.lang.RuntimeException: Invoking the beforeTestMethod method on PowerMock test listener org.powermock.api.extension.listener.AnnotationEnabler@770f8c86 failed.\r\n\r\n\tat org.powermock.tests.utils.impl.PowerMockTestNotifierImpl.notifyBeforeTestMethod(PowerMockTestNotifierImpl.java:84)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$PowerMockJUnit44MethodRunner.executeTest(PowerMockJUnit44RunnerDelegateImpl.java:308)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.executeTestInSuper(PowerMockJUnit47RunnerDelegateImpl.java:131)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.access$100(PowerMockJUnit47RunnerDelegateImpl.java:59)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner$TestExecutorStatement.evaluate(PowerMockJUnit47RunnerDelegateImpl.java:147)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.evaluateStatement(PowerMockJUnit47RunnerDelegateImpl.java:107)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.executeTest(PowerMockJUnit47RunnerDelegateImpl.java:82)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$PowerMockJUnit44MethodRunner.runBeforesThenTestThenAfters(PowerMockJUnit44RunnerDelegateImpl.java:298)\r\n\tat org.junit.internal.runners.MethodRoadie.runTest(MethodRoadie.java:87)\r\n\tat org.junit.internal.runners.MethodRoadie.run(MethodRoadie.java:50)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.invokeTestMethod(PowerMockJUnit44RunnerDelegateImpl.java:218)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.runMethods(PowerMockJUnit44RunnerDelegateImpl.java:160)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$1.run(PowerMockJUnit44RunnerDelegateImpl.java:134)\r\n\tat org.junit.internal.runners.ClassRoadie.runUnprotected(ClassRoadie.java:34)\r\n\tat org.junit.internal.runners.ClassRoadie.runProtected(ClassRoadie.java:44)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.run(PowerMockJUnit44RunnerDelegateImpl.java:136)\r\n\tat org.powermock.modules.junit4.common.internal.impl.JUnit4TestSuiteChunkerImpl.run(JUnit4TestSuiteChunkerImpl.java:117)\r\n\tat org.powermock.modules.junit4.common.internal.impl.AbstractCommonPowerMockRunner.run(AbstractCommonPowerMockRunner.java:57)\r\n\tat org.powermock.modules.junit4.PowerMockRunner.run(PowerMockRunner.java:59)\r\n\tat org.junit.runner.JUnitCore.run(JUnitCore.java:137)\r\n\tat org.junit.runner.JUnitCore.run(JUnitCore.java:115)\r\n\tat org.junit.vintage.engine.execution.RunnerExecutor.execute(RunnerExecutor.java:43)\r\n\tat java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)\r\n\tat java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)\r\n\tat java.util.Iterator.forEachRemaining(Iterator.java:116)\r\n\tat java.util.Spliterators$IteratorSpliterator.forEachRemaining(Spliterators.java:1801)\r\n\tat java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:482)\r\n\tat java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:472)\r\n\tat java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)\r\n\tat java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)\r\n\tat java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)\r\n\tat java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)\r\n\tat org.junit.vintage.engine.VintageTestEngine.executeAllChildren(VintageTestEngine.java:82)\r\n\tat org.junit.vintage.engine.VintageTestEngine.execute(VintageTestEngine.java:73)\r\n\tat org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:248)\r\n\tat org.junit.platform.launcher.core.DefaultLauncher.lambda$execute$5(DefaultLauncher.java:211)\r\n\tat org.junit.platform.launcher.core.DefaultLauncher.withInterceptedStreams(DefaultLauncher.java:226)\r\n\tat org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:199)\r\n\tat org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:132)\r\n\tat com.intellij.junit5.JUnit5IdeaTestRunner.startRunnerWithArgs(JUnit5IdeaTestRunner.java:69)\r\n\tat com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)\r\n\tat com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)\r\n\tat com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)\r\nCaused by: org.mockito.exceptions.base.MockitoException: \r\nMockito cannot mock this class: class com.vlocity.xom.kafka.KafkaFactory.\r\n\r\nMockito can only mock non-private & non-final classes.\r\nIf you're not sure why you're getting this error, please report to the mailing list.\r\n\r\n\r\nJava : 1.8\r\nJVM vendor name : Oracle Corporation\r\nJVM vendor version : 25.251-b08\r\nJVM name : Java HotSpot(TM) 64-Bit Server VM\r\nJVM version : 1.8.0_251-b08\r\nJVM info : mixed mode\r\nOS name : Windows 10\r\nOS version : 10.0\r\n\r\n\r\nUnderlying exception : java.lang.IllegalStateException: Error invoking java.lang.reflect.Executable#getAnnotatedParameterTypes\r\n\tat org.junit.internal.runners.MethodRoadie.runTest(MethodRoadie.java:87)\r\n\tat org.junit.internal.runners.MethodRoadie.run(MethodRoadie.java:50)\r\n\tat org.junit.internal.runners.ClassRoadie.runUnprotected(ClassRoadie.java:34)\r\n\tat org.junit.internal.runners.ClassRoadie.runProtected(ClassRoadie.java:44)\r\n\t... 24 more\r\nCaused by: java.lang.IllegalStateException: Error invoking java.lang.reflect.Executable#getAnnotatedParameterTypes\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedParameterizedType.resolve(TypeDescription.java:3025)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Delegator.asList(TypeDescription.java:3238)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$OfNonGenericType$ForLoadedType.getDeclaredAnnotations(TypeDescription.java:3987)\r\n\tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.apply(AnnotationAppender.java:725)\r\n\tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.onNonGenericType(AnnotationAppender.java:706)\r\n\tat net.bytebuddy.implementation.attribute.AnnotationAppender$ForTypeAnnotations.onNonGenericType(AnnotationAppender.java:409)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$OfNonGenericType.accept(TypeDescription.java:3769)\r\n\tat net.bytebuddy.implementation.attribute.MethodAttributeAppender$ForInstrumentedMethod.apply(MethodAttributeAppender.java:208)\r\n\tat net.bytebuddy.implementation.attribute.MethodAttributeAppender$Compound.apply(MethodAttributeAppender.java:484)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod$WithBody.applyAttributes(TypeWriter.java:701)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod$WithBody.applyBody(TypeWriter.java:691)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$MethodPool$Record$ForDefinedMethod.apply(TypeWriter.java:600)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default$ForCreation.create(TypeWriter.java:5660)\r\n\tat net.bytebuddy.dynamic.scaffold.TypeWriter$Default.make(TypeWriter.java:2166)\r\n\tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:232)\r\n\tat net.bytebuddy.dynamic.scaffold.subclass.SubclassDynamicTypeBuilder.make(SubclassDynamicTypeBuilder.java:204)\r\n\tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase.make(DynamicType.java:3595)\r\n\tat net.bytebuddy.dynamic.DynamicType$Builder$AbstractBase$Delegator.make(DynamicType.java:3819)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassBytecodeGenerator.mockClass(SubclassBytecodeGenerator.java:128)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:37)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator$1.call(TypeCachingBytecodeGenerator.java:34)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:152)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:365)\r\n\tat net.bytebuddy.TypeCache.findOrInsert(TypeCache.java:174)\r\n\tat net.bytebuddy.TypeCache$WithInlineExpunction.findOrInsert(TypeCache.java:376)\r\n\tat org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator.mockClass(TypeCachingBytecodeGenerator.java:32)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMockType(SubclassByteBuddyMockMaker.java:71)\r\n\tat org.mockito.internal.creation.bytebuddy.SubclassByteBuddyMockMaker.createMock(SubclassByteBuddyMockMaker.java:42)\r\n\tat org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker.createMock(ByteBuddyMockMaker.java:25)\r\n\tat org.powermock.api.mockito.mockmaker.PowerMockMaker.createMock(PowerMockMaker.java:41)\r\n\tat org.mockito.internal.util.MockUtil.createMock(MockUtil.java:35)\r\n\tat org.mockito.internal.MockitoCore.mock(MockitoCore.java:69)\r\n\tat org.mockito.Mockito.mock(Mockito.java:1895)\r\n\tat org.powermock.api.mockito.internal.mockcreation.DefaultMockCreator.createMethodInvocationControl(DefaultMockCreator.java:108)\r\n\tat org.powermock.api.mockito.internal.mockcreation.DefaultMockCreator.doCreateMock(DefaultMockCreator.java:61)\r\n\tat org.powermock.api.mockito.internal.mockcreation.DefaultMockCreator.createMock(DefaultMockCreator.java:53)\r\n\tat org.powermock.api.mockito.internal.mockcreation.DefaultMockCreator.mock(DefaultMockCreator.java:40)\r\n\tat org.powermock.api.mockito.PowerMockito.mock(PowerMockito.java:181)\r\n\tat org.powermock.api.extension.listener.AnnotationEnabler.standardInject(AnnotationEnabler.java:98)\r\n\tat org.powermock.api.extension.listener.AnnotationEnabler.beforeTestMethod(AnnotationEnabler.java:55)\r\n\tat org.powermock.tests.utils.impl.PowerMockTestNotifierImpl.notifyBeforeTestMethod(PowerMockTestNotifierImpl.java:82)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$PowerMockJUnit44MethodRunner.executeTest(PowerMockJUnit44RunnerDelegateImpl.java:308)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.executeTestInSuper(PowerMockJUnit47RunnerDelegateImpl.java:131)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.access$100(PowerMockJUnit47RunnerDelegateImpl.java:59)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner$TestExecutorStatement.evaluate(PowerMockJUnit47RunnerDelegateImpl.java:147)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.evaluateStatement(PowerMockJUnit47RunnerDelegateImpl.java:107)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit47RunnerDelegateImpl$PowerMockJUnit47MethodRunner.executeTest(PowerMockJUnit47RunnerDelegateImpl.java:82)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$PowerMockJUnit44MethodRunner.runBeforesThenTestThenAfters(PowerMockJUnit44RunnerDelegateImpl.java:298)\r\n\tat org.junit.internal.runners.MethodRoadie.runTest(MethodRoadie.java:87)\r\n\tat org.junit.internal.runners.MethodRoadie.run(MethodRoadie.java:50)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.invokeTestMethod(PowerMockJUnit44RunnerDelegateImpl.java:218)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.runMethods(PowerMockJUnit44RunnerDelegateImpl.java:160)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl$1.run(PowerMockJUnit44RunnerDelegateImpl.java:134)\r\n\tat org.junit.internal.runners.ClassRoadie.runUnprotected(ClassRoadie.java:34)\r\n\tat org.junit.internal.runners.ClassRoadie.runProtected(ClassRoadie.java:44)\r\n\tat org.powermock.modules.junit4.internal.impl.PowerMockJUnit44RunnerDelegateImpl.run(PowerMockJUnit44RunnerDelegateImpl.java:136)\r\n\tat org.powermock.modules.junit4.common.internal.impl.JUnit4TestSuiteChunkerImpl.run(JUnit4TestSuiteChunkerImpl.java:117)\r\n\tat org.powermock.modules.junit4.common.internal.impl.AbstractCommonPowerMockRunner.run(AbstractCommonPowerMockRunner.java:57)\r\n\tat org.powermock.modules.junit4.PowerMockRunner.run(PowerMockRunner.java:59)\r\n\t... 24 more\r\nCaused by: java.lang.NullPointerException\r\n\tat sun.reflect.annotation.TypeAnnotationParser.mapTypeAnnotations(TypeAnnotationParser.java:356)\r\n\tat sun.reflect.annotation.AnnotatedTypeFactory$AnnotatedTypeBaseImpl.<init>(AnnotatedTypeFactory.java:139)\r\n\tat sun.reflect.annotation.AnnotatedTypeFactory.buildAnnotatedType(AnnotatedTypeFactory.java:65)\r\n\tat sun.reflect.annotation.TypeAnnotationParser.buildAnnotatedTypes(TypeAnnotationParser.java:137)\r\n\tat java.lang.reflect.Executable.getAnnotatedParameterTypes(Executable.java:688)\r\n\tat sun.reflect.GeneratedMethodAccessor18.invoke(Unknown Source)\r\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.lang.reflect.Method.invoke(Method.java:498)\r\n\tat net.bytebuddy.description.type.TypeDescription$Generic$AnnotationReader$Dispatcher$ForJava8CapableVm$AnnotatedParameterizedType.resolve(TypeDescription.java:3021)\r\n\t... 82 more\r\n\r\n\r\n\r\nDependency tree:\r\n+- org.springframework.boot:spring-boot-starter-test:jar:2.3.2.RELEASE:test\r\n[INFO] | +- org.springframework.boot:spring-boot-test:jar:2.3.2.RELEASE:test\r\n[INFO] | +- org.springframework.boot:spring-boot-test-autoconfigure:jar:2.3.2.RELEASE:test\r\n[INFO] | +- org.junit.jupiter:junit-jupiter:jar:5.6.2:test\r\n[INFO] | | +- org.junit.jupiter:junit-jupiter-api:jar:5.6.2:test\r\n[INFO] | | | +- org.opentest4j:opentest4j:jar:1.2.0:test\r\n[INFO] | | | \\- org.junit.platform:junit-platform-commons:jar:1.6.2:test\r\n[INFO] | | +- org.junit.jupiter:junit-jupiter-params:jar:5.6.2:test\r\n[INFO] | | \\- org.junit.jupiter:junit-jupiter-engine:jar:5.6.2:test\r\n[INFO] | +- org.junit.vintage:junit-vintage-engine:jar:5.6.2:test\r\n[INFO] | | +- org.apiguardian:apiguardian-api:jar:1.1.0:test\r\n[INFO] | | \\- org.junit.platform:junit-platform-engine:jar:1.6.2:test\r\n[INFO] | +- org.mockito:mockito-junit-jupiter:jar:3.3.3:test\r\n[INFO] | +- org.skyscreamer:jsonassert:jar:1.5.0:test\r\n[INFO] | | \\- com.vaadin.external.google:android-json:jar:0.0.20131108.vaadin1:test\r\n[INFO] | +- org.springframework:spring-test:jar:5.2.8.RELEASE:test\r\n[INFO] | \\- org.xmlunit:xmlunit-core:jar:2.7.0:test\r\n[INFO] +- org.powermock:powermock-module-junit4:jar:2.0.7:test\r\n[INFO] | +- org.powermock:powermock-module-junit4-common:jar:2.0.7:test\r\n[INFO] | | +- org.powermock:powermock-reflect:jar:2.0.7:test\r\n[INFO] | | \\- org.powermock:powermock-core:jar:2.0.7:test\r\n[INFO] | | \\- org.javassist:javassist:jar:3.27.0-GA:test\r\n[INFO] | +- junit:junit:jar:4.13:compile\r\n[INFO] | \\- org.hamcrest:hamcrest-core:jar:2.2:test\r\n[INFO] +- org.powermock:powermock-api-mockito2:jar:2.0.7:test\r\n[INFO] | \\- org.powermock:powermock-api-support:jar:2.0.7:test\r\n[INFO] +- org.mockito:mockito-core:jar:2.23.0:test\r\n[INFO] | +- net.bytebuddy:byte-buddy:jar:1.10.13:test\r\n[INFO] | +- net.bytebuddy:byte-buddy-agent:jar:1.10.13:test\r\n[INFO] | \\- org.objenesis:objenesis:jar:2.6:test", "Seems like you are using a version of PowerMock that is not compatible with the particular version of Mockito. Please check the PowerMock documentation to see what version to use and see if there's a compatible update.", "for my case, after i added dependencies of spring-test, spring-tx, assertj-core. error does not appear any more.", "It is work for me.\r\n\r\n```\r\nandroidTestImplementation(\"org.mockito:mockito-android:3.6.28\")\r\nandroidTestImplementation(\"io.mockk:mockk-android:1.10.3\") {\r\n exclude module: 'dexmaker'\r\n}\r\n// newer versions break Mockito\r\nandroidTestImplementation \"com.linkedin.dexmaker:dexmaker:2.28.0\"\r\n```", "We haven't received any new reports for almost a year, so I am closing this issue now. Thanks everyone for your contributions! If anybody else runs into this issue in the future, please double-check the version of ByteBuddy you are using and make sure it adheres to the dependency requirements that Mockito has." ]

[ "I don't think this warrants a new minor release. I think this should be just 2.25.5", "No probs. I generally like to publish new minor every few weeks. It's arbitrary what we warrant a new minor release, and that's OK.\r\n\r\nI need to finally set up the automation that automatically pushes to MavenCentral if the version is next minor." ]

"2019-03-23T17:08:56Z"

[]

[ "gradle/dependencies.gradle" ]

[ "gradle/dependencies.gradle" ]

[]

"2019-02-04T10:48:15Z"

[ "keyword_pr_to_issue" ]

[ "Nice report, thank you! Do you want to take a stub at fixing it? I suspect that we need to tweak the reporting, so that we print other interactions, too. We do something like that for regular verification failures (as opposed to verification failures due to mismatched arguments)", "I can try and take a look at this.", "hi @mockitoguy\r\nsorry my email is bleeding with spam and I've been caught up with some deadlines\r\nit would be an interesting piece of work that I'd like to take but I don't have the time right now for\r\nit's going into my todo list, though", "Just started working on this today. Doesn't seem like too bad of a change. I should have something to show later today or tomorrow." ]

[]

"2019-05-02T17:27:15Z"

[ "please contribute" ]

[ "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/reporting/SmartPrinter.java", "src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java" ]

[ "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/reporting/SmartPrinter.java", "src/main/java/org/mockito/internal/verification/checkers/MissingInvocationChecker.java" ]

[ "src/test/java/org/mockito/internal/verification/SmartPrinterTest.java", "src/test/java/org/mockito/internal/verification/checkers/MissingInvocationCheckerTest.java", "src/test/java/org/mockito/internal/verification/checkers/MissingInvocationInOrderCheckerTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java", "src/test/java/org/mockitousage/verification/VerifyPrintsAllInvocationsOnErrorTest.java" ]

"2018-11-23T15:17:22Z"

[ "timestamp(timedelta=4.0, similarity=0.9213547190073447)", "keyword_pr_to_issue" ]

[ "I would welcome a PR for this :smile: " ]

[]

"2019-05-06T15:05:32Z"

[ "enhancement" ]

[ "src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java", "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java", "src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java" ]

[ "src/main/java/org/mockito/exceptions/verification/TooFewActualInvocations.java", "src/main/java/org/mockito/exceptions/verification/TooLittleActualInvocations.java", "src/main/java/org/mockito/internal/exceptions/Reporter.java", "src/main/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsChecker.java", "src/main/java/org/mockito/internal/verification/checkers/NumberOfInvocationsChecker.java" ]

[ "src/test/java/org/mockito/internal/exceptions/ReporterTest.java", "src/test/java/org/mockito/internal/verification/checkers/AtLeastXNumberOfInvocationsCheckerTest.java", "src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsCheckerTest.java", "src/test/java/org/mockito/internal/verification/checkers/NumberOfInvocationsInOrderCheckerTest.java", "src/test/java/org/mockitousage/junitrunner/SilentRunnerTest.java", "src/test/java/org/mockitousage/spies/SpyingOnRealObjectsTest.java", "src/test/java/org/mockitousage/stacktrace/ModellingDescriptiveMessagesTest.java", "src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationChunkInOrderTest.java", "src/test/java/org/mockitousage/stacktrace/PointingStackTraceToActualInvocationInOrderTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesOnVerificationInOrderErrorsTest.java", "src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenTimesXVerificationFailsTest.java", "src/test/java/org/mockitousage/verification/ExactNumberOfTimesVerificationTest.java", "src/test/java/org/mockitousage/verification/SelectedMocksInOrderVerificationTest.java", "src/test/java/org/mockitousage/verification/VerificationWithTimeoutTest.java" ]

"2019-02-18T11:22:32Z"

[ "keyword_pr_to_issue" ]

[ "For reference, the change was introduced in JaCoCo with jacoco/jacoco#845." ]

[]

"2019-05-24T12:45:41Z"

[]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java" ]

[ "src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java" ]

[ "src/test/java/org/mockito/internal/creation/bytebuddy/InlineByteBuddyMockMakerTest.java" ]

"2019-05-24T12:36:19Z"

[ "keyword_pr_to_issue" ]

[ "Any thoughts on this one? I'm just curious to know." ]

[]

"2019-09-25T00:53:55Z"

[]

[ "src/main/java/org/mockito/internal/stubbing/StubberImpl.java" ]

[ "src/main/java/org/mockito/internal/stubbing/StubberImpl.java" ]

[ "src/test/java/org/mockitousage/stubbing/MisusingStubbingTest.java" ]

"2019-03-05T22:45:40Z"

[ "keyword_pr_to_issue" ]

[]

[]

"2019-09-27T20:03:05Z"

[]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2019-09-27T19:58:25Z"

[ "keyword_pr_to_issue" ]

[ "Hey! Can you take a look at our FAQ wiki. We documented how Mockito supports parallel execution.", "I took a look at the wiki, but found just a very short section about parallel testing in the FAQ section. I issued the bug, because the parallel execution of whole test cases with JUnit 5 seems to be broken. I do not have any complex tests which use mocks in combination with multithreading.\r\n\r\nAnyway this seems to be a problem of the MockitoExtension, not Mockito itself. Because with our simple JUnit 5 extension for Mockito, parallel execution of test cases which use mocks with JUnit 5 works fine.", "I got a similar issue. \r\nI have got a workaround, if only a few of your \"Mockito\"-test-classes in you testsuite are failing when running JUnit jupiter in parallel. You can execute those problematic tests using \"SAME_THREAD\" for avoiding Mockito concurrency issues.\r\n\r\n```\r\nimport org.junit.jupiter.api.extension.ExtendWith;\r\nimport org.junit.jupiter.api.parallel.Execution;\r\nimport org.junit.jupiter.api.parallel.ExecutionMode;\r\nimport org.mockito.junit.jupiter.MockitoExtension;\r\n\r\n@ExtendWith(MockitoExtension.class)\r\n@Execution(ExecutionMode.SAME_THREAD) // <--- Workaround\r\nclass SomeTest {\r\n```", "To be a bit more specific, WantedButNotInvoked exceptions are thrown by verification calls failing, because of not recorded invocations: \"Actually, there were zero interactions with this mock.\".", "The main difference between the current and the simple implementation above is, that the simple one inits the mocks in postProcessTestInstance() whereas the current one inits them in beforeEach(). Any ideas why that might be a problem? \r\n\r\nI tried the failing tests with a modified version of the current MockitoExtension which was just altered to init the mocks in postProcessTestInstance() and disabled the init in beforeEach() and the tests do no longer fail. So this seems to be the source of the problems.", "Hey guys, can you provide us a test that reproduces the problem? Thanks!", "@mockitoguy Here you go: https://github.com/SchulteMarkus/mockito.bug1630\r\n\r\nI am not sure, if I reduced the example as much as possible, but, well, the project is not large.", "Thank you! The sample project looks great!\r\n\r\nI looked at the code but I haven't had time to debug it. How does the JUnit5 parallel execution work? Are we sharing the test instance (and thus, sharing mocks, SUTs?).", "You are welcome :-) \r\nI don't know details about JUnit's parallelization.", "> How does the JUnit5 parallel execution work? Are we sharing the test instance (and thus, sharing mocks, SUTs?).\r\n\r\nBy default not, and the user must be very explicit to enable sharing of the same test class instance with parallel execution enabled. I.e., even if parallel execution mode is enabled by default, and a test class is annotated with `Lifecycle.PER_CLASS`, its tests will still be executed sequentially _unless_ it is also annotated with `@Execution(CONCURRENT)`: https://junit.org/junit5/docs/current/user-guide/#writing-tests-parallel-execution\r\n\r\nI also bumped into this issue in our codebase, with some tests using `MockitoExtension` failing in parallel mode, and some working fine. Could not spot anything particularly special about the failing ones.\r\n", "I can confirm, that the problem exists. I also have tests using MockitoExtension and they fail in a non-deterministic way randomly only if Junit5 parralelization is used.", "Scenario:\r\n\r\n1. JUnit 5 creates a single `ClassExtensionContext `for a multithreaded test, but each thread becomes an instance of the test class\r\n2. Each thread will come into `postProcessTestInstance `where they put their test instance in the same `ClassExtensionContext.getStore(MOCKITO)` map with the same key (`TEST_INSTANCE`)\r\n3. Each thread then will get into `beforeEach`. They get a thread unique `MethodExtensionContext`, but each of them contain the same instance of `ClassExtensionContext`. Then they fetch the the last updated `TEST_INSTANCE `from the parent `ClassExtensionContext `inside the `collectParentTestInstances `method. Each thread gets quasi a random Test Instance depending on the fact which thread was before inside the `postProcessTestInstance `method. Then they prepare their broken Session inside the store of the current `MethodExtensionContext `with a random Test Instance included.\r\n\r\nThat is the explanation. I am thinking about how to solve this.\r\n\r\nIt is not 100% clear to me why the parent context test instance is included. I will check how this scenario looks like in a singlethreaded environment.", "This is really painful to debug but I'm making progress. What I found out is that \"collectParentTestInstances()\" is non-deterministic:\r\n\r\n```\r\nThread[16] collectParentTestInstances() - returns: [org.mockito.AnotherTest@2bf588f6]\r\nThread[13] collectParentTestInstances() - returns: [org.mockito.AnotherTest@240da1f5, org.mockito.AnotherTest@6646267a]\r\nThread[17] collectParentTestInstances() - returns: [org.mockito.AnotherTest@6646267a]\r\nThread[14] collectParentTestInstances() - returns: [org.mockito.AnotherTest@f9b9d48]\r\n```\r\n\r\nNotice that AnotherTest@6646267a is processed twice. Effectively, initMocks() is called twice for that test instance, clearing up the invocations.\r\n\r\nDo you have an idea how to fix collectParentTestInstances()?", "Perhaps we drop the collectParentTestInstances() complexity and just keep the test instances in static ThreadLocal object in the extension. postProcessTestInstance() feeds the thread local state, beforeEach() consumes it. I don't know enough about the \"context store\" API, though.", "I have a plan how to fix it. First, we need to upgrade junit-jupiter (#1788)", "@mockitoguy I am not sure why you have closed the issue. In the attached commit I cannot see the fix for the problem.\r\n\r\nContext store API seems to be pretty simple to me, it is just a map in the context to store some information. The real question is what is this kind of context hierarchy used for in Junit 5 and how it behaves in case of nested tests or multithreaded tests, or even in multithreaded nested tests. I guess it could have some interesting beahaviour in case of parameterized (dynamic) tests. Probably it would be a good idea simply to ask the JUnit developers about this issue. Maybe they could provide some valuable feedback.", "PR #1789 fixes the problem. This ticket got closed by accident. Thanks for looking into it!", "Looking forward to the next release!\r\nI would like to confirm the bug is gone, but I don't know how to do it in https://github.com/SchulteMarkus/mockito.bug1630.\r\nCan someone add a PR to https://github.com/SchulteMarkus/mockito.bug1630 using Mockito 3.0.12 (at least)? ", "Release have been already published. See https://bintray.com/mockito/maven/mockito-development", "@mockitoguy when will this fix be released to maven central?", "I will publish a release today", "I updated https://github.com/SchulteMarkus/mockito.bug1630 - seems to work without problems using Mockito v.3.1.0, thanks a lot!\r\nI will delete https://github.com/SchulteMarkus/mockito.bug1630 within a few weeks.", "Publish to Maven Central failed yet again. I will need to contact sonatype again...", "(Although https://repo1.maven.org/maven2/org/mockito/mockito-core/3.1.0/ does exist, so it might just work)", "I can confirm, that the solution of 3.1.0 version works for all of the tests in my project. Still I don't understand how JUnit works, but it is fine now, since the tests work.\r\n\r\nThanks for your fast fix & release!" ]

[]

"2019-09-28T01:31:15Z"

[ "junit5" ]

[ "gradle/dependencies.gradle" ]

[ "gradle/dependencies.gradle" ]

[ "subprojects/junit-jupiter/src/test/java/org/mockitousage/MultiLevelNestedTest.java" ]

"2019-02-25T12:54:15Z"

[ "keyword_issue_to_pr", "keyword_pr_to_issue" ]

[ "Hey! Can you take a look at our FAQ wiki. We documented how Mockito supports parallel execution.", "I took a look at the wiki, but found just a very short section about parallel testing in the FAQ section. I issued the bug, because the parallel execution of whole test cases with JUnit 5 seems to be broken. I do not have any complex tests which use mocks in combination with multithreading.\r\n\r\nAnyway this seems to be a problem of the MockitoExtension, not Mockito itself. Because with our simple JUnit 5 extension for Mockito, parallel execution of test cases which use mocks with JUnit 5 works fine.", "I got a similar issue. \r\nI have got a workaround, if only a few of your \"Mockito\"-test-classes in you testsuite are failing when running JUnit jupiter in parallel. You can execute those problematic tests using \"SAME_THREAD\" for avoiding Mockito concurrency issues.\r\n\r\n```\r\nimport org.junit.jupiter.api.extension.ExtendWith;\r\nimport org.junit.jupiter.api.parallel.Execution;\r\nimport org.junit.jupiter.api.parallel.ExecutionMode;\r\nimport org.mockito.junit.jupiter.MockitoExtension;\r\n\r\n@ExtendWith(MockitoExtension.class)\r\n@Execution(ExecutionMode.SAME_THREAD) // <--- Workaround\r\nclass SomeTest {\r\n```", "To be a bit more specific, WantedButNotInvoked exceptions are thrown by verification calls failing, because of not recorded invocations: \"Actually, there were zero interactions with this mock.\".", "The main difference between the current and the simple implementation above is, that the simple one inits the mocks in postProcessTestInstance() whereas the current one inits them in beforeEach(). Any ideas why that might be a problem? \r\n\r\nI tried the failing tests with a modified version of the current MockitoExtension which was just altered to init the mocks in postProcessTestInstance() and disabled the init in beforeEach() and the tests do no longer fail. So this seems to be the source of the problems.", "Hey guys, can you provide us a test that reproduces the problem? Thanks!", "@mockitoguy Here you go: https://github.com/SchulteMarkus/mockito.bug1630\r\n\r\nI am not sure, if I reduced the example as much as possible, but, well, the project is not large.", "Thank you! The sample project looks great!\r\n\r\nI looked at the code but I haven't had time to debug it. How does the JUnit5 parallel execution work? Are we sharing the test instance (and thus, sharing mocks, SUTs?).", "You are welcome :-) \r\nI don't know details about JUnit's parallelization.", "> How does the JUnit5 parallel execution work? Are we sharing the test instance (and thus, sharing mocks, SUTs?).\r\n\r\nBy default not, and the user must be very explicit to enable sharing of the same test class instance with parallel execution enabled. I.e., even if parallel execution mode is enabled by default, and a test class is annotated with `Lifecycle.PER_CLASS`, its tests will still be executed sequentially _unless_ it is also annotated with `@Execution(CONCURRENT)`: https://junit.org/junit5/docs/current/user-guide/#writing-tests-parallel-execution\r\n\r\nI also bumped into this issue in our codebase, with some tests using `MockitoExtension` failing in parallel mode, and some working fine. Could not spot anything particularly special about the failing ones.\r\n", "I can confirm, that the problem exists. I also have tests using MockitoExtension and they fail in a non-deterministic way randomly only if Junit5 parralelization is used.", "Scenario:\r\n\r\n1. JUnit 5 creates a single `ClassExtensionContext `for a multithreaded test, but each thread becomes an instance of the test class\r\n2. Each thread will come into `postProcessTestInstance `where they put their test instance in the same `ClassExtensionContext.getStore(MOCKITO)` map with the same key (`TEST_INSTANCE`)\r\n3. Each thread then will get into `beforeEach`. They get a thread unique `MethodExtensionContext`, but each of them contain the same instance of `ClassExtensionContext`. Then they fetch the the last updated `TEST_INSTANCE `from the parent `ClassExtensionContext `inside the `collectParentTestInstances `method. Each thread gets quasi a random Test Instance depending on the fact which thread was before inside the `postProcessTestInstance `method. Then they prepare their broken Session inside the store of the current `MethodExtensionContext `with a random Test Instance included.\r\n\r\nThat is the explanation. I am thinking about how to solve this.\r\n\r\nIt is not 100% clear to me why the parent context test instance is included. I will check how this scenario looks like in a singlethreaded environment.", "This is really painful to debug but I'm making progress. What I found out is that \"collectParentTestInstances()\" is non-deterministic:\r\n\r\n```\r\nThread[16] collectParentTestInstances() - returns: [org.mockito.AnotherTest@2bf588f6]\r\nThread[13] collectParentTestInstances() - returns: [org.mockito.AnotherTest@240da1f5, org.mockito.AnotherTest@6646267a]\r\nThread[17] collectParentTestInstances() - returns: [org.mockito.AnotherTest@6646267a]\r\nThread[14] collectParentTestInstances() - returns: [org.mockito.AnotherTest@f9b9d48]\r\n```\r\n\r\nNotice that AnotherTest@6646267a is processed twice. Effectively, initMocks() is called twice for that test instance, clearing up the invocations.\r\n\r\nDo you have an idea how to fix collectParentTestInstances()?", "Perhaps we drop the collectParentTestInstances() complexity and just keep the test instances in static ThreadLocal object in the extension. postProcessTestInstance() feeds the thread local state, beforeEach() consumes it. I don't know enough about the \"context store\" API, though.", "I have a plan how to fix it. First, we need to upgrade junit-jupiter (#1788)", "@mockitoguy I am not sure why you have closed the issue. In the attached commit I cannot see the fix for the problem.\r\n\r\nContext store API seems to be pretty simple to me, it is just a map in the context to store some information. The real question is what is this kind of context hierarchy used for in Junit 5 and how it behaves in case of nested tests or multithreaded tests, or even in multithreaded nested tests. I guess it could have some interesting beahaviour in case of parameterized (dynamic) tests. Probably it would be a good idea simply to ask the JUnit developers about this issue. Maybe they could provide some valuable feedback.", "PR #1789 fixes the problem. This ticket got closed by accident. Thanks for looking into it!", "Looking forward to the next release!\r\nI would like to confirm the bug is gone, but I don't know how to do it in https://github.com/SchulteMarkus/mockito.bug1630.\r\nCan someone add a PR to https://github.com/SchulteMarkus/mockito.bug1630 using Mockito 3.0.12 (at least)? ", "Release have been already published. See https://bintray.com/mockito/maven/mockito-development", "@mockitoguy when will this fix be released to maven central?", "I will publish a release today", "I updated https://github.com/SchulteMarkus/mockito.bug1630 - seems to work without problems using Mockito v.3.1.0, thanks a lot!\r\nI will delete https://github.com/SchulteMarkus/mockito.bug1630 within a few weeks.", "Publish to Maven Central failed yet again. I will need to contact sonatype again...", "(Although https://repo1.maven.org/maven2/org/mockito/mockito-core/3.1.0/ does exist, so it might just work)", "I can confirm, that the solution of 3.1.0 version works for all of the tests in my project. Still I don't understand how JUnit works, but it is fine now, since the tests work.\r\n\r\nThanks for your fast fix & release!" ]

[ "Instead of having a boolean here, can we pass in `context.getParent()` on line 164. E.g. we pass the first parent in already, but then we keep all the other logic the same. That seems a little bit nicer to me and easier to follow. The comment can then be placed before line 164 instead.", "Please push a commit to this branch - it's simpler!", "Sadly I am not at my working computer. I can do a push on Monday if you prefer.", "This works :-) Push on Monday. Have a nice weekend!", "Done PTAL" ]

"2019-09-28T22:08:17Z"

[ "junit5" ]

[ "settings.gradle.kts", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java" ]

[ "settings.gradle.kts", "subprojects/junit-jupiter/src/main/java/org/mockito/junit/jupiter/MockitoExtension.java", "subprojects/junitJupiterParallelTest/junitJupiterParallelTest.gradle" ]

[ "subprojects/junitJupiterParallelTest/src/test/java/org/mockito/ParallelBugTest.java", "subprojects/junitJupiterParallelTest/src/test/resources/junit-platform.properties" ]

"2019-02-25T12:54:15Z"

[ "keyword_pr_to_issue" ]

[ "Feel free to send a PR!" ]

[]

"2019-10-05T08:57:05Z"

[]

[ "src/main/java/org/mockito/Mockito.java" ]

[ "src/main/java/org/mockito/Mockito.java" ]

[]

"2019-09-30T19:34:37Z"

[ "keyword_issue_to_pr" ]

[ "Is there any update on this? This has broken our tests as well attempting to upgrade our version of Mockito. The usage of an @InjectMocks as well as a @Spy & @InjectMocks makes sense from the perspective of integration testing of two components that act as one cohesive unit. ", "Here's a pseudo code to describe the issues around this issue.\r\n\r\n# Before 2.23.15:\t\r\n\r\n```\r\nwhile (clazz != Object.clazz) {\r\n\tval mocks = aggregateSpyOrMockFields(clazz.getMockFields());\r\n val fields = aggregateInjectMocksFields(clazz);\r\n\tval ret = tryConstructorInjection(clazz, fields, mock);\r\n if (! ret.fieldWasInitializedUsingConstructorInjection()) {\r\n trySetterOrPropertyInjection(clazz, fields, mock);\r\n }\r\n\tclazz = clazz.getSuperclass();\r\n}\r\n```\r\n# After 2.23.15:\r\n```\r\n\tval mocks = aggregateSpyOrMockFields(clazz.getMockFields());\r\n val fields = aggregateInjectMocksFields(clazz);\r\n\tval ret = tryConstructorInjection(clazz, fields, mock);\r\n if (! ret.fieldWasInitializedUsingConstructorInjection()) {\r\n trySetterOrPropertyInjection(clazz, fields, mock);\r\n }\r\n```\r\n\r\n# Details\r\n\r\nBefore 2.23.15, if the `@InjectMocks` field has a field that not listed in the constructor argument will fill by setter/property injection at the 2nd loop 😃\r\nIt may not the expected behaviors by Mockito authors, but some users' code depends on this behavior.\r\n\r\nMy suggestion is to revert the [Fixes #1587 : Remove unnecessary loop from InjectingAnnotationEngine by LihMeh · Pull Request #1588 · mockito/mockito · GitHub](https://github.com/mockito/mockito/pull/1588) at this time.\r\n", "Feel free to open a PR with regression test and I will be happy to merge it. Thanks!", "This should be fixed with #1810" ]

[ "Can we assert here on `target.getBar()`. Also please add another assertion with `assertEquals(target.foo, foo)`", "Thanks. applied your feedback.", "Why would you iterate over the super classes of the Test class ???", "This behaviour does not reflect the docs of the annotation", "This test only works if I is extended... seems to make little sense" ]

"2019-10-24T23:29:02Z"

[ "injection" ]

[ "src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java" ]

[ "src/main/java/org/mockito/internal/configuration/InjectingAnnotationEngine.java" ]

[ "src/test/java/org/mockito/internal/configuration/InjectingAnnotationEngineTest.java" ]

"2019-02-26T15:29:04Z"

[ "keyword_pr_to_issue" ]