Tej Pratap Singh

Sometimes we are faced with a situation, where a parameter can have multiple values, or even it can have combination of those values.
We have a few choices here, either we create multiple fields for each property, which is hard to scale but easier to understand.
Here is a code sample for that:
<pre><code class="lang-kotlin">fun main() {
 order(true, true, false)
}

fun order(hasOrderedCheeseBurger: Boolean, hasOrderedFries: Boolean, hasOrderedSoda: Boolean) {
 println("Has Ordered CHEESEBURGER : ${hasOrderedCheeseBurger}"); // true
 println("Has Ordered FRIES : ${hasOrderedFries}"); // true
 println("Has Ordered SODA : ${hasOrderedSoda}"); // false
}
</code></pre>
As you can see, we had to send 3 different parameters to know what this user had ordered and imagine, if, in future we need to add another item, let's say <code>SANDWICH</code> then we need to add another parameter.
<hr>
Now, instead of passing multiple parameters, we can use bit manipulation to combine multiple parameters into a single parameter.
<pre><code class="lang-kotlin">val CHEESEBURGER = 2; // 00000010
val FRIES = 4; // 00000100
val SODA = 8; // 00001000

fun main() {
 val ordered = CHEESEBURGER or FRIES;

 order(ordered)
}

fun order(what: Int) {
 val hasOrderedCheeseBurger = what and CHEESEBURGER == CHEESEBURGER;
 val hasOrderedFries = what and FRIES == FRIES;
 val hasOrderedSoda = what and SODA == SODA;
 println("Has Ordered CHEESEBURGER : ${hasOrderedCheeseBurger}"); // true
 println("Has Ordered FRIES : ${hasOrderedFries}"); // true
 println("Has Ordered SODA : ${hasOrderedSoda}"); // false
}
</code></pre>
Here, bitwise allows us to add as many values as we need into a single parameter.

How to use Bitwise while setting properties

Powemock is a very powerful tool in any Java Developer's arsenal, it allows a developer to change his code at the bytecode level. This is especially beneficial when we want to modify some functionality of source (System Under Test).
<h3>Whey we need <code>whenNew()</code> ?</h3>
<code>whenNew()</code> allows us to inject our <code>fake</code> or <code>mock</code> instead of actually creating a new object of said class.
This works great, we just need to add our class in <code>@PrepareForTest</code> annotation and PowerMock will inject our mock. Just like that.
Here is an example class:
<pre><code class="lang-java">// Example Source Class
public class ExampleClass {
 public int getHeight() {
 // Lets say we have a generic method which provides different result base on the provided id
 final CustomClass customClassInstance = new CustomClass();
 return customClass.getHeight();
 }
}
</code></pre>
and here is a test case using <code>whenNew()</code> injection.
<pre><code class="lang-java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 ExampleClass.class
})
public class ExampleClassTest {

 private ExampleClass classUnderTest;

 @Before
 public void setUp() throws Exception {
 // Create constructor of ExampleClass
 classUnderTest = new ExampleClass();
 }

 @Test
 public void getHeight_shoudReturnHeightOfView() throws NoSuchMethodException {
 final int expectedHeight = 100;
 // Given
 final CustomClass mckCustomClass = Mockito.mock(CustomClass.class);
 Mockito.when(mckCustomClass.getHeight()).theReturn(expectedHeight);
 // Make sure you match exact parameters while mocking (same as we do for Mockito.mock statements).
 // There is also withArguments(first, second, ....)
 // and withAnyArguments() for cases when you don't care for arguments passed.
 PowerMockito.whenNew(CustomClass.class).withNoArguments().thenReturn(mckCustomClass);

 final int actualResult = classUnderTest.getHeight();

 Assert.assertEquals(expectedHeight, actualResult);
 }
}
</code></pre>
<h3>Now let's come to the problem...</h3>
Let's say you have the following class to test:
<pre><code class="lang-java">// ClassToTest
public class ClassToTest {
 // heavy method
 private void doInBackground() {
 new Thread() {
 @Override
 public void run() {
 final CustomClass customClassInstance = new CustomClass();
 int height = customClass.getHeight();
 // ... some heavey operation on height
 }
 }.start();
 }
}
</code></pre>
Now, in the above example, a new instance of <code>CustomClass</code> is created inside a nested scope (<code>Thread</code>), hence modifying bytecode of <code>ClassToTest</code> will no longer work as <code>new CustomClass()</code> is not inside its scope.
<h3>What to do?</h3>
Powermock has other tools to deal with such situations, firstly, you need to add <code>CustomClass</code> in <code>@PrepareForTest()</code> and <code>suppress()</code> constructors and <code>stub()</code> <code>getHeight()</code> method to modify its behaviour according to your test requirements.
Here is example code:
<pre><code class="lang-java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 ExampleClass.class,
 CustomClass.class
})
public class ExampleClassTest {

