test: new passing test

Author: cstml

lambda-buffers-compiler/test/Test/KindCheck.hs

@@ -25,6 +25,7 @@ import Test.QuickCheck (
  )
 import Test.Samples.Proto.CompilerInput (
   compilerInput'doubleDeclaration,
+  compilerInput'doubleDeclarationDiffMod,
   compilerInput'incoherent,
   compilerInput'maybe,
  )
@@ -43,13 +44,18 @@ test = testGroup "Compiler tests" [testCheck, testFolds, testRefl, testMultipleD
 -- Multiple declaration test
 
 testMultipleDec :: TestTree
-testMultipleDec = testGroup "Multiple declaration tests." [doubleDeclaration]
+testMultipleDec = testGroup "Multiple declaration tests." [doubleDeclaration, passingDoubleDeclaration]
 
 doubleDeclaration :: TestTree
 doubleDeclaration =
-  testCase "Two declarations of the same type was not detected." $
+  testCase "Two declarations of Maybe within the same module are caught." $
     check_ compilerInput'doubleDeclaration @?= Left (P.CompReaderError $ P.MultipleDeclaration (_tyName "Maybe") (_tyName "Maybe"))
 
+passingDoubleDeclaration :: TestTree
+passingDoubleDeclaration =
+  testCase "Two declarations of Maybe within different modules are fine." $
+    check_ compilerInput'doubleDeclarationDiffMod @?= Right ()
+
 --------------------------------------------------------------------------------
 -- Module tests
 

lambda-buffers-compiler/test/Test/Samples/Proto/CompilerInput.hs

@@ -1,12 +1,15 @@
-module Test.Samples.Proto.CompilerInput (compilerInput'incoherent, compilerInput'maybe, compilerInput'doubleDeclaration) where
+module Test.Samples.Proto.CompilerInput (compilerInput'incoherent, compilerInput'maybe, compilerInput'doubleDeclaration, compilerInput'doubleDeclarationDiffMod) where
 
-import Control.Lens ((&), (.~))
+import Control.Lens ((%~), (&), (.~))
 import LambdaBuffers.Compiler.ProtoCompat qualified as P
 import Test.Samples.Proto.Module (module'incoherent, module'maybe)
+import Test.Samples.Proto.SourceInfo
+
+_CompilerInput x = P.CompilerInput {P.modules = x}
 
 -- | Compiler Input containing 1 module with 1 definition - Maybe.
 compilerInput'maybe :: P.CompilerInput
-compilerInput'maybe = P.CompilerInput {P.modules = [module'maybe]}
+compilerInput'maybe = _CompilerInput [module'maybe]
 
 -- | Contains 2 definitions - 1 wrong one.
 compilerInput'incoherent :: P.CompilerInput
@@ -15,3 +18,11 @@ compilerInput'incoherent = compilerInput'maybe & #modules .~ [module'incoherent]
 -- | Declares maybe twice.
 compilerInput'doubleDeclaration :: P.CompilerInput
 compilerInput'doubleDeclaration = compilerInput'maybe <> compilerInput'maybe
+
+-- | Declares maybe twice - in different modules
+compilerInput'doubleDeclarationDiffMod :: P.CompilerInput
+compilerInput'doubleDeclarationDiffMod =
+  compilerInput'maybe
+    <> _CompilerInput
+      [ module'maybe & #moduleName . #parts %~ (P.ModuleNamePart "Module" sourceInfo'empty :)
+      ]

lambda-buffers-compiler/test/Test/Samples/Proto/Module.hs

@@ -5,6 +5,15 @@ import LambdaBuffers.Compiler.ProtoCompat qualified as P
 import Test.Samples.Proto.SourceInfo (sourceInfo'empty)
 import Test.Samples.Proto.TyDef (tyDef'incoherent, tyDef'maybe)
 
+_Module mn tds cds ins =
+  P.Module
+    { P.moduleName = mn
+    , P.typeDefs = tds
+    , P.classDefs = cds
+    , P.instances = ins
+    , P.sourceInfo = sourceInfo'empty
+    }
+
 module'maybe :: P.Module
 module'maybe =
   P.Module