expectRevert() not working

[linghuccc]

My contract codes are as below:

    function purchase(address nftContract, uint256 tokenId) external payable {
        Order storage order = orders[nftContract][tokenId];
        require(order.price > 0, "Order does not exist");
        require(msg.value >= order.price, "Insufficient payment");

        // Transfer NFT to buyer
        IERC721(nftContract).safeTransferFrom(order.owner, msg.sender, tokenId);

        // Transfer payment to seller, refund excess payment
        payable(order.owner).transfer(order.price);

        if (msg.value > order.price) {
            payable(msg.sender).transfer(msg.value - order.price);
        }

        // Clear the order
        delete orders[nftContract][tokenId];
    }

When I use below codes to test (Situation 1):

    function testFailPurchaseWithInsufficientPayment() public {
        vm.startPrank(seller);
        uint256 tokenId = 1;
        uint256 price = 1 ether;

        mockNft.setApprovalForAll(address(nftSwap), true);
        nftSwap.list(address(mockNft), tokenId, price);
        vm.stopPrank();

        // Buyer tries to purchase with insufficient funds
        vm.startPrank(buyer);
        vm.expectRevert("Insufficient payment");
        nftSwap.purchase{value: 0}(address(mockNft), tokenId);
        vm.stopPrank();
    }

I got below traces:

Traces:
  [94481] NftSwapTest::testFailPurchaseWithInsufficientPayment()
    ├─ [0] VM::startPrank(0x0000000000000000000000000000000000000111)
    │   └─ ← [Return] 
    ├─ [24581] MockNFT::setApprovalForAll(NftSwap: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], true)
    │   ├─ emit ApprovalForAll(owner: 0x0000000000000000000000000000000000000111, operator: NftSwap: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f], approved: true)
    │   └─ ← [Stop] 
    ├─ [49238] NftSwap::list(MockNFT: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], 1, 1000000000000000000 [1e18])
    │   ├─ [2598] MockNFT::ownerOf(1) [staticcall]
    │   │   └─ ← [Return] 0x0000000000000000000000000000000000000111
    │   ├─ [838] MockNFT::isApprovedForAll(0x0000000000000000000000000000000000000111, NftSwap: [0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f]) [staticcall]
    │   │   └─ ← [Return] true
    │   └─ ← [Stop] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    ├─ [0] VM::startPrank(0x0000000000000000000000000000000000000222)
    │   └─ ← [Return] 
    ├─ [0] VM::expectRevert(Insufficient payment)
    │   └─ ← [Return] 
    ├─ [819] NftSwap::purchase(MockNFT: [0x2e234DAe75C793f67A35089C9d99245E1C58470b], 1)
    │   └─ ← [Revert] revert: Insufficient payment
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    └─ ← [Stop] 

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 337.76ms (34.18ms CPU time)

Ran 1 test suite in 554.86ms (337.76ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/NftSwap.t.sol:NftSwapTest
[FAIL. Reason: assertion failed] testFailPurchaseWithInsufficientPayment() (gas: 94481)

When I use below codes to test (Situation 2):

    function testFailPurchaseWithInsufficientPayment() public {
        vm.startPrank(seller);
        uint256 tokenId = 1;
        uint256 price = 1 ether;

        mockNft.setApprovalForAll(address(nftSwap), true);
        nftSwap.list(address(mockNft), tokenId, price);
        vm.stopPrank();

        // Buyer tries to purchase with insufficient funds
        vm.startPrank(buyer);
        vm.expectRevert(); // Expect any revert
        nftSwap.purchase{value: 0}(address(mockNft), tokenId);
        vm.stopPrank();
    }

"vm.expectRevert(); " is supposed to expect any revert, but it did not work and I got the same traces.

The test only works when I use below codes (Situation 3):

    function testFailPurchaseWithInsufficientPayment() public {
        vm.startPrank(seller);
        uint256 tokenId = 1;
        uint256 price = 1 ether;

        mockNft.setApprovalForAll(address(nftSwap), true);
        nftSwap.list(address(mockNft), tokenId, price);
        vm.stopPrank();

        // Buyer tries to purchase with insufficient funds
        vm.startPrank(buyer);
        vm.expectRevert("revert: Insufficient payment");
        nftSwap.purchase{value: 0}(address(mockNft), tokenId);
        vm.stopPrank();
    }

My question is: Where is the extra "revert: " coming from???

[linghuccc]

By deleting "Fail" in the test function will fix this issue.