 private ExampleClass classUnderTest;

 @Before
 public void setUp() throws Exception {
 // Create constructor of ExampleClass
 classUnderTest = new ExampleClass();
 }

 @Test
 public void getHeight_shoudReturnHeightOfView() throws NoSuchMethodException {
 final int expectedHeight = 100;
 // Given
 PowerMockito.suppress(CustomClass.class.getConstructors());
 PowerMockito.stub(CustomClass.class.getMethod("getHeight")).toReturn(expectedHeight);
 // ...
 }
}
</code></pre>
P.S. PowerMock has <code>suppress()</code> , <code>sub()</code> and <code>replace()</code> methods to modify individual elements of any class. Please read more about methods declared in <code>PowerMockito</code> class and see if you find an alternate solution to your use case.

Limitation of PowerMockito.whenNew()

<blockquote>
Post inspired by <a target="_blank" href="https://github.com/tejpratap46/RecyclerCalendarAndroid">RecyclerCalendarAndroid Lib</a>
</blockquote>
<h3>RecyclerView</h3>
The theory is simple, we need each day of the calendar rendered as one cell of the RecyclerView.
To achieve this, we need to first prepare list of all dates, but there is a problem, we are missing a few things:
<ol>
<li>
Header Cell for Month with span size of 7.
</li>
<li>
Preceding empty cell (if the month start from Wednesday, we need to add an empty cell with a span of 2)
</li>
<li>
Succeeding empty cell (if the month ends on a Friday, then we need to add an empty cell with a span of 2)
</li>
</ol>
Now we need to achieve this,
we need to iterate from our start date to the end date:
<pre><code class="lang-kotlin">while (startCalendar.time.before(endCalendar.time) || startCalendar.time == endCalendar.time) {
 //...
}
</code></pre>
Now, inside out while loop, we check if the date is the first date of the month, we add our empty cell before we add an actual cell with a date.
<pre><code class="lang-kotlin">val calendarEmptyHeader: RecyclerCalenderViewItem =
 RecyclerCalenderViewItem(
 date = startCalendar.time,
 spanSize = 7,
 isEmpty = false,
 isHeader = true
 )
calendarItemList.add(calendarEmptyHeader)

val calendarEmptyWeek: RecyclerCalenderViewItem =
 RecyclerCalenderViewItem(
 date = startCalendar.time,
 spanSize = 1,
 isEmpty = true,
 isHeader = false
 )
if (dayOfWeek - 1 &lt; 0) {
 dayOfWeek = 7 + (dayOfWeek - 1)
 calendarEmptyWeek.spanSize = dayOfWeek
} else {
 calendarEmptyWeek.spanSize = dayOfWeek - 1
}
if (calendarEmptyWeek.spanSize &gt; 0) {
 // Is span size is greater then 0, then add empty cell
 calendarItemList.add(calendarEmptyWeek)
}
</code></pre>
Now, after you added an empty cell, just add the actual date and increment the start date by 1 day
<pre><code class="lang-kotlin">val calendarDateItem: RecyclerCalenderViewItem =
 RecyclerCalenderViewItem(
 date = startCalendar.time,
 spanSize = 1,
 isEmpty = false,
 isHeader = false
 )
calendarItemList.add(calendarDateItem)
startCalendar.add(Calendar.DATE, 1)
</code></pre>
After doing all that in the while loop, we now have a list with all the dates, headers and empty cells.
Use this list as input to your <code>RecyclerView</code> and render each date, month and empty cell with different views, customize them as per your need.
<h1>Or</h1>
Simply use this library, customize your views as per your need, supports events, and add additional views and animations, the possibilities are endless.
<div class="embed-wrapper">
<div class="embed-loading">
<div class="loadingRow"></div>
<div class="loadingRow"></div>
</div>
<a class="embed-card" href="https://github.com/tejpratap46/RecyclerCalendarAndroid">https://github.com/tejpratap46/RecyclerCalendarAndroid</a>
</div>

