Fixes #2489 : Fixed codestyle

andrey-kozel · andrey-kozel · commit 7ec800d5d15e · 2022-01-22T10:57:31.000+03:00
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java b/src/main/java/org/mockito/internal/creation/bytebuddy/MockMethodAdvice.java
@@ -315,7 +315,8 @@ private static Object tryInvoke(Method origin, Object instance, Object[] argumen
             return accessor.invoke(origin, instance, arguments);
         } catch (InvocationTargetException exception) {
             Throwable cause = exception.getCause();
-            new ConditionalStackTraceFilter().filter(removeRecursiveCalls(cause, origin.getDeclaringClass()));
+            new ConditionalStackTraceFilter()
+                    .filter(removeRecursiveCalls(cause, origin.getDeclaringClass()));
             throw cause;
         }
     }
@@ -332,12 +333,13 @@ static Throwable removeRecursiveCalls(final Throwable cause, final Class<?> decl
                 indexesToBeRemoved.add(elementIndex);
             }
         }
-        final List<StackTraceElement> adjustedList = new ArrayList<>(Arrays.asList(cause.getStackTrace()));
+        final List<StackTraceElement> adjustedList =
+                new ArrayList<>(Arrays.asList(cause.getStackTrace()));
         indexesToBeRemoved.stream()
-            .sorted(Comparator.reverseOrder())
-            .mapToInt(Integer::intValue)
-            .forEach(adjustedList::remove);
-        cause.setStackTrace(adjustedList.toArray(new StackTraceElement[]{}));
+                .sorted(Comparator.reverseOrder())
+                .mapToInt(Integer::intValue)
+                .forEach(adjustedList::remove);
+        cause.setStackTrace(adjustedList.toArray(new StackTraceElement[] {}));
         return cause;
     }
 
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
@@ -249,13 +249,17 @@ public void should_leave_causing_stack() throws Exception {
                         settings, new MockHandlerImpl<>(settings), new ExceptionThrowingClass());
 
         StackTraceElement[] returnedStack =
-            assertThrows(IOException.class, () -> proxy.get().throwException()).getStackTrace();
+                assertThrows(IOException.class, () -> proxy.get().throwException()).getStackTrace();
 
         assertNotNull("Stack trace from mockito expected", returnedStack);
 
-        List<StackTraceElement> exceptionClassElements = Arrays.stream(returnedStack)
-            .filter(element -> element.getClassName().equals(ExceptionThrowingClass.class.getName()))
-            .collect(Collectors.toList());
+        List<StackTraceElement> exceptionClassElements =
+                Arrays.stream(returnedStack)
+                        .filter(
+                                element ->
+                                        element.getClassName()
+                                                .equals(ExceptionThrowingClass.class.getName()))
+                        .collect(Collectors.toList());
         assertEquals(3, exceptionClassElements.size());
         assertEquals("internalThrowException", exceptionClassElements.get(0).getMethodName());
         assertEquals("internalThrowException", exceptionClassElements.get(1).getMethodName());
@@ -264,26 +268,34 @@ public void should_leave_causing_stack() throws Exception {
 
     @Test
     public void should_leave_causing_stack_with_two_spies() throws Exception {
-        //given
+        // given
         MockSettingsImpl<ExceptionThrowingClass> settingsEx = new MockSettingsImpl<>();
         settingsEx.setTypeToMock(ExceptionThrowingClass.class);
         settingsEx.defaultAnswer(Answers.CALLS_REAL_METHODS);
         Optional<ExceptionThrowingClass> proxyEx =
-            mockMaker.createSpy(settingsEx, new MockHandlerImpl<>(settingsEx), new ExceptionThrowingClass());
+                mockMaker.createSpy(
+                        settingsEx,
+                        new MockHandlerImpl<>(settingsEx),
+                        new ExceptionThrowingClass());
 
         MockSettingsImpl<WrapperClass> settingsWr = new MockSettingsImpl<>();
         settingsWr.setTypeToMock(WrapperClass.class);
         settingsWr.defaultAnswer(Answers.CALLS_REAL_METHODS);
         Optional<WrapperClass> proxyWr =
-            mockMaker.createSpy(settingsWr, new MockHandlerImpl<>(settingsWr), new WrapperClass());
+                mockMaker.createSpy(
+                        settingsWr, new MockHandlerImpl<>(settingsWr), new WrapperClass());
 
-        //when
-        IOException ex = assertThrows(IOException.class, () -> proxyWr.get().callWrapped(proxyEx.get()));
-        List<StackTraceElement> wrapperClassElements = Arrays.stream(ex.getStackTrace())
-            .filter(element -> element.getClassName().equals(WrapperClass.class.getName()))
-            .collect(Collectors.toList());
+        // when
+        IOException ex =
+                assertThrows(IOException.class, () -> proxyWr.get().callWrapped(proxyEx.get()));
+        List<StackTraceElement> wrapperClassElements =
+                Arrays.stream(ex.getStackTrace())
+                        .filter(
+                                element ->
+                                        element.getClassName().equals(WrapperClass.class.getName()))
+                        .collect(Collectors.toList());
 
-        //then
+        // then
         assertEquals(1, wrapperClassElements.size());
         assertEquals("callWrapped", wrapperClassElements.get(0).getMethodName());
     }

Original file line number	Diff line number	Diff line change
`@@ -315,7 +315,8 @@ private static Object tryInvoke(Method origin, Object instance, Object[] argumen`
`315`	`315`	`return accessor.invoke(origin, instance, arguments);`
`316`	`316`	`} catch (InvocationTargetException exception) {`
`317`	`317`	`Throwable cause = exception.getCause();`
`318`		`- new ConditionalStackTraceFilter().filter(removeRecursiveCalls(cause, origin.getDeclaringClass()));`
	`318`	`+ new ConditionalStackTraceFilter()`
	`319`	`+ .filter(removeRecursiveCalls(cause, origin.getDeclaringClass()));`
`319`	`320`	`throw cause;`
`320`	`321`	`}`
`321`	`322`	`}`
`@@ -332,12 +333,13 @@ static Throwable removeRecursiveCalls(final Throwable cause, final Class<?> decl`
`332`	`333`	`indexesToBeRemoved.add(elementIndex);`
`333`	`334`	`}`
`334`	`335`	`}`
`335`		`- final List<StackTraceElement> adjustedList = new ArrayList<>(Arrays.asList(cause.getStackTrace()));`
	`336`	`+ final List<StackTraceElement> adjustedList =`
	`337`	`+ new ArrayList<>(Arrays.asList(cause.getStackTrace()));`
`336`	`338`	`indexesToBeRemoved.stream()`
`337`		`- .sorted(Comparator.reverseOrder())`
`338`		`- .mapToInt(Integer::intValue)`
`339`		`- .forEach(adjustedList::remove);`
`340`		`- cause.setStackTrace(adjustedList.toArray(new StackTraceElement[]{}));`
	`339`	`+ .sorted(Comparator.reverseOrder())`
	`340`	`+ .mapToInt(Integer::intValue)`
	`341`	`+ .forEach(adjustedList::remove);`
	`342`	`+ cause.setStackTrace(adjustedList.toArray(new StackTraceElement[] {}));`
`341`	`343`	`return cause;`
`342`	`344`	`}`
`343`	`345`