How do you decide when to use raw values versus matchers in Mockito

Raw Values

Use Cases:
- Specific Behavior: Use raw values when you want to test a specific behavior of your method with exact input parameters. This ensures that your test is precise and only passes if the method behaves as expected with those exact inputs.
- Equality Matching: Raw values are implicitly matched using `eq()` by Mockito, meaning that if you pass a raw value, Mockito will automatically use an equality matcher (`eq()`) for it. This is useful when you want to ensure that the method is called with a specific value.

Example:

java
Mockito.when(mockFoo.bool("false", 10, new Object())).thenReturn(false);

Matchers

Use Cases:
- Generic Behavior: Use matchers when you want to test a generic behavior of your method, regardless of the specific input values. This is particularly useful when you're testing that a method is called, but you don't care about the exact values passed to it.
- Flexibility: Matchers provide flexibility in your tests. For example, you can use `anyString()`, `anyInt()`, or `any()` to match any value of a specific type. This makes your tests less brittle and more focused on the overall functionality rather than specific input values.

Example:

java
Mockito.when(mockFoo.bool(anyString(), anyInt(), any(Object.class))).thenReturn(true);

Mixing Raw Values and Matchers

**Important Rule: When using matchers, all arguments must be provided by matchers. You cannot mix raw values with matchers in the same method call. If you need to specify a specific value while using matchers for other arguments, use the `eq()` matcher explicitly for the specific value.

Example:

java
Mockito.when(mockFoo.bool(eq("false"), anyInt(), any(Object.class))).thenReturn(false);

Choosing Between Raw Values and Matchers

- Test Specificity: If your test requires a specific input to validate a particular behavior, use raw values. If you're testing a more generic scenario where the exact input doesn't matter, use matchers.
- Test Robustness: Using matchers can make your tests more robust by reducing their dependency on specific input values. However, if the method's behavior is tightly coupled with specific inputs, raw values might be more appropriate.
- Readability and Maintainability: Consider the readability and maintainability of your tests. If a test is overly complex due to many specific raw values, using matchers might simplify it and make it easier to understand.

Ultimately, the choice between raw values and matchers in Mockito depends on the specific requirements of your test scenario and your testing strategy.