Android: How to create Custom Calendar with RecyclerView

Transitions in Android help users navigate from one screen to another with a smooth animation.
There are mainly 2 ways you can create and attach a transition.
<ol>
<li>
Create a <code>res/anim</code> resource and attach it to fragment transaction via <code>setCustomAnimations</code>
</li>
<li>
Create a <code>res/transition</code> resource and attach it to fragment via <code>setEnterTransition</code> and <code>setExitTransition</code>
</li>
</ol>
<h3>via <a target="_blank" href="https://developer.android.com/reference/androidx/fragment/app/FragmentTransaction#setCustomAnimations(int,%20int)"><code>setCustomAnimations</code></a>
</h3>
Simplest way to set custom transition animation is via <code>setCustomAnimations</code> which accepts 4 animation files, one for each transition.
<pre><code class="lang-kotlin">val fragment = FragmentB()
supportFragmentManager.commit {
 setCustomAnimations(
 enter = R.anim.slide_in,
 exit = R.anim.fade_out,
 popEnter = R.anim.fade_in,
 popExit = R.anim.slide_out
 )
 replace(R.id.fragment_container, fragment)
 addToBackStack(null)
}
</code></pre>
All transitions will be part of your <code>res/anim</code> folder.
Pros:
<ul>
<li>
Simplest way to add a transition.
</li>
<li>
Supports all build-in animations such as <code>scale</code>, <code>Fade</code>, <code>translate</code> etc.
</li>
<li>
Handles most common scenarios.
</li>
</ul>
Cons:
<ul>
<li>Cannot fine-tune transitions based of <code>Views</code>. Transition will be applied to whole view.</li>
</ul>
To overcome the above limitation, android has another method to attach a transition.
<h3>Via <a target="_blank" href="https://developer.android.com/reference/android/app/Fragment#setEnterTransition(android.transition.Transition)"><code>setEnterTransition</code></a> Or <a target="_blank" href="https://developer.android.com/reference/android/app/Fragment#setExitTransition(android.transition.Transition)"><code>setExitTransition</code></a>
</h3>
<code>setEnterTransition</code> and <code>setExitTransition</code> work differently than <code>setCustomAnimations</code> as they accept Transition Object instead of animation, we need to create transitions in <code>res/transition</code> folder.
Pros:
<ul>
<li>
Instead of running animation on complete view, a transition will run transition on all the child view's and their child views if they have any background.
</li>
<li>
We can exclude a view from transition with <code>excludeTarget(</code><a target="_blank" href="http://r.id/"><code>R.id</code></a><code>.view_to_exclude, true)</code> . Transition will run on all views except this view and its children.
</li>
<li>
Similarly, you can add a view to transition using <code>addTarget(</code><a target="_blank" href="http://r.id/"><code>R.id</code></a><code>.rv_bottom_widget_list)</code> . Transition will only run on this view and exclude all other views in the fragment.
</li>
</ul>
Now we can come to the part where we run multiple transitions on same fragment.
<h3>Running Multiple Transitions At Once</h3>
We can use <code>TransitionSet</code> to create a set of all the transitions that we want to run together. The only caveat is:
<blockquote>
You can only run one type of transition only once per view
</blockquote>
Q. What does it mean?
A. For example, if you are running <code>Fade</code> transition on a <code>layout</code> then that it's child, a <code>imageView</code> cannot have another <code>Fade</code> transition which goes on for a longer duration. You have only one choice, remove <code>imageVIew</code> from 1st transition and add only <code>imageView</code> in the second Fade Transition.
<pre><code class="lang-kotlin">// Remove imageView from parent transition, this will remove Fade transition only from imageView
val firstTransition = new Fade().excludeTarget(R.id.imageView, true)
// add second fade transition to imageView so second transition will only run on imageView
val secondTransition = new Fade().addTarge(R.id.imageVIew)
</code></pre>
<h3>Add delay to transition</h3>
<ul>
<li>
With <code>setStarteDelay</code> : You can add delay with <code>setStartDelay(long delay)</code>. It will ask the transition to run after a specified delay.
<pre><code class="lang-kotlin"> new Fade().setStartDelay(1000)
</code></pre>
</li>
</ul>
<ul>
<li>
with <code>setOrdering</code> : You can also create a <code>TransitionSet</code> and make it execute sequentially so each transition will execute one after another.
<pre><code class="lang-kotlin"> TransitionSet()
 .setOrdering(TransitionSet.ORDERING_SEQUENTIAL)
