From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mp11.migadu.com ([2001:41d0:403:478a::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by ms9.migadu.com with LMTPS id 8MXDDaLc+WQr8QAA9RJhRA:P1 (envelope-from ) for ; Thu, 07 Sep 2023 16:22:26 +0200 Received: from aspmx1.migadu.com ([2001:41d0:403:478a::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by mp11.migadu.com with LMTPS id 8MXDDaLc+WQr8QAA9RJhRA (envelope-from ) for ; Thu, 07 Sep 2023 16:22:26 +0200 Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by aspmx1.migadu.com (Postfix) with ESMTPS id A0EAEF8B1 for ; Thu, 7 Sep 2023 16:22:25 +0200 (CEST) Authentication-Results: aspmx1.migadu.com; dkim=pass header.d=gmail.com header.s=20221208 header.b="V8I/P/ZS"; spf=pass (aspmx1.migadu.com: domain of "emacs-orgmode-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="emacs-orgmode-bounces+larch=yhetil.org@gnu.org"; dmarc=pass (policy=none) header.from=gmail.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=yhetil.org; s=key1; t=1694096545; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:in-reply-to:in-reply-to: references:references:list-id:list-help:list-unsubscribe: list-subscribe:list-post:dkim-signature; bh=DJ4HjMWjzTO/ORItI55YDs5L6v3bEYsAAmnlLtUQRhg=; b=Efnh7KOBgkFUg+/x+jg+6kzv6L6CWDv16Fv/D+nJpZzJnOgoyNgsmZ825KMKy1Yi5juWY1 Fq2v8YCzDkSVZfJAFZuKfNHM7oOP4qMM2PSrY1VYIiNvVl94ElrIIZqwIqTk311NReXKVX tp1jE+VIFfLCV8IvO8tK/ThENuPLPMFByavDPMj+vURm27MsT4+M1EbxMYk4xq0Izao+s6 kam28bEjL4//Vu/E8Oww6W4zFriN9IPLMaHW9P+209AGoOXz7oh5Bg+/iedxME0NTOa53u ylYWdtxE/Uj8NeH0JNQXY9PywXb0Q5yVTytcNOT8hjkEK1QFv2FXnEBLRJ1MtA== ARC-Seal: i=1; s=key1; d=yhetil.org; t=1694096545; a=rsa-sha256; cv=none; b=tYvq3j0ZrNC6IKFNlV4ukyASunnGrN7OuWsR6Ttm3YzdUAPfJhnP+KgApsDQ2PhOTDa3i9 c5Vc/FQZ0EGhGZHSI1JV8NZFrs1IALnCnZbdnvQ8reo7mC3dK05bCgpOW+l/X3OhYumTlA Nk0/hEPEz1RsmEMHz5ZF6suLnZAVgaKuZtgHpXS6KN84TTorZcg4JgNH9riQ2obK+TD2rt XBSa+1vrQz2e0FuC/xQPV1sjBpzzDLELBdCZ5ODFQ4CKwYDVYRpZTubwGgNFMVq2IB6oAp qg3c5CctjS9Lb6AoWUMiRBNSAlV45slejHFt9VXFoCSVx1yjkN2ghNb2YlW3Pw== ARC-Authentication-Results: i=1; aspmx1.migadu.com; dkim=pass header.d=gmail.com header.s=20221208 header.b="V8I/P/ZS"; spf=pass (aspmx1.migadu.com: domain of "emacs-orgmode-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="emacs-orgmode-bounces+larch=yhetil.org@gnu.org"; dmarc=pass (policy=none) header.from=gmail.com Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1qeFtQ-0000pk-Sk; Thu, 07 Sep 2023 10:22:00 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1qeFtP-0000p5-1R for emacs-orgmode@gnu.org; Thu, 07 Sep 2023 10:21:59 -0400 Received: from mail-wm1-x335.google.com ([2a00:1450:4864:20::335]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1qeFtG-0001Jh-EI for emacs-orgmode@gnu.org; Thu, 07 Sep 2023 10:21:58 -0400 Received: by mail-wm1-x335.google.com with SMTP id 5b1f17b1804b1-401b393ddd2so11827975e9.0 for ; Thu, 07 Sep 2023 07:21:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20221208; t=1694096507; x=1694701307; darn=gnu.org; h=mime-version:date:references:in-reply-to:subject:cc:to:from :message-id:from:to:cc:subject:date:message-id:reply-to; bh=DJ4HjMWjzTO/ORItI55YDs5L6v3bEYsAAmnlLtUQRhg=; b=V8I/P/ZSRAeVepZVG33puoaSh+QEhxeCHim6Ikv634IK7CudOLD9OTlBoqJohwqC/2 O06dSUcrVM7kDDuYc/8o/eFHKgm4it5ICpyeWiA3YH1Pi/uILFhobg+icy1fqRExXi/F n9108uzOmYMMIE7g9bZ9w054aWtj9xH8xVlKAWIEGDFnmjM69WMvMTHnG27CdQ9uRgdh juSo/DUKkp/Hg+XGxjHVdg6XSeZ5iH0Q8pvtsGLQA4L+sevOAMzP4X9pGqkJwh045y+O apfxFf5yCEPcb1+KzBSMmn5rJdRSe80hKUsdgVokxurSI5sFfXSgvvJk/0PTGCNrm3HB ClSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1694096507; x=1694701307; h=mime-version:date:references:in-reply-to:subject:cc:to:from :message-id:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=DJ4HjMWjzTO/ORItI55YDs5L6v3bEYsAAmnlLtUQRhg=; b=SvRI2nlMj0uG0cJrxCKDKw8YaeBKyg/9k1HU2hyGW5GjEJdo6HfdgXTI1XPyuWWIkg C/fHLWbM7Hfra56ujpdMSTVVBQX4T54bUfgdnp9X9rZFB41EzMrxmYL0j5uKxZnSKjEP 6AIbZAliesTitD5brwZvMZ/w1bxf4aSvu0yQN7b0MjfxRzH93+xNrXWpdQoqzE9ziZDT L/ba7VaD3E51LYCXIBd5JzmmNQCw0iYRR0OR3lbiNC18CPDkYbq0BMyx5BjVH1W4iKSZ XtXvQQof4bcDZg5E5AftGlb6xg24hpKCoqHcqzUVNiMoxpmam43gqeCfRO8kDmIe07DA Ld1Q== X-Gm-Message-State: AOJu0YzvUJmNeNO9GiC16cAyUyO1F4fGkJ1+x9uPLIR3ZBwM3StD4UuX Ag1rz60r9EX2bNWOCVNIAwN/ay0Rv2w= X-Google-Smtp-Source: AGHT+IGV+TGfPOTIOlf5CEZzljxq4TU2YTEx8D46TowbVI/1X+whv8pQpEcr+K8HEoM82GwGjwvM3A== X-Received: by 2002:a7b:cc8f:0:b0:3ff:233f:2cfb with SMTP id p15-20020a7bcc8f000000b003ff233f2cfbmr4837044wma.23.1694096506377; Thu, 07 Sep 2023 07:21:46 -0700 (PDT) Received: from keynux ([2a01:e0a:505:3460:169:7511:f49a:58eb]) by smtp.gmail.com with ESMTPSA id 3-20020a05600c020300b003fc04d13242sm2675502wmi.0.2023.09.07.07.21.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 07 Sep 2023 07:21:45 -0700 (PDT) Message-ID: <64f9dc79.050a0220.194d1.9020@mx.google.com> Received: by keynux (sSMTP sendmail emulation); Thu, 07 Sep 2023 16:21:44 +0200 From: Bruno Barbier To: Ihor Radchenko Cc: emacs-orgmode@gnu.org Subject: Re: [PATCH] Add tests for ob-haskell (GHCi) In-Reply-To: <87a5xi5k47.fsf@localhost> References: <6416d214.5d0a0220.d9c1.54aa@mx.google.com> <875yaxvy93.fsf@localhost> <6416e4d9.df0a0220.ce03d.5c4b@mx.google.com> <87h6udozvh.fsf@localhost> <87r0texwor.fsf@localhost> <641ec686.050a0220.16dbc.a6ca@mx.google.com> <87fs9rvpyj.fsf@localhost> <6457663a.df0a0220.f6b38.a05e@mx.google.com> <873547ks1t.fsf@localhost> <6469cafa.1c0a0220.4db6f.0396@mx.google.com> <87a5xi5k47.fsf@localhost> Date: Thu, 07 Sep 2023 16:21:44 +0200 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" Received-SPF: pass client-ip=2a00:1450:4864:20::335; envelope-from=brubar.cs@gmail.com; helo=mail-wm1-x335.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, MSGID_FROM_MTA_HEADER=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, T_SPF_TEMPERROR=0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: emacs-orgmode@gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: "General discussions about Org-mode." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-orgmode-bounces+larch=yhetil.org@gnu.org Sender: emacs-orgmode-bounces+larch=yhetil.org@gnu.org X-Migadu-Country: US X-Migadu-Flow: FLOW_IN X-Migadu-Scanner: mx0.migadu.com X-Migadu-Spam-Score: -6.59 X-Spam-Score: -6.59 X-Migadu-Queue-Id: A0EAEF8B1 X-TUID: /ooandkMsKiR --=-=-= Content-Type: text/plain Hi Ihor, Sorry for the delay, thanks again for the ping. Ihor Radchenko writes: > Bruno Barbier writes: > >>>> + (when (bufferp "*haskell*") (error "Conflicting buffer '*haskell*', rename it or kill it.")) >>>> + (with-current-buffer session (rename-buffer "*haskell*"))) >>> >>> So, you are now renaming the unique session buffer back to "*haskell*". >>> And never rename it back to expected :session . Users might be confused. >> >> I do rename it back once inf-haskell has initialized the buffer (after >> run-haskell in the last version). > > A comment would help to clarify things for the readers. Right. I've improved the comment. Thanks. >>>> + (save-window-excursion >>>> + ;; We don't use `run-haskell' to not popup the buffer. >>>> + ;; And we protect default-directory. >>>> + (let ((default-directory default-directory)) >>>> + (inferior-haskell-start-process)) >>> >> About 'default-directory', I'm not sure. Maybe the side effect is done >> on purpose in inf-haskell. > > I can see the haskell-mode overrides default-directory with > `inferior-haskell-root-dir', running ghci in that directory, if it is > non-nil. Even with your let binding, it is calling for trouble when > source block uses :dir header argument. > > Maybe we can bind `inferior-haskell-root-dir' to `default-directory' > instead? `default-directory' is modified according to :dir by ob-core.el > when necessary. You may be right that we should use `inferior-haskell-root-dir' to tell haskell-mode where to run the interpreter. Done. >> The function 'putStr' output the string without a newline on stdout >> (as opposed to the function putStrLn that does add a newline). >> >> So, in GHCi, entering: >> >> putStr("4") >> >> outputs "4" on stdout, then GHCi outputs the prompt, so we get: >> >> 4ghci> >> >> In the end, 'org-babel-comint-with-output' gets this >> 1ghci> 2ghci> 3ghci> >> ghci> org-babel-haskell-eoe >> ghci> ghci> >> >> and filters out everything as being GHCi prompts and the EOE. >> >> I'm not really expecting this to be fixed; I just wanted to record the >> fact. > > We actually might be able to deal with this if we change the prompt and > update comint-prompt-regexp to something more accurate. I couldn't make it work by simply restricting the prompt. I think it's OK if character by character output doesn't work; ghci is about line based interaction afterall. >>>> Subject: [PATCH 11/13] lisp/ob-haskell.el: Fix how to use sessions >>>> >>>> + (org-babel-haskell-with-session >>> >>> This kind of names are usually dedicated to macro calls. But >>> `org-babel-haskell-with-session' is instead a function. I think a macro >>> will be better. And you will be able to get rid of unnecessary lambda. >> >> That looks kind of complicated just to avoid one lambda in one call. >> But, as I couldn't find a better name, I've translated it into a >> macro. > > I think you misunderstood what I meant. > See the attached diff on top of your patches that simplifies things a > bit. > diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el ... > (defmacro org-babel-haskell-with-session (session-symbol params &rest body) > "Get the session identified by PARAMS and run BODY with it. .. > + `(let* ((params ,params) > + (sn (cdr (assq :session params))) > + (session (org-babel-haskell-initiate-session sn params)) > + (,session-symbol session) > + (one-shot (equal sn "none"))) > + (unwind-protect > + (progn ,@body) I don't think it's correct to create local variables like this in a macro: we need to use uninterned symbols, else we may capture caller variables (params, sn, session and one-shot). I personnaly find it easier when I keep my macros as short as possible, and, to do any non-trivial work in a function: easier to read, to modify and to debug. >>>> - (let ((buffer (org-babel-haskell-initiate-session session))) >>>> + (let ((buffer (org-babel-haskell-initiate-session session params))) >>> >>> PARAMS argument is ignored by `org-babel-haskell-initiate-session'. I am >>> not sure why you are trying to pass it here. >> >> We have the PARAMS, and, org-babel-haskell-initiate-session has a >> PARAMS arguments. So, at the API level, I think it's better to >> propagate it than to ignore it. But you're right that, today, the >> current implementation ignores it. >> >> I'm fine with dropping that change if you so prefer. > > I am mostly neutral here. Slightly in favour of keeping things unchanged. I've removed my change. The function `org-babel-load-session:haskell` now ignores the parameter PARAMS, as before. Thanks for the review. Bruno --=-=-= Content-Type: text/x-patch; charset=utf-8 Content-Disposition: attachment; filename=0001-ob-haskell-Add-tests-for-GHCi.patch Content-Transfer-Encoding: quoted-printable >From 86a5443948fc84a6a412ccf49d0c537608f465a7 Mon Sep 17 00:00:00 2001 From: Bruno BARBIER Date: Fri, 18 Nov 2022 20:14:20 +0100 Subject: [PATCH 1/7] ob-haskell: Add tests for GHCi testing/lisp/test-ob-haskell-ghci.el: New file. --- testing/lisp/test-ob-haskell-ghci.el | 430 +++++++++++++++++++++++++++ 1 file changed, 430 insertions(+) create mode 100644 testing/lisp/test-ob-haskell-ghci.el diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-ha= skell-ghci.el new file mode 100644 index 000000000..920103858 --- /dev/null +++ b/testing/lisp/test-ob-haskell-ghci.el @@ -0,0 +1,430 @@ +;;; test-ob-haskell-ghci.el --- tests for ob-haskell.el GHCi -*- lexical-= binding: t; -*- + +;; Copyright (c) 2023 Free Software Foundation, Inc. +;; Authors: Bruno BARBIER + +;; This file is part of GNU Emacs. + +;; This program is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see . + +;;; Commentary: +;; + +;;;; Useful references +;; +;; - https://orgmode.org/worg/org-contrib/babel/languages/lang-compat.html +;; - GHCi manual: https://downloads.haskell.org/ghc/latest/docs/users_gui= de/ghci.html + +;;; Code: +;; + +(require 'org-test "../testing/org-test") +(org-test-for-executable "ghci") +(unless (featurep 'haskell-mode) + (signal 'missing-test-dependency "haskell-mode")) +(unless (featurep 'haskell) + (signal 'missing-test-dependency "haskell")) + + +;;; Helpers +;; + +(defun test-ob-haskell-ghci-checking-buffers (todo) + "Check some buffer related invariants.." + (when (get-buffer "*haskell*") + (error "A buffer named '*haskell*' exists. Can't safely test haskell = blocks")) + (prog1 (funcall todo) + (when-let ((hb (get-buffer "*haskell*"))) + ;; We created a "*haskell*" buffer. That shouldn't happen. + (error "'ob-haskell' created a buffer named '*haskell*'")))) + + + +(defun test-ob-haskell-ghci (args content &optional preamble unprotected) + "Execute the code block CONTENT in a new GHCi session; return the result. +Add ARGS to the code block argument line. Insert PREAMBLE +before the code block. When UNPROTECTED is non-nil, check pre/post condit= ions." + (when (listp content) + (setq content (string-join content "\n"))) + (unless preamble + (setq preamble "")) + (let ((todo (lambda () + (prog1 (org-test-with-temp-text + (concat preamble "\n" "#+begin_src haskell :com= pile no " + args "\n" "" content "\n#+end_sr= c") + (org-babel-execute-src-block)))))) + (if unprotected (funcall todo) + (test-ob-haskell-ghci-checking-buffers todo)))) + + + +;;; Tests + + +;;;; Hello Worlds. +;; + +(ert-deftest ob-haskell/hello-world-value-pure () + (should (equal "Hello World!" + (test-ob-haskell-ghci "" "\"Hello World!\"")))) + +(ert-deftest ob-haskell/hello-world-value-IO () + (should (equal "Hello World!" + (test-ob-haskell-ghci "" "return \"Hello World!\"")))) + +(ert-deftest ob-haskell/hello-world-output () + (should (equal "Hello World!" + (test-ob-haskell-ghci ":results output" "putStrLn \"Hello= World!\"")))) + +(ert-deftest ob-haskell/hello-world-output-nothing () + :expected-result :failed + (should (equal "" + (test-ob-haskell-ghci ":results output" "return \"Hello W= orld!\"")))) + +(ert-deftest ob-haskell/hello-world-output-multilines () + :expected-result :failed + (should (equal "Hello World!" + (test-ob-haskell-ghci ":results output" " +:{ +main :: IO () +main =3D putStrLn \"Hello World!\" +:} + +main +")))) + +;;;; Sessions +;; + +(ert-deftest ob-haskell/sessions-must-not-share-variables () + "Sessions must not share variables." + :expected-result :failed + (test-ob-haskell-ghci-with-global-session + (test-ob-haskell-ghci ":session s1" "x=3D2" nil :unprotected) + (should (equal 2 (test-ob-haskell-ghci ":session s1" "x" nil :unprotect= ed))) + (test-ob-haskell-ghci ":session s2" "x=3D3" nil :unprotected) + (should-not (equal 3 (test-ob-haskell-ghci ":session s1" "x" nil :unpro= tected))) + )) + +(ert-deftest ob-haskell/no-session-means-one-shot-sessions () + "When no session, use a new session." + :expected-result :failed + (test-ob-haskell-ghci-with-global-session + (test-ob-haskell-ghci "" "x=3D2" nil :unprotected) + (should-not (equal 2 (test-ob-haskell-ghci "" "x" nil :unprotected))))) + + +;;;; Values +;; + +(ert-deftest ob-haskell/value-is-the-last-expression () + "Return the value of the last expression." + (should (equal 3 (test-ob-haskell-ghci "" '("1" "1+1" "1+1+1")))) + (should (equal 3 (test-ob-haskell-ghci "" '("x=3D1" "y=3D1+1" "x+y"))))) + +(ert-deftest ob-haskell/value-is-the-last-expression-2 () + "Return the value of the last expression." + (should (equal 7 (test-ob-haskell-ghci "" " +putStrLn \"a string\" +return \"useless\" +3+4 +")))) + + + +(ert-deftest ob-haskell/eval-numbers () + "Evaluation of numbers." + (should (equal 7 (test-ob-haskell-ghci "" "7"))) + (should (equal 7.5 (test-ob-haskell-ghci "" "7.5"))) + (should (equal 10.0 (test-ob-haskell-ghci "" "10::Double"))) + (should (equal 10 (test-ob-haskell-ghci "" "10::Int")))) + + +(ert-deftest ob-haskell/eval-strings () + "Evaluation of strings." + (should (equal "a string" (test-ob-haskell-ghci "" "\"a string\"")))) + + +;;;; Local variables +(ert-deftest ob-haskell/let-one-line () + "Local definitions on one line." + (should (equal 6 (test-ob-haskell-ghci "" "let { x=3D2; y=3D3 } in x*y")= ))) + +(ert-deftest ob-haskell/let-multilines-1 () + "Local definitions on multiple lines." + :expected-result :failed + (should (equal 6 (test-ob-haskell-ghci "" " +:{ + let { x=3D2 + ; y=3D3 + } + in x*y +:} +")))) + +(ert-deftest ob-haskell/let-multilines-2 () + "Local definitions on multiple lines, relying on indentation." + :expected-result :failed + (should (equal 6 (test-ob-haskell-ghci "" " +:{ + let x=3D2 + y=3D3 + in x*y +:} +")))) + +;;;; Declarations with multiple lines. +(ert-deftest ob-haskell/decl-multilines-1 () + "A multiline declaration, then use it." + (should (equal 3 (test-ob-haskell-ghci "" " +:{ +let length' [] =3D 0 + length' (_:l) =3D 1 + length' l +:} +length' [1,2,3] +")))) + +(ert-deftest ob-haskell/decl-multilines-2 () + "A multiline declaration, then use it." + (should (equal 5 (test-ob-haskell-ghci "" " +:{ +length' :: [a] -> Int +length' [] =3D 0 +length' (_:l) =3D 1 + length' l +:} + +length' [1..5] +")))) + + +(ert-deftest ob-haskell/primes () + "From haskell.org.""" + :expected-result :failed + (should (equal '(2 3 5 7 11 13 17 19 23 29) + (test-ob-haskell-ghci "" " +:{ +primes =3D filterPrime [2..] where + filterPrime (p:xs) =3D + p : filterPrime [x | x <- xs, x `mod` p /=3D 0] +:} + +take 10 primes +")))) + +;;;; Lists +;; + +(ert-deftest ob-haskell/a-simple-list () + "Evaluation of list of values." + (should (equal '(1 2 3) (test-ob-haskell-ghci "" "[1,2,3]")))) + + +(ert-deftest ob-haskell/2D-lists () + "Evaluation of nested lists into a table." + (should (equal '((1 2 3) (4 5 6)) + (test-ob-haskell-ghci "" "[[1..3], [4..6]]")))) + +(ert-deftest ob-haskell/2D-lists-multilines () + "Evaluation of nested lists into a table, as multilines." + :expected-result :failed + (should (equal '((1 2 3) (4 5 6)) + (test-ob-haskell-ghci "" " +:{ +[ [1..3] +, [4..6] +, [7..9] +] +:} +")))) + + +;;;; Tuples +;; + +(ert-deftest ob-haskell/a-simple-tuple () + "Evaluation of tuple of values." + (should (equal '(1 2 3) (test-ob-haskell-ghci "" "(1,2,3)")))) + + +(ert-deftest ob-haskell/2D-tuples () + "Evaluation of nested tuples into a table." + (should (equal '((1 2 3) (4 5 6)) + (test-ob-haskell-ghci "" "((1,2,3), (4,5,6))")))) + +(ert-deftest ob-haskell/2D-tuples-multilines () + "Evaluation of nested tuples into a table, as multilines." + (should (equal '((1 2 3) (4 5 6) (7 8 9)) + (test-ob-haskell-ghci "" " +:{ +( (1,2,3) +, (4,5,6) +, (7,8,9) +) +:} +")))) + + +;;;; Data tables +;; + +(ert-deftest ob-haskell/int-table-data () + "From worg: int-table-data." + (should (equal 10 (test-ob-haskell-ghci ":var t=3Dint-table-data" + "sum [sum r | r <- t]" + "#+name: int-table-data + | 1 | 2 | + | 3 | 4 |")))) + +(ert-deftest ob-haskell/float-table-data () + "From worg: float-table-data." + (should (equal 11.0 (test-ob-haskell-ghci ":var t=3Dfloat-table-data" + "sum [sum r | r <- t]" + "#+name: float-table-data + | 1.1 | 2.2 | + | 3.3 | 4.4 |")))) + +(ert-deftest ob-haskell/string-table-data () + "From worg: string-table-data." + (should (equal "abcd" (test-ob-haskell-ghci ":var t=3Dstring-table-data" + "concat [concat r | r <- t]" + "#+name: string-table-data + | a | b | + | c | d |")))) + +;;;; Reuse results +;; +(ert-deftest ob-haskell/reuse-table () + "Reusing a computed tables." + (should (equal 78 (test-ob-haskell-ghci ":var t=3Da-table" + "sum [sum r | r <- t]" + "#+name: a-table +#+begin_src haskell + [ [x..x+2] | x <- [1,4 .. 12] ] +#+end_src +")))) + + +;;;; Not defined errors +;; + +(ert-deftest ob-haskell/not-defined () + "Evaluation of undefined variables." + :expected-result :failed + (should-error (test-ob-haskell-ghci "" "notDefined :: IO Int"))) + + +(ert-deftest ob-haskell/not-defined-then-defined-1 () + "Evaluation of undefined variables. +This is a valid haskell source, but, invalid when entered one +line at a time in GHCi." + :expected-result :failed + (should-error (test-ob-haskell-ghci "" " +v :: Int +v =3D 4 +"))) + + +(ert-deftest ob-haskell/not-defined-then-defined-1-fixed () + "Like not-defined-then-defined-1, but using the mutiline marks." + :expected-result :failed + (let ((r (test-ob-haskell-ghci "" " +:{ + v :: Int + v =3D 4 +:} +"))) + (should (eq nil r)))) + +(ert-deftest ob-haskell/not-defined-then-defined-1-fixed-2 () + "Like not-defined-then-defined-1, but using one line." + (should (eq nil (test-ob-haskell-ghci "" "v =3D 4 :: Int")))) + + + +(ert-deftest ob-haskell/not-defined-then-defined-2 () + "Evaluation of undefined variables, followed by a correct one." + ;; ghci output is: + ;; | :2:1-4: error: + ;; | =E2=80=A2 Variable not in scope: main :: IO () + ;; | =E2=80=A2 Perhaps you meant =E2=80=98min=E2=80=99 (imported fr= om Prelude) + ;; | Hello, World! + ;; and ob-haskell just reports the last line "Hello, World!". + (should (string-match "Variable not in scope" + (test-ob-haskell-ghci ":results output" " +main :: IO () +main =3D putStrLn \"Hello, World!\" +main +")))) + +;;;; Imports +;; + +(ert-deftest ob-haskell/import () + "Import and use library." + (should (equal 65 (test-ob-haskell-ghci "" " +import Data.IORef +r <- newIORef 65 +readIORef r +")))) + +(ert-deftest ob-haskell/import-with-vars () + "Import and use library with vars." + (should (equal 65 (test-ob-haskell-ghci ":var x=3D65" " +import Data.IORef +r <- newIORef x +readIORef r +")))) + +;;;; What is the result? +;; + +(ert-deftest ob-haskell/results-value-1 () + "Don't confuse output and values: nothing." + (should (equal nil (test-ob-haskell-ghci ":results value" "return ()")))) + +(ert-deftest ob-haskell/results-value-2 () + "Don't confuse output and values: a list." + (should (equal '(1 2) (test-ob-haskell-ghci ":results value" "return [1,= 2]")))) + +(ert-deftest ob-haskell/results-value-3 () + "Don't confuse output and values: nothing." + :expected-result :failed + (should (equal nil (test-ob-haskell-ghci ":results value" "putStrLn \"3\= "")))) + +(ert-deftest ob-haskell/results-value-4 () + "Don't confuse output and values: nothing." + :expected-result :failed + (should (equal nil (test-ob-haskell-ghci ":results value" " +putStrLn \"3\" +return () +")))) + + +;;;; GHCi commands +;; + +(ert-deftest ob-haskell/ghci-type () + "The ghci meta command ':type'." + (should (equal "n :: Int" + (test-ob-haskell-ghci ":results output" "let n=3D3::Int\n= :type n")))) + +(ert-deftest ob-haskell/ghci-info () + "The ghci meta command ':info' ." + (should (equal "repeat :: a -> [a] -- Defined in =E2=80=98GHC.List=E2= =80=99" + (test-ob-haskell-ghci ":results output" ":info repeat")))) + + +(provide 'test-ob-haskell-ghci) + +;;; test-ob-haskell-ghci.el ends here --=20 2.41.0 --=-=-= Content-Type: text/x-patch Content-Disposition: attachment; filename=0002-org-babel-haskell-initiate-session-Remove-secondary-.patch >From b0e162a4238be505844a460bea7e4b42a72402ad Mon Sep 17 00:00:00 2001 From: Ihor Radchenko Date: Fri, 24 Mar 2023 11:20:22 +0100 Subject: [PATCH 2/7] org-babel-haskell-initiate-session: Remove secondary prompt * lisp/ob-haskell.el (org-babel-haskell-initiate-session): Set secondary prompt to "". If we do not do this, org-comint may treat secondary prompts as a part of output. --- lisp/ob-haskell.el | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el index 5babb2bb9..7e36c29e6 100644 --- a/lisp/ob-haskell.el +++ b/lisp/ob-haskell.el @@ -169,7 +169,16 @@ (defun org-babel-haskell-initiate-session (&optional _session _params) then create one. Return the initialized session." (org-require-package 'inf-haskell "haskell-mode") (or (get-buffer "*haskell*") - (save-window-excursion (run-haskell) (sleep-for 0.25) (current-buffer)))) + (save-window-excursion + (run-haskell) + (sleep-for 0.25) + ;; Disable secondary prompt: If we do not do this, + ;; org-comint may treat secondary prompts as a part of + ;; output. + (org-babel-comint-input-command + (current-buffer) + ":set prompt-cont \"\"") + (current-buffer)))) (defun org-babel-load-session:haskell (session body params) "Load BODY into SESSION." -- 2.41.0 --=-=-= Content-Type: text/x-patch; charset=utf-8 Content-Disposition: attachment; filename=0003-testing-lisp-test-ob-haskell-ghci.el-Fix-some-tests.patch Content-Transfer-Encoding: quoted-printable >From 5164ef6db8e9d722536b0dbb00523202f1ae917c Mon Sep 17 00:00:00 2001 From: Ihor Radchenko Date: Fri, 24 Mar 2023 11:25:19 +0100 Subject: [PATCH 3/7] * testing/lisp/test-ob-haskell-ghci.el: Fix some tests (ob-haskell/2D-lists-multilines): (ob-haskell/ghci-info): Fix incorrect test assertions. --- testing/lisp/test-ob-haskell-ghci.el | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-ha= skell-ghci.el index 920103858..e34dfacd9 100644 --- a/testing/lisp/test-ob-haskell-ghci.el +++ b/testing/lisp/test-ob-haskell-ghci.el @@ -237,8 +237,7 @@ (ert-deftest ob-haskell/2D-lists () =20 (ert-deftest ob-haskell/2D-lists-multilines () "Evaluation of nested lists into a table, as multilines." - :expected-result :failed - (should (equal '((1 2 3) (4 5 6)) + (should (equal '((1 2 3) (4 5 6) (7 8 9)) (test-ob-haskell-ghci "" " :{ [ [1..3] @@ -421,8 +420,9 @@ (ert-deftest ob-haskell/ghci-type () =20 (ert-deftest ob-haskell/ghci-info () "The ghci meta command ':info' ." - (should (equal "repeat :: a -> [a] -- Defined in =E2=80=98GHC.List=E2= =80=99" - (test-ob-haskell-ghci ":results output" ":info repeat")))) + (should (string-match-p + "repeat :: a -> \\[a\\][ \t]+-- Defined in =E2=80=98GHC.List=E2= =80=99" + (test-ob-haskell-ghci ":results output" ":info repeat")))) =20 =20 (provide 'test-ob-haskell-ghci) --=20 2.41.0 --=-=-= Content-Type: text/x-patch Content-Disposition: attachment; filename=0004-testing-lisp-test-ob-haskell-ghci.el-Enable-fixed-te.patch >From 5bf5f05f1d76d6128d56d48b9b23a767ba458a2d Mon Sep 17 00:00:00 2001 From: Ihor Radchenko Date: Fri, 24 Mar 2023 11:26:00 +0100 Subject: [PATCH 4/7] * testing/lisp/test-ob-haskell-ghci.el: Enable fixed tests (ob-haskell/hello-world-output-multilines): (ob-haskell/let-multilines-1): (ob-haskell/let-multilines-2): (ob-haskell/primes): (ob-haskell/not-defined-then-defined-1-fixed): Re-enable tests. --- testing/lisp/test-ob-haskell-ghci.el | 5 ----- 1 file changed, 5 deletions(-) diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el index e34dfacd9..c56ad8f51 100644 --- a/testing/lisp/test-ob-haskell-ghci.el +++ b/testing/lisp/test-ob-haskell-ghci.el @@ -93,7 +93,6 @@ (ert-deftest ob-haskell/hello-world-output-nothing () (test-ob-haskell-ghci ":results output" "return \"Hello World!\"")))) (ert-deftest ob-haskell/hello-world-output-multilines () - :expected-result :failed (should (equal "Hello World!" (test-ob-haskell-ghci ":results output" " :{ @@ -163,7 +162,6 @@ (ert-deftest ob-haskell/let-one-line () (ert-deftest ob-haskell/let-multilines-1 () "Local definitions on multiple lines." - :expected-result :failed (should (equal 6 (test-ob-haskell-ghci "" " :{ let { x=2 @@ -175,7 +173,6 @@ (ert-deftest ob-haskell/let-multilines-1 () (ert-deftest ob-haskell/let-multilines-2 () "Local definitions on multiple lines, relying on indentation." - :expected-result :failed (should (equal 6 (test-ob-haskell-ghci "" " :{ let x=2 @@ -210,7 +207,6 @@ (ert-deftest ob-haskell/decl-multilines-2 () (ert-deftest ob-haskell/primes () "From haskell.org.""" - :expected-result :failed (should (equal '(2 3 5 7 11 13 17 19 23 29) (test-ob-haskell-ghci "" " :{ @@ -336,7 +332,6 @@ (ert-deftest ob-haskell/not-defined-then-defined-1 () (ert-deftest ob-haskell/not-defined-then-defined-1-fixed () "Like not-defined-then-defined-1, but using the mutiline marks." - :expected-result :failed (let ((r (test-ob-haskell-ghci "" " :{ v :: Int -- 2.41.0 --=-=-= Content-Type: text/x-patch; charset=utf-8 Content-Disposition: attachment; filename=0005-lisp-ob-haskell-Request-the-last-value-from-GHCi.patch Content-Transfer-Encoding: quoted-printable >From cb35845d9b85ad37a90e6858651ac826679e41ae Mon Sep 17 00:00:00 2001 From: Bruno BARBIER Date: Sat, 25 Mar 2023 09:59:31 +0100 Subject: [PATCH 5/7] lisp/ob-haskell: Request the last value from GHCi * lisp/ob-haskell.el (org-babel-interpret-haskell): When the result type is 'value, use the last value as defined by GHCi. (org-babel-haskell-eoe): New default value. (org-babel-interpret-haskell): Update for the new value of `org-babel-haske= ll-eoe'. * testing/lisp/test-ob-haskell-ghci.el: Update tests related to output/valu= e. --- lisp/ob-haskell.el | 80 ++++++++++++++++++---------- testing/lisp/test-ob-haskell-ghci.el | 6 +-- 2 files changed, 53 insertions(+), 33 deletions(-) diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el index 7e36c29e6..55687769f 100644 --- a/lisp/ob-haskell.el +++ b/lisp/ob-haskell.el @@ -61,7 +61,7 @@ (defvar org-babel-default-header-args:haskell =20 (defvar org-babel-haskell-lhs2tex-command "lhs2tex") =20 -(defvar org-babel-haskell-eoe "\"org-babel-haskell-eoe\"") +(defvar org-babel-haskell-eoe "org-babel-haskell-eoe") =20 (defvar haskell-prompt-regexp) =20 @@ -127,34 +127,56 @@ (defun org-babel-interpret-haskell (body params) (lambda () (setq-local comint-prompt-regexp (concat haskell-prompt-regexp "\\|^=CE=BB?> ")))) - (let* ((session (cdr (assq :session params))) - (result-type (cdr (assq :result-type params))) - (full-body (org-babel-expand-body:generic - body params - (org-babel-variable-assignments:haskell params))) - (session (org-babel-haskell-initiate-session session params)) - (comint-preoutput-filter-functions - (cons 'ansi-color-filter-apply comint-preoutput-filter-functions)) - (raw (org-babel-comint-with-output - (session org-babel-haskell-eoe nil full-body) - (insert (org-trim full-body)) - (comint-send-input nil t) - (insert org-babel-haskell-eoe) - (comint-send-input nil t))) - (results (mapcar #'org-strip-quotes - (cdr (member org-babel-haskell-eoe - (reverse (mapcar #'org-trim raw))))= ))) - (org-babel-reassemble-table - (let ((result - (pcase result-type - (`output (mapconcat #'identity (reverse results) "\n")) - (`value (car results))))) - (org-babel-result-cond (cdr (assq :result-params params)) - result (when result (org-babel-script-escape result)))) - (org-babel-pick-name (cdr (assq :colname-names params)) - (cdr (assq :colname-names params))) - (org-babel-pick-name (cdr (assq :rowname-names params)) - (cdr (assq :rowname-names params)))))) + (org-babel-haskell-with-session session params + (cl-labels + ((send-txt-to-ghci (txt) + (insert txt) (comint-send-input nil t)) + (send-eoe () + (send-txt-to-ghci (concat "putStrLn \"" org-babel-haskell-eoe "= \"\n"))) + (comint-with-output (todo) + (let ((comint-preoutput-filter-functions + (cons 'ansi-color-filter-apply + comint-preoutput-filter-functions))) + (org-babel-comint-with-output + (session org-babel-haskell-eoe nil nil) + (funcall todo))))) + (let* ((result-type (cdr (assq :result-type params))) + (full-body (org-babel-expand-body:generic + body params + (org-babel-variable-assignments:haskell params))) + (raw (pcase result-type + (`output + (comint-with-output + (lambda () (send-txt-to-ghci (org-trim full-body)) (= send-eoe)))) + (`value + ;; We first compute the value and store it, + ;; ignoring any output. + (comint-with-output + (lambda () + (send-txt-to-ghci "__LAST_VALUE_IMPROBABLE_NAME__= =3D()::()\n") + (send-txt-to-ghci (org-trim full-body)) + (send-txt-to-ghci "__LAST_VALUE_IMPROBABLE_NAME__= =3Dit\n") + (send-eoe))) + ;; We now display and capture the value. + (comint-with-output + (lambda() + (send-txt-to-ghci "__LAST_VALUE_IMPROBABLE_NAME__\= n") + (send-eoe)))))) + (results (mapcar #'org-strip-quotes + (cdr (member org-babel-haskell-eoe + (reverse (mapcar #'org-trim raw= ))))))) + (org-babel-reassemble-table + (let ((result + (pcase result-type + (`output (mapconcat #'identity (reverse results) "\n")) + (`value (car results))))) + (org-babel-result-cond (cdr (assq :result-params params)) + result (when result (org-babel-script-escape result)))) + (org-babel-pick-name (cdr (assq :colname-names params)) + (cdr (assq :colname-names params))) + (org-babel-pick-name (cdr (assq :rowname-names params)) + (cdr (assq :rowname-names params)))))))) + =20 (defun org-babel-execute:haskell (body params) "Execute a block of Haskell code." diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-ha= skell-ghci.el index c56ad8f51..9cdc763d9 100644 --- a/testing/lisp/test-ob-haskell-ghci.el +++ b/testing/lisp/test-ob-haskell-ghci.el @@ -88,8 +88,8 @@ (ert-deftest ob-haskell/hello-world-output () (test-ob-haskell-ghci ":results output" "putStrLn \"Hello= World!\"")))) =20 (ert-deftest ob-haskell/hello-world-output-nothing () - :expected-result :failed - (should (equal "" + ;; GHCi prints the value on standard output. So, the last value is part= of the output. + (should (equal "Hello World!" (test-ob-haskell-ghci ":results output" "return \"Hello W= orld!\"")))) =20 (ert-deftest ob-haskell/hello-world-output-multilines () @@ -393,12 +393,10 @@ (ert-deftest ob-haskell/results-value-2 () =20 (ert-deftest ob-haskell/results-value-3 () "Don't confuse output and values: nothing." - :expected-result :failed (should (equal nil (test-ob-haskell-ghci ":results value" "putStrLn \"3\= "")))) =20 (ert-deftest ob-haskell/results-value-4 () "Don't confuse output and values: nothing." - :expected-result :failed (should (equal nil (test-ob-haskell-ghci ":results value" " putStrLn \"3\" return () --=20 2.41.0 --=-=-= Content-Type: text/x-patch Content-Disposition: attachment; filename=0006-ob-haskell-Implement-sessions.patch >From 4beb4e6c1abe2c5a560662903f236a6c1ab3d44f Mon Sep 17 00:00:00 2001 From: Bruno BARBIER Date: Sat, 25 Mar 2023 10:06:44 +0100 Subject: [PATCH 6/7] ob-haskell: Implement sessions * lisp/ob-haskell.el (org-babel-haskell-initiate-session): Implement sessions. (org-babel-haskell-with-session): New macro to manage sessions. (org-babel-interpret-haskell): Refactor code. Use `org-babel-haskell-with-session` to manage sessions. * testing/lisp/test-ob-haskell-ghci.el: Update tests related to sessions. --- lisp/ob-haskell.el | 96 ++++++++++++++++++++++++---- testing/lisp/test-ob-haskell-ghci.el | 47 ++++++++++---- 2 files changed, 115 insertions(+), 28 deletions(-) diff --git a/lisp/ob-haskell.el b/lisp/ob-haskell.el index 55687769f..8f6d5aebd 100644 --- a/lisp/ob-haskell.el +++ b/lisp/ob-haskell.el @@ -77,6 +77,32 @@ (defcustom org-babel-haskell-compiler "ghc" (defconst org-babel-header-args:haskell '((compile . :any)) "Haskell-specific header arguments.") + +(defun org-babel-haskell-with-session--worker (params todo) + "See `org-babel-haskell-with-session'." + (let* ((sn (cdr (assq :session params))) + (session (org-babel-haskell-initiate-session sn params)) + (one-shot (equal sn "none"))) + (unwind-protect + (funcall todo session) + (when (and one-shot (buffer-live-p session)) + ;; As we don't control how the session temporary buffer is + ;; created, we need to explicitly work around the hooks and + ;; query functions. + (with-current-buffer session + (let ((kill-buffer-query-functions nil) + (kill-buffer-hook nil)) + (kill-buffer session))))))) + +(defmacro org-babel-haskell-with-session (session-symbol params &rest body) + "Get the session identified by PARAMS and run BODY with it. + +Get or create a session, as needed to match PARAMS. Assign the session to +SESSION-SYMBOL. Execute BODY. Destroy the session if needed. +Return the value of the last form of BODY." + (declare (indent 2) (debug (symbolp form body))) + `(org-babel-haskell-with-session--worker ,params (lambda (,session-symbol) ,@body))) + (defun org-babel-haskell-execute (body params) "This function should only be called by `org-babel-execute:haskell'." (let* ((tmp-src-file (org-babel-temp-file "Haskell-src-" ".hs")) @@ -185,22 +211,64 @@ (defun org-babel-execute:haskell (body params) (org-babel-interpret-haskell body params) (org-babel-haskell-execute body params)))) -(defun org-babel-haskell-initiate-session (&optional _session _params) + + + +;; Variable defined in inf-haskell (haskell-mode package). +(defvar inferior-haskell-buffer) + +(defun org-babel-haskell-initiate-session (&optional session-name _params) "Initiate a haskell session. -If there is not a current inferior-process-buffer in SESSION -then create one. Return the initialized session." +Return the initialized session, i.e. the buffer for this session. +When SESSION-NAME is nil, use a global session named +\"*ob-haskell*\". When SESSION-NAME is the string \"none\", use +a temporary buffer. Else, (re)use the session named +SESSION-NAME. The buffer name is the session name. See also +`org-babel-haskell-with-session'." (org-require-package 'inf-haskell "haskell-mode") - (or (get-buffer "*haskell*") - (save-window-excursion - (run-haskell) - (sleep-for 0.25) - ;; Disable secondary prompt: If we do not do this, - ;; org-comint may treat secondary prompts as a part of - ;; output. - (org-babel-comint-input-command - (current-buffer) - ":set prompt-cont \"\"") - (current-buffer)))) + (cond + ((equal "none" session-name) + ;; Temporary buffer name. + (setq session-name (generate-new-buffer-name " *ob-haskell-tmp*"))) + ((eq nil session-name) + ;; The global default session. As haskell-mode is using the buffer + ;; named "*haskell*", we stay away from it. + (setq session-name "*ob-haskell*")) + ((not (stringp session-name)) + (error "session-name must be a string"))) + (let ((session (get-buffer session-name))) + ;; NOTE: By construction, as SESSION-NAME is a string, session is + ;; either nil or a live buffer. + (save-window-excursion + (or (org-babel-comint-buffer-livep session) + (let ((inferior-haskell-buffer session)) + ;; As inferior-haskell expects the buffer to be named + ;; "*haskell*", we temporarily rename it while executing + ;; `run-haskell' (unless the user explicitly requested to + ;; use the name "*haskell*"). + (when (not (equal "*haskell*" session-name)) + (when (bufferp session) + (when (bufferp "*haskell*") + (user-error "Conflicting buffer '*haskell*', rename it or kill it")) + (with-current-buffer session (rename-buffer "*haskell*")))) + (unwind-protect + (let ((inferior-haskell-root-dir default-directory)) + (run-haskell) + (sleep-for 0.25) + (setq session inferior-haskell-buffer)) + (when (and (not (equal "*haskell*" session-name)) + (bufferp session)) + (with-current-buffer session (rename-buffer session-name)))) + ;; Disable secondary prompt: If we do not do this, + ;; org-comint may treat secondary prompts as a part of + ;; output. + (org-babel-comint-input-command + session + ":set prompt-cont \"\"") + session) + )) + session)) + (defun org-babel-load-session:haskell (session body params) "Load BODY into SESSION." diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el index 9cdc763d9..9ccc60e90 100644 --- a/testing/lisp/test-ob-haskell-ghci.el +++ b/testing/lisp/test-ob-haskell-ghci.el @@ -108,20 +108,39 @@ (ert-deftest ob-haskell/hello-world-output-multilines () (ert-deftest ob-haskell/sessions-must-not-share-variables () "Sessions must not share variables." - :expected-result :failed - (test-ob-haskell-ghci-with-global-session - (test-ob-haskell-ghci ":session s1" "x=2" nil :unprotected) - (should (equal 2 (test-ob-haskell-ghci ":session s1" "x" nil :unprotected))) - (test-ob-haskell-ghci ":session s2" "x=3" nil :unprotected) - (should-not (equal 3 (test-ob-haskell-ghci ":session s1" "x" nil :unprotected))) - )) - -(ert-deftest ob-haskell/no-session-means-one-shot-sessions () - "When no session, use a new session." - :expected-result :failed - (test-ob-haskell-ghci-with-global-session - (test-ob-haskell-ghci "" "x=2" nil :unprotected) - (should-not (equal 2 (test-ob-haskell-ghci "" "x" nil :unprotected))))) + (test-ob-haskell-ghci ":session s1" "x=2" nil) + (should (equal 2 (test-ob-haskell-ghci ":session s1" "x" nil))) + (test-ob-haskell-ghci ":session s2" "x=3" nil) + (should-not (equal 3 (test-ob-haskell-ghci ":session s1" "x" nil))) + ) + +(ert-deftest ob-haskell/session-named-none-means-one-shot-sessions () + "When no session, use a new session. +\"none\" is a special name that means `no session'." + (test-ob-haskell-ghci ":session none" "x=2" nil) + (should-not (equal 2 (test-ob-haskell-ghci ":session \"none\"" "x" nil))) + (test-ob-haskell-ghci ":session none" "x=2" nil) + (should-not (equal 2 (test-ob-haskell-ghci ":session \"none\"" "x" nil)))) + +(ert-deftest ob-haskell/reuse-variables-in-same-session () + "Reuse variables between blocks using the same session." + (test-ob-haskell-ghci ":session s1" "x=2" nil) + (should (equal 2 (test-ob-haskell-ghci ":session s1" "x")))) + +(ert-deftest ob-haskell/may-use-the-*haskell*-session () + "The user may use the special *haskell* buffer." + (when (get-buffer "*haskell*") + (error "A buffer named '*haskell*' exists. Can't run this test")) + (unwind-protect + (progn + (test-ob-haskell-ghci ":session *haskell*" "x=2" nil :unprotected) + (should (equal 2 (test-ob-haskell-ghci ":session *haskell*" "x" nil :unprotected)))) + (with-current-buffer "*haskell*" + (let ((kill-buffer-query-functions nil) + (kill-buffer-hook nil)) + (kill-buffer "*haskell*"))))) + + ;;;; Values -- 2.41.0 --=-=-= Content-Type: text/x-patch Content-Disposition: attachment; filename=0007-testing-lisp-test-ob-haskell-ghci.el-Test-output-wit.patch >From d0f0d40d570a6b63aa0b4ad3ae6f1b67a32e99a3 Mon Sep 17 00:00:00 2001 From: Bruno BARBIER Date: Sat, 29 Apr 2023 10:27:57 +0200 Subject: [PATCH 7/7] * testing/lisp/test-ob-haskell-ghci.el: Test output without EOL (ob-haskell/output-without-eol-1): (ob-haskell/output-without-eol-2): (ob-haskell/output-without-eol-3): New tests. --- testing/lisp/test-ob-haskell-ghci.el | 32 ++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/testing/lisp/test-ob-haskell-ghci.el b/testing/lisp/test-ob-haskell-ghci.el index 9ccc60e90..e64e87203 100644 --- a/testing/lisp/test-ob-haskell-ghci.el +++ b/testing/lisp/test-ob-haskell-ghci.el @@ -173,6 +173,38 @@ (ert-deftest ob-haskell/eval-strings () "Evaluation of strings." (should (equal "a string" (test-ob-haskell-ghci "" "\"a string\"")))) +;;;; Output without EOL +;; + +(ert-deftest ob-haskell/output-without-eol-1 () + "Cannot get output from incomplete lines, when entered line by line." + :expected-result :failed + (should (equal "123" + (test-ob-haskell-ghci ":results output" " + putStr(\"1\") + putStr(\"2\") + putStr(\"3\") + putStr(\"\\n\") +")))) + +(ert-deftest ob-haskell/output-without-eol-2 () + "Incomplete output lines are OK when using a multiline block." + (should (equal "123" + (test-ob-haskell-ghci ":results output" " +:{ + do putStr(\"1\") + putStr(\"2\") + putStr(\"3\") + putStr(\"\\n\") +:} +")))) + +(ert-deftest ob-haskell/output-without-eol-3 () + "Incomplete output lines are OK on one line." + (should (equal "123" + (test-ob-haskell-ghci ":results output" " +do { putStr(\"1\"); putStr(\"2\"); putStr(\"3\"); putStr(\"\\n\") } +")))) ;;;; Local variables (ert-deftest ob-haskell/let-one-line () -- 2.41.0 --=-=-=--