@RunWith(JUnit4.class)
public class CollectionsTasksResolverTest {

    private final CollectionSupplier collectionSupplier = Mockito.mock(CollectionSupplier.class);
    private final TasksSupplier tasksSupplier = Mockito.mock(TasksSupplier.class);
    private final Context context = Mockito.spy(new Context());
    private final CollectionsTasksResolver collectionsTasksResolver =
            new CollectionsTasksResolver(context, collectionSupplier, tasksSupplier);

    private void verifyNoMore() {
        Mockito.verifyNoMoreInteractions(collectionSupplier, tasksSupplier);
    }

    @Test
    public void getTreeMapAdding_formatTest() {
        // precondition
        final String tag = "TreeMap_adding";
        Mockito.when(collectionSupplier.getTreeMap(0)).thenReturn(new TreeMap<>());
        final ArgumentCaptor<Map<Integer, Integer>> captor = ArgumentCaptor.forClass(Map.class);
        Mockito.when(tasksSupplier.getTimeAdding(captor.capture())).thenReturn("0.0 ms");

        // call tested method
        final CalculationResult result = collectionsTasksResolver.getTestTime(tag, 0);

        // check results
        Mockito.verify(context, Mockito.times(1)).getString(R.string.TreeMap);
        Mockito.verify(context, Mockito.times(1)).getString(R.string.adding);
        Mockito.verify(collectionSupplier, Mockito.times(1)).getTreeMap(0);
        Mockito.verify(tasksSupplier, Mockito.times(1)).getTimeAdding(captor.capture());
        Assert.assertEquals(result.tag, "TreeMap_adding");
        verifyNoMore();
    }
}



@RunWith(JUnit4.class)
public class CollectionsGeneratorTest {

    private final CollectionSupplier collectionsGenerator = new CollectionsGenerator();

    @Test
    public void map_is_HashMap() {
        final Map<Integer, Integer> hashMap = collectionsGenerator.getHashMap(4);

        assertTrue(hashMap instanceof HashMap);
        assertEquals(hashMap.size(), 4);
    }
}


@RunWith(JUnit4.class)
public class CollectionsTaskSupplier {
    private final Pattern p = Pattern.compile("^\\d+\\.\\d+\\sms$");
    private final Context context = Mockito.spy(new Context());
    private final TasksSupplier collectionsTaskSupplier =
            new CollectionsTasksSupplier(context);

    @Test
    public void getTimeAddingFormatTest() {
        // precondition
        final LinkedList<Integer> linkedList = new LinkedList<>(Collections.nCopies(100, new Integer(1)));

        // call tested function
        final String result = collectionsTaskSupplier.getTimeAdding(linkedList, 0);

        // check expected result
        Assert.assertTrue(p.matcher(result).matches());

    }
}





public class Context {

    public String getString(int strResId) {

        if (strResId == R.string.adding) {
            return "adding";
        }
        ......
        } else if (strResId == R.string.ms) {
            return "%1$s ms";
        }

        return "";
    }

    public String getString(int strResId, Object... time) {
        return String.format(getString(strResId), time);
    }
}



@RunWith(JUnit4.class)
public class FragmentPresenterTest {

    private final TaskResolver calculator = Mockito.mock(TaskResolver.class);
    private final FragmentContract.View view = Mockito.mock(FragmentContract.View.class);
    private final FragmentPresenter presenter = new FragmentPresenter(calculator);

    @BeforeClass
    public static void setupClass() {
        RxAndroidPlugins.setInitMainThreadSchedulerHandler(
                (Callable<Scheduler> schedulerCallable) -> Schedulers.trampoline());
    }

    @Before
    public void setup() {
        presenter.subscribe(view);
    }

......

    @Test(expected = NumberFormatException.class)
    public void testInvalidSizesAmount_shouldShowError() {
        presenter.startCalculation(new ArrayList<>(), "abc", "10");
    }

    @Test(expected = NumberFormatException.class)
    public void testInvalidThreadsAmount_shouldShowError() {
        presenter.startCalculation(new ArrayList<>(), "1", "abc");
    }

    @Test
    public void testViewsWorking() throws InterruptedException {
        final String tag = "HashMap_adding";
        final List<String> tags = new ArrayList<>();
        tags.add(tag);

        //ArgumentCaptor<Runnable> runnableArgumentCaptor = ArgumentCaptor.forClass(Runnable.class);
        //Mockito.verify(runnable, Mockito.times(1)).(runnableArgumentCaptor.capture());
        //runnableArgumentCaptor.getValue().run();

        final ArgumentCaptor<String> tagCaptor = ArgumentCaptor.forClass(String.class);
        final ArgumentCaptor<Integer> sizeCaptor = ArgumentCaptor.forClass(Integer.class);
        Mockito.when(calculator.getTestTime(tagCaptor.capture(), sizeCaptor.capture()))
                .thenReturn(new CalculationResult(tag, "0.0 ms"));

        presenter.startCalculation(tags, "30", "2");
        Thread.sleep(500L); // wait till multithreading operations are done

        Mockito.verify(view, Mockito.times(1)).showProgress();
        Mockito.verify(view, Mockito.times(1)).calculationFinished();
        Mockito.verify(view, Mockito.times(1)).updateView(tag, "0.0 ms");
        Mockito.verify(calculator, Mockito.times(1)).getTestTime(tagCaptor.capture(), sizeCaptor.capture());
        verifyNoMore();
    }
}