</code></pre>
</li>
<li>
With <code>Interpolator</code> : interpolator allows you to return different time value instead of a linear time. With this, you can return time value as <code>zero</code> until you want to start your animation.
<pre><code class="lang-kotlin"> public class SlideInterpolator implements TimeInterpolator {
 public SlideInterpolator() {
 }

 @Override
 public float getInterpolation(float input) {
 float out;
 if (input &lt; 0.5f) {
 out = 0;
 } else {
 out = input;
 }
 return out;
 }
 }
</code></pre>
</li>
</ul>

How to run Multiple Transitions in Android at Once

Sometimes when you are running tests in Android Studio or Intellij Idea, you might face a failed case with following error statement:
<blockquote>
test should never throw an exception to this level
</blockquote>
Cause of these errors are usually <code>NullPointer</code> or some other Exception which is not handled properly and statement is not clear where this Exception might be.
Now we can use Debugger to find exact line which is causing this failure.
Here are the steps on how:
<ol>
<li>Press <code>ctrl+shift+F8</code> or search for 'View Breakpoints'</li>
</ol>
You will see a dialog like this:
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1668510612650/O34iADbDd.png" alt="image.png">
<ol>
<li>
Check 'Any Exception' checkbox. It will now tell debugger to pause on any line that throws any uncaught exception.
</li>
<li>
Debug you test case and you will get the exact line that is causing this failure.
</li>
</ol>

Android Studio/IntelliJ: How to break on NullPointer or any other Excetion

