Unit tests for a stack trace parser

Parsers.purs

module Test.Parsers (tests) where

import Prelude

import Data.Default

import Test.Prelude
import Test.Data
import Test.Unit (runTest, test, assert)

import SharpStacktrace.Types
import SharpStacktrace.Constructors

import qualified SharpStacktrace.Parsers as P

testTypeParsing = test "type parsing\n" do
  let try desc raw result =
    assert ("cannot parse type (" <> desc <> "): " <> raw) (P.parseType raw `hasRight` result)

  try "simple, without namespace"
    "object" $
    def # withName "object"

  try "simple, with namespace"
    "System.String" $
    systemString

  try "simple array"
    "System.String[]" $
    arrayOf systemString

  try "generic"
    "System.Collections.Generic.List`1[System.String]" $
    genericListOfString

  try "generic with angle brackets"
    "System.Collections.Generic.List`1<System.String>" $
    genericListOfString

  try "generic arity 2"
    "System.Collections.Generic.Dictionary`2[System.String,System.String]" $
    genericDictionaryOfStringString

  try "nested"
    "System.String+T1" $
    systemString # withChild t1

  try "nested generics"
    "System.Collections.Generic.List`1+T1`1[System.String,T2]" $
    genericListOfString # withChild (t1 # withGeneric t2)

testInvocationParsing = test "invocation parsing\n" do
  let try desc raw result =
    assert ("cannot parse invocation: (" <> desc <> "): " <> raw) (P.parseInvocation raw `hasRight` result)

  try "simple"
    "System.Object.ToString ()" $
    systemObject .. toString

  try "generic"
    "System.Object.ToString[T1] ()" $
    systemObject .. (toString # withGeneric t1)

  try "generic type"
    "System.Collections.Generic.List`1[System.String].ToString ()" $
    genericListOfString .. toString

  try "generic type and method"
    "System.Collections.Generic.List`1[System.String].ToString[System.Object] ()" $
    genericListOfString .. (toString # withGeneric systemObject)

tests = do
  testTypeParsing
  testInvocationParsing