Fix missing space in shown exceptions; test both legacy and new Exception(s) module API

inline-c-cpp/src/Language/C/Inline/Cpp/Exception.hs

@@ -41,7 +41,7 @@ data CppException
   | CppNonStdException CppExceptionPtr (Maybe ByteString)
 
 instance Show CppException where
-  showsPrec p (CppStdException _ msg typ) = showParen (p >= 11) (showString "CppStdException e " . showsPrec 11 msg . showsPrec 11 typ)
+  showsPrec p (CppStdException _ msg typ) = showParen (p >= 11) (showString "CppStdException e " . showsPrec 11 msg . showChar ' ' . showsPrec 11 typ)
   showsPrec p (CppHaskellException e) = showParen (p >= 11) (showString "CppHaskellException " . showsPrec 11 e)
   showsPrec p (CppNonStdException _ typ) = showParen (p >= 11) (showString "CppOtherException e " . showsPrec 11 typ)
 

inline-c-cpp/test/tests.hs

@@ -13,7 +13,7 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeInType #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE TypeApplications #-}
@@ -121,21 +121,26 @@
         throw std::runtime_error("C++ error message");
         |]
 
-      result `shouldBeCppStdException` "Exception: C++ error message; type: std::runtime_error"
+      result `shouldBeCppStdException` ("C++ error message", Just "std::runtime_error")
+      result `shouldBeLegacyCppStdException` "Exception: C++ error message; type: std::runtime_error"
+      -- Test that we don't accidentally mess up formatting:
+      result `shouldBeShownException` "CppStdException e \"C++ error message\" (Just \"std::runtime_error\")"
 
     Hspec.it "non-exceptions are caught (unsigned int)" $ do
       result <- try [C.catchBlock|
         throw 0xDEADBEEF;
         |]
 
-      result `shouldBeCppOtherException` (Just "unsigned int")
+      result `shouldBeCppNonStdException` (Just "unsigned int")
+      result `shouldBeLegacyCppOtherException` (Just "unsigned int")
 
     Hspec.it "non-exceptions are caught (void *)" $ do
       result <- try [C.catchBlock|
         throw (void *)0xDEADBEEF;
         |]
 
-      result `shouldBeCppOtherException` (Just "void*")
+      result `shouldBeCppNonStdException` (Just "void*")
+      result `shouldBeLegacyCppOtherException` (Just "void*")
 
     Hspec.it "non-exceptions are caught (std::string)" $ do
       result <- try [C.catchBlock|
@@ -169,7 +174,8 @@
         }
         |]
 
-      result `shouldBeCppStdException` "Exception: C++ error message; type: std::runtime_error"
+      result `shouldBeCppStdException` ("C++ error message", Just "std::runtime_error")
+      result `shouldBeLegacyCppStdException` "Exception: C++ error message; type: std::runtime_error"
 
     Hspec.it "try and return without throwing (pure)" $ do
       result <- [C.tryBlock| int {
@@ -195,15 +201,17 @@
         }
         |]
 
-      result `shouldBeCppStdException` "Exception: C++ error message; type: std::runtime_error"
+      result `shouldBeCppStdException` ("C++ error message", Just "std::runtime_error")
+      result `shouldBeLegacyCppStdException` "Exception: C++ error message; type: std::runtime_error"
 
     Hspec.it "catch without return (pure)" $ do
       result <- [C.tryBlock| void {
           throw std::runtime_error("C++ error message");
         }
         |]
 
-      result `shouldBeCppStdException` "Exception: C++ error message; type: std::runtime_error"
+      result `shouldBeCppStdException` ("C++ error message", Just "std::runtime_error")
+      result `shouldBeLegacyCppStdException` "Exception: C++ error message; type: std::runtime_error"
 
     Hspec.it "try and return without throwing (throw)" $ do
       result :: Either C.CppException C.CInt <- try [C.throwBlock| int {
@@ -229,7 +237,8 @@
         }
         |]
 
-      result `shouldBeCppStdException` "Exception: C++ error message; type: std::runtime_error"
+      result `shouldBeCppStdException` ("C++ error message", Just "std::runtime_error")
+      result `shouldBeLegacyCppStdException` "Exception: C++ error message; type: std::runtime_error"
 
     Hspec.it "return throwing Haskell" $ do
       let exc = toException $ userError "This is from Haskell"
@@ -275,7 +284,8 @@
         }
         |]
 
