[SHIRO-811] fix toggling test through Mockito conversion.

core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java

@@ -21,10 +21,17 @@
 import org.apache.shiro.subject.support.SubjectRunnable;
 import org.apache.shiro.test.SecurityManagerTestSupport;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 
-import java.util.concurrent.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
-import static org.easymock.EasyMock.*;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 /**
  * Test cases for the {@link SubjectAwareExecutorService} implementation.
@@ -34,40 +41,42 @@ public class SubjectAwareExecutorServiceTest extends SecurityManagerTestSupport
     @SuppressWarnings({"unchecked"})
     @Test
     public void testSubmitRunnable() {
-        ExecutorService mockExecutorService = createNiceMock(ExecutorService.class);
-        expect(mockExecutorService.submit(isA(SubjectRunnable.class))).andReturn(new DummyFuture());
-        replay(mockExecutorService);
+        ExecutorService mockExecutorService = mock(ExecutorService.class);
+        ArgumentCaptor<SubjectRunnable> captor = ArgumentCaptor.forClass(SubjectRunnable.class);
+        when(mockExecutorService.submit(captor.capture())).thenReturn(new DummyFuture<>());
 
         final SubjectAwareExecutorService executor = new SubjectAwareExecutorService(mockExecutorService);
 
-        Runnable testRunnable = new Runnable() {
-            public void run() {
-                System.out.println("Hello World");
-            }
-        };
+        Runnable testRunnable = () -> System.out.println("Hello World");
 
         executor.submit(testRunnable);
-        verify(mockExecutorService);
+        SubjectRunnable subjectRunnable = captor.getValue();
+        assertNotNull(subjectRunnable);
     }
 
     private class DummyFuture<V> implements Future<V> {
 
+        @Override
         public boolean cancel(boolean b) {
             return false;
         }
 
+        @Override
         public boolean isCancelled() {
             return false;
         }
 
+        @Override
         public boolean isDone() {
             return true;
         }
 
+        @Override
         public V get() throws InterruptedException, ExecutionException {
             return null;
         }
 
+        @Override
         public V get(long l, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
             return null;
         }

core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java

@@ -21,10 +21,13 @@
 import org.apache.shiro.subject.support.SubjectRunnable;
 import org.apache.shiro.test.SecurityManagerTestSupport;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 
 import java.util.concurrent.Executor;
 
-import static org.easymock.EasyMock.*;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 /**
  * Test cases for the {@link SubjectAwareExecutor} implementation.
@@ -35,21 +38,17 @@ public class SubjectAwareExecutorTest extends SecurityManagerTestSupport {
 
     @Test
     public void testExecute() {
-        Executor targetMockExecutor = createNiceMock(Executor.class);
-        //* ensure the target Executor receives a SubjectRunnable instance that retains the subject identity:
-        //(this is what verifies the test is valid):
-        targetMockExecutor.execute(isA(SubjectRunnable.class));
-        replay(targetMockExecutor);
-
+        Executor targetMockExecutor = mock(Executor.class);
         final SubjectAwareExecutor executor = new SubjectAwareExecutor(targetMockExecutor);
 
-        Runnable work = new Runnable() {
-            public void run() {
-                System.out.println("Hello World");
-            }
-        };
+        Runnable work = () -> System.out.println("Hello World");
         executor.execute(work);
 
-        verify(targetMockExecutor);
+        //* ensure the target Executor receives a SubjectRunnable instance that retains the subject identity:
+        //(this is what verifies the test is valid):
+        ArgumentCaptor<SubjectRunnable> subjectRunnableArgumentCaptor = ArgumentCaptor.forClass(SubjectRunnable.class);
+        verify(targetMockExecutor).execute(subjectRunnableArgumentCaptor.capture());
+        SubjectRunnable subjectRunnable = subjectRunnableArgumentCaptor.getValue();
+        assertNotNull(subjectRunnable);
     }
 }

web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java

@@ -82,9 +82,10 @@ public BasicHttpAuthenticationFilter() {
      * </ol>
      *
      * @param request  incoming ServletRequest
-     * @param response outgoing ServletResponse
+     * @param response outgoing ServletResponse (never used)
      * @return the AuthenticationToken used to execute the login attempt
      */
+    @Override
     protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
         String authorizationHeader = getAuthzHeader(request);
         if (authorizationHeader == null || authorizationHeader.length() == 0) {
@@ -125,6 +126,7 @@ protected AuthenticationToken createToken(ServletRequest request, ServletRespons
      * @param encoded the Base64-encoded username:password value found after the scheme in the header
      * @return the username (index 0)/password (index 1) pair obtained from the encoded header data.
      */
+    @Override
     protected String[] getPrincipalsAndCredentials(String scheme, String encoded) {
         String decoded = Base64.decodeToString(encoded);
         return decoded.split(":", 2);

web/src/test/java/org/apache/shiro/web/WebTest.java

@@ -18,21 +18,21 @@
  */
 package org.apache.shiro.web;
 
-import static org.easymock.EasyMock.createNiceMock;
-import static org.easymock.EasyMock.expect;
-
 import javax.servlet.FilterConfig;
 import javax.servlet.ServletContext;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 /**
  * @since 1.0
  */
 public abstract class WebTest {
 
     protected FilterConfig createNiceMockFilterConfig() {
-        FilterConfig mock = createNiceMock(FilterConfig.class);
-        ServletContext mockServletContext = createNiceMock(ServletContext.class);
-        expect(mock.getServletContext()).andReturn(mockServletContext);
+        FilterConfig mock = mock(FilterConfig.class);
+        ServletContext mockServletContext = mock(ServletContext.class);
+        when(mock.getServletContext()).thenReturn(mockServletContext);
         return mock;
     }