<code>Mockito.when()</code> allows us to mock behavior of methods in that class. But in order to achieve this we need to mock supplied parameters exactly as our source class expected, If any of our parameter is mismatched, our method will not be mocked and it will return <code>null</code> as a result.
We can avoid this by using ArgumentMatcher and ArgumentCaptor.
Here is a simple example:
<pre><code class="lang-Java">// This is a simple method that has to be mocked
final int addition = calculator.getAddition(2, 3);
</code></pre>
<pre><code class="lang-Java">// For cases, where you do not know exact parameter then you can use Mockito.anyInt()
Mockito.when(mckCalculator.getAddition(Mockito.anyInt(), Mockito.anyInt())).thenReturn(5);
</code></pre>
These <code>any</code> matchers comes too handy when parameters are either computed by program or you simply want to assert if correct parameter are passed to the method.
Similar to <code>any()</code>, we also have type specific matchers, but keep in mind these matcher will not work if your argument is null.
Here is a list of all other matchers available to you:
Mockito.anyInt(), Mockito.anyLong(), Mockito.anyString(), Mockito.anyBoolean(), Mockito.anyByte(), Mockito.anyChar(), Mockito.anyFloat(), Mockito.anyDouble(), Mockito.anyShort(), Mockito.anyList(), Mockito.anySet() and Mockito.anyMap()
Lets see an example:
We have a <code>TaskManager.class</code> which will be mocked eventually.
<pre><code class="lang-Java">public class TaskManager {
 private Map&lt;String, Task&gt; taskMap = new ConcurrentHashMap&lt;&gt;();
 public Task createTask(String name) {
 final task = new Task();
 taskMap.put(name, task);
 return task;
 }

 public void deleteTask(String name) {
 taskMap.remove(name);
 }

 public void executeTask(String name, Runnable runnable) {
 // Some long running task
 runnable.run();
 }
}
</code></pre>
We have another class which uses <code>TaskManager.class</code> internally, lets call it <code>ExampleWorker</code>. We have to write tests for <code>ExampleWorker</code>.
<pre><code class="lang-Java">public class ExampleWorker {
 private final String TASK_NAME = "exampleWorkedTask";

 private final TaskManager mTaskManager;
 private final Task mTask;

 public ExampleTask(TaskManager taskManager) {
 mTaskManager = taskManager;
 mTask = mTaskManager.createTask(TASK_NAME);
 }

 public Task getTask() {
 return mTask;
 }

 public void deleteTask() {
 mTaskManager.deleteTask(TASK_NAME);
 mTask = null;
 }

 public void runTask() {
 mTaskManager.executeTask(TASK_NAME, new Runnable() {
 @Override
 public void run() {
 // Do something here
 }
 });
 }
}
</code></pre>
We can write test for <code>ExampleWorker</code> as below:
<pre><code class="lang-Java">public class ExampleWorkerTest {
 private ExampleWorker classUnderTest;

 private TaskManager mckTaskManager;

 @Before
 public void setUp() throws Exception {
 mckTaskManager = Mockito.mock(TaskManager.class);

 classUnderTest = new ExampleWorker(mckTaskManager);
 }

 @After
 public void tearDown() throws Exception {
 classUnderTest = null;
 }

 @Test
 public void constructor_shouldCreateTask() {
 // Then
 final Task actualResult = classUnderTest.getTask();
 Assert.assertNotNull(actualResult);
 }
}
</code></pre>
Now comes the fun part where we try to test <code>deleteTask()</code> method which will internally call <code>TaskManager</code>'s <code>deleteTask(taskName)</code> method.
We can write simple tests with ArgumentMatcher.
<pre><code class="lang-Java">@Test
public void deleteTask_shouldRemoveTask() {
 // Given
 // There are multiple ways to mock same statement, use eany one of these three based on your requirement
 // You can match exact parameter
 Mockito.doNothing().when(mckTaskManager).deleteTask("exampleWorkedTask");
 // You can match anyString(), but it will not work when string is null
 Mockito.doNothing().when(mckTaskManager).deleteTask(Mockito.anyString());
 // You can match any(), it will work even if parameter String is null
 Mockito.doNothing().when(mckTaskManager).deleteTask(Mockito.any());

 // When
 classUnderTest.deleteTask();

 // Then
 final Task actualResult = classUnderTest.getTask();
 Assert.assertNotNull(actualResult);
}
</code></pre>
But what if we want to assert on the parameters passed while calling <code>deleteTask(taskName)</code> method, we can use ArgumentCaptor
<pre><code class="lang-Java">@Test
public void deleteTask_shouldRemoveTask_assertWithArgumenCaptor() {
 // Given
 final ArgumentCaptor&lt;String&gt; taskNameArgumentMatcher = ArgumentCaptor.forClass(String.class);
 // You can create a captor and validate
 Mockito.doNothing().when(mckTaskManager).deleteTask(taskNameArgumentMatcher.captor());

 // When
 classUnderTest.deleteTask();

 // Then
 // Now we can get the value from taskNameArgumentMatcher and assert it with expectedValue
 final String actualTaskName = taskNameArgumentMatcher.getValue();
 Assert.assertEquals("exampleWorkedTask", actualTaskName);
}
</code></pre>
But guess what, you can also get parameters used with ArgumentMatcher same as ArgumentCaptor. Here is an example:
<pre><code class="lang-Java">@Test
public void deleteTask_shouldRemoveTask_assertWithArgumenMatcher() {
 // Given
 final AtomicReference&lt;String&gt; taskNameReference = new AtomicReference&lt;&gt;();
 Mockito.doAnswer(invocation -&gt; {
 taskNameReference.set(0, invocation.getArgument(0, String.class));
 return null;
 }).when(mckTaskManager).deleteTask(Mockito.anyString());

 // When
 classUnderTest.deleteTask();

 // Then
 // Now we can get the value from taskNameArgumentMatcher and assert it with expectedValue
 final String actualTaskName = taskNameReference.get();
 Assert.assertEquals("exampleWorkedTask", actualTaskName);
}
</code></pre>
P.S. ArgumentMatcher and ArgumentCaptor both work in a similar way difference is just with the syntax. ArgumentCaptor gives clear API to assert the values passed while ArgumentMatcher was general purpose matchers that can do everything.

Mockito: ArgumentMatcher vs ArgumentCaptor

