Is it possible to verify method calls in a specific order without using InOrder

Using `InOrder` (Recommended Approach)

Before exploring alternatives, it's worth noting how `InOrder` works. It allows you to verify that methods are called in a specific order on one or more mock objects. Here's a basic example:

java
// Create mock objects
List mockList = mock(List.class);

// Perform method calls
mockList.add("first");
mockList.add("second");

// Verify order of method calls
InOrder inOrder = inOrder(mockList);
inOrder.verify(mockList).add("first");
inOrder.verify(mockList).add("second");

Alternative Approaches

1. Manual Tracking**

You can manually track method calls by using a custom class that logs or tracks invocations. This approach requires more code and is not as straightforward as using `InOrder`.

java
public class MethodTracker {
    private List methodCalls = new ArrayList();

    public void trackMethodCall(String methodName) {
        methodCalls.add(methodName);
    }

    public boolean verifyOrder(String[] expectedOrder) {
        return methodCalls.equals(Arrays.asList(expectedOrder));
    }
}

// Example usage
MethodTracker tracker = new MethodTracker();

// Simulate method calls
tracker.trackMethodCall("methodOne");
tracker.trackMethodCall("methodTwo");

// Verify order
String[] expectedOrder = {"methodOne", "methodTwo"};
if (!tracker.verifyOrder(expectedOrder)) {
    // Order verification failed
}

2. Using `verify` with `times` and `ArgumentCaptor`

While not directly verifying order, you can use `verify` with `times` and `ArgumentCaptor` to capture arguments and then manually verify the order of captured arguments. This is more complex and less efficient than using `InOrder`.

java
// Create mock object
List mockList = mock(List.class);

// Perform method calls
mockList.add("first");
mockList.add("second");

// Capture arguments
ArgumentCaptor captor = ArgumentCaptor.forClass(String.class);
verify(mockList, times(2)).add(captor.capture());

// Verify order of captured arguments
List capturedArgs = captor.getAllValues();
if (!capturedArgs.equals(Arrays.asList("first", "second"))) {
    // Order verification failed
}

Conclusion

While it is technically possible to verify method calls in a specific order without using `InOrder`, the recommended approach is to use `InOrder` due to its simplicity and clarity. Manual tracking or using `verify` with `times` and `ArgumentCaptor` can achieve similar results but are more cumbersome and less intuitive.