Tej Pratap Singh

We all know, each component in Android has its lifecycle, be it Activity, Fragment or Service. Each component gets created and destroys (and a few other stages in between).To create a custom class that is lifecycle aware inherently, we can use a set of libraries provided under <a target="_blank" href="https://developer.android.com/jetpack/androidx/releases/lifecycle">jetpack lifecycle</a>.
For example, I want to create a timer, which invokes a method on each interval, and also, it should be lifecycle aware so it dies with its owner.
Firstly, we will create an interface that extends <code>LifecycleOwner</code>, this interface is implemented all new <code>androidx.</code> components.
<pre><code class="lang-java">public interface OnIntervalListener extends LifecycleOwner { void onTimerInterval();}</code></pre>
Now, we create out actual timer,
<pre><code class="lang-java">/** * @implNote An implementation of lifecycle aware timer, can be attached to Activity or fragment */public class LifecycleAwareTimer implements Runnable, DefaultLifecycleObserver { public interface OnIntervalListener extends LifecycleOwner { void onTimerInterval(); } private final Handler mHandler = new Handler(Looper.getMainLooper()); private final long mInterval; private final OnIntervalListener mOnIntervalListener; public LifecycleAwareTimer(long interval, @NonNull OnIntervalListener onIntervalListener) { mInterval = interval; mOnIntervalListener = onIntervalListener; mOnIntervalListener.getLifecycle().addObserver(this); } @Override public void run() { mOnIntervalListener.onTimerInterval(); } @Override public void onResume(@NonNull LifecycleOwner owner) { mHandler.removeCallbacksAndMessages(null); mHandler.postDelayed(this, mInterval); } @Override public void onPause(@NonNull LifecycleOwner owner) { mHandler.removeCallbacksAndMessages(null); } @Override public void onDestroy(@NonNull LifecycleOwner owner) { mHandler.removeCallbacksAndMessages(null); mOnIntervalListener.getLifecycle().removeObserver(this); }}</code></pre>
Now, you can use it creates a new instance from Activity or Fragment and it will die once its owner dies.]]&gt;

We all know, each component in Android has its lifecycle, be it Activity, Fragment or Service. Each component gets created and destroys (and a few other stages in between).
To create a custom class that is lifecycle aware inherently, we can use a set...

How to create a lifecycle aware custom class in Android.

