functest

Command
  commands
    are prefixed
    get de-prefixed
Completion
  completions
    works
    does not pull in unnecessary modules until needed
    completes imports
    completes qualified imports
    completes language extensions
    completes pragmas
    completes pragmas no close
    completes options pragma
    completes ghc options pragma values
    completes with no prefix
    strips compiler generated stuff from completions
    contexts
      only provides type suggestions
      only provides type suggestions
    have implicit foralls on basic polymorphic types
    have implicit foralls with multiple type variables
    snippets
      work for argumentless constructors
      work for polymorphic types
      work for complex types
      work for infix functions
      work for infix functions in backticks
      work for qualified infix functions
      work for qualified infix functions in backticks
      respects lsp configuration
      respects client capabilities
Deferred
  deferred responses
    do not affect hover requests
    instantly respond to failed modules with no cache
    respond to untypecheckable modules with parsed module cache FAILED [1]
    returns hints as diagnostics
  multi-server setup
    doesn't have clashing commands on two servers
  multiple main modules
    Can load one file at a time, when more than one Main module exists FAILED [2]
Definition
  definitions
    goto's symbols
    goto's imported modules
    goto's exported modules
    goto's imported modules that are loaded
    goto's imported modules that are loaded, and then closed
Diagnostics
  diagnostics providers
    diagnostics triggers
      runs diagnostics on save
    typed hole errors
      is deferred
    Warnings are warnings
      Overrides -Werror FAILED [3]
    only diagnostics on save
      Respects diagnosticsOnChange setting
Format
  format document
    works
    works with custom tab size
  format range
    works
    works with custom tab size
  formatting provider
    respects none
    can change on the fly
  brittany
    formats a document with LF endings
    formats a document with CRLF endings
    formats a range with LF endings
    formats a range with CRLF endings
FunctionalBadProject
  behaviour on malformed projects
    deals with cabal file with unsatisfiable dependency FAILED [4]
FunctionalCodeActions
  code actions
    hlint suggestions
      provides 3.8 code actions
      falls back to pre 3.8 code actions
      runs diagnostics on save
    rename suggestions
      works
      doesn't give both documentChanges and changes
    import suggestions
      formats with brittany
        Execute HsImport with formatter brittany
          works with 3.8 code action kinds
          formats
          import-list formats
          multiple import-list formats FAILED [5]
          respects format config, multiple import-list FAILED [6]
          respects format config
          import-list respects format config
          complex import-list FAILED [7]
          complex import-list respects format config FAILED [8]
      formats with floskell
        Execute HsImport with formatter floskell
          works with 3.8 code action kinds
          formats
          import-list formats
          multiple import-list formats FAILED [9]
          respects format config, multiple import-list FAILED [10]
          respects format config
          import-list respects format config
          complex import-list FAILED [11]
          complex import-list respects format config FAILED [12]
    add package suggestions
      adds to .cabal files
      adds to hpack package.yaml files
    redundant import code actions
      remove solitary redundant imports FAILED [13]
      doesn't touch other imports FAILED [14]
    typed hole code actions
      works FAILED [15]
      shows more suggestions
    missing top level signature code actions
      Adds top level signature
    missing pragma warning code actions
      Adds TypeSynonymInstances pragma
    unused term code actions
      Prefixes with '_' FAILED [16]
    respect 'only' parameter
FunctionalLiquid
  liquid haskell diagnostics
    runs diagnostics on save, no liquid
    runs diagnostics on save, with liquid haskell FAILED [17]
HaRe
  HaRe
    code actions
      lift one level
        works
      lift to top level
        works
      delete definition
        works
      duplicate definition
        works
      demote definition
        works
      casesplit argument
        works FAILED [18]
Highlight
  highlight
    works
Hover
  hover
    works
Progress
  window/progress
    sends indefinite progress notifications
    sends indefinite progress notifications with liquid FAILED [19]
References
  references
    works with definitions
Rename
  rename
    works
Symbols
  document symbols
    3.10 hierarchical document symbols
      provides nested data types and constructors
      provides nested where functions
      provides pattern synonyms
    pre 3.10 symbol information
      provides nested data types and constructors
      provides nested where functions
TypeDefinition
  type definitions
    finds local definition of record variable
    finds local definition of newtype variable
    finds local definition of sum type variable
    finds local definition of sum type contructor
    can not find non-local definition of type def
    find local definition of type def
    find type-definition of type def in component
    find definition of parameterized data type

