Home | History | Annotate | Download | only in extended 
      1 /*
      2  * Copyright (C) 2018 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.dx.mockito.inline.extended;
     18 
     19 import org.mockito.InOrder;
     20 import org.mockito.Mockito;
     21 import org.mockito.verification.VerificationMode;
     22 
     23 /**
     24  * Same as {@link InOrder} but adds the ability to verify static method calls via
     25  * {@link #verify(MockedMethod)}, {@link #verify(MockedVoidMethod)},
     26  * {@link #verify(MockedMethod, VerificationMode)}, and
     27  * {@link #verify(MockedVoidMethod, VerificationMode)}.
     28  */
     29 @UnstableApi
     30 public class StaticInOrder implements InOrder {
     31     private final InOrder instanceInOrder;
     32 
     33     StaticInOrder(InOrder inOrder) {
     34         instanceInOrder = inOrder;
     35     }
     36 
     37     @Override
     38     public <T> T verify(T mock) {
     39         return instanceInOrder.verify(mock);
     40     }
     41 
     42     @Override
     43     public <T> T verify(T mock, VerificationMode mode) {
     44         return instanceInOrder.verify(mock, mode);
     45     }
     46 
     47     /**
     48      * To be used for static mocks/spies in place of {@link #verify(Object)} when calling void
     49      * methods.
     50      * <p>E.g.
     51      * <pre>
     52      *     private class C {
     53      *         void instanceMethod(String arg) {}
     54      *         void void staticMethod(String arg) {}
     55      *     }
     56      *
     57      *    {@literal @}Test
     58      *     public void test() {
     59      *         // instance mocking
     60      *         C mock = mock(C.class);
     61      *         mock.staticMethod("Hello");
     62      *         mock.instanceMethod("World");
     63      *         inOrder().verify(mock).mockedVoidInstanceMethod(eq("Hello"));
     64      *         inOrder().verify(mock).mockedVoidInstanceMethod(eq("World"));
     65      *
     66      *         // static mocking
     67      *         MockitoSession session = mockitoSession().staticMock(C.class).startMocking();
     68      *         C.staticMethod("Hello");
     69      *         C.staticMethod("World");
     70      *
     71      *         StaticInOrder inOrder = inOrder();
     72      *         inOrder.verify(() -> C.staticMethod(eq("Hello"));
     73      *         inOrder.verify(() -> C.staticMethod(eq("World"));
     74      *         session.finishMocking();
     75      *     }
     76      * </pre>
     77      */
     78     public void verify(MockedVoidMethod method) {
     79         verify(method, Mockito.times(1));
     80     }
     81 
     82     /**
     83      * To be used for static mocks/spies in place of {@link #verify(Object)}.
     84      * <p>E.g.
     85      * <pre>
     86      *     private class C {
     87      *         int instanceMethod(String arg) {
     88      *             return 1;
     89      *         }
     90      *
     91      *         int static staticMethod(String arg) {
     92      *             return 2;
     93      *         }
     94      *     }
     95      *
     96      *    {@literal @}Test
     97      *     public void test() {
     98      *         // instance mocking
     99      *         C mock = mock(C.class);
    100      *         mock.instanceMethod("Hello");
    101      *         mock.instanceMethod("World");
    102      *         inOrder().verify(mock).mockedVoidInstanceMethod(eq("Hello"));
    103      *         inOrder().verify(mock).mockedVoidInstanceMethod(eq("World"));
    104      *
    105      *         // static mocking
    106      *         MockitoSession session = mockitoSession().staticMock(C.class).startMocking();
    107      *         C.staticMethod("Hello");
    108      *         C.staticMethod("World");
    109      *
    110      *         StaticInOrder inOrder = inOrder();
    111      *         inOrder.verify(() -> C.staticMethod(eq("Hello"));
    112      *         inOrder.verify(() -> C.staticMethod(eq("World"));
    113      *         session.finishMocking();
    114      *     }
    115      * </pre>
    116      */
    117     @UnstableApi
    118     public void verify(MockedMethod method) {
    119         verify(method, Mockito.times(1));
    120     }
    121 
    122     /**
    123      * To be used for static mocks/spies in place of
    124      * {@link InOrder#verify(Object, VerificationMode)} when calling void methods.
    125      *
    126      * @see #verify(MockedVoidMethod)
    127      */
    128     @UnstableApi
    129     public void verify(MockedVoidMethod method, VerificationMode mode) {
    130         ExtendedMockito.verifyInt(method, mode, instanceInOrder);
    131     }
    132 
    133     /**
    134      * To be used for static mocks/spies in place of
    135      * {@link InOrder#verify(Object, VerificationMode)}.
    136      *
    137      * @see #verify(MockedMethod)
    138      */
    139     @UnstableApi
    140     public void verify(MockedMethod method, VerificationMode mode) {
    141         verify((MockedVoidMethod) method::get, mode);
    142     }
    143 
    144     @Override
    145     public void verifyNoMoreInteractions() {
    146         instanceInOrder.verifyNoMoreInteractions();
    147     }
    148 }
    149