The Android Interface Definition Language (AIDL) is similar to other <a target="_blank" href="https://en.wikipedia.org/wiki/Interface_description_language">IDLs</a>: it lets you define the programming interface that both the client and service agree upon in order to communicate with each other using interprocess communication (IPC).
Aidl consists of 3 parts:
<ol>
<li>AIDL file</li>
<li>Client application</li>
<li>Server application</li>
</ol>
<h3>Creating AIDL file</h3>
<ol>
<li>
Enable build feature in your <code>build.gradle</code>.
<pre><code class="lang-java"> buildFeatures { aidl = true }</code></pre>
</li>
<li>Create a new AIDL file using <code>File</code> -&gt; <code>New</code> -&gt; <code>AIDL</code> -&gt; <code>AIDL File</code></li>
<li>Let's name it <code>ICalculator.aidl</code></li>
<li>
Declare aidl methods:
<pre><code class="lang-kotlin"> interface IExampleAidlInterface { int add(int a, int b); }</code></pre>
</li>
</ol>
<h3>Create an AIDL server</h3>
An AIDL server is an app that does the actual work and sends back the result to requesting clients. One service can connect with multiple clients via Binders.
Steps:
<ol>
<li>Create a service, e.g. <code>CalculatorService extends Service</code></li>
<li>Create an Implementation of <code>ICalculator.Stub</code>, lets name it <code>CalculatorImpl</code></li>
<li>
Implement methods:
<pre><code class="lang-kotlin"> object CalculatorImpl : ICalculator.Stub() { override fun add(a: Int, b: Int): Int { return a + b } }</code></pre>
</li>
<li>
Expose your stub implementation with a service binder:
<pre><code class="lang-kotlin"> class CalculatorService : Service() { override fun onBind(intent: Intent): IBinder { return CalculatorImpl } }</code></pre>
</li>
</ol>
Now your service is ready to be consumed by your clients, now let's create a client application.
<h3>Create an AIDL client</h3>
An AIDL client is an app that binds to an AIDL service, calls API, and shows a response inside its views.
Steps:
<ol>
<li>
Create a service connection:
<pre><code class="lang-kotlin"> private var aidlService: ICalculator? = null private val serviceConnection = object : ServiceConnection { override fun onServiceConnected(name: ComponentName?, service: IBinder?) { aidlService = ICalculator.Stub.asInterface(service) Toast.makeText(applicationContext, "Service Connected", Toast.LENGTH_LONG).show() } override fun onServiceDisconnected(name: ComponentName?) { aidlService = null Toast.makeText(applicationContext, "Service Disconnected", Toast.LENGTH_LONG).show() } }</code></pre>
</li>
<li>
Connect to AIDL service via Binders.
<pre><code class="lang-kotlin"> val serviceIntent = Intent() serviceIntent.component = ComponentName(BuildConfig.AIDL_PACKAGE, BuildConfig.AIDL_SERVICE) bindService(serviceIntent, serviceConnection, BIND_AUTO_CREATE)</code></pre>
</li>
<li>
Call methods of AIDL after successful connection:
<pre><code class="lang-kotlin"> aidlService?.add(2, 2)?.let { Toast.makeText( applicationContext, String.format(Locale.getDefault(), "Sum is: %d", it), Toast.LENGTH_LONG ).show() }</code></pre>
</li>
</ol>
<h2>Limitations</h2>
There is one BIG gotcha with AIDL services, which is when the system is in doze mode, your service app might not start to respond to requests.
<hr>
Here is an example application using AIDL in real life 😎
<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/AIDL-Example">https://github.com/tejpratap46/AIDL-Example</a>
</div>]]&gt;

The Android Interface Definition Language (AIDL) is similar to other IDLs: it lets you define the programming interface that both the client and service agree upon in order to communicate with each other using interprocess communication (IPC).

Aidl ...

AIDL : IPC, The Android way

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; // 00000010val FRIES = 4; // 00000100val SODA = 8; // 00001000fun 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.]]&gt;

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...

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 Classpublic 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">// ClassToTestpublic 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.]]&gt;

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).
Whey we need when...

Limitation of PowerMockito.whenNew()

Post inspired by <a target="_blank" href="https://github.com/tejpratap46/RecyclerCalendarAndroid">RecyclerCalendarAndroid Lib</a>
<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>]]&gt;

Post inspired by RecyclerCalendarAndroid Lib

RecyclerView
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 mi...

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 imageViewval firstTransition = new Fade().excludeTarget(R.id.imageView, true)// add second fade transition to imageView so second transition will only run on imageViewval 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>]]&gt;

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.

Create a res/anim resource and attach it to fragment transaction via setCustomAnimations

...

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>]]&gt;

Sometimes when you are running tests in Android Studio or Intellij Idea, you might face a failed case with following error statement:

test should never throw an exception to this level

Cause of these errors are usually NullPointer or some other Exc...

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 mockedfinal 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">@Testpublic 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">@Testpublic 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">@Testpublic 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.]]&gt;

Mockito.when() 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 wil...

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 Classpublic 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 ConstructorPowerMockito.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>]]&gt;

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 @PrepareForTest. If you need to know more about other things PowerMock can do, read this one first
PrepareForTes...

PowerMock: Understanding @PrepareForTest

Why we need Powermock?
Although Mockito is most popular Mocking Library for Java Developers, But there are certain cases where Simple Mockito does not work. For Example, if your codebase uses any Singleton, you cannot mock them with Simple Mockito.
T...