Failures:

  test/functional/DeferredSpec.hs:99:5: 
  1) Deferred, deferred responses, respond to untypecheckable modules with parsed module cache
       uncaught exception: SessionException
       Received an unexpected message from the server:
       Was parsing: Pattern match failure in do expression at test/functional/DeferredSpec.hs:102:9-22
       Last message received: RspDocumentSymbols (ResponseMessage {_jsonrpc = "2.0", _id = IdRspInt 1, _result = Just (DSDocumentSymbols (List [])), _error = Nothing})

  To rerun use: --match "/Deferred/deferred responses/respond to untypecheckable modules with parsed module cache/"

  test/functional/DeferredSpec.hs:154:5: 
  2) Deferred, multiple main modules, Can load one file at a time, when more than one Main module exists
       uncaught exception: SessionException
       Language server unexpectedly terminated

  To rerun use: --match "/Deferred/multiple main modules/Can load one file at a time, when more than one Main module exists/"

  test/functional/DiagnosticsSpec.hs:71:5: 
  3) Diagnostics, diagnostics providers, Warnings are warnings, Overrides -Werror
       uncaught exception: SessionException
       Timed out waiting to receive a message from the server.

  To rerun use: --match "/Diagnostics/diagnostics providers/Warnings are warnings/Overrides -Werror/"

  test/functional/FunctionalBadProjectSpec.hs:19:5: 
  4) FunctionalBadProject, behaviour on malformed projects, deals with cabal file with unsatisfiable dependency
       uncaught exception: SessionException
       Timed out waiting to receive a message from the server.

  To rerun use: --match "/FunctionalBadProject/behaviour on malformed projects/deals with cabal file with unsatisfiable dependency/"

  test/functional/FunctionalCodeActionsSpec.hs:588:16: 
  5) FunctionalCodeActions, code actions, import suggestions, formats with brittany, Execute HsImport with formatter brittany, multiple import-list formats
       expected: fromList ["                                                )","                                                , hPutStrLn","        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import           Control.Monad                  ( when )","import           Data.Maybe                     ( fromMaybe )","import           System.IO                      ( stdout","main :: IO ()","main ="]
        but got: fromList ["        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import           Control.Monad                  ( when )","import           Data.Maybe                     ( fromMaybe )","import           System.IO                      ( hPutStrLn )","import           System.IO                      ( stdout )","main :: IO ()","main ="]

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with brittany/Execute HsImport with formatter brittany/multiple import-list formats/"

  test/functional/FunctionalCodeActionsSpec.hs:603:16: 
  6) FunctionalCodeActions, code actions, import suggestions, formats with brittany, Execute HsImport with formatter brittany, respects format config, multiple import-list
       expected: fromList ["        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import Control.Monad (when)","import Data.Maybe (fromMaybe)","import System.IO (stdout, hPutStrLn)","main :: IO ()","main ="]
        but got: fromList ["        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import Control.Monad (when)","import Data.Maybe (fromMaybe)","import System.IO (hPutStrLn)","import System.IO (stdout)","main :: IO ()","main ="]

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with brittany/Execute HsImport with formatter brittany/respects format config, multiple import-list/"

  test/functional/FunctionalCodeActionsSpec.hs:729:11: 
  7) FunctionalCodeActions, code actions, import suggestions, formats with brittany, Execute HsImport with formatter brittany, complex import-list
       uncaught exception: ErrorCall
       No action found to be executed!
        Actual actions titles: []
        Expected actions titles: ["Import module System.IO (hPutStrLn)","Import module Control.Monad (when)","Import module Data.Maybe (fromMaybe)","Import module Data.Function (($))","Import module Data.Maybe (Maybe (Just))","Import module Prelude (Bool (..))","Import module System.IO (stderr)"]
       CallStack (from HasCallStack):
         error, called at test/functional/FunctionalCodeActionsSpec.hs:729:11 in main:FunctionalCodeActionsSpec

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with brittany/Execute HsImport with formatter brittany/complex import-list/"

  test/functional/FunctionalCodeActionsSpec.hs:729:11: 
  8) FunctionalCodeActions, code actions, import suggestions, formats with brittany, Execute HsImport with formatter brittany, complex import-list respects format config
       uncaught exception: ErrorCall
       No action found to be executed!
        Actual actions titles: []
        Expected actions titles: ["Import module System.IO (hPutStrLn)","Import module Control.Monad (when)","Import module Data.Maybe (fromMaybe)","Import module Data.Function (($))","Import module Data.Maybe (Maybe (Just))","Import module Prelude (Bool (..))","Import module System.IO (stderr)"]
       CallStack (from HasCallStack):
         error, called at test/functional/FunctionalCodeActionsSpec.hs:729:11 in main:FunctionalCodeActionsSpec

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with brittany/Execute HsImport with formatter brittany/complex import-list respects format config/"

  test/functional/FunctionalCodeActionsSpec.hs:588:16: 
  9) FunctionalCodeActions, code actions, import suggestions, formats with floskell, Execute HsImport with formatter floskell, multiple import-list formats
       expected: fromList ["        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import           Control.Monad (when)","import           Data.Maybe (fromMaybe)","import           System.IO (stdout, hPutStrLn)","main :: IO ()","main ="]
        but got: fromList ["        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import           Control.Monad (when)","import           Data.Maybe (fromMaybe)","import           System.IO (hPutStrLn)","import           System.IO (stdout)","main :: IO ()","main ="]

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with floskell/Execute HsImport with formatter floskell/multiple import-list formats/"

  test/functional/FunctionalCodeActionsSpec.hs:603:16: 
  10) FunctionalCodeActions, code actions, import suggestions, formats with floskell, Execute HsImport with formatter floskell, respects format config, multiple import-list
       expected: fromList ["        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import Control.Monad (when)","import Data.Maybe (fromMaybe)","import System.IO (stdout, hPutStrLn)","main :: IO ()","main ="]
        but got: fromList ["        $ fromMaybe \"Good night, World!\" (Just \"Hello, World!\")","        $ hPutStrLn stdout","    when True","-- | Main entry point to the program","import Control.Monad (when)","import Data.Maybe (fromMaybe)","import System.IO (hPutStrLn)","import System.IO (stdout)","main :: IO ()","main ="]

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with floskell/Execute HsImport with formatter floskell/respects format config, multiple import-list/"

  test/functional/FunctionalCodeActionsSpec.hs:729:11: 
  11) FunctionalCodeActions, code actions, import suggestions, formats with floskell, Execute HsImport with formatter floskell, complex import-list
       uncaught exception: ErrorCall
       No action found to be executed!
        Actual actions titles: []
        Expected actions titles: ["Import module System.IO (hPutStrLn)","Import module Control.Monad (when)","Import module Data.Maybe (fromMaybe)","Import module Data.Function (($))","Import module Data.Maybe (Maybe (Just))","Import module Prelude (Bool (..))","Import module System.IO (stderr)"]
       CallStack (from HasCallStack):
         error, called at test/functional/FunctionalCodeActionsSpec.hs:729:11 in main:FunctionalCodeActionsSpec

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with floskell/Execute HsImport with formatter floskell/complex import-list/"

  test/functional/FunctionalCodeActionsSpec.hs:729:11: 
  12) FunctionalCodeActions, code actions, import suggestions, formats with floskell, Execute HsImport with formatter floskell, complex import-list respects format config
       uncaught exception: ErrorCall
       No action found to be executed!
        Actual actions titles: []
        Expected actions titles: ["Import module System.IO (hPutStrLn)","Import module Control.Monad (when)","Import module Data.Maybe (fromMaybe)","Import module Data.Function (($))","Import module Data.Maybe (Maybe (Just))","Import module Prelude (Bool (..))","Import module System.IO (stderr)"]
       CallStack (from HasCallStack):
         error, called at test/functional/FunctionalCodeActionsSpec.hs:729:11 in main:FunctionalCodeActionsSpec

  To rerun use: --match "/FunctionalCodeActions/code actions/import suggestions/formats with floskell/Execute HsImport with formatter floskell/complex import-list respects format config/"

  test/functional/FunctionalCodeActionsSpec.hs:275:5: 
  13) FunctionalCodeActions, code actions, redundant import code actions, remove solitary redundant imports
       uncaught exception: SessionException
       Received an unexpected message from the server:
       Was parsing: Pattern match failure in do expression at test/functional/FunctionalCodeActionsSpec.hs:280:9-18
       Last message received: NotPublishDiagnostics (NotificationMessage {_jsonrpc = "2.0", _method = TextDocumentPublishDiagnostics, _params = PublishDiagnosticsParams {_uri = Uri {getUri = "file:///home/zubin/haskell-ide-engine/test/testdata/redundantImportTest/src/CodeActionRedundant.hs"}, _diagnostics = List []}})

  To rerun use: --match "/FunctionalCodeActions/code actions/redundant import code actions/remove solitary redundant imports/"

  test/functional/FunctionalCodeActionsSpec.hs:302:5: 
  14) FunctionalCodeActions, code actions, redundant import code actions, doesn't touch other imports
       uncaught exception: SessionException
       Received an unexpected message from the server:
       Was parsing: Pattern match failure in do expression at test/functional/FunctionalCodeActionsSpec.hs:307:7-24
       Last message received: NotPublishDiagnostics (NotificationMessage {_jsonrpc = "2.0", _method = TextDocumentPublishDiagnostics, _params = PublishDiagnosticsParams {_uri = Uri {getUri = "file:///home/zubin/haskell-ide-engine/test/testdata/redundantImportTest/src/MultipleImports.hs"}, _diagnostics = List []}})

  To rerun use: --match "/FunctionalCodeActions/code actions/redundant import code actions/doesn't touch other imports/"

  test/functional/FunctionalCodeActionsSpec.hs:332:26: 
  15) FunctionalCodeActions, code actions, typed hole code actions, works
       Actual list is not a permutation of expected list!
         expected list contains:   ["Substitute hole (Int) with x ([Int])", "Substitute hole (Int) with foo ([Int] -> Int Valid hole fits include)", "Substitute hole (Int) with maxBound (forall a. Bounded a => a with maxBound @Int)", "Substitute hole (Int) with minBound (forall a. Bounded a => a with minBound @Int)"]
         actual list contains:     ["Substitute hole (Int) with x ([Int])", "Substitute hole (Int) with foo ([Int] -> Int)", "Substi
tute hole (Int) with maxBound (forall a. Bounded a => a with maxBound @Int)", "Substitute hole (Int) with minBound (forall a. Bounded a => a with minBound @Int)"]
         the missing elements are: ["Substitute hole (Int) with foo ([Int] -> Int Valid hole fits include)"]
         the extra elements are:   ["Substitute hole (Int) with foo ([Int] -> Int)"]

  To rerun use: --match "/FunctionalCodeActions/code actions/typed hole code actions/works/"

  test/functional/FunctionalCodeActionsSpec.hs:494:18: 
  16) FunctionalCodeActions, code actions, unused term code actions, Prefixes with '_'
       expected: "{-# OPTIONS_GHC -Wall #-}\nmodule UnusedTerm () where\n_imUnused :: Int -> Int\n_imUnused 1 = 1\n_imUnused 2 = 2\n_imUnused _ = 3\n"
        but got: "\nmodule UnusedTerm () where\n_imUnused :: Int -> Int\n_imUnused 1 = 1\n_imUnused 2 = 2\n_imUnused _ = 3\n"

  To rerun use: --match "/FunctionalCodeActions/code actions/unused term code actions/Prefixes with '_'/"

  test/functional/FunctionalLiquidSpec.hs:93:18: 
  17) FunctionalLiquid, liquid haskell diagnostics, runs diagnostics on save, with liquid haskell
       expected: 0
        but got: 2

  To rerun use: --match "/FunctionalLiquid/liquid haskell diagnostics/runs diagnostics on save, with liquid haskell/"

  test/functional/HaReSpec.hs:52:36: 
  18) HaRe.HaRe, code actions, casesplit argument, works
       uncaught exception: SessionException
       Timed out waiting to receive a message from the server.

  To rerun use: --match "/HaRe/HaRe/code actions/casesplit argument/works/"

  test/functional/ProgressSpec.hs:63:3: 
  19) Progress.window/progress sends indefinite progress notifications with liquid
       uncaught exception: SessionException
       Received an unexpected message from the server:
       Was parsing: Publish diagnostics notification
       Last message received: NotProgressStart (NotificationMessage {_jsonrpc = "2.0", _method = WindowProgressStart, _params = ProgressStartParams {_id = "0", _title = "Initialising Cradle", _cancellable = Just False, _message = Nothing, _percentage = Just 0.0}})

  To rerun use: --match "/Progress/window/progress/sends indefinite progress notifications with liquid/"