-      result `shouldBeCppStdException` "Exception: C++ error message; type: std::runtime_error"
+      result `shouldBeCppStdException` ("C++ error message", Just "std::runtime_error")
+      result `shouldBeLegacyCppStdException` "Exception: C++ error message; type: std::runtime_error"
 
     Hspec.it "code without exceptions works normally" $ do
       result :: Either C.CppException C.CInt <- try $ C.withPtr_ $ \resPtr -> [C.catchBlock|
@@ -298,19 +308,19 @@
     {- Manual test cases for testing lineDirective and splitTypedC -- For CI, uncomment this line.
 
     Hspec.it "error reporting test case" $ do
       result <- try $ [C.throwBlock| int { 0 = 0; return 0xDEADBEEF; /* Test this line. */}|]
       result `shouldBeRight` 0xDEADBEEF
 
     Hspec.it "error reporting test case" $ do
       result <- try $ [C.throwBlock| int
         { 1 = 1; return 0xDEADBEEF; /* Test this line. */}
       |]
       result `shouldBeRight` 0xDEADBEEF
 
     Hspec.it "error reporting test case" $ do
       result <- try $ [C.throwBlock| int
         {
           2 = 2; /* Test this line. */
           return 0xDEADBEEF;
         }
       |]
@@ -320,7 +330,7 @@
       result <- try $ [C.throwBlock|
         int
         {
           3 = 3;  /* Test this line. */
           return 0xDEADBEEF;
         }
       |]
@@ -331,7 +341,7 @@
 
         int
         {
           4 = 4;  /* Test this line. */
           return 0xDEADBEEF;
         }
       |]
@@ -368,19 +378,37 @@
 tag :: C.CppException -> String
 tag (C.CppStdException {}) = "CppStdException"
 tag (C.CppHaskellException {}) = "CppHaskellException"
-tag (Legacy.CppOtherException {}) = "CppStdException"
+tag (C.CppNonStdException {}) = "CppNonStdException"
 
-shouldBeCppStdException :: Either C.CppException a -> String -> IO ()
-shouldBeCppStdException (Left (Legacy.CppStdException actualMsg)) expectedMsg = do
-  actualMsg `Hspec.shouldBe` expectedMsg
+shouldBeShownException :: Either C.CppException a -> String -> IO ()
+shouldBeShownException (Left e) expectedStr = show e `shouldBe` expectedStr
+shouldBeShownException (Right _) _expectedStr = "Right _" `Hspec.shouldBe` "Left _"
+
+shouldBeCppStdException :: Either C.CppException a -> (ByteString, Maybe ByteString) -> IO ()
+shouldBeCppStdException (Left (C.CppStdException _ actualMsg actualType)) (expectedMsg, expectedType) = do
+  (actualMsg, actualType) `shouldBe` (expectedMsg, expectedType)
 shouldBeCppStdException (Left x) expectedMsg = tag x `Hspec.shouldBe` ("CppStdException " <> show expectedMsg)
 shouldBeCppStdException (Right _) expectedMsg = "Right _" `Hspec.shouldBe` ("Left (CppStdException " <> show expectedMsg <> ")")
 
-shouldBeCppOtherException :: Either C.CppException a -> Maybe String -> IO ()
-shouldBeCppOtherException (Left (Legacy.CppOtherException actualType)) expectedType = do
+-- | Tests that the old, deprecated exception's module and error messages still work.
+shouldBeLegacyCppStdException :: Either Legacy.CppException a -> String -> IO ()
+shouldBeLegacyCppStdException (Left (Legacy.CppStdException actualMsg)) expectedMsg = do
+  actualMsg `Hspec.shouldBe` expectedMsg
+shouldBeLegacyCppStdException (Left x) expectedMsg = tag x `Hspec.shouldBe` ("CppStdException " <> show expectedMsg)
+shouldBeLegacyCppStdException (Right _) expectedMsg = "Right _" `Hspec.shouldBe` ("Left (CppStdException " <> show expectedMsg <> ")")
+
+shouldBeCppNonStdException :: Either C.CppException a -> Maybe ByteString -> IO ()
+shouldBeCppNonStdException (Left (C.CppNonStdException _ actualType)) expectedType = do
+  actualType `Hspec.shouldBe` expectedType
+shouldBeCppNonStdException (Left x) expectedType = tag x `Hspec.shouldBe` ("CppOtherException " <> show expectedType)
+shouldBeCppNonStdException (Right _) expectedType = "Right _" `Hspec.shouldBe` ("Left (CppOtherException " <> show expectedType <> ")")
+
+-- | Tests that the old, deprecated exception's module and error messages still work.
+shouldBeLegacyCppOtherException :: Either Legacy.CppException a -> Maybe String -> IO ()
+shouldBeLegacyCppOtherException (Left (Legacy.CppOtherException actualType)) expectedType = do
   actualType `Hspec.shouldBe` expectedType
-shouldBeCppOtherException (Left x) expectedType = tag x `Hspec.shouldBe` ("CppOtherException " <> show expectedType)
-shouldBeCppOtherException (Right _) expectedType = "Right _" `Hspec.shouldBe` ("Left (CppOtherException " <> show expectedType <> ")")
+shouldBeLegacyCppOtherException (Left x) expectedType = tag x `Hspec.shouldBe` ("CppOtherException " <> show expectedType)
+shouldBeLegacyCppOtherException (Right _) expectedType = "Right _" `Hspec.shouldBe` ("Left (CppOtherException " <> show expectedType <> ")")
 
 shouldBeRight :: (Eq a, Show a) => Either C.CppException a -> a -> IO ()
 shouldBeRight (Right actual) expected = actual `Hspec.shouldBe` expected