PowerMock is a powerful library that works on byte code level of our program.
This blog will only talk about when and how you need to use <code>@PrepareForTest</code>. If you need to know more about other things PowerMock can do, <a target="_blank" href="https://blog.tejpratapsingh.com/powermock-cheatsheet-tldr-and-tips-cl9cvkr9q000h09l685g2dqhe">read this one first</a>
<h2>PrepareForTest annotation</h2>
PrepareForTest has one job, it will creates a reflection of your class at bytecode level. It allows you to manipulate your source code such that you can change behavior (implementation) of declared methods.
This comes handy when you are working with class or methods that are now allowed to be mocked by Java Reflection.
Here are some f the use cases for PrepareForTest:
<ol>
<li>mock static methods<pre><code class="lang-Java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 ClassWithStaticMethods.class,
})
public class ClassToTest {
 @Before
 public void setUp() throws Exception {
 PowerMockito.mockStatic(ClassWithStaticMethods.class);
 PowerMockito.when(ClassWithStaticMethods.staticMethod()).thenReturn(someValue);
 }
}
</code></pre>
</li>
<li>
mock final classes/methods:
Mockito cannot mock final methods even if you have created mock of that class. To mock these methods, we need to prepare that class and mock it with <code>PowerMockito.mock()</code>.
<pre><code class="lang-Java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 FinalClass.class,
 ClassWithFinalMethods.class,
})
public class ClassToTest {
 @Test
 public void testFinalMethods() throws Exception {
 final FinalClass mckFinalClass = PowerMockito.mock(FinalClass.class);
 PowerMockito.when(mckFinalClass.someMethod()).thenReturn(someValue);

 final ClassWithFinalMethods mckClassWithFinalMethods = PowerMockito.mock(ClassWithFinalMethods.class);
 PowerMockito.when(mckClassWithFinalMethods.someFinalMethod()).thenReturn(someValue);
 }
}
</code></pre>
</li>
<li>
Inject with PowerMockito.whenNew()
When you need to inject a mock instead of creating an actual instance of a class, you can use <code>PowerMockito.whenNew()</code>. This will inject your mock whenever new instance is created in your source class.
<pre><code class="lang-Java">// Example Source Class
public class ExampleClass {
 public int getHeight() {
 // Lets say we have a generic method which provides different result base on the provided id
 final CustomClass customClassInstance = new CustomClass();
 return customClass.getHeight();
 }
}
</code></pre>
In this example class, we are creating <code>CustomClass</code> without any injection mechanism, we can inject our mock by adding <code>ExampleClass</code> in <code>PrepareForTest</code> and using <code>PowerMockito.whenNew()</code>:
<pre><code class="lang-Java">@RunWith(PowerMockRunner.class)
@PrepareForTest({
 ExampleClass.class
})
public class ExampleClassTest {

 private ExampleClass classUnderTest;

 @Before
 public void setUp() throws Exception {
 // Create constructor of ExampleClass
 classUnderTest = new ExampleClass();
 }

 @Test
 public void getHeight_shoudReturnHeightOfView() throws NoSuchMethodException {
 final int expectedHeight = 100;
 // Given
 final CustomClass mckCustomClass = Mockito.mock(CustomClass.class);
 Mockito.when(mckCustomClass.getHeight()).theReturn(expectedHeight);
 // Make sure you match exact parameters while mocking (same as we do for Mockito.mock statements).
 // There is also withArguments(first, second, ....)
 // and withAnyArguments() for cases when you don't care for arguments passed.
 PowerMockito.whenNew(CustomClass.class).withNoArguments().thenReturn(mckCustomClass);

 final int actualResult = classUnderTest.getHeight();

 Assert.assertEquals(expectedHeight, actualResult);
 }
}
</code></pre>
</li>
<li>To <code>suppress()</code>, <code>stub()</code> or <code>replace()</code> any method of a Class.
You can modify behavior of methods declared in any class, You can:</li>
<li>
<code>suppress()</code> methods and constructors.<pre><code class="lang-Java">// Suppress Constructor
PowerMockito.suppress(CustomLibClass.class.getConstructors());
// Suppress Method, it will return null if method has a return.
PowerMockito.suppress(CustomLibClass.class.getDeclaredMethod("someMethod"));
</code></pre>
</li>
<li>
<code>stub()</code> methods to return different value.<pre><code class="lang-Java">PowerMockito.stub(CustomLibClass.class.getDeclaredMethod("someMethodThatOnlyWorksOnRumtime")).toReturn(2);
</code></pre>
</li>
<li>
<code>replace()</code> methods to return different value depending on parameter supplied.
<pre><code class="lang-Java">PowerMockito.replace(View.class.getDeclaredMethod("someMethodThatWillReturnDifferentValue", int.class)).with(new InvocationHandler() {
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 final int viewId = (int) args[0];

 if (viewId == ViewFactory.text_view) {
 // return mock of TextView
 return Mockito.mock(TextView.class);
 } else if (viewId == ViewFactory.image_view) {
 // return mock of ImageView
 return Mockito.mock(ImageView.class);
 }
 // else you can call real method as well
 return method.invoke(proxy, args);
 }
});
</code></pre>
</li>
</ol>

