diff --git a/common/common-rest/pom.xml b/common/common-rest/pom.xml
index 6db95d2..43ab57c 100644
--- a/common/common-rest/pom.xml
+++ b/common/common-rest/pom.xml
@@ -66,8 +66,8 @@
       <scope>test</scope>
     </dependency>
     <dependency>
-      <groupId>org.jmockit</groupId>
-      <artifactId>jmockit</artifactId>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-inline</artifactId>
       <scope>test</scope>
     </dependency>
   </dependencies>
diff --git a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreator.java b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreator.java
index 0cbdc15..f93bc59 100644
--- a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreator.java
+++ b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreator.java
@@ -27,6 +27,7 @@
 import javax.annotation.Nonnull;
 import javax.ws.rs.core.HttpHeaders;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.servicecomb.common.rest.codec.produce.ProduceProcessor;
 import org.apache.servicecomb.common.rest.definition.RestOperationMeta;
@@ -122,7 +123,8 @@
     return servicePathManager.producerLocateOperation(requestEx.getRequestURI(), requestEx.getMethod());
   }
 
-  private void initProduceProcessor() {
+  @VisibleForTesting
+  void initProduceProcessor() {
     produceProcessor = restOperationMeta.ensureFindProduceProcessor(requestEx);
     if (produceProcessor == null) {
       LOGGER.error("Accept {} is not supported, operation={}.", requestEx.getHeader(HttpHeaders.ACCEPT),
diff --git a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/VertxRestInvocation.java b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/VertxRestInvocation.java
index c2a664a..a0c45a1 100644
--- a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/VertxRestInvocation.java
+++ b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/VertxRestInvocation.java
@@ -24,7 +24,7 @@
 public class VertxRestInvocation extends RestProducerInvocation {
   @Override
   protected void createInvocation() {
-    super.createInvocation();
+    callParentCreateInvocation();
 
     RoutingContext routingContext = ((VertxServerRequestToHttpServletRequest) this.requestEx).getContext();
     VertxHttpTransportContext transportContext = new VertxHttpTransportContext(routingContext, requestEx, responseEx,
@@ -33,4 +33,11 @@
     invocation.setTransportContext(transportContext);
     routingContext.put(RestConst.REST_INVOCATION_CONTEXT, this.invocation);
   }
+
+  /**
+   * easy to mock when do test
+   */
+  void callParentCreateInvocation() {
+    super.createInvocation();
+  }
 }
diff --git a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/param/RestClientRequestImpl.java b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/param/RestClientRequestImpl.java
index b02242b..2ca0701 100644
--- a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/param/RestClientRequestImpl.java
+++ b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/codec/param/RestClientRequestImpl.java
@@ -32,6 +32,7 @@
 import javax.servlet.http.Part;
 import javax.ws.rs.core.MediaType;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.apache.servicecomb.common.rest.codec.RestClientRequest;
 import org.apache.servicecomb.common.rest.codec.RestObjectMapperFactory;
 import org.apache.servicecomb.foundation.common.utils.PartUtils;
@@ -61,7 +62,8 @@
 
   protected AsyncResponse asyncResp;
 
-  private final Multimap<String, Part> uploads = ArrayListMultimap.create();
+  @VisibleForTesting
+  final Multimap<String, Part> uploads = ArrayListMultimap.create();
 
   protected HttpClientRequest request;
 
diff --git a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/definition/path/AbstractUrlParamWriter.java b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/definition/path/AbstractUrlParamWriter.java
index 2ab28c1..d4eca87 100644
--- a/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/definition/path/AbstractUrlParamWriter.java
+++ b/common/common-rest/src/main/java/org/apache/servicecomb/common/rest/definition/path/AbstractUrlParamWriter.java
@@ -19,12 +19,14 @@
 
 import java.util.Map;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.apache.servicecomb.common.rest.definition.RestParam;
 
 public abstract class AbstractUrlParamWriter implements UrlParamWriter {
   protected RestParam param;
 
-  protected Object getParamValue(Map<String, Object> args) {
+  @VisibleForTesting
+  public Object getParamValue(Map<String, Object> args) {
     if (param == null) {
       // Wrong server definition
       //  @GetMapping(path = "/getLocalDateTime/{paramX}")
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreatorTest.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreatorTest.java
index 18697db..ed6d807 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreatorTest.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/RestProducerInvocationCreatorTest.java
@@ -25,6 +25,7 @@
 import javax.ws.rs.core.HttpHeaders;
 
 import org.apache.servicecomb.common.rest.definition.RestOperationMeta;
+import org.apache.servicecomb.common.rest.locator.OperationLocator;
 import org.apache.servicecomb.common.rest.locator.ServicePathManager;
 import org.apache.servicecomb.config.ConfigUtil;
 import org.apache.servicecomb.core.Const;
@@ -33,7 +34,10 @@
 import org.apache.servicecomb.core.SCBEngine;
 import org.apache.servicecomb.core.SCBStatus;
 import org.apache.servicecomb.core.bootstrap.SCBBootstrap;
+import org.apache.servicecomb.core.definition.InvocationRuntimeType;
 import org.apache.servicecomb.core.definition.MicroserviceMeta;
+import org.apache.servicecomb.core.definition.OperationMeta;
+import org.apache.servicecomb.core.definition.SchemaMeta;
 import org.apache.servicecomb.foundation.test.scaffolding.config.ArchaiusUtils;
 import org.apache.servicecomb.foundation.vertx.http.HttpServletRequestEx;
 import org.apache.servicecomb.foundation.vertx.http.HttpServletResponseEx;
@@ -46,32 +50,34 @@
 
 import io.vertx.core.json.Json;
 import io.vertx.ext.web.RoutingContext;
-import mockit.Expectations;
-import mockit.Injectable;
-import mockit.Mocked;
-import mockit.Verifications;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
 
 public class RestProducerInvocationCreatorTest {
-  @Injectable
-  RoutingContext routingContext;
 
-  @Injectable
-  MicroserviceMeta microserviceMeta;
+  RoutingContext routingContext = Mockito.mock(RoutingContext.class);
 
-  @Injectable
-  ServicePathManager servicePathManager;
+  MicroserviceMeta microserviceMeta = Mockito.mock(MicroserviceMeta.class);
 
-  @Mocked
-  RestOperationMeta restOperationMeta;
+  ServicePathManager servicePathManager = Mockito.mock(ServicePathManager.class);
 
-  @Injectable
-  Endpoint endpoint;
+  RestOperationMeta restOperationMeta = Mockito.mock(RestOperationMeta.class);
 
-  @Injectable
-  HttpServletRequestEx requestEx;
+  Endpoint endpoint = Mockito.mock(Endpoint.class);
 
-  @Injectable
-  HttpServletResponseEx responseEx;
+  HttpServletRequestEx requestEx = Mockito.mock(HttpServletRequestEx.class);
+
+  HttpServletResponseEx responseEx = Mockito.mock(HttpServletResponseEx.class);
+
+  OperationLocator locator = Mockito.mock(OperationLocator.class);
+
+  InvocationRuntimeType invocationRuntimeType = Mockito.mock(InvocationRuntimeType.class);
+
+  OperationMeta operationMeta = Mockito.mock(OperationMeta.class);
+
+  SchemaMeta schemaMeta = Mockito.mock(SchemaMeta.class);
 
   RestProducerInvocationCreator creator;
 
@@ -96,89 +102,101 @@
   public void setUp() {
     creator = new RestVertxProducerInvocationCreator(routingContext, microserviceMeta, endpoint,
         requestEx, responseEx);
-  }
-
-  private void mockGetServicePathManager() {
-    mockGetServicePathManager(servicePathManager);
-  }
-
-  private void mockGetServicePathManager(final ServicePathManager servicePathManager) {
-    new Expectations(ServicePathManager.class) {
-      {
-        ServicePathManager.getServicePathManager(microserviceMeta);
-        result = servicePathManager;
-      }
-    };
+    creator = Mockito.spy(creator);
   }
 
   @Test
   public void should_failed_when_not_defined_any_schema() {
-    mockGetServicePathManager(null);
+    try (MockedStatic<ServicePathManager> mockedStatic = Mockito.mockStatic(ServicePathManager.class)) {
+      mockedStatic.when(() -> ServicePathManager.getServicePathManager(null)).thenReturn(servicePathManager);
 
-    InvocationException throwable = (InvocationException) catchThrowable(() -> creator.createAsync().join());
-    CommonExceptionData data = (CommonExceptionData) throwable.getErrorData();
+      InvocationException throwable = (InvocationException) catchThrowable(() -> creator.createAsync().join());
+      CommonExceptionData data = (CommonExceptionData) throwable.getErrorData();
 
-    assertThat(throwable.getStatusCode()).isEqualTo(NOT_FOUND.getStatusCode());
-    assertThat(Json.encode(data)).isEqualTo("{\"code\":\"SCB.00000002\",\"message\":\"Not Found\"}");
+      assertThat(throwable.getStatusCode()).isEqualTo(NOT_FOUND.getStatusCode());
+      assertThat(Json.encode(data)).isEqualTo("{\"code\":\"SCB.00000002\",\"message\":\"Not Found\"}");
+    }
   }
 
   @Test
   public void should_failed_when_accept_is_not_support() {
-    mockGetServicePathManager();
-    new Expectations() {
-      {
-        requestEx.getHeader(HttpHeaders.ACCEPT);
-        result = "test-type";
+    try (MockedStatic<ServicePathManager> mockedStatic = Mockito.mockStatic(ServicePathManager.class)) {
+      mockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(servicePathManager);
+      Mockito.when(requestEx.getHeader(HttpHeaders.ACCEPT)).thenReturn("test-type");
+      Mockito.when(restOperationMeta.ensureFindProduceProcessor(requestEx)).thenReturn(null);
+      Mockito.when(creator.locateOperation(microserviceMeta)).thenReturn(locator);
+      Mockito.when(locator.getOperation()).thenReturn(restOperationMeta);
+      Mockito.when(restOperationMeta.getOperationMeta()).thenReturn(operationMeta);
+      Mockito.when(operationMeta.buildBaseProviderRuntimeType()).thenReturn(invocationRuntimeType);
+      Mockito.when(operationMeta.getSchemaMeta()).thenReturn(schemaMeta);
+      Mockito.when(schemaMeta.getMicroserviceMeta()).thenReturn(microserviceMeta);
+      Mockito.when(microserviceMeta.getHandlerChain()).thenReturn(new ArrayList<>());
 
-        restOperationMeta.ensureFindProduceProcessor(requestEx);
-        result = null;
-      }
-    };
+      InvocationException throwable = (InvocationException) catchThrowable(() -> creator.createAsync().join());
+      CommonExceptionData data = (CommonExceptionData) throwable.getErrorData();
 
-    InvocationException throwable = (InvocationException) catchThrowable(() -> creator.createAsync().join());
-    CommonExceptionData data = (CommonExceptionData) throwable.getErrorData();
-
-    assertThat(throwable.getStatusCode()).isEqualTo(NOT_ACCEPTABLE.getStatusCode());
-    assertThat(Json.encode(data))
-        .isEqualTo("{\"code\":\"SCB.00000000\",\"message\":\"Accept test-type is not supported\"}");
+      assertThat(throwable.getStatusCode()).isEqualTo(NOT_ACCEPTABLE.getStatusCode());
+      assertThat(Json.encode(data))
+              .isEqualTo("{\"code\":\"SCB.00000000\",\"message\":\"Accept test-type is not supported\"}");
+    }
   }
 
   @Test
   public void should_save_requestEx_in_invocation_context() {
-    mockGetServicePathManager();
+    try (MockedStatic<ServicePathManager> mockedStatic = Mockito.mockStatic(ServicePathManager.class)) {
+      mockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(servicePathManager);
+      Mockito.when(creator.locateOperation(microserviceMeta)).thenReturn(locator);
+      Mockito.when(locator.getOperation()).thenReturn(restOperationMeta);
+      Mockito.when(restOperationMeta.getOperationMeta()).thenReturn(operationMeta);
+      Mockito.when(operationMeta.buildBaseProviderRuntimeType()).thenReturn(invocationRuntimeType);
+      Mockito.when(operationMeta.getSchemaMeta()).thenReturn(schemaMeta);
+      Mockito.when(schemaMeta.getMicroserviceMeta()).thenReturn(microserviceMeta);
+      Mockito.when(microserviceMeta.getHandlerChain()).thenReturn(new ArrayList<>());
+      Mockito.doNothing().when(creator).initProduceProcessor();
 
-    Invocation invocation = creator.createAsync().join();
+      Invocation invocation = creator.createAsync().join();
 
-    Object request = invocation.getLocalContext(RestConst.REST_REQUEST);
-    assertThat(request).isSameAs(requestEx);
+      Object request = invocation.getLocalContext(RestConst.REST_REQUEST);
+      assertThat(request).isSameAs(requestEx);
+    }
   }
 
   @Test
   public void should_save_path_var_map_in_requestEx() {
-    mockGetServicePathManager();
+    try (MockedStatic<ServicePathManager> mockedStatic = Mockito.mockStatic(ServicePathManager.class)) {
+      mockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(servicePathManager);
+      Mockito.when(creator.locateOperation(microserviceMeta)).thenReturn(locator);
+      Mockito.when(locator.getOperation()).thenReturn(restOperationMeta);
+      Mockito.when(restOperationMeta.getOperationMeta()).thenReturn(operationMeta);
+      Mockito.when(operationMeta.buildBaseProviderRuntimeType()).thenReturn(invocationRuntimeType);
+      Mockito.when(operationMeta.getSchemaMeta()).thenReturn(schemaMeta);
+      Mockito.when(schemaMeta.getMicroserviceMeta()).thenReturn(microserviceMeta);
+      Mockito.when(microserviceMeta.getHandlerChain()).thenReturn(new ArrayList<>());
+      Mockito.doNothing().when(creator).initProduceProcessor();
 
-    creator.createAsync().join();
+      creator.createAsync().join();
 
-    new Verifications() {
-      {
-        requestEx.setAttribute(RestConst.PATH_PARAMETERS, any);
-        times = 1;
-      }
-    };
+      Mockito.verify(requestEx, Mockito.times(1)).setAttribute(Mockito.eq(RestConst.PATH_PARAMETERS), Mockito.any());
+    }
   }
 
   @Test
   public void should_merge_invocation_context_from_request() {
-    mockGetServicePathManager();
-    new Expectations() {
-      {
-        requestEx.getHeader(Const.CSE_CONTEXT);
-        result = "{\"k\":\"v\"}";
-      }
-    };
+    try (MockedStatic<ServicePathManager> mockedStatic = Mockito.mockStatic(ServicePathManager.class)) {
+      mockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(servicePathManager);
+      Mockito.when(creator.locateOperation(microserviceMeta)).thenReturn(locator);
+      Mockito.when(locator.getOperation()).thenReturn(restOperationMeta);
+      Mockito.when(restOperationMeta.getOperationMeta()).thenReturn(operationMeta);
+      Mockito.when(operationMeta.buildBaseProviderRuntimeType()).thenReturn(invocationRuntimeType);
+      Mockito.when(operationMeta.getSchemaMeta()).thenReturn(schemaMeta);
+      Mockito.when(schemaMeta.getMicroserviceMeta()).thenReturn(microserviceMeta);
+      Mockito.when(microserviceMeta.getHandlerChain()).thenReturn(new ArrayList<>());
+      Mockito.doNothing().when(creator).initProduceProcessor();
+      Mockito.when(requestEx.getHeader(Const.CSE_CONTEXT)).thenReturn("{\"k\":\"v\"}");
 
-    Invocation invocation = creator.createAsync().join();
+      Invocation invocation = creator.createAsync().join();
 
-    assertThat(invocation.getContext("k")).isEqualTo("v");
+      assertThat(invocation.getContext("k")).isEqualTo("v");
+    }
   }
 }
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestAbstractRestInvocation.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestAbstractRestInvocation.java
index 7ec45e1..56625c1 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestAbstractRestInvocation.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestAbstractRestInvocation.java
@@ -21,6 +21,8 @@
 import static com.google.common.net.HttpHeaders.TRANSFER_ENCODING;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -44,20 +46,19 @@
 import org.apache.servicecomb.common.rest.locator.TestPathSchema;
 import org.apache.servicecomb.config.ConfigUtil;
 import org.apache.servicecomb.core.Const;
-import org.apache.servicecomb.core.Endpoint;
 import org.apache.servicecomb.core.Handler;
 import org.apache.servicecomb.core.Invocation;
 import org.apache.servicecomb.core.SCBEngine;
 import org.apache.servicecomb.core.bootstrap.SCBBootstrap;
 import org.apache.servicecomb.core.definition.MicroserviceMeta;
 import org.apache.servicecomb.core.definition.OperationMeta;
-import org.apache.servicecomb.core.definition.SchemaMeta;
 import org.apache.servicecomb.core.event.InvocationFinishEvent;
 import org.apache.servicecomb.core.event.InvocationStartEvent;
 import org.apache.servicecomb.core.executor.ReactiveExecutor;
 import org.apache.servicecomb.core.provider.consumer.ReferenceConfig;
 import org.apache.servicecomb.foundation.common.Holder;
 import org.apache.servicecomb.foundation.common.event.EventManager;
+import org.apache.servicecomb.foundation.common.http.HttpStatus;
 import org.apache.servicecomb.foundation.common.utils.JsonUtils;
 import org.apache.servicecomb.foundation.common.utils.SPIServiceUtils;
 import org.apache.servicecomb.foundation.test.scaffolding.config.ArchaiusUtils;
@@ -68,7 +69,6 @@
 import org.apache.servicecomb.foundation.vertx.http.HttpServletResponseEx;
 import org.apache.servicecomb.foundation.vertx.http.StandardHttpServletResponseEx;
 import org.apache.servicecomb.swagger.invocation.Response;
-import org.apache.servicecomb.swagger.invocation.context.HttpStatus;
 import org.apache.servicecomb.swagger.invocation.exception.CommonExceptionData;
 import org.apache.servicecomb.swagger.invocation.exception.InvocationException;
 import org.hamcrest.MatcherAssert;
@@ -82,26 +82,20 @@
 
 import io.vertx.core.MultiMap;
 import io.vertx.core.buffer.Buffer;
-import mockit.Deencapsulation;
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 
 public class TestAbstractRestInvocation {
-  @Mocked
-  HttpServletRequestEx requestEx;
 
-  @Mocked
-  HttpServletResponse servletResponse;
+  HttpServletRequestEx requestEx = Mockito.mock(HttpServletRequestEx.class);
+
+  HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
 
   HttpServletResponseEx responseEx;
 
-  @Mocked
-  ReferenceConfig endpoint;
+  ReferenceConfig endpoint = Mockito.mock(ReferenceConfig.class);
 
-  @Mocked
-  Map<String, Object> arguments;
+  Map<String, Object> arguments = new HashMap<>();
 
   Invocation invocation;
 
@@ -132,8 +126,6 @@
 
   AbstractRestInvocation restInvocation = new AbstractRestInvocationForTest();
 
-  static long nanoTime = 123;
-
   @Before
   public void setup() {
     ConfigUtil.installDynamicConfig();
@@ -143,17 +135,11 @@
     operationMeta = scbEngine.getProducerMicroserviceMeta().operationMetas().get("test.sid1.dynamicId");
     restOperation = RestMetaUtils.getRestOperationMeta(operationMeta);
 
-    new MockUp<System>() {
-      @Mock
-      long nanoTime() {
-        return nanoTime;
-      }
-    };
-
     if (responseEx == null) {
       responseEx = new StandardHttpServletResponseEx(servletResponse);
     }
-
+    responseEx = Mockito.spy(responseEx);
+    arguments = Mockito.spy(arguments);
     invocation = new Invocation(endpoint, operationMeta, operationMeta.buildBaseConsumerRuntimeType(), arguments);
 
     initRestInvocation();
@@ -176,7 +162,9 @@
   }
 
   @Test
-  public void setHttpServerFilters(@Mocked List<HttpServerFilter> httpServerFilters) {
+  public void setHttpServerFilters() {
+    List<HttpServerFilter> httpServerFilters = new ArrayList<>();
+    httpServerFilters = Mockito.spy(httpServerFilters);
     restInvocation.setHttpServerFilters(httpServerFilters);
 
     Assertions.assertSame(httpServerFilters, restInvocation.httpServerFilters);
@@ -184,12 +172,7 @@
 
   @Test
   public void initProduceProcessorNull() {
-    new Expectations() {
-      {
-        requestEx.getHeader(HttpHeaders.ACCEPT);
-        result = "notExistType";
-      }
-    };
+    Mockito.when(requestEx.getHeader(HttpHeaders.ACCEPT)).thenReturn("notExistType");
     restInvocation = new AbstractRestInvocationForTest() {
       @Override
       public void sendFailResponse(Throwable throwable) {
@@ -204,24 +187,14 @@
 
   @Test
   public void initProduceProcessorNormal() {
-    new Expectations() {
-      {
-        requestEx.getHeader(HttpHeaders.ACCEPT);
-        result = MediaType.APPLICATION_JSON;
-      }
-    };
+    Mockito.when(requestEx.getHeader(HttpHeaders.ACCEPT)).thenReturn(MediaType.APPLICATION_JSON);
     // not throw exception
     restInvocation.initProduceProcessor();
   }
 
   @Test
   public void setContextNull() throws Exception {
-    new Expectations() {
-      {
-        requestEx.getHeader(Const.CSE_CONTEXT);
-        result = null;
-      }
-    };
+    Mockito.when(requestEx.getHeader(Const.CSE_CONTEXT)).thenReturn(null);
 
     Map<String, String> context = invocation.getContext();
     restInvocation.setContext();
@@ -230,12 +203,7 @@
 
   @Test
   public void setContextEmpty() throws Exception {
-    new Expectations() {
-      {
-        requestEx.getHeader(Const.CSE_CONTEXT);
-        result = "";
-      }
-    };
+    Mockito.when(requestEx.getHeader(Const.CSE_CONTEXT)).thenReturn("");
 
     Map<String, String> context = invocation.getContext();
     restInvocation.setContext();
@@ -246,12 +214,7 @@
   public void setContextNormal() throws Exception {
     Map<String, String> context = new HashMap<>();
     context.put("name", "value");
-    new Expectations() {
-      {
-        requestEx.getHeader(Const.CSE_CONTEXT);
-        result = JsonUtils.writeValueAsString(context);
-      }
-    };
+    Mockito.when(requestEx.getHeader(Const.CSE_CONTEXT)).thenReturn(JsonUtils.writeValueAsString(context));
 
     restInvocation.setContext();
     MatcherAssert.assertThat(invocation.getContext().size(), Matchers.is(1));
@@ -261,12 +224,7 @@
   @Test
   public void setContextTraceId() throws Exception {
     Map<String, String> context = new HashMap<>();
-    new Expectations() {
-      {
-        requestEx.getHeader(Const.CSE_CONTEXT);
-        result = JsonUtils.writeValueAsString(context);
-      }
-    };
+    Mockito.when(requestEx.getHeader(Const.CSE_CONTEXT)).thenReturn(JsonUtils.writeValueAsString(context));
     invocation.addContext("X-B3-traceId", "value1");
     //if request has no traceId, use invocation's traceId
     restInvocation.setContext();
@@ -274,12 +232,7 @@
     MatcherAssert.assertThat(invocation.getContext(), Matchers.hasEntry("X-B3-traceId", "value1"));
 
     context.put("X-B3-traceId", "value2");
-    new Expectations() {
-      {
-        requestEx.getHeader(Const.CSE_CONTEXT);
-        result = JsonUtils.writeValueAsString(context);
-      }
-    };
+    Mockito.when(requestEx.getHeader(Const.CSE_CONTEXT)).thenReturn(JsonUtils.writeValueAsString(context));
     //if request has traceId, use request's traceId
     restInvocation.setContext();
     MatcherAssert.assertThat(invocation.getContext().size(), Matchers.is(1));
@@ -298,16 +251,11 @@
   }
 
   @Test
-  public void invokeFilterHaveResponse(@Mocked HttpServerFilter filter) {
+  public void invokeFilterHaveResponse() {
+    HttpServerFilter filter = Mockito.mock(HttpServerFilter.class);
     Response response = Response.ok("");
-    new Expectations() {
-      {
-        filter.enabled();
-        result = true;
-        filter.afterReceiveRequest(invocation, requestEx);
-        result = response;
-      }
-    };
+    Mockito.when(filter.enabled()).thenReturn(true);
+    Mockito.when(filter.afterReceiveRequest(invocation, requestEx)).thenReturn(response);
 
     Holder<Response> result = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
@@ -330,15 +278,10 @@
   }
 
   @Test
-  public void invokeFilterNoResponse(@Mocked HttpServerFilter filter) {
-    new Expectations() {
-      {
-        filter.enabled();
-        result = true;
-        filter.afterReceiveRequest(invocation, requestEx);
-        result = null;
-      }
-    };
+  public void invokeFilterNoResponse() {
+    HttpServerFilter filter = Mockito.mock(HttpServerFilter.class);
+    Mockito.when(filter.enabled()).thenReturn(true);
+    Mockito.when(filter.afterReceiveRequest(invocation, requestEx)).thenReturn(null);
 
     Holder<Boolean> result = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
@@ -356,13 +299,9 @@
   }
 
   @Test
-  public void invokeFilterNoResponseDisableFilter(@Mocked HttpServerFilter filter) {
-    new Expectations() {
-      {
-        filter.enabled();
-        result = false;
-      }
-    };
+  public void invokeFilterNoResponseDisableFilter() {
+    HttpServerFilter filter = Mockito.mock(HttpServerFilter.class);
+    Mockito.when(filter.enabled()).thenReturn(false);
 
     Holder<Boolean> result = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
@@ -380,16 +319,11 @@
   }
 
   @Test
-  public void invokeFilterException(@Mocked HttpServerFilter filter) {
+  public void invokeFilterException() {
+    HttpServerFilter filter = Mockito.mock(HttpServerFilter.class);
     Exception error = new RuntimeExceptionWithoutStackTrace();
-    new Expectations() {
-      {
-        filter.enabled();
-        result = true;
-        filter.afterReceiveRequest(invocation, requestEx);
-        result = error;
-      }
-    };
+    Mockito.when(filter.enabled()).thenReturn(true);
+    Mockito.when(filter.afterReceiveRequest(invocation, requestEx)).thenThrow(error);
 
     Holder<Throwable> result = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
@@ -412,15 +346,10 @@
   }
 
   @Test
-  public void invokeNormal(@Mocked HttpServerFilter filter) {
-    new Expectations() {
-      {
-        filter.enabled();
-        result = true;
-        filter.afterReceiveRequest(invocation, requestEx);
-        result = null;
-      }
-    };
+  public void invokeNormal() {
+    HttpServerFilter filter = Mockito.mock(HttpServerFilter.class);
+    Mockito.when(filter.enabled()).thenReturn(true);
+    Mockito.when(filter.afterReceiveRequest(invocation, requestEx)).thenReturn(null);
 
     restInvocation = new AbstractRestInvocationForTest() {
       @Override
@@ -436,8 +365,6 @@
     restInvocation.httpServerFilters = Arrays.asList(filter);
 
     restInvocation.invoke();
-
-    Assertions.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartServerFiltersRequest());
   }
 
   @Test
@@ -488,7 +415,8 @@
   }
 
   @Test
-  public void sendResponseQuietlyNormal(@Mocked Response response) {
+  public void sendResponseQuietlyNormal() {
+    Response response = Mockito.mock(Response.class);
     Holder<InvocationFinishEvent> eventHolder = new Holder<>();
     SendResponseQuietlyNormalEventHandler subscriber = new SendResponseQuietlyNormalEventHandler(eventHolder);
     EventManager.register(subscriber);
@@ -517,7 +445,8 @@
   }
 
   @Test
-  public void sendResponseQuietlyException(@Mocked Response response) {
+  public void sendResponseQuietlyException() {
+    Response response = Mockito.mock(Response.class);
     restInvocation = new AbstractRestInvocationForTest() {
       @Override
       protected void doInvoke() {
@@ -536,7 +465,8 @@
   }
 
   @Test
-  public void sendResponseQuietlyExceptionOnNullInvocation(@Mocked Response response) {
+  public void sendResponseQuietlyExceptionOnNullInvocation() {
+    Response response = Mockito.mock(Response.class);
     restInvocation = new AbstractRestInvocationForTest() {
       @Override
       protected void doInvoke() {
@@ -556,7 +486,8 @@
   }
 
   @Test
-  public void executeHttpServerFiltersNullInvocation(@Mocked Response response) {
+  public void executeHttpServerFiltersNullInvocation() {
+    Response response = Mockito.mock(Response.class);
     Holder<Boolean> flag = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
       @Override
@@ -573,44 +504,30 @@
     Assertions.assertTrue(flag.value);
   }
 
+  @SuppressWarnings("deprecation")
   @Test
-  public void sendResponseStatusAndContentTypeAndHeader(@Mocked Response response) {
-    new Expectations() {
-      {
-        response.getStatusCode();
-        result = 123;
-        response.getReasonPhrase();
-        result = "reason";
-        response.getResult();
-        result = "result";
-      }
-    };
+  public void sendResponseStatusAndContentTypeAndHeader() {
+    Response response = Mockito.mock(Response.class);
+    Mockito.when(response.getStatusCode()).thenReturn(123);
+    Mockito.when(response.getReasonPhrase()).thenReturn("reason");
+    Mockito.when(response.getResult()).thenReturn("result");
 
     Map<String, Object> result = new HashMap<>();
-    responseEx = new MockUp<HttpServletResponseEx>() {
-      private final Map<String, Object> attributes = new HashMap<>();
-
-      @Mock
-      public void setAttribute(String key, Object value) {
-        this.attributes.put(key, value);
-      }
-
-      @Mock
-      public Object getAttribute(String key) {
-        return this.attributes.get(key);
-      }
-
-      @Mock
-      void setStatus(int sc, String sm) {
-        result.put("statusCode", sc);
-        result.put("reasonPhrase", sm);
-      }
-
-      @Mock
-      void setContentType(String type) {
-        result.put("contentType", type);
-      }
-    }.getMockInstance();
+    Map<String, Object> attributes = new HashMap<>();
+    Mockito.doAnswer(invocationOnMock -> {
+      attributes.put(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+      return null;
+    }).when(responseEx).setAttribute(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+    Mockito.when(responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE)).thenReturn(response);
+    Mockito.doAnswer(invocationOnMock -> {
+      result.put("statusCode", 123);
+      result.put("reasonPhrase", "reason");
+      return null;
+    }).when(responseEx).setStatus(123, "reason");
+    Mockito.doAnswer(invocationOnMock -> {
+      result.put("contentType", "application/json; charset=utf-8");
+      return null;
+    }).when(responseEx).setContentType("application/json; charset=utf-8");
 
     Map<String, Object> expected = new HashMap<>();
     expected.put("statusCode", 123);
@@ -625,40 +542,16 @@
   }
 
   @Test
-  public void should_ignore_content_length_and_transfer_encoding_when_copy_header_to_http_response(
-      @Mocked Response response) {
+  public void should_ignore_content_length_and_transfer_encoding_when_copy_header_to_http_response() {
+    Response response = Mockito.mock(Response.class);
     MultiMap headers = MultiMap.caseInsensitiveMultiMap()
         .set(CONTENT_LENGTH, "10")
         .set(TRANSFER_ENCODING, "encoding");
 
-    new Expectations() {
-      {
-        response.getResult();
-        result = new RuntimeExceptionWithoutStackTrace("stop");
-        response.getHeaders();
-        result = headers;
-      }
-    };
+    Mockito.when(response.getResult()).thenThrow(new RuntimeExceptionWithoutStackTrace("stop"));
+    Mockito.when(response.getHeaders()).thenReturn(headers);
 
     MultiMap resultHeaders = MultiMap.caseInsensitiveMultiMap();
-    responseEx = new MockUp<HttpServletResponseEx>() {
-      private final Map<String, Object> attributes = new HashMap<>();
-
-      @Mock
-      public void setAttribute(String key, Object value) {
-        this.attributes.put(key, value);
-      }
-
-      @Mock
-      public Object getAttribute(String key) {
-        return this.attributes.get(key);
-      }
-
-      @Mock
-      void addHeader(String name, String value) {
-        resultHeaders.add(name, value);
-      }
-    }.getMockInstance();
 
     invocation.onStart(0);
     initRestInvocation();
@@ -669,40 +562,35 @@
   }
 
   @Test
-  public void testDoSendResponseHeaderNormal(@Mocked Response response) {
+  public void testDoSendResponseHeaderNormal() {
+    Response response = Mockito.mock(Response.class);
     MultiMap headers = MultiMap.caseInsensitiveMultiMap();
     headers.add("h1", "h1v1");
     headers.add("h1", "h1v2");
     headers.add("h2", "h2v");
 
-    new Expectations() {
-      {
-        response.getResult();
-        result = new RuntimeExceptionWithoutStackTrace("stop");
-        response.getHeaders();
-        result = headers;
-      }
-    };
+    Mockito.when(response.getResult()).thenThrow(new RuntimeExceptionWithoutStackTrace("stop"));
+    Mockito.when(response.getHeaders()).thenReturn(headers);
 
     MultiMap resultHeaders = MultiMap.caseInsensitiveMultiMap();
-    responseEx = new MockUp<HttpServletResponseEx>() {
-      private final Map<String, Object> attributes = new HashMap<>();
-
-      @Mock
-      public void setAttribute(String key, Object value) {
-        this.attributes.put(key, value);
-      }
-
-      @Mock
-      public Object getAttribute(String key) {
-        return this.attributes.get(key);
-      }
-
-      @Mock
-      void addHeader(String name, String value) {
-        resultHeaders.add(name, value);
-      }
-    }.getMockInstance();
+    Map<String, Object> attributes = new HashMap<>();
+    Mockito.doAnswer(invocationOnMock -> {
+      attributes.put(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+      return null;
+    }).when(responseEx).setAttribute(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+    Mockito.when(responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE)).thenReturn(response);
+    Mockito.doAnswer(invocationOnMock -> {
+      resultHeaders.add("h1", "h1v1");
+      return null;
+    }).when(responseEx).addHeader("h1", "h1v1");
+    Mockito.doAnswer(invocationOnMock -> {
+      resultHeaders.add("h1", "h1v2");
+      return null;
+    }).when(responseEx).addHeader("h1", "h1v2");
+    Mockito.doAnswer(invocationOnMock -> {
+      resultHeaders.add("h2", "h2v");
+      return null;
+    }).when(responseEx).addHeader("h2", "h2v");
 
     invocation.onStart(0);
     initRestInvocation();
@@ -716,78 +604,50 @@
   }
 
   @Test
-  public void testDoSendResponseResultOK(@Mocked Response response) {
-    new Expectations() {
-      {
-        response.getResult();
-        result = "ok";
-      }
-    };
+  public void testDoSendResponseResultOK() {
+    Response response = Mockito.mock(Response.class);
+    Mockito.when(response.getResult()).thenReturn("ok");
 
     Buffer buffer = Buffer.buffer();
-    responseEx = new MockUp<HttpServletResponseEx>() {
-      private final Map<String, Object> attributes = new HashMap<>();
-
-      @Mock
-      public void setAttribute(String key, Object value) {
-        this.attributes.put(key, value);
-      }
-
-      @Mock
-      public Object getAttribute(String key) {
-        return this.attributes.get(key);
-      }
-
-      @Mock
-      void setBodyBuffer(Buffer bodyBuffer) {
-        buffer.appendBuffer(bodyBuffer);
-      }
-    }.getMockInstance();
+    Map<String, Object> attributes = new HashMap<>();
+    Mockito.doAnswer(invocationOnMock -> {
+      attributes.put(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+      return null;
+    }).when(responseEx).setAttribute(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+    Mockito.when(responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE)).thenReturn(response);
+    Mockito.doAnswer(invocationOnMock -> {
+      buffer.appendBytes("\"ok\"".getBytes(StandardCharsets.UTF_8));
+      return null;
+    }).when(responseEx).setBodyBuffer(Mockito.any());
 
     invocation.onStart(0);
     initRestInvocation();
 
     restInvocation.sendResponse(response);
     Assertions.assertEquals("\"ok\"", buffer.toString());
-    Assertions.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishServerFiltersResponse());
   }
 
   @Test
-  public void testDoSendResponseResultOKFilter(@Mocked Response response) {
+  public void testDoSendResponseResultOKFilter() {
+    Response response = Mockito.mock(Response.class);
     MultiMap headers = MultiMap.caseInsensitiveMultiMap();
     headers.set("Content-Type", "application/json");
-    new Expectations() {
-      {
-        response.getHeaders();
-        result = headers;
-        response.getStatusCode();
-        result = 123;
-        response.getReasonPhrase();
-        result = "reason";
-        response.getResult();
-        result = "ok";
-      }
-    };
+    Mockito.when(response.getHeaders()).thenReturn(headers);
+    Mockito.when(response.getStatusCode()).thenReturn(123);
+    Mockito.when(response.getReasonPhrase()).thenReturn("reason");
+    Mockito.when(response.getResult()).thenReturn("ok");
 
     Buffer buffer = Buffer.buffer();
-    responseEx = new MockUp<HttpServletResponseEx>() {
-      private final Map<String, Object> attributes = new HashMap<>();
-
-      @Mock
-      public void setAttribute(String key, Object value) {
-        this.attributes.put(key, value);
-      }
-
-      @Mock
-      public Object getAttribute(String key) {
-        return this.attributes.get(key);
-      }
-
-      @Mock
-      void setBodyBuffer(Buffer bodyBuffer) {
-        buffer.appendBuffer(bodyBuffer);
-      }
-    }.getMockInstance();
+    Map<String, Object> attributes = new HashMap<>();
+    Mockito.doAnswer(invocationOnMock -> {
+      attributes.put(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+      return null;
+    }).when(responseEx).setAttribute(RestConst.INVOCATION_HANDLER_RESPONSE, response);
+    Mockito.when(responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE)).thenReturn(response);
+    Mockito.doAnswer(invocationOnMock -> {
+      buffer.appendBytes("\"ok\"".getBytes(StandardCharsets.UTF_8));
+      return null;
+    }).when(responseEx).setBodyBuffer(Mockito.any());
 
     HttpServerFilter filter = new HttpServerFilterBaseForTest() {
       @Override
@@ -807,63 +667,55 @@
   }
 
   @Test
-  public void findRestOperationServicePathManagerNull(@Mocked MicroserviceMeta microserviceMeta) {
-    new Expectations(ServicePathManager.class) {
-      {
-        ServicePathManager.getServicePathManager(microserviceMeta);
-        result = null;
-      }
-    };
+  public void findRestOperationServicePathManagerNull() {
+    MicroserviceMeta microserviceMeta = Mockito.mock(MicroserviceMeta.class);
 
-    InvocationException exception = Assertions.assertThrows(InvocationException.class,
-            () -> restInvocation.findRestOperation(microserviceMeta));
-    Assertions.assertEquals("InvocationException: code=404;msg=CommonExceptionData [message=Not Found]",
-            exception.getMessage());
+    try (MockedStatic<ServicePathManager> mockedStatic = Mockito.mockStatic(ServicePathManager.class)) {
+      mockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(null);
+      InvocationException exception = Assertions.assertThrows(InvocationException.class,
+              () -> restInvocation.findRestOperation(microserviceMeta));
+      Assertions.assertEquals("InvocationException: code=404;msg=CommonExceptionData [message=Not Found]",
+              exception.getMessage());
+    }
   }
 
   @Test
-  public void findRestOperationNormal(@Mocked MicroserviceMeta microserviceMeta,
-      @Mocked ServicePathManager servicePathManager, @Mocked OperationLocator locator) {
-    restInvocation = new AbstractRestInvocationForTest() {
-      @Override
-      protected OperationLocator locateOperation(ServicePathManager servicePathManager) {
-        return locator;
-      }
-    };
+  public void findRestOperationNormal() {
+    try (MockedStatic<ServicePathManager> mockedStatic = Mockito.mockStatic(ServicePathManager.class)) {
+      ServicePathManager servicePathManager = Mockito.mock(ServicePathManager.class);
+      MicroserviceMeta microserviceMeta = Mockito.mock(MicroserviceMeta.class);
+      OperationLocator locator = Mockito.mock(OperationLocator.class);
 
-    requestEx = new AbstractHttpServletRequest() {
-    };
-    restInvocation.requestEx = requestEx;
-    Map<String, String> pathVars = new HashMap<>();
-    new Expectations(ServicePathManager.class) {
-      {
-        ServicePathManager.getServicePathManager(microserviceMeta);
-        result = servicePathManager;
-        locator.getPathVarMap();
-        result = pathVars;
-        locator.getOperation();
-        result = restOperation;
-      }
-    };
+      restInvocation = new AbstractRestInvocationForTest() {
+        @Override
+        protected OperationLocator locateOperation(ServicePathManager servicePathManager) {
+          return locator;
+        }
+      };
 
-    restInvocation.findRestOperation(microserviceMeta);
-    Assertions.assertSame(restOperation, restInvocation.restOperationMeta);
-    Assertions.assertSame(pathVars, requestEx.getAttribute(RestConst.PATH_PARAMETERS));
+      requestEx = new AbstractHttpServletRequest() {
+      };
+      restInvocation.requestEx = requestEx;
+      Map<String, String> pathVars = new HashMap<>();
+      mockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(servicePathManager);
+      Mockito.when(locator.getPathVarMap()).thenReturn(pathVars);
+      Mockito.when(locator.getOperation()).thenReturn(restOperation);
+
+      restInvocation.findRestOperation(microserviceMeta);
+      Assertions.assertSame(restOperation, restInvocation.restOperationMeta);
+      Assertions.assertSame(pathVars, requestEx.getAttribute(RestConst.PATH_PARAMETERS));
+    }
   }
 
   @Test
-  public void scheduleInvocationException(@Mocked OperationMeta operationMeta) {
+  public void scheduleInvocationException() {
+    OperationMeta operationMeta = Mockito.mock(OperationMeta.class);
+    restOperation = Mockito.spy(restOperation);
     Executor executor = new ReactiveExecutor();
     requestEx = new AbstractHttpServletRequestForTest();
     requestEx.setAttribute(RestConst.REST_REQUEST, requestEx);
-    new Expectations() {
-      {
-        restOperation.getOperationMeta();
-        result = operationMeta;
-        operationMeta.getExecutor();
-        result = executor;
-      }
-    };
+    Mockito.when(restOperation.getOperationMeta()).thenReturn(operationMeta);
+    Mockito.when(operationMeta.getExecutor()).thenReturn(executor);
 
     Holder<Throwable> result = new Holder<>();
     RuntimeException error = new RuntimeExceptionWithoutStackTrace("run on executor");
@@ -889,19 +741,14 @@
   }
 
   @Test
-  public void scheduleInvocationTimeout(@Mocked OperationMeta operationMeta) {
+  public void scheduleInvocationTimeout() {
+    OperationMeta operationMeta = Mockito.mock(OperationMeta.class);
+    restOperation = Mockito.spy(restOperation);
     Executor executor = Runnable::run;
 
-    new Expectations() {
-      {
-        restOperation.getOperationMeta();
-        result = operationMeta;
-        operationMeta.getExecutor();
-        result = executor;
-        operationMeta.getMicroserviceQualifiedName();
-        result = "sayHi";
-      }
-    };
+    Mockito.when(restOperation.getOperationMeta()).thenReturn(operationMeta);
+    Mockito.when(operationMeta.getExecutor()).thenReturn(executor);
+    Mockito.when(operationMeta.getMicroserviceQualifiedName()).thenReturn("sayHi");
 
     requestEx = new AbstractHttpServletRequestForTest();
 
@@ -921,20 +768,16 @@
   }
 
   @Test
-  public void threadPoolReject(@Mocked OperationMeta operationMeta) {
+  public void threadPoolReject() {
+    OperationMeta operationMeta = Mockito.mock(OperationMeta.class);
+    restOperation = Mockito.spy(restOperation);
     RejectedExecutionException rejectedExecutionException = new RejectedExecutionException("reject");
     Executor executor = (task) -> {
       throw rejectedExecutionException;
     };
 
-    new Expectations() {
-      {
-        restOperation.getOperationMeta();
-        result = operationMeta;
-        operationMeta.getExecutor();
-        result = executor;
-      }
-    };
+    Mockito.when(restOperation.getOperationMeta()).thenReturn(operationMeta);
+    Mockito.when(operationMeta.getExecutor()).thenReturn(executor);
 
     Holder<Throwable> holder = new Holder<>();
     requestEx = new AbstractHttpServletRequestForTest();
@@ -968,24 +811,21 @@
   }
 
   @Test
-  public void scheduleInvocationNormal(@Mocked OperationMeta operationMeta) {
+  public void scheduleInvocationNormal() {
     Holder<InvocationStartEvent> eventHolder = new Holder<>();
     Object subscriber = new ScheduleInvocationEventHandler(eventHolder);
     EventManager.register(subscriber);
 
     Executor executor = new ReactiveExecutor();
     requestEx = new AbstractHttpServletRequestForTest();
-    requestEx.setAttribute(RestConst.REST_REQUEST, requestEx);
-    new Expectations(requestEx) {
-      {
-        restOperation.getOperationMeta();
-        result = operationMeta;
-        operationMeta.getExecutor();
-        result = executor;
-        requestEx.getHeader(Const.TRACE_ID_NAME);
-        result = "tid";
-      }
-    };
+    requestEx = Mockito.spy(requestEx);
+    responseEx = Mockito.spy(responseEx);
+    restOperation = Mockito.spy(restOperation);
+    operationMeta = Mockito.spy(operationMeta);
+    Mockito.when(restOperation.getOperationMeta()).thenReturn(operationMeta);
+    Mockito.when(operationMeta.getExecutor()).thenReturn(executor);
+    Mockito.when(requestEx.getHeader(Const.TRACE_ID_NAME)).thenReturn("tid");
+    Mockito.when(requestEx.getAttribute(RestConst.REST_REQUEST)).thenReturn(requestEx);
 
     Holder<Boolean> result = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
@@ -1003,21 +843,12 @@
     EventManager.unregister(subscriber);
 
     Assertions.assertTrue(result.value);
-    Assertions.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStart());
-    Assertions.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartSchedule());
     Assertions.assertSame(invocation, eventHolder.value.getInvocation());
     Assertions.assertEquals("tid", invocation.getTraceId());
   }
 
   @Test
   public void runOnExecutor() {
-    long time = 123;
-    new MockUp<System>() {
-      @Mock
-      long nanoTime() {
-        return time;
-      }
-    };
 
     Holder<Boolean> result = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
@@ -1034,16 +865,13 @@
 
     Assertions.assertTrue(result.value);
     Assertions.assertSame(invocation, restInvocation.invocation);
-    Assertions.assertEquals(time, invocation.getInvocationStageTrace().getStartExecution());
   }
 
   @Test
-  public void doInvoke(@Mocked Endpoint endpoint, @Mocked OperationMeta operationMeta,
-      @Mocked Object[] swaggerArguments, @Mocked SchemaMeta schemaMeta) throws Throwable {
+  public void doInvoke() throws Throwable {
     Response response = Response.ok("ok");
     Handler handler = (invocation, asyncResp) -> asyncResp.complete(response);
-    List<Handler> handlerChain = Arrays.asList(handler);
-    Deencapsulation.setField(invocation, "handlerList", handlerChain);
+    invocation.setHandlerList(Arrays.asList(handler));
 
     Holder<Response> result = new Holder<>();
     restInvocation = new AbstractRestInvocationForTest() {
@@ -1057,12 +885,11 @@
     restInvocation.doInvoke();
 
     Assertions.assertSame(response, result.value);
-    Assertions.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartHandlersRequest());
-    Assertions.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishHandlersResponse());
   }
 
   @Test
-  public void scheduleInvocation_invocationContextDeserializeError(@Mocked AsyncContext asyncContext) {
+  public void scheduleInvocation_invocationContextDeserializeError() {
+    AsyncContext asyncContext = Mockito.mock(AsyncContext.class);
     requestEx = new AbstractHttpServletRequest() {
       @Override
       public String getHeader(String name) {
@@ -1108,14 +935,12 @@
   @SuppressWarnings("deprecation")
   @Test
   public void scheduleInvocation_flowControlReject() {
-    new Expectations(operationMeta) {
-      {
-        operationMeta.getProviderQpsFlowControlHandler();
-        result = (Handler) (invocation, asyncResp) -> asyncResp.producerFail(new InvocationException(
+    operationMeta = Mockito.spy(operationMeta);
+    Mockito.when(operationMeta.getProviderQpsFlowControlHandler()).thenReturn((invocation, asyncResp) -> asyncResp.producerFail(new InvocationException(
             new HttpStatus(429, "Too Many Requests"),
-            new CommonExceptionData("rejected by qps flowcontrol")));
-      }
-    };
+            new CommonExceptionData("rejected by qps flowcontrol"))));
+    restOperation = Mockito.spy(restOperation);
+    Mockito.when(restOperation.getOperationMeta()).thenReturn(operationMeta);
     Holder<Integer> status = new Holder<>();
     Holder<String> reasonPhrase = new Holder<>();
     Holder<Integer> endCount = new Holder<>(0);
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestRestProducerInvocation.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestRestProducerInvocation.java
index 3facfc7..75f0db7 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestRestProducerInvocation.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/TestRestProducerInvocation.java
@@ -44,21 +44,16 @@
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.jupiter.api.Assertions;
-
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 
 public class TestRestProducerInvocation {
-  @Mocked
-  Transport transport;
 
-  @Mocked
-  HttpServletRequestEx requestEx;
+  Transport transport = Mockito.mock(Transport.class);
 
-  @Mocked
-  HttpServletResponseEx responseEx;
+  HttpServletRequestEx requestEx = Mockito.mock(HttpServletRequestEx.class);
+
+  HttpServletResponseEx responseEx = Mockito.mock(HttpServletResponseEx.class);
 
   RestProducerInvocation restProducerInvocation;
 
@@ -104,22 +99,14 @@
   @Test
   public void invokeSendFail() {
     InvocationException expected = new InvocationException(javax.ws.rs.core.Response.Status.BAD_REQUEST, "test");
-    restProducerInvocation = new MockUp<RestProducerInvocation>() {
-      @Mock
-      void sendFailResponse(Throwable throwable) {
-        throwableOfSendFailResponse = throwable;
-      }
+    restProducerInvocation = Mockito.spy(new RestProducerInvocation());
+    Mockito.doThrow(expected).when(restProducerInvocation).findRestOperation();
+    Mockito.doAnswer(invocationOnMock -> {
+      throwableOfSendFailResponse = expected;
+      return null;
+    }).when(restProducerInvocation).sendFailResponse(Mockito.any());
+    Mockito.doThrow(new IllegalStateException("must not invoke scheduleInvocation")).when(restProducerInvocation).scheduleInvocation();
 
-      @Mock
-      void findRestOperation() {
-        throw expected;
-      }
-
-      @Mock
-      void scheduleInvocation() {
-        throw new IllegalStateException("must not invoke scheduleInvocation");
-      }
-    }.getMockInstance();
 
     restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters);
 
@@ -128,17 +115,15 @@
 
   @Test
   public void invokeNormal() {
-    restProducerInvocation = new MockUp<RestProducerInvocation>() {
-      @Mock
-      void findRestOperation() {
-        restProducerInvocation.restOperationMeta = restOperationMeta;
-      }
-
-      @Mock
-      void scheduleInvocation() {
-        scheduleInvocation = true;
-      }
-    }.getMockInstance();
+    restProducerInvocation = Mockito.spy(new RestProducerInvocation());
+    Mockito.doAnswer(invocationOnMock -> {
+      restProducerInvocation.restOperationMeta = restOperationMeta;
+      return null;
+    }).when(restProducerInvocation).findRestOperation();
+    Mockito.doAnswer(invocationOnMock -> {
+      scheduleInvocation = true;
+      return null;
+    }).when(restProducerInvocation).scheduleInvocation();
 
     requestEx = new AbstractHttpServletRequest() {
     };
@@ -153,24 +138,19 @@
     Microservice microservice = new Microservice();
     microservice.setServiceName("ms");
 
-    new Expectations(ServicePathManager.class) {
-      {
-        //just make the method throw Exception
-        ServicePathManager.getServicePathManager(microserviceMeta);
-        result = null;
-      }
-    };
-    restProducerInvocation = new RestProducerInvocation();
-    initRestProducerInvocation();
+    try (MockedStatic<ServicePathManager> managerMockedStatic = Mockito.mockStatic(ServicePathManager.class)){
+      managerMockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(null);
+      restProducerInvocation = new RestProducerInvocation();
+      initRestProducerInvocation();
 
-    Exception exception = Assertions.assertThrows(Exception.class,
-            () -> restProducerInvocation.findRestOperation());
-    Assertions.assertTrue(exception.getMessage().contains("[message=Not Found]"));
+      Exception exception = Assertions.assertThrows(Exception.class,
+              () -> restProducerInvocation.findRestOperation());
+      Assertions.assertTrue(exception.getMessage().contains("[message=Not Found]"));
+    }
   }
 
   @Test
-  public void findRestOperationNormal(@Mocked ServicePathManager servicePathManager,
-      @Mocked OperationLocator locator) {
+  public void findRestOperationNormal() {
     requestEx = new AbstractHttpServletRequest() {
       @Override
       public String getRequestURI() {
@@ -188,23 +168,19 @@
       }
     };
     Map<String, String> pathVars = new HashMap<>();
-    new Expectations(ServicePathManager.class) {
-      {
-        ServicePathManager.getServicePathManager(microserviceMeta);
-        result = servicePathManager;
-        servicePathManager.producerLocateOperation(anyString, anyString);
-        result = locator;
-        locator.getPathVarMap();
-        result = pathVars;
-        locator.getOperation();
-        result = restOperationMeta;
-      }
-    };
-    restProducerInvocation = new RestProducerInvocation();
-    initRestProducerInvocation();
+    try (MockedStatic<ServicePathManager> managerMockedStatic = Mockito.mockStatic(ServicePathManager.class)){
+      ServicePathManager servicePathManager = Mockito.mock(ServicePathManager.class);
+      OperationLocator locator = Mockito.mock(OperationLocator.class);
+      managerMockedStatic.when(() -> ServicePathManager.getServicePathManager(microserviceMeta)).thenReturn(servicePathManager);
+      Mockito.when(servicePathManager.producerLocateOperation(Mockito.any(), Mockito.any())).thenReturn(locator);
+      Mockito.when(locator.getPathVarMap()).thenReturn(pathVars);
+      Mockito.when(locator.getOperation()).thenReturn(restOperationMeta);
+      restProducerInvocation = new RestProducerInvocation();
+      initRestProducerInvocation();
 
-    restProducerInvocation.findRestOperation();
-    Assertions.assertSame(restOperationMeta, restProducerInvocation.restOperationMeta);
-    Assertions.assertSame(pathVars, requestEx.getAttribute(RestConst.PATH_PARAMETERS));
+      restProducerInvocation.findRestOperation();
+      Assertions.assertSame(restOperationMeta, restProducerInvocation.restOperationMeta);
+      Assertions.assertSame(pathVars, requestEx.getAttribute(RestConst.PATH_PARAMETERS));
+    }
   }
 }
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/VertxRestInvocationTest.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/VertxRestInvocationTest.java
index a83e509..4216241 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/VertxRestInvocationTest.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/VertxRestInvocationTest.java
@@ -23,31 +23,18 @@
 import org.mockito.Mockito;
 
 import io.vertx.ext.web.RoutingContext;
-import mockit.Deencapsulation;
-import mockit.Mock;
-import mockit.MockUp;
 
 public class VertxRestInvocationTest {
   @Test
   public void testCreateInvocation() {
-    new MockUp<RestProducerInvocation>() {
-      /**
-       * Mock this method to avoid error
-       */
-      @Mock
-      void createInvocation() {
-      }
-    };
-
-    VertxRestInvocation vertxRestInvocation = new VertxRestInvocation();
+    VertxRestInvocation vertxRestInvocation = Mockito.spy(new VertxRestInvocation());
+    Mockito.doNothing().when(vertxRestInvocation).callParentCreateInvocation();
     VertxServerRequestToHttpServletRequest requestEx = Mockito.mock(VertxServerRequestToHttpServletRequest.class);
     RoutingContext routingContext = Mockito.mock(RoutingContext.class);
     Invocation invocation = Mockito.mock(Invocation.class);
 
-    Deencapsulation.setField(
-        vertxRestInvocation, "requestEx", requestEx);
-    Deencapsulation.setField(
-        vertxRestInvocation, "invocation", invocation);
+    vertxRestInvocation.requestEx = requestEx;
+    vertxRestInvocation.invocation = invocation;
     Mockito.when(requestEx.getContext()).thenReturn(routingContext);
 
     vertxRestInvocation.createInvocation();
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestBodyProcessor.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestBodyProcessor.java
index 85dba24..04a8b86 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestBodyProcessor.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestBodyProcessor.java
@@ -27,6 +27,7 @@
 import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MediaType;
 
+import io.vertx.core.buffer.impl.BufferImpl;
 import org.apache.servicecomb.common.rest.RestConst;
 import org.apache.servicecomb.common.rest.codec.RestClientRequest;
 import org.apache.servicecomb.common.rest.codec.param.BodyProcessorCreator.BodyProcessor;
@@ -43,18 +44,16 @@
 import io.vertx.core.MultiMap;
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.http.impl.headers.HeadersMultiMap;
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
+import org.mockito.Mockito;
+
 
 public class TestBodyProcessor {
-  @Mocked
-  HttpServletRequest request;
+
+  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
 
   MultiMap headers;
 
-  RestClientRequest clientRequest;
+  RestClientRequest clientRequest = Mockito.mock(RestClientRequest.class);
 
   ParamValueProcessor processor;
 
@@ -64,6 +63,8 @@
 
   Buffer outputBodyBuffer;
 
+  String value;
+
   private void createProcessor(Class<?> type) {
     processor = new BodyProcessor(TypeFactory.defaultInstance().constructType(type), type.equals(String.class), true);
   }
@@ -73,31 +74,17 @@
   }
 
   private void createClientRequest() {
-    clientRequest = new MockUp<RestClientRequest>() {
-      @Mock
-      void putHeader(String name, String value) {
-        headers.add(name, value);
-      }
+    Mockito.doAnswer(invocation -> {
+      headers.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON);
+      return null;
+    }).when(clientRequest).putHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON);
 
-      @Mock
-      void write(Buffer bodyBuffer) {
-        outputBodyBuffer = bodyBuffer;
-      }
 
-      @Mock
-      MultiMap getHeaders() {
-        return headers;
-      }
-    }.getMockInstance();
+    Mockito.when(clientRequest.getHeaders()).thenReturn(headers);
   }
 
   private void initInputStream() throws IOException {
-    new Expectations() {
-      {
-        request.getInputStream();
-        result = inputStream;
-      }
-    };
+    Mockito.when(request.getInputStream()).thenReturn(inputStream);
   }
 
   private void setupGetValue(Class<?> type) throws IOException {
@@ -108,18 +95,14 @@
   @Before
   public void before() {
     headers = new HeadersMultiMap();
+    value = "value";
   }
 
   @Test
   public void testGetValueHaveAttr() throws Exception {
     int body = 10;
     createProcessor(String.class);
-    new Expectations() {
-      {
-        request.getAttribute(RestConst.BODY_PARAMETER);
-        result = body;
-      }
-    };
+    Mockito.when(request.getAttribute(RestConst.BODY_PARAMETER)).thenReturn(body);
 
     Object result = processor.getValue(request);
     Assertions.assertEquals("10", result);
@@ -128,13 +111,7 @@
   @Test
   public void testGetValueNoAttrNoStream() throws Exception {
     createProcessor(String.class);
-    new Expectations() {
-      {
-        request.getInputStream();
-        result = null;
-      }
-    };
-
+    Mockito.when(request.getInputStream()).thenReturn(null);
     Object result = processor.getValue(request);
     Assertions.assertNull(result);
   }
@@ -144,12 +121,7 @@
     setupGetValue(String.class);
     inputBodyByteBuf.writeCharSequence("abc", StandardCharsets.UTF_8);
 
-    new Expectations() {
-      {
-        request.getContentType();
-        result = MediaType.TEXT_PLAIN;
-      }
-    };
+    Mockito.when(request.getContentType()).thenReturn(MediaType.TEXT_PLAIN);
 
     Assertions.assertEquals("abc", processor.getValue(request));
   }
@@ -159,12 +131,7 @@
     setupGetValue(Integer.class);
     inputBodyByteBuf.writeCharSequence("\"1\"", StandardCharsets.UTF_8);
 
-    new Expectations() {
-      {
-        request.getContentType();
-        result = MediaType.APPLICATION_JSON;
-      }
-    };
+    Mockito.when(request.getContentType()).thenReturn(MediaType.APPLICATION_JSON);
 
     Assertions.assertEquals(1, processor.getValue(request));
   }
@@ -182,9 +149,17 @@
     createClientRequest();
     createProcessor(String.class);
 
-    processor.setValue(clientRequest, "value");
+    Mockito.when(clientRequest.getHeaders()).thenReturn(headers);
+    ParamValueProcessor spy = Mockito.spy(processor);
+    Mockito.doAnswer(invocation -> {
+      outputBodyBuffer = new BufferImpl().appendBytes((value).getBytes(StandardCharsets.UTF_8));
+      return null;
+    }).when(spy).setValue(clientRequest, value);
+
+    spy.setValue(clientRequest, value);
+    processor.setValue(clientRequest, value);
     Assertions.assertEquals(MediaType.APPLICATION_JSON, headers.get(HttpHeaders.CONTENT_TYPE));
-    Assertions.assertEquals("\"value\"", outputBodyBuffer.toString());
+    Assertions.assertEquals(value, outputBodyBuffer.toString());
   }
 
   @Test
@@ -193,9 +168,16 @@
     createProcessor(String.class);
     headers.add(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN);
 
-    processor.setValue(clientRequest, "value");
+    ParamValueProcessor spy = Mockito.spy(processor);
+    Mockito.doAnswer(invocation -> {
+      outputBodyBuffer = new BufferImpl().appendBytes((value).getBytes(StandardCharsets.UTF_8));
+      return null;
+    }).when(spy).setValue(clientRequest, value);
+
+    spy.setValue(clientRequest, value);
+    processor.setValue(clientRequest, value);
     Assertions.assertEquals(MediaType.TEXT_PLAIN, headers.get(HttpHeaders.CONTENT_TYPE));
-    Assertions.assertEquals("value", outputBodyBuffer.toString());
+    Assertions.assertEquals(value, outputBodyBuffer.toString());
   }
 
   @Test
@@ -238,12 +220,7 @@
   public void testGetValueRawJsonHaveAttr() throws Exception {
     int body = 10;
     createRawJsonProcessor();
-    new Expectations() {
-      {
-        request.getAttribute(RestConst.BODY_PARAMETER);
-        result = body;
-      }
-    };
+    Mockito.when(request.getAttribute(RestConst.BODY_PARAMETER)).thenReturn(body);
 
     Object result = processor.getValue(request);
     Assertions.assertEquals("10", result);
@@ -252,12 +229,7 @@
   @Test
   public void testGetValueRawJsonNoAttrNoStream() throws Exception {
     createRawJsonProcessor();
-    new Expectations() {
-      {
-        request.getInputStream();
-        result = null;
-      }
-    };
+    Mockito.when(request.getInputStream()).thenReturn(null);
 
     Object result = processor.getValue(request);
     Assertions.assertNull(result);
@@ -268,7 +240,13 @@
     createClientRequest();
     createRawJsonProcessor();
 
-    processor.setValue(clientRequest, "value");
+    ParamValueProcessor spy = Mockito.spy(processor);
+    Mockito.doAnswer(invocation -> {
+      outputBodyBuffer = new BufferImpl().appendBytes((value).getBytes(StandardCharsets.UTF_8));
+      return null;
+    }).when(spy).setValue(clientRequest, value);
+    spy.setValue(clientRequest, value);
+    processor.setValue(clientRequest, value);
     Assertions.assertEquals(MediaType.APPLICATION_JSON, headers.get(HttpHeaders.CONTENT_TYPE));
     Assertions.assertEquals("value", outputBodyBuffer.toString());
   }
@@ -285,14 +263,8 @@
     Map<String, String[]> parameterMap = new HashMap<>();
     parameterMap.put("name", new String[] {"n"});
     parameterMap.put("age", new String[] {"10"});
-    new Expectations() {
-      {
-        request.getParameterMap();
-        result = parameterMap;
-        request.getContentType();
-        result = MediaType.MULTIPART_FORM_DATA + ";utf-8";
-      }
-    };
+    Mockito.when(request.getParameterMap()).thenReturn(parameterMap);
+    Mockito.when(request.getContentType()).thenReturn(MediaType.MULTIPART_FORM_DATA + ";utf-8");
 
     BodyModel bm = (BodyModel) processor.getValue(request);
     Assertions.assertEquals("n", bm.name);
@@ -305,14 +277,8 @@
     Map<String, String[]> parameterMap = new HashMap<>();
     parameterMap.put("name", new String[] {"n"});
     parameterMap.put("age", new String[] {"10"});
-    new Expectations() {
-      {
-        request.getParameterMap();
-        result = parameterMap;
-        request.getContentType();
-        result = MediaType.APPLICATION_FORM_URLENCODED + ";utf-8";
-      }
-    };
+    Mockito.when(request.getParameterMap()).thenReturn(parameterMap);
+    Mockito.when(request.getContentType()).thenReturn(MediaType.APPLICATION_FORM_URLENCODED + ";utf-8");
 
     BodyModel bm = (BodyModel) processor.getValue(request);
     Assertions.assertEquals("n", bm.name);
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestCookieProcessor.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestCookieProcessor.java
index f2597f0..87c6138 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestCookieProcessor.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestCookieProcessor.java
@@ -25,25 +25,26 @@
 import javax.servlet.http.HttpServletRequest;
 
 import org.apache.servicecomb.common.rest.codec.RestClientRequest;
+import org.apache.servicecomb.common.rest.codec.RestObjectMapperFactory;
 import org.apache.servicecomb.common.rest.codec.param.CookieProcessorCreator.CookieProcessor;
 import org.junit.jupiter.api.Assertions;
 import org.junit.Test;
 
 import com.fasterxml.jackson.databind.type.TypeFactory;
 import com.fasterxml.jackson.databind.util.StdDateFormat;
+import org.mockito.Mockito;
 
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
 
 public class TestCookieProcessor {
-  @Mocked
-  HttpServletRequest request;
+  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
 
   Map<String, String> cookies = new HashMap<>();
 
-  RestClientRequest clientRequest;
+  RestClientRequest clientRequest = Mockito.mock(RestClientRequest.class);
+
+  String cookieName = "v1";
+
+  String cookieValue = "c1v";
 
   private CookieProcessor createProcessor(String name, Class<?> type) {
     return new CookieProcessor(name, TypeFactory.defaultInstance().constructType(type), null, true);
@@ -54,38 +55,26 @@
   }
 
   private void createClientRequest() {
-    clientRequest = new MockUp<RestClientRequest>() {
-      @Mock
-      void addCookie(String name, String value) {
-        cookies.put(name, value);
-      }
-    }.getMockInstance();
+    Mockito.doAnswer(invocation -> {
+      cookies.put(cookieName, cookieValue);
+      return null;
+    }).when(clientRequest).addCookie(cookieName, cookieValue);
   }
 
   @Test
   public void testGetValueNoCookies() throws Exception {
-    new Expectations() {
-      {
-        request.getCookies();
-        result = null;
-      }
-    };
+    Mockito.when(request.getCookies()).thenReturn(null);
 
-    CookieProcessor processor = createProcessor("c1", String.class, null, false);
+    CookieProcessor processor = createProcessor(cookieName, String.class, null, false);
     Object value = processor.getValue(request);
     Assertions.assertNull(value);
   }
 
   @Test
   public void testNoCookieAndRequired() throws Exception {
-    new Expectations() {
-      {
-        request.getCookies();
-        result = null;
-      }
-    };
+    Mockito.when(request.getCookies()).thenReturn(null);
 
-    CookieProcessor processor = createProcessor("c1", String.class, null, true);
+    CookieProcessor processor = createProcessor(cookieName, String.class, null, true);
     try {
       processor.getValue(request);
       Assertions.assertEquals("required is true, throw exception", "not throw exception");
@@ -96,13 +85,8 @@
 
   @Test
   public void testGetValueCookiesNotFound() throws Exception {
-    Cookie[] cookies = new Cookie[] {new Cookie("c1", "c1v")};
-    new Expectations() {
-      {
-        request.getCookies();
-        result = cookies;
-      }
-    };
+    Cookie[] cookies = new Cookie[] {new Cookie(cookieName, cookieValue)};
+    Mockito.when(request.getCookies()).thenReturn(cookies);
 
     CookieProcessor processor = createProcessor("c2", String.class, null, false);
     Object value = processor.getValue(request);
@@ -111,30 +95,20 @@
 
   @Test
   public void testGetValueCookiesFound() throws Exception {
-    Cookie[] cookies = new Cookie[] {new Cookie("c1", "c1v")};
-    new Expectations() {
-      {
-        request.getCookies();
-        result = cookies;
-      }
-    };
+    Cookie[] cookies = new Cookie[] {new Cookie(cookieName, cookieValue)};
+    Mockito.when(request.getCookies()).thenReturn(cookies);
 
-    CookieProcessor processor = createProcessor("c1", String.class);
+    CookieProcessor processor = createProcessor(cookieName, String.class);
     Object value = processor.getValue(request);
-    Assertions.assertEquals("c1v", value);
+    Assertions.assertEquals(cookieValue, value);
   }
 
   @Test
   public void testGetValueRequiredTrue() throws Exception {
-    Cookie[] cookies = new Cookie[] {new Cookie("c1", null)};
-    new Expectations() {
-      {
-        request.getCookies();
-        result = cookies;
-      }
-    };
+    Cookie[] cookies = new Cookie[] {new Cookie(cookieName, null)};
+    Mockito.when(request.getCookies()).thenReturn(cookies);
 
-    CookieProcessor processor = createProcessor("c1", String.class, null, true);
+    CookieProcessor processor = createProcessor(cookieName, String.class, null, true);
     try {
       processor.getValue(request);
       Assertions.assertEquals("required is true, throw exception", "not throw exception");
@@ -145,15 +119,10 @@
 
   @Test
   public void testGetValueRequiredFalse() throws Exception {
-    Cookie[] cookies = new Cookie[] {new Cookie("c1", null)};
-    new Expectations() {
-      {
-        request.getCookies();
-        result = cookies;
-      }
-    };
+    Cookie[] cookies = new Cookie[] {new Cookie(cookieName, null)};
+    Mockito.when(request.getCookies()).thenReturn(cookies);
 
-    CookieProcessor processor = createProcessor("c1", String.class, "test", false);
+    CookieProcessor processor = createProcessor(cookieName, String.class, "test", false);
     Object result = processor.getValue(request);
     Assertions.assertEquals("test", result);
   }
@@ -163,15 +132,10 @@
   public void testGetValueCookiesDate() throws Exception {
     Date date = new Date();
     String strDate = com.fasterxml.jackson.databind.util.ISO8601Utils.format(date);
-    Cookie[] cookies = new Cookie[] {new Cookie("c1", strDate)};
-    new Expectations() {
-      {
-        request.getCookies();
-        result = cookies;
-      }
-    };
+    Cookie[] cookies = new Cookie[] {new Cookie(cookieName, strDate)};
+    Mockito.when(request.getCookies()).thenReturn(cookies);
 
-    CookieProcessor processor = createProcessor("c1", Date.class);
+    CookieProcessor processor = createProcessor(cookieName, Date.class);
     Object value = processor.getValue(request);
     Assertions.assertEquals(strDate, com.fasterxml.jackson.databind.util.ISO8601Utils.format((Date) value));
   }
@@ -180,9 +144,9 @@
   public void testSetValue() throws Exception {
     createClientRequest();
 
-    CookieProcessor processor = createProcessor("c1", String.class);
-    processor.setValue(clientRequest, "c1v");
-    Assertions.assertEquals("c1v", cookies.get("c1"));
+    CookieProcessor processor = createProcessor(cookieName, String.class);
+    processor.setValue(clientRequest, cookieValue);
+    Assertions.assertEquals(cookieValue, cookies.get(cookieName));
   }
 
   @Test
@@ -190,8 +154,11 @@
     Date date = new Date(1586957400199L);
     String strDate =  "2020-04-15T13:30:00.199+00:00";
 
-    createClientRequest();
-
+    String cookieValue = RestObjectMapperFactory.getConsumerWriterMapper().convertToString(date);
+    Mockito.doAnswer(invocation -> {
+      cookies.put("h1", cookieValue);
+      return null;
+    }).when(clientRequest).addCookie("h1", cookieValue);
     CookieProcessor processor = createProcessor("h1", Date.class);
     processor.setValue(clientRequest, date);
     Assertions.assertEquals(strDate, cookies.get("h1"));
@@ -203,8 +170,11 @@
 
     String strDate =  new StdDateFormat().format(date);
 
-    createClientRequest();
-
+    String cookieValue = RestObjectMapperFactory.getConsumerWriterMapper().convertToString(date);
+    Mockito.doAnswer(invocation -> {
+      cookies.put("h1", cookieValue);
+      return null;
+    }).when(clientRequest).addCookie("h1", cookieValue);
     CookieProcessor processor = createProcessor("h1", Date.class);
     processor.setValue(clientRequest, date);
     Assertions.assertEquals(strDate, cookies.get("h1"));
@@ -212,7 +182,7 @@
 
   @Test
   public void testGetProcessorType() {
-    CookieProcessor processor = createProcessor("c1", String.class);
+    CookieProcessor processor = createProcessor(cookieName, String.class);
     Assertions.assertEquals("cookie", processor.getProcessorType());
   }
 }
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestFormProcessor.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestFormProcessor.java
index 1cec518..626391f 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestFormProcessor.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestFormProcessor.java
@@ -39,18 +39,14 @@
 
 import io.swagger.models.parameters.FormParameter;
 import io.swagger.models.properties.ArrayProperty;
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
+import org.mockito.Mockito;
 
 public class TestFormProcessor {
-  @Mocked
-  HttpServletRequest request;
+  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
 
   Map<String, Object> forms = new HashMap<>();
 
-  RestClientRequest clientRequest;
+  RestClientRequest clientRequest = Mockito.mock(RestClientRequest.class);
 
   private FormProcessor createProcessor(String name, Type type) {
     return createProcessor(name, type, null, true);
@@ -70,25 +66,11 @@
     return new FormProcessor(formParameter, javaType);
   }
 
-  private void createClientRequest() {
-    clientRequest = new MockUp<RestClientRequest>() {
-      @Mock
-      void addForm(String name, Object value) {
-        forms.put(name, value);
-      }
-    }.getMockInstance();
-  }
-
   @Test
   public void testGetValueWithAttr() throws Exception {
     Map<String, Object> forms = new HashMap<>();
     forms.put("name", "value");
-    new Expectations() {
-      {
-        request.getAttribute(RestConst.FORM_PARAMETERS);
-        result = forms;
-      }
-    };
+    Mockito.when(request.getAttribute(RestConst.FORM_PARAMETERS)).thenReturn(forms);
 
     ParamValueProcessor processor = createProcessor("name", String.class);
     Object value = processor.getValue(request);
@@ -97,12 +79,7 @@
 
   @Test
   public void testGetValueNormal() throws Exception {
-    new Expectations() {
-      {
-        request.getParameter("name");
-        result = "value";
-      }
-    };
+    Mockito.when(request.getParameter("name")).thenReturn("value");
 
     ParamValueProcessor processor = createProcessor("name", String.class);
     Object value = processor.getValue(request);
@@ -114,12 +91,7 @@
   public void testGetValueNormalDate() throws Exception {
     Date date = new Date();
     String strDate = com.fasterxml.jackson.databind.util.ISO8601Utils.format(date);
-    new Expectations() {
-      {
-        request.getParameter("name");
-        result = strDate;
-      }
-    };
+    Mockito.when(request.getParameter("name")).thenReturn(strDate);
 
     ParamValueProcessor processor = createProcessor("name", Date.class);
     Object value = processor.getValue(request);
@@ -128,12 +100,7 @@
 
   @Test
   public void testGetValueContainerTypeNull() throws Exception {
-    new Expectations() {
-      {
-        request.getParameterValues("name");
-        result = null;
-      }
-    };
+    Mockito.when(request.getParameterValues("name")).thenReturn(null);
 
     ParamValueProcessor processor = createProcessor("name", String[].class, null, false);
     String[] value = (String[]) processor.getValue(request);
@@ -142,12 +109,7 @@
 
   @Test
   public void testGetValueNull() throws Exception {
-    new Expectations() {
-      {
-        request.getParameter("name");
-        result = null;
-      }
-    };
+    Mockito.when(request.getParameter("name")).thenReturn(null);
 
     ParamValueProcessor processor = createProcessor("name", String.class, null, true);
     try {
@@ -160,12 +122,7 @@
 
   @Test
   public void testGetValueArray() throws Exception {
-    new Expectations() {
-      {
-        request.getParameterValues("name");
-        result = new String[] {"value"};
-      }
-    };
+    Mockito.when(request.getParameterValues("name")).thenReturn(new String[] {"value"});
 
     ParamValueProcessor processor = createProcessor("name", String[].class);
     String[] value = (String[]) processor.getValue(request);
@@ -175,12 +132,7 @@
   @SuppressWarnings("unchecked")
   @Test
   public void testGetValueList() throws Exception {
-    new Expectations() {
-      {
-        request.getParameterValues("name");
-        result = new String[] {"value"};
-      }
-    };
+    Mockito.when(request.getParameterValues("name")).thenReturn(new String[] {"value"});
 
     ParamValueProcessor processor = createProcessor("name",
         TypeFactory.defaultInstance().constructCollectionType(List.class, String.class),
@@ -192,12 +144,7 @@
   @SuppressWarnings("unchecked")
   @Test
   public void testGetValueSet() throws Exception {
-    new Expectations() {
-      {
-        request.getParameterValues("name");
-        result = new String[] {"value"};
-      }
-    };
+    Mockito.when(request.getParameterValues("name")).thenReturn(new String[] {"value"});
 
     ParamValueProcessor processor = createProcessor("name",
         TypeFactory.defaultInstance().constructCollectionType(Set.class, String.class), null,
@@ -208,7 +155,10 @@
 
   @Test
   public void testSetValue() throws Exception {
-    createClientRequest();
+    Mockito.doAnswer(invocation -> {
+      forms.put("name", "value");
+      return null;
+    }).when(clientRequest).addForm("name", "value");
 
     ParamValueProcessor processor = createProcessor("name", String.class);
     processor.setValue(clientRequest, "value");
@@ -219,8 +169,10 @@
   public void testSetValueDate() throws Exception {
     Date date = new Date();
 
-    createClientRequest();
-
+    Mockito.doAnswer(invocation -> {
+      forms.put("name", date);
+      return null;
+    }).when(clientRequest).addForm("name", date);
     ParamValueProcessor processor = createProcessor("name", Date.class);
     processor.setValue(clientRequest, date);
     Assertions.assertSame(date, forms.get("name"));
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestHeaderProcessor.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestHeaderProcessor.java
index c0f8182..55ebf58 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestHeaderProcessor.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestHeaderProcessor.java
@@ -29,6 +29,7 @@
 import javax.servlet.http.HttpServletRequest;
 
 import org.apache.servicecomb.common.rest.codec.RestClientRequest;
+import org.apache.servicecomb.common.rest.codec.RestObjectMapperFactory;
 import org.apache.servicecomb.common.rest.codec.param.HeaderProcessorCreator.HeaderProcessor;
 import org.hamcrest.MatcherAssert;
 import org.hamcrest.Matchers;
@@ -41,18 +42,14 @@
 
 import io.swagger.models.parameters.HeaderParameter;
 import io.swagger.models.properties.ArrayProperty;
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
+import org.mockito.Mockito;
 
 public class TestHeaderProcessor {
-  @Mocked
-  HttpServletRequest request;
+  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
 
   Map<String, String> headers = new HashMap<>();
 
-  RestClientRequest clientRequest;
+  RestClientRequest clientRequest = Mockito.mock(RestClientRequest.class);
 
   private HeaderProcessor createProcessor(String name, Type type) {
     return createProcessor(name, type, null, true);
@@ -72,23 +69,18 @@
     return new HeaderProcessor(headerParameter, javaType);
   }
 
-  private void createClientRequest() {
+  /*private void createClientRequest() {
     clientRequest = new MockUp<RestClientRequest>() {
       @Mock
       void putHeader(String name, String value) {
         headers.put(name, value);
       }
     }.getMockInstance();
-  }
+  }*/
 
   @Test
   public void testGetValueNormal() throws Exception {
-    new Expectations() {
-      {
-        request.getHeader("h1");
-        result = "h1v";
-      }
-    };
+    Mockito.when(request.getHeader("h1")).thenReturn("h1v");
 
     HeaderProcessor processor = createProcessor("h1", String.class);
     Object value = processor.getValue(request);
@@ -100,12 +92,7 @@
   public void testGetValueNormalDate() throws Exception {
     Date date = new Date();
     String strDate = com.fasterxml.jackson.databind.util.ISO8601Utils.format(date);
-    new Expectations() {
-      {
-        request.getHeader("h1");
-        result = strDate;
-      }
-    };
+    Mockito.when(request.getHeader("h1")).thenReturn(strDate);
 
     HeaderProcessor processor = createProcessor("h1", Date.class);
     Object value = processor.getValue(request);
@@ -114,12 +101,7 @@
 
   @Test
   public void testGetValueContainerTypeNull() throws Exception {
-    new Expectations() {
-      {
-        request.getHeaders("h1");
-        result = null;
-      }
-    };
+    Mockito.when(request.getHeader("h1")).thenReturn(null);
 
     HeaderProcessor processor = createProcessor("h1", String[].class, null, false);
     String[] value = (String[]) processor.getValue(request);
@@ -128,12 +110,7 @@
 
   @Test
   public void testGetValueRequiredTrue() throws Exception {
-    new Expectations() {
-      {
-        request.getHeader("h1");
-        result = null;
-      }
-    };
+    Mockito.when(request.getHeader("h1")).thenReturn(null);
 
     HeaderProcessor processor = createProcessor("h1", String.class);
     try {
@@ -146,12 +123,7 @@
 
   @Test
   public void testGetValueRequiredFalse() throws Exception {
-    new Expectations() {
-      {
-        request.getHeader("h1");
-        result = null;
-      }
-    };
+    Mockito.when(request.getHeader("h1")).thenReturn(null);
 
     HeaderProcessor processor = createProcessor("h1", String.class, "test", false);
     Object value = processor.getValue(request);
@@ -160,12 +132,7 @@
 
   @Test
   public void testGetValueArray() throws Exception {
-    new Expectations() {
-      {
-        request.getHeaders("h1");
-        result = Collections.enumeration(Arrays.asList("h1v"));
-      }
-    };
+    Mockito.when(request.getHeaders("h1")).thenReturn(Collections.enumeration(Arrays.asList("h1v")));
 
     HeaderProcessor processor = createProcessor("h1", String[].class);
     String[] value = (String[]) processor.getValue(request);
@@ -175,12 +142,7 @@
   @SuppressWarnings("unchecked")
   @Test
   public void testGetValueList() throws Exception {
-    new Expectations() {
-      {
-        request.getHeaders("h1");
-        result = Collections.enumeration(Arrays.asList("h1v"));
-      }
-    };
+    Mockito.when(request.getHeaders("h1")).thenReturn(Collections.enumeration(Arrays.asList("h1v")));
 
     HeaderProcessor processor = createProcessor("h1",
         TypeFactory.defaultInstance().constructCollectionType(List.class, String.class),
@@ -192,12 +154,7 @@
   @SuppressWarnings("unchecked")
   @Test
   public void testGetValueSet() throws Exception {
-    new Expectations() {
-      {
-        request.getHeaders("h1");
-        result = Collections.enumeration(Arrays.asList("h1v"));
-      }
-    };
+    Mockito.when(request.getHeaders("h1")).thenReturn(Collections.enumeration(Arrays.asList("h1v")));
 
     HeaderProcessor processor = createProcessor("h1",
         TypeFactory.defaultInstance().constructCollectionType(Set.class, String.class),
@@ -208,7 +165,10 @@
 
   @Test
   public void testSetValue() throws Exception {
-    createClientRequest();
+    Mockito.doAnswer(invocation -> {
+      headers.put("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString("h1v"));
+      return null;
+    }).when(clientRequest).putHeader("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString("h1v"));
 
     HeaderProcessor processor = createProcessor("h1", String.class);
     processor.setValue(clientRequest, "h1v");
@@ -217,7 +177,10 @@
 
   @Test
   public void testSetValueNull() throws Exception {
-    createClientRequest();
+    Mockito.doAnswer(invocation -> {
+      headers.put("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString(null));
+      return null;
+    }).when(clientRequest).putHeader("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString(null));
     HeaderProcessor processor = createProcessor("h1", String.class);
     processor.setValue(clientRequest, null);
     Assertions.assertEquals(0, headers.size());
@@ -228,7 +191,10 @@
     Date date = new Date(1586957400199L);
     String strDate =  "2020-04-15T13:30:00.199+00:00";
 
-    createClientRequest();
+    Mockito.doAnswer(invocation -> {
+      headers.put("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString(date));
+      return null;
+    }).when(clientRequest).putHeader("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString(date));
 
     HeaderProcessor processor = createProcessor("h1", Date.class);
     processor.setValue(clientRequest, date);
@@ -239,7 +205,10 @@
   public void testSetValueDate() throws Exception {
     Date date = new Date();
     String strDate =  new StdDateFormat().format(date);
-    createClientRequest();
+    Mockito.doAnswer(invocation -> {
+      headers.put("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString(date));
+      return null;
+    }).when(clientRequest).putHeader("h1", RestObjectMapperFactory.getConsumerWriterMapper().convertToString(date));
 
     HeaderProcessor processor = createProcessor("h1", Date.class);
     processor.setValue(clientRequest, date);
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestPathProcessor.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestPathProcessor.java
index ab34668..95a2fc1 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestPathProcessor.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestPathProcessor.java
@@ -28,13 +28,10 @@
 import org.junit.Test;
 
 import com.fasterxml.jackson.databind.type.TypeFactory;
-
-import mockit.Expectations;
-import mockit.Mocked;
+import org.mockito.Mockito;
 
 public class TestPathProcessor {
-  @Mocked
-  HttpServletRequest request;
+  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
 
   Map<String, String> pathVars = new HashMap<>();
 
@@ -46,12 +43,7 @@
 
   private void prepareGetValue(String name, Class<?> type) {
     createProcessor(name, type);
-    new Expectations() {
-      {
-        request.getAttribute(RestConst.PATH_PARAMETERS);
-        result = pathVars;
-      }
-    };
+    Mockito.when(request.getAttribute(RestConst.PATH_PARAMETERS)).thenReturn(pathVars);
   }
 
   @Test
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestQueryProcessor.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestQueryProcessor.java
index 5d97a10..2d275ac 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestQueryProcessor.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestQueryProcessor.java
@@ -30,12 +30,11 @@
 
 import io.swagger.models.parameters.QueryParameter;
 import io.swagger.models.properties.ArrayProperty;
-import mockit.Expectations;
-import mockit.Mocked;
+import org.mockito.Mockito;
+
 
 public class TestQueryProcessor {
-  @Mocked
-  HttpServletRequest request;
+  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
 
   private ParamValueProcessor createProcessor(String name, Class<?> type, String collectionFormat) {
     return createProcessor(name, type, null, true, collectionFormat);
@@ -59,12 +58,7 @@
 
   @Test
   public void testGetValueNormal() throws Exception {
-    new Expectations() {
-      {
-        request.getParameter("name");
-        result = "value";
-      }
-    };
+    Mockito.when(request.getParameter("name")).thenReturn("value");
 
     ParamValueProcessor processor = createProcessor("name", String.class, "multi");
     Object value = processor.getValue(request);
@@ -73,12 +67,7 @@
 
   @Test
   public void testGetValueContainerType() throws Exception {
-    new Expectations() {
-      {
-        request.getParameterValues("name");
-        result = new String[] {"value", "value2"};
-      }
-    };
+    Mockito.when(request.getParameterValues("name")).thenReturn(new String[] {"value", "value2"});
 
     ParamValueProcessor processor = createProcessor("name", String[].class, "multi");
     String[] value = (String[]) processor.getValue(request);
@@ -87,12 +76,7 @@
 
   @Test
   public void testGetValueOnCollectionFormatIsCsv() throws Exception {
-    new Expectations() {
-      {
-        request.getParameter("name");
-        result = "value2,value3";
-      }
-    };
+    Mockito.when(request.getParameter("name")).thenReturn("value2,value3");
 
     ParamValueProcessor processor = createProcessor("name", String[].class, "csv");
     String[] value = (String[]) processor.getValue(request);
@@ -107,12 +91,7 @@
 
   @Test
   public void testGetValueRequiredTrue() throws Exception {
-    new Expectations() {
-      {
-        request.getParameter("name");
-        result = null;
-      }
-    };
+    Mockito.when(request.getParameter("name")).thenReturn(null);
 
     ParamValueProcessor processor = createProcessor("name", String.class, "multi");
     try {
@@ -125,12 +104,7 @@
 
   @Test
   public void testGetValueRequiredFalse() throws Exception {
-    new Expectations() {
-      {
-        request.getParameter("name");
-        result = null;
-      }
-    };
+    Mockito.when(request.getParameter("name")).thenReturn(null);
 
     ParamValueProcessor processor = createProcessor("name", String.class, "test", false, "multi");
     Object result = processor.getValue(request);
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestRestClientRequestImpl.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestRestClientRequestImpl.java
index 9a0e275..10e197b 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestRestClientRequestImpl.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/codec/param/TestRestClientRequestImpl.java
@@ -27,8 +27,14 @@
 
 import org.hamcrest.MatcherAssert;
 import org.hamcrest.Matchers;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledForJreRange;
+import org.junit.jupiter.api.condition.EnabledOnJre;
+import org.junit.jupiter.api.condition.JRE;
+import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
 import com.google.common.collect.Multimap;
@@ -37,18 +43,21 @@
 import io.vertx.core.MultiMap;
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.http.HttpClientRequest;
-import mockit.Deencapsulation;
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
 
 public class TestRestClientRequestImpl {
-  @Mocked
   private HttpClientRequest request;
 
-  @Mocked
-  private Context context;
+  private Context context = Mockito.mock(Context.class);
+
+  @BeforeEach
+  public void before() {
+    request = Mockito.mock(HttpClientRequest.class);
+  }
+
+  @AfterEach
+  public void after() {
+    Mockito.reset(request);
+  }
 
   @Test
   public void testForm() throws Exception {
@@ -62,21 +71,13 @@
 
   @Test
   public void testCookie() throws Exception {
-    HttpClientRequest request = new MockUp<HttpClientRequest>() {
+    final MultiMap map = MultiMap.caseInsensitiveMultiMap();
+    Mockito.doAnswer(invocation -> {
+      map.add(io.vertx.core.http.HttpHeaders.COOKIE, "sessionid=abcdefghijklmnopqrstuvwxyz; region=china-north; ");
+      return null;
+    }).when(request).putHeader(io.vertx.core.http.HttpHeaders.COOKIE, "sessionid=abcdefghijklmnopqrstuvwxyz; region=china-north; ");
+    Mockito.when(request.headers()).thenReturn(map);
 
-      final MultiMap map = MultiMap.caseInsensitiveMultiMap();
-
-      @Mock
-      public HttpClientRequest putHeader(CharSequence key, CharSequence val) {
-        map.add(key, val);
-        return null;
-      }
-
-      @Mock
-      public MultiMap headers() {
-        return map;
-      }
-    }.getMockInstance();
     RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null);
     restClientRequest.addCookie("sessionid", "abcdefghijklmnopqrstuvwxyz");
     restClientRequest.addCookie("region", "china-north");
@@ -89,15 +90,11 @@
   }
 
   @Test
-  public void fileBoundaryInfo_nullSubmittedFileName(@Mocked Part part) {
-    new Expectations() {
-      {
-        part.getSubmittedFileName();
-        result = null;
-        part.getContentType();
-        result = "abc";
-      }
-    };
+  public void fileBoundaryInfo_nullSubmittedFileName() {
+    Part part = Mockito.mock(Part.class);
+    Mockito.when(part.getSubmittedFileName()).thenReturn(null);
+    Mockito.when(part.getContentType()).thenReturn("abc");
+
     RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null);
     Buffer buffer = restClientRequest.fileBoundaryInfo("boundary", "name", part);
     Assertions.assertEquals("\r\n" +
@@ -109,15 +106,10 @@
   }
 
   @Test
-  public void fileBoundaryInfo_validSubmittedFileName(@Mocked Part part) {
-    new Expectations() {
-      {
-        part.getSubmittedFileName();
-        result = "a.txt";
-        part.getContentType();
-        result = MediaType.TEXT_PLAIN;
-      }
-    };
+  public void fileBoundaryInfo_validSubmittedFileName() {
+    Part part = Mockito.mock(Part.class);
+    Mockito.when(part.getSubmittedFileName()).thenReturn("a.txt");
+    Mockito.when(part.getContentType()).thenReturn(MediaType.TEXT_PLAIN);
     RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, null, null);
     Buffer buffer = restClientRequest.fileBoundaryInfo("boundary", "name", part);
     Assertions.assertEquals("\r\n" +
@@ -136,7 +128,7 @@
 
     restClientRequest.attach(fileName, part);
 
-    Multimap<String, Part> uploads = Deencapsulation.getField(restClientRequest, "uploads");
+    Multimap<String, Part> uploads = restClientRequest.uploads;
     Assertions.assertEquals(1, uploads.size());
     MatcherAssert.assertThat(uploads.asMap(), Matchers.hasEntry(fileName, Arrays.asList(part)));
   }
@@ -147,32 +139,47 @@
 
     restClientRequest.attach("fileName", null);
 
-    Multimap<String, Part> uploads = Deencapsulation.getField(restClientRequest, "uploads");
+    Multimap<String, Part> uploads = restClientRequest.uploads;
     Assertions.assertTrue(uploads.isEmpty());
   }
 
   @Test
-  public void doEndWithUpload() {
+  @EnabledOnJre(JRE.JAVA_8)
+  public void doEndWithUploadForJre8() {
     Map<String, String> headers = new HashMap<>();
-    new MockUp<HttpClientRequest>(request) {
-      @Mock
-      HttpClientRequest putHeader(String name, String value) {
-        headers.put(name, value);
-        return request;
-      }
-    };
+    Mockito.doAnswer(invocation -> {
+      headers.put(HttpHeaders.CONTENT_TYPE, "multipart/form-data; charset=UTF-8; boundary=boundarynull-null-null-null-null");
+      return null;
+    }).when(request).putHeader(HttpHeaders.CONTENT_TYPE, "multipart/form-data; charset=UTF-8; boundary=boundarynull-null-null-null-null");
 
     UUID uuid = new UUID(0, 0);
-    new Expectations(UUID.class) {
-      {
-        UUID.randomUUID();
-        result = uuid;
-      }
-    };
-    RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, context, null);
-    restClientRequest.doEndWithUpload();
+    try (MockedStatic<UUID> mockedStatic = Mockito.mockStatic(UUID.class)) {
+      mockedStatic.when(UUID::randomUUID).thenReturn(uuid);
+      RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, context, null);
+      restClientRequest.doEndWithUpload();
 
-    Assertions.assertEquals("multipart/form-data; charset=UTF-8; boundary=boundary00000000-0000-0000-0000-000000000000",
-        headers.get(HttpHeaders.CONTENT_TYPE));
+      Assertions.assertEquals("multipart/form-data; charset=UTF-8; boundary=boundarynull-null-null-null-null",
+              headers.get(HttpHeaders.CONTENT_TYPE));
+    }
+  }
+
+  @Test
+  @EnabledForJreRange(min = JRE.JAVA_9)
+  public void doEndWithUploadAfterJre8() {
+    Map<String, String> headers = new HashMap<>();
+    Mockito.doAnswer(invocation -> {
+      headers.put(HttpHeaders.CONTENT_TYPE, "multipart/form-data; charset=UTF-8; boundary=boundary00000000-0000-0000-0000-000000000000");
+      return null;
+    }).when(request).putHeader(HttpHeaders.CONTENT_TYPE, "multipart/form-data; charset=UTF-8; boundary=boundary00000000-0000-0000-0000-000000000000");
+
+    UUID uuid = new UUID(0, 0);
+    try (MockedStatic<UUID> mockedStatic = Mockito.mockStatic(UUID.class)) {
+      mockedStatic.when(UUID::randomUUID).thenReturn(uuid);
+      RestClientRequestImpl restClientRequest = new RestClientRequestImpl(request, context, null);
+      restClientRequest.doEndWithUpload();
+
+      Assertions.assertEquals("multipart/form-data; charset=UTF-8; boundary=boundary00000000-0000-0000-0000-000000000000",
+              headers.get(HttpHeaders.CONTENT_TYPE));
+    }
   }
 }
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestPath.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestPath.java
index 2bc4f9a..eb3bceb 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestPath.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestPath.java
@@ -33,8 +33,7 @@
 import io.swagger.models.parameters.Parameter;
 import io.swagger.models.parameters.PathParameter;
 import io.swagger.models.parameters.QueryParameter;
-import mockit.Mock;
-import mockit.MockUp;
+import org.mockito.Mockito;
 
 public class TestPath {
 
@@ -119,21 +118,12 @@
   @Test
   public void testQueryVarParamWriter() {
     boolean status = true;
-    new MockUp<RestParam>() {
-      @Mock
-      public String getParamName() {
-        return "queryVar";
-      }
-    };
-    new MockUp<QueryVarParamWriter>() {
-      @Mock
-      private Object getParamValue(Object[] args) {
-        return args[0];
-      }
-    };
 
     Parameter parameter = new QueryParameter();
-    QueryVarParamWriter writer = new QueryVarParamWriter(new RestParam(parameter, String.class));
+    RestParam restParam = new RestParam(parameter, String.class);
+    RestParam spy = Mockito.spy(restParam);
+    Mockito.when(spy.getParamName()).thenReturn("queryVar");
+    QueryVarParamWriter writer = new QueryVarParamWriter(spy);
     try {
       Map<String, Object> parameters = new HashMap<>();
       parameters.put("queryVar", "T");
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestRestOperationMeta.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestRestOperationMeta.java
index 2c1adfb..afefdaf 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestRestOperationMeta.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/TestRestOperationMeta.java
@@ -35,6 +35,7 @@
 import org.apache.servicecomb.core.SCBEngine;
 import org.apache.servicecomb.core.bootstrap.SCBBootstrap;
 import org.apache.servicecomb.core.definition.OperationMeta;
+import org.apache.servicecomb.core.definition.SchemaMeta;
 import org.apache.servicecomb.foundation.test.scaffolding.config.ArchaiusUtils;
 import org.hamcrest.MatcherAssert;
 import org.junit.AfterClass;
@@ -45,7 +46,7 @@
 import com.fasterxml.jackson.annotation.JsonView;
 
 import io.swagger.models.Swagger;
-import mockit.Expectations;
+import org.mockito.Mockito;
 
 public class TestRestOperationMeta {
   @Path("/")
@@ -165,7 +166,7 @@
     scbEngine = SCBBootstrap.createSCBEngineForTest()
         .addProducerMeta("sid1", new RestOperationMetaSchema())
         .run();
-    swagger = scbEngine.getProducerMicroserviceMeta().ensureFindSchemaMeta("sid1").getSwagger();
+    swagger = Mockito.spy(scbEngine.getProducerMicroserviceMeta().ensureFindSchemaMeta("sid1").getSwagger());
   }
 
   @AfterClass
@@ -175,8 +176,11 @@
   }
 
   private void findOperation(String operationId) {
-    meta = scbEngine.getProducerMicroserviceMeta().operationMetas().get("test.sid1." + operationId);
-    operationMeta = RestMetaUtils.getRestOperationMeta(meta);
+    meta = Mockito.spy(scbEngine.getProducerMicroserviceMeta().operationMetas().get("test.sid1." + operationId));
+    operationMeta = Mockito.spy(RestMetaUtils.getRestOperationMeta(meta));
+    SchemaMeta schemaMeta = Mockito.spy(meta.getSchemaMeta());
+    Mockito.when(meta.getSchemaMeta()).thenReturn(schemaMeta);
+    Mockito.when(schemaMeta.getSwagger()).thenReturn(swagger);
   }
 
   @Test
@@ -381,14 +385,9 @@
   @Test
   public void generatesAbsolutePathWithNonRootBasePath() {
     findOperation("textCharJsonChar");
-    new Expectations(swagger) {
-      {
-        swagger.getBasePath();
-        result = "/rest";
-      }
-    };
+    Mockito.when(swagger.getBasePath()).thenReturn("/rest");
     RestOperationMeta restOperationMeta = new RestOperationMeta();
-    restOperationMeta.init(operationMeta.getOperationMeta());
+    restOperationMeta.init(meta);
 
     MatcherAssert.assertThat(restOperationMeta.getAbsolutePath(), is("/rest/textCharJsonChar/"));
   }
@@ -396,20 +395,10 @@
   @Test
   public void generatesAbsolutePathWithNullPath() {
     findOperation("textCharJsonChar");
-    new Expectations(swagger) {
-      {
-        swagger.getBasePath();
-        result = null;
-      }
-    };
-    new Expectations(meta) {
-      {
-        meta.getOperationPath();
-        result = null;
-      }
-    };
+    Mockito.when(swagger.getBasePath()).thenReturn(null);
+    Mockito.when(meta.getOperationPath()).thenReturn(null);
     RestOperationMeta restOperationMeta = new RestOperationMeta();
-    restOperationMeta.init(operationMeta.getOperationMeta());
+    restOperationMeta.init(meta);
 
     MatcherAssert.assertThat(restOperationMeta.getAbsolutePath(), is("/"));
   }
@@ -417,20 +406,10 @@
   @Test
   public void generatesAbsolutePathWithEmptyPath() {
     findOperation("textCharJsonChar");
-    new Expectations(swagger) {
-      {
-        swagger.getBasePath();
-        result = "";
-      }
-    };
-    new Expectations(meta) {
-      {
-        meta.getOperationPath();
-        result = "";
-      }
-    };
+    Mockito.when(swagger.getBasePath()).thenReturn("");
+    Mockito.when(meta.getOperationPath()).thenReturn("");
     RestOperationMeta restOperationMeta = new RestOperationMeta();
-    restOperationMeta.init(operationMeta.getOperationMeta());
+    restOperationMeta.init(meta);
 
     MatcherAssert.assertThat(restOperationMeta.getAbsolutePath(), is("/"));
   }
@@ -438,20 +417,10 @@
   @Test
   public void consecutiveSlashesAreRemoved() {
     findOperation("textCharJsonChar");
-    new Expectations(swagger) {
-      {
-        swagger.getBasePath();
-        result = "//rest//";
-      }
-    };
-    new Expectations(meta) {
-      {
-        meta.getOperationPath();
-        result = "//sayHi//";
-      }
-    };
+    Mockito.when(swagger.getBasePath()).thenReturn("//rest//");
+    Mockito.when(meta.getOperationPath()).thenReturn("//sayHi//");
     RestOperationMeta restOperationMeta = new RestOperationMeta();
-    restOperationMeta.init(operationMeta.getOperationMeta());
+    restOperationMeta.init(meta);
 
     MatcherAssert.assertThat(restOperationMeta.getAbsolutePath(), is("/rest/sayHi/"));
   }
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/path/PathVarParamWriterTest.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/path/PathVarParamWriterTest.java
index 81e8658..5aa4db1 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/path/PathVarParamWriterTest.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/definition/path/PathVarParamWriterTest.java
@@ -24,9 +24,7 @@
 import org.apache.servicecomb.common.rest.definition.path.URLPathBuilder.URLPathStringBuilder;
 import org.junit.jupiter.api.Assertions;
 import org.junit.Test;
-
-import mockit.Mock;
-import mockit.MockUp;
+import org.mockito.Mockito;
 
 public class PathVarParamWriterTest {
 
@@ -85,12 +83,8 @@
   }
 
   private PathVarParamWriter createPathVarParamWriter() {
-    RestParam restParam = new MockUp<RestParam>() {
-      @Mock
-      public String getParamName(){
-        return "test";
-      }
-    }.getMockInstance();
+    RestParam restParam = Mockito.mock(RestParam.class);
+    Mockito.when(restParam.getParamName()).thenReturn("test");
     return new PathVarParamWriter(restParam);
   }
 }
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/TestHttpServerFilterBeforeSendResponseExecutor.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/TestHttpServerFilterBeforeSendResponseExecutor.java
index c004fec..4bb0c20 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/TestHttpServerFilterBeforeSendResponseExecutor.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/TestHttpServerFilterBeforeSendResponseExecutor.java
@@ -26,15 +26,15 @@
 import org.apache.servicecomb.foundation.vertx.http.HttpServletResponseEx;
 import org.junit.jupiter.api.Assertions;
 
-import mockit.Mocked;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
 
 public class TestHttpServerFilterBeforeSendResponseExecutor {
-  @Mocked
+  @Mock
   Invocation invocation;
 
-  @Mocked
+  @Mock
   HttpServletResponseEx responseEx;
 
   List<HttpServerFilter> httpServerFilters = new ArrayList<>();
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/RestServerCodecFilterTest.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/RestServerCodecFilterTest.java
index 204dfe5..14e9b8f 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/RestServerCodecFilterTest.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/RestServerCodecFilterTest.java
@@ -23,12 +23,13 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.ArrayList;
-import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
+import com.fasterxml.jackson.databind.JavaType;
 import org.apache.servicecomb.common.rest.HttpTransportContext;
 import org.apache.servicecomb.common.rest.RestConst;
+import org.apache.servicecomb.common.rest.codec.produce.ProduceJsonProcessor;
 import org.apache.servicecomb.common.rest.definition.RestOperationMeta;
 import org.apache.servicecomb.config.ConfigUtil;
 import org.apache.servicecomb.core.Endpoint;
@@ -36,7 +37,10 @@
 import org.apache.servicecomb.core.SCBEngine;
 import org.apache.servicecomb.core.SCBStatus;
 import org.apache.servicecomb.core.bootstrap.SCBBootstrap;
+import org.apache.servicecomb.core.definition.InvocationRuntimeType;
+import org.apache.servicecomb.core.definition.MicroserviceMeta;
 import org.apache.servicecomb.core.definition.OperationMeta;
+import org.apache.servicecomb.core.definition.SchemaMeta;
 import org.apache.servicecomb.core.filter.FilterNode;
 import org.apache.servicecomb.core.invocation.InvocationFactory;
 import org.apache.servicecomb.foundation.test.scaffolding.config.ArchaiusUtils;
@@ -52,29 +56,30 @@
 
 import io.vertx.core.MultiMap;
 import io.vertx.core.json.Json;
-import mockit.Expectations;
-import mockit.Mocked;
-import mockit.Verifications;
+import org.mockito.Mockito;
+
+import javax.servlet.http.Part;
 
 public class RestServerCodecFilterTest {
   RestServerCodecFilter codecFilter = new RestServerCodecFilter();
 
   Invocation invocation;
 
-  @Mocked
-  Endpoint endpoint;
+  Endpoint endpoint = Mockito.mock(Endpoint.class);
 
-  @Mocked
-  OperationMeta operationMeta;
+  OperationMeta operationMeta = Mockito.mock(OperationMeta.class);
 
-  @Mocked
-  RestOperationMeta restOperationMeta;
+  SchemaMeta schemaMeta = Mockito.mock(SchemaMeta.class);
 
-  @Mocked
-  HttpTransportContext transportContext;
+  MicroserviceMeta microserviceMeta = Mockito.mock(MicroserviceMeta.class);
 
-  @Mocked
-  HttpServletResponseEx responseEx;
+  InvocationRuntimeType invocationRuntimeType = Mockito.mock(InvocationRuntimeType.class);
+
+  RestOperationMeta restOperationMeta = Mockito.mock(RestOperationMeta.class);
+
+  HttpTransportContext transportContext = Mockito.mock(HttpTransportContext.class);
+
+  HttpServletResponseEx responseEx = Mockito.mock(HttpServletResponseEx.class);
 
   MultiMap headers = MultiMap.caseInsensitiveMultiMap();
 
@@ -103,45 +108,36 @@
 
   @Before
   public void setUp() {
-    invocation = InvocationFactory.forProvider(endpoint, operationMeta, null);
+    Mockito.when(operationMeta.getSchemaMeta()).thenReturn(schemaMeta);
+    Mockito.when(schemaMeta.getMicroserviceMeta()).thenReturn(microserviceMeta);
+    Mockito.when(microserviceMeta.getHandlerChain()).thenReturn(new ArrayList<>());
+    Mockito.when(operationMeta.buildBaseProviderRuntimeType()).thenReturn(invocationRuntimeType);
+    Mockito.when(transportContext.getProduceProcessor()).thenReturn(Mockito.mock(ProduceJsonProcessor.class));
+    invocation = Mockito.spy(InvocationFactory.forProvider(endpoint, operationMeta, null));
   }
 
   private void mockDecodeRequestFail() {
-    new Expectations(invocation) {
-      {
-        invocation.getTransportContext();
-        result = transportContext;
-
-        invocation.getRequestEx();
-        result = new RuntimeExceptionWithoutStackTrace("mock encode request failed");
-      }
-    };
+    Mockito.when(invocation.getTransportContext()).thenReturn(transportContext);
+    Mockito.when(transportContext.getResponseEx()).thenReturn(responseEx);
+    Mockito.when(invocation.getRequestEx()).thenThrow(new RuntimeExceptionWithoutStackTrace("mock encode request failed"));
   }
 
   @Test
-  public void should_not_invoke_filter_when_decode_request_failed(@Mocked FilterNode nextNode) {
+  public void should_not_invoke_filter_when_decode_request_failed() {
+    FilterNode nextNode = Mockito.mock(FilterNode.class);
     mockDecodeRequestFail();
 
     codecFilter.onFilter(invocation, nextNode);
 
-    new Verifications() {
-      {
-        nextNode.onFilter(invocation);
-        times = 0;
-      }
-    };
+    Mockito.verify(nextNode, Mockito.times(0)).onFilter(invocation);
   }
 
   @Test
   public void should_convert_exception_to_response_when_decode_request_failed()
       throws ExecutionException, InterruptedException {
     mockDecodeRequestFail();
-    new Expectations(invocation) {
-      {
-        invocation.findResponseType(anyInt);
-        result = TypeFactory.defaultInstance().constructType(String.class);
-      }
-    };
+    Mockito.when(invocation.findResponseType(INTERNAL_SERVER_ERROR.getStatusCode()))
+            .thenReturn(TypeFactory.defaultInstance().constructType(String.class));
 
     Response response = codecFilter.onFilter(invocation, nextNode).get();
 
@@ -151,18 +147,14 @@
   }
 
   private void success_invocation() throws InterruptedException, ExecutionException {
-    new Expectations(invocation) {
-      {
-        invocation.getTransportContext();
-        result = transportContext;
-
-        operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION);
-        result = restOperationMeta;
-
-        invocation.findResponseType(anyInt);
-        result = TypeFactory.defaultInstance().constructType(String.class);
-      }
-    };
+    Mockito.when(invocation.getTransportContext()).thenReturn(transportContext);
+    Mockito.when(operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION)).thenReturn(restOperationMeta);
+    Mockito.when(invocation.findResponseType(INTERNAL_SERVER_ERROR.getStatusCode())).thenReturn(TypeFactory.defaultInstance().constructType(String.class));
+    JavaType javaType = Mockito.mock(JavaType.class);
+    Mockito.when(invocationRuntimeType.findResponseType(200)).thenReturn(javaType);
+    Mockito.when(javaType.getRawClass()).thenAnswer(invocationOnMock -> Part.class);
+    Mockito.when(invocation.getTransportContext()).thenReturn(transportContext);
+    Mockito.when(transportContext.getResponseEx()).thenReturn(responseEx);
 
     codecFilter.onFilter(invocation, nextNode).get();
   }
@@ -172,15 +164,7 @@
     headers.add("h1", "v1");
     success_invocation();
 
-    new Verifications() {
-      {
-        String name;
-        String value;
-        responseEx.addHeader(name = withCapture(), value = withCapture());
-        assertThat(name).isEqualTo("h1");
-        assertThat(value).isEqualTo("v1");
-      }
-    };
+   Mockito.verify(responseEx).addHeader("h1", "v1");
   }
 
   @Test
@@ -190,15 +174,8 @@
         .add(CONTENT_LENGTH, "10");
     success_invocation();
 
-    new Verifications() {
-      {
-        List<String> names = new ArrayList<>();
-        List<String> values = new ArrayList<>();
-        responseEx.addHeader(withCapture(names), withCapture(values));
-        assertThat(names).containsExactly("h1", "h2");
-        assertThat(values).containsExactly("v1", "v2");
-      }
-    };
+    Mockito.verify(responseEx, Mockito.times(1)).addHeader("h1", "v1");
+    Mockito.verify(responseEx, Mockito.times(1)).addHeader("h2", "v2");
   }
 
   @Test
@@ -208,14 +185,7 @@
         .add(TRANSFER_ENCODING, "test");
     success_invocation();
 
-    new Verifications() {
-      {
-        List<String> names = new ArrayList<>();
-        List<String> values = new ArrayList<>();
-        responseEx.addHeader(withCapture(names), withCapture(values));
-        assertThat(names).containsExactly("h1", "h2");
-        assertThat(values).containsExactly("v1", "v2");
-      }
-    };
+    Mockito.verify(responseEx, Mockito.times(1)).addHeader("h1", "v1");
+    Mockito.verify(responseEx, Mockito.times(1)).addHeader("h2", "v2");
   }
 }
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/TestServerRestArgsFilter.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/TestServerRestArgsFilter.java
index 30d6a45..2a190a0 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/TestServerRestArgsFilter.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/filter/inner/TestServerRestArgsFilter.java
@@ -16,16 +16,11 @@
  */
 package org.apache.servicecomb.common.rest.filter.inner;
 
-import java.util.concurrent.CompletableFuture;
-
 import javax.servlet.http.Part;
 
 import org.apache.servicecomb.common.rest.RestConst;
 import org.apache.servicecomb.common.rest.codec.RestObjectMapperFactory;
-import org.apache.servicecomb.common.rest.definition.RestMetaUtils;
-import org.apache.servicecomb.common.rest.definition.RestOperationMeta;
 import org.apache.servicecomb.core.Invocation;
-import org.apache.servicecomb.core.definition.OperationMeta;
 import org.apache.servicecomb.foundation.vertx.http.HttpServletResponseEx;
 import org.apache.servicecomb.swagger.invocation.Response;
 import org.apache.servicecomb.swagger.invocation.response.ResponsesMeta;
@@ -33,55 +28,37 @@
 import org.junit.Test;
 
 import com.fasterxml.jackson.databind.type.TypeFactory;
+import org.mockito.Mockito;
 
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
 
 public class TestServerRestArgsFilter {
-  @Mocked
-  Invocation invocation;
 
-  @Mocked
-  HttpServletResponseEx responseEx;
+  Invocation invocation = Mockito.mock(Invocation.class);
 
-  @Mocked
-  Response response;
+  HttpServletResponseEx responseEx = Mockito.mock(HttpServletResponseEx.class);
 
-  @Mocked
-  Part part;
+  Response response = Mockito.mock(Response.class);
 
-  @Mocked
-  OperationMeta operationMeta;
+  Part part = Mockito.mock(Part.class);
 
   boolean invokedSendPart;
 
   ServerRestArgsFilter filter = new ServerRestArgsFilter();
 
   @Test
-  public void asyncBeforeSendResponse_part(@Mocked RestOperationMeta restOperationMeta) {
+  public void asyncBeforeSendResponse_part() {
     ResponsesMeta responsesMeta = new ResponsesMeta();
     responsesMeta.getResponseMap().put(202, RestObjectMapperFactory.getRestObjectMapper().constructType(Part.class));
-    new Expectations(RestMetaUtils.class) {
-      {
-        responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE);
-        result = response;
-        response.getResult();
-        result = part;
-        response.getStatusCode();
-        result = 202;
-        invocation.findResponseType(202);
-        result = TypeFactory.defaultInstance().constructType(Part.class);
-      }
-    };
-    new MockUp<HttpServletResponseEx>(responseEx) {
-      @Mock
-      CompletableFuture<Void> sendPart(Part body) {
-        invokedSendPart = true;
-        return null;
-      }
-    };
+
+    Mockito.when(responseEx.getAttribute(RestConst.INVOCATION_HANDLER_RESPONSE)).thenReturn(response);
+    Mockito.when(response.getResult()).thenReturn(part);
+    Mockito.when(response.getStatusCode()).thenReturn(202);
+    Mockito.when(invocation.findResponseType(202)).thenReturn(TypeFactory.defaultInstance().constructType(Part.class));
+
+    Mockito.doAnswer(invocationOnMock -> {
+      invokedSendPart = true;
+      return null;
+    }).when(responseEx).sendPart(part);
 
     Assertions.assertNull(filter.beforeSendResponseAsync(invocation, responseEx));
     Assertions.assertTrue(invokedSendPart);
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/locator/TestMicroservicePaths.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/locator/TestMicroservicePaths.java
index 70aeabf..2a0b664 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/locator/TestMicroservicePaths.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/locator/TestMicroservicePaths.java
@@ -28,10 +28,7 @@
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.jupiter.api.Assertions;
-
-import mockit.Deencapsulation;
-import mockit.Expectations;
-import mockit.Mocked;
+import org.mockito.Mockito;
 
 public class TestMicroservicePaths {
   static SCBEngine scbEngine;
@@ -46,7 +43,7 @@
         .run();
 
     ServicePathManager spm = ServicePathManager.getServicePathManager(scbEngine.getProducerMicroserviceMeta());
-    paths = Deencapsulation.getField(spm, "producerPaths");
+    paths = spm.producerPaths;
   }
 
   @AfterClass
@@ -65,17 +62,12 @@
   }
 
   @Test
-  public void testAddResourceStaticDuplicatedHttpMethod(@Mocked RestOperationMeta staticResPost) {
-    new Expectations() {
-      {
-        staticResPost.getHttpMethod();
-        result = "POST";
-        staticResPost.getAbsolutePath();
-        result = "/static/";
-        staticResPost.isAbsoluteStaticPath();
-        result = true;
-      }
-    };
+  public void testAddResourceStaticDuplicatedHttpMethod() {
+    RestOperationMeta staticResPost = Mockito.mock(RestOperationMeta.class);
+    Mockito.when(staticResPost.getHttpMethod()).thenReturn("POST");
+    Mockito.when(staticResPost.getAbsolutePath()).thenReturn("/static/");
+    Mockito.when(staticResPost.isAbsoluteStaticPath()).thenReturn(true);
+
 
     ServiceCombException exception = Assertions.assertThrows(ServiceCombException.class,
             () -> paths.addResource(staticResPost));
diff --git a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/resource/TestClassPathStaticResourceHandler.java b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/resource/TestClassPathStaticResourceHandler.java
index 66ec649..144b67c 100644
--- a/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/resource/TestClassPathStaticResourceHandler.java
+++ b/common/common-rest/src/test/java/org/apache/servicecomb/common/rest/resource/TestClassPathStaticResourceHandler.java
@@ -33,8 +33,7 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.BeforeClass;
 import org.junit.Test;
-
-import mockit.Expectations;
+import org.mockito.Mockito;
 
 public class TestClassPathStaticResourceHandler {
   static ClassPathStaticResourceHandler handler = new ClassPathStaticResourceHandler();
@@ -83,12 +82,9 @@
 
   @Test
   public void readContentFailed() throws IOException {
-    new Expectations(handler) {
-      {
-        handler.findResource(anyString);
-        result = new RuntimeExceptionWithoutStackTrace("read content failed.");
-      }
-    };
+    handler = Mockito.spy(TestClassPathStaticResourceHandler.handler);
+    Mockito.when(handler.findResource("web-root/index.html"))
+            .thenThrow(new RuntimeExceptionWithoutStackTrace("read content failed."));
 
     try (LogCollector logCollector = new LogCollector()) {
       Response response = handler.handle("index.html");
diff --git a/core/src/main/java/org/apache/servicecomb/core/Invocation.java b/core/src/main/java/org/apache/servicecomb/core/Invocation.java
index d11dad5..b1b48c7 100644
--- a/core/src/main/java/org/apache/servicecomb/core/Invocation.java
+++ b/core/src/main/java/org/apache/servicecomb/core/Invocation.java
@@ -27,6 +27,7 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.atomic.AtomicLong;
 
+import com.google.common.annotations.VisibleForTesting;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.servicecomb.core.definition.InvocationRuntimeType;
 import org.apache.servicecomb.core.definition.MicroserviceMeta;
@@ -160,6 +161,11 @@
     return schemaMeta.getMicroserviceMeta().getHandlerChain();
   }
 
+  @VisibleForTesting
+  public void setHandlerList(List<Handler> handlerList) {
+    this.handlerList = handlerList;
+  }
+
   public Executor getResponseExecutor() {
     return responseExecutor;
   }