PowerMock: Understanding @PrepareForTest

Powermock CheatSheet: Tldr and Tips

These are some of the useful methods and classes provided by Mockito
<h3>1. Mockito.mock()</h3>
Creates a mock of any class. By default, it will return default value for methods and fields when not mocked.
For Example:
Primitive data types such as <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, <code>float</code>, <code>double</code>, <code>boolean</code> and char will return default value i.e <code>0</code> or <code>false</code>
Non-primitive data types such as <code>String</code>, <code>Arrays</code> and <code>Classes</code> return <code>null</code> when they are not mocked. 
<pre><code class="lang-java">// with annotation
@Mock
private ClassName mock;

// Or with static method
final ClassName mock = Mockito.mock(ClassName.class);

// mock methods that returns something
Mockito.when(mock.sampleMethod()).thenReturn(sampleVal);

// mock method to throw Exception
Mockito.when(mock.sampleMethod()).thenThrow(SampleException.class);

// Mock void methods
Mockito.doNothing().when(mock).method();

// you can get invocation parameters with .thenAnswer()
Mockito.when(mock.sampleMethod(Mockito.any(OtherClass.class))).thenAnswer((Answer&lt;ThirdClass&gt;) invocation -&gt; {
 final OtherClass parameter1 = invocation.getArgument(0);
 return thirdClassObject; 
});

// Verify interactions
Mockito.verify(mock, Mockito.times(1)).sampleMethod();

// Verify, method should not be invoked even once
Mockito.verify(mock, Mockito.never()).sampleMethod2();

// Verify, no methods should be called on given mock
Mockito.verifyNoMoreInteractions(otherMockedClass);
</code></pre>
<h3>2. Mockito.spy()</h3>
It is similar to <code>mock()</code> but instead of return default value it will call the actual implementation when not mocked.
<pre><code class="lang-java">// with annotation
@Spy
private ClassName spy;

// Or with static method
final ClassName spy = Mockito.spy(ClassName.class);

// mock methods that returns something
Mockito.doReturn(value).when(spy).method();

// mock method to throw exception
Mockito.doThrow(new ExceptionClass()).when(spy).metohd();

// mock void methods
Mockito.doNothing().when(spy).method();
</code></pre>
<h3>3. Mockito.mockStatic()</h3>
Now with Mockito 3, you can mock Classes with static methods.
<pre><code class="lang-java">try (MockedStatic&lt;Foo&gt; dummyStatic = Mockito.mockStatic(ClassName.class)) {
 dummyStatic.when(() -&gt; ClassName.method("param1"))
 .thenReturn("someValue");
 // when
 System.out.println(ClassName.method("param1"));
 //then
 dummyStatic.verify(
 () -&gt; ClassName.method("param1"),
 times(1), 
 );
}
</code></pre>
<h3>4. ArgumentMatcher</h3>
Basic Rule to match any statement with Mockito is to correctly match its parameters. If any of the parameter did not match then instruction will not be mocked.
<pre><code class="lang-java">// example statement
final int addition = calculator.getAddition(2, 3);

// you have to match exact parameters, in this case (2,3)
Mockito.when(mckCalculator.getAddition(2, 3)).thenReturn(5);

// If you mock for (3,4), you mocked result will not be returned
Mockito.when(mckCalculator.getAddition(3, 4)).thenReturn(5);

// For cases, where you do not know exact parameter then you can use Mockito.anyInt()
Mockito.when(mckCalculator.getAddition(Mockito.anyInt(), Mockito.anyInt())).thenReturn(5);
</code></pre>
Similarly we have <code>Mockito.any()</code>, <code>Mockito.anyLong()</code>, <code>Mockito.anyString()</code>, <code>Mockito.anyBoolean()</code>, <code>Mockito.anyByte()</code>, <code>Mockito.anyChar()</code>, <code>Mockito.anyFloat()</code>, <code>Mockito.anyDouble()</code>, <code>Mockito.anyShort()</code>, <code>Mockito.anyList()</code>, <code>Mockito.anySet()</code> and <code>Mockito.anyMap()</code>
<h3>5. ArgumentCaptor</h3>
You can also get value of parameters of mocked methods, you can then Assert for their value.
Below is the same example of calculator class.
<pre><code class="lang-java">// example statement
final int addition = calculator.getAddition(2, 3);

// Create captor
ArgumentCaptor&lt;Integer&gt; argumentCaptor = ArgumentCaptor.forClass(Integer.class);

Mockito.when(mckCalculator.getAddition(argumentCaptor.capture(), argumentCaptor.capture())).thenReturn(5);

final int firstNum = argumentCaptor.getValue();
Assert.assertEquals(2, firstNum);

// You can get second num by calling getAllValues()
final int secondNum = argumentCaptor.getAllValues()[1];
Assert.assertEquals(3, secondNum);
</code></pre>

Mockito CheatSheet: Tldr and Tips

In <a target="_blank" rel="noopener noreferrer" href="https://blog.tejpratapsingh.com/android-create-pdf-without-any-library-part-2-ck9eads8g05e3css1bx1mlns2">last part</a> we successfully created a complex Pdf with dynamic data.
After we create a Pdf, we should be able to show contents of Pdf to User, to do that we can use <code>PdfRenderer</code> class and get bitmap of every page inside Pdf.
Here is a simple function you can use to get Pdf pages as Bitmap
<pre><code class="lang-java"> /**
 * Convert PDF to bitmap, only works on devices above LOLLIPOP
 *
 * @param pdfFile pdf file
 * @return list of bitmap of every page
 * @throws Exception
 */
 public static ArrayList&lt;Bitmap&gt; pdfToBitmap(File pdfFile) throws Exception, IllegalStateException {
 if (pdfFile == null || pdfFile.exists() == false) {
 throw new IllegalStateException("");
 }
 if (android.os.Build.VERSION.SDK_INT &lt; android.os.Build.VERSION_CODES.LOLLIPOP) {
 throw new Exception("PDF preview image cannot be generated in this device");
 }
 if (android.os.Build.VERSION.SDK_INT &lt; android.os.Build.VERSION_CODES.LOLLIPOP) {
 return null;
 }

 ArrayList&lt;Bitmap&gt; bitmaps = new ArrayList&lt;&gt;();

 try {
 PdfRenderer renderer = new PdfRenderer(ParcelFileDescriptor.open(pdfFile, ParcelFileDescriptor.MODE_READ_ONLY));

 Bitmap bitmap;
 final int pageCount = renderer.getPageCount();
 for (int i = 0; i &lt; pageCount; i++) {
 PdfRenderer.Page page = renderer.openPage(i);

 int width = page.getWidth();
 int height = page.getHeight();

 /* FOR HIGHER QUALITY IMAGES, USE:
 int width = context.getResources().getDisplayMetrics().densityDpi / 72 * page.getWidth();
 int height = context.getResources().getDisplayMetrics().densityDpi / 72 * page.getHeight();
 */

 bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
 page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);

 bitmaps.add(bitmap);

 // close the page
 page.close();
 }
 // close the renderer
 renderer.close();
 } catch (Exception ex) {
 ex.printStackTrace();
 }
 return bitmaps;
 }
</code></pre>
<hr>
To make your work easier i have created a Library to generate dynamic PDF using above methods <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid">View on Github</a>
 <a target="_blank" rel="noopener noreferrer" href="https://github.com/tejpratap46/PDFCreatorAndroid"><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1587719632043/mXw6_IETk.png" alt="Simple library to generate and view PDF in Android.png"></a>