Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs/elpa

[gnu-emacs-elpa] / packages / stream / tests / stream-tests.el

diff --git a/packages/stream/tests/stream-tests.el b/packages/stream/tests/stream-tests.el
index a59aced1ea017f0d4594837c1f1d31d9b9e78de5..88edf918c7382eddf30b632c97fb8f76e482bbf6 100644 (file)
--- a/packages/stream/tests/stream-tests.el
+++ b/packages/stream/tests/stream-tests.el
@@ -26,6 +26,7 @@
 
 (require 'ert)
 (require 'stream)
+(require 'cl-lib)
 
 (defun stream-to-list (stream)
   "Eagerly traverse STREAM and return a list of its elements."
@@ -36,11 +37,11 @@
     (reverse result)))
 
 (ert-deftest stream-empty-test ()
-  (should (stream-p (stream-empty)))
+  (should (streamp (stream-empty)))
   (should (stream-empty-p (stream-empty))))
 
 (ert-deftest stream-make-test ()
-  (should (stream-p (stream-range)))
+  (should (streamp (stream-range)))
   (should (not (stream-empty-p (stream-range))))) ;; Should use stream-list or something
 
 (ert-deftest stream-first-test ()
@@ -51,8 +52,37 @@
   (should (= 4 (stream-first (stream-rest (stream-range 3)))))
   (should (= 5 (stream-first (stream-rest (stream-rest (stream-range 3)))))))
 
-(ert-deftest stream-seq-p-test ()
-  (should (seq-p (stream-range))))
+(ert-deftest stream-from-iterator-test ()
+  (skip-unless (require 'generator nil t))
+  (should (equal '(1 2)
+                 (seq-into-sequence
+                  (stream-from-iterator
+                   (funcall (iter-lambda ()
+                              (iter-yield 1)
+                              (iter-yield 2))))))))
+
+(ert-deftest stream-append-test ()
+  (should (stream-empty-p (stream-append)))
+  (should (let ((list '(1 2)))
+            (equal list (seq-into-sequence (stream-append (stream list))))))
+  (should (= (seq-elt (stream-append
+                       (stream (list 0 1))
+                       (stream-range 2))
+                      4)
+             4))
+  (should (let ((stream (stream (list 0))))
+            (and (= (seq-elt (stream-append stream (stream-range 1)) 10)
+                    10)
+                 (stream-empty-p (stream-rest stream)))))
+  (should (equal (seq-into-sequence
+                  (stream-append
+                   (stream '(1))
+                   (stream '())
+                   (stream '(2 3))))
+                 '(1 2 3))))
+
+(ert-deftest stream-seqp-test ()
+  (should (seqp (stream-range))))
 
 (ert-deftest stream-seq-elt-test ()
   (should (null (seq-elt (stream-empty) 0)))
@@ -76,7 +106,7 @@
     (should (= first 2))
     (should (= third 4))
     ;; The rest of the stream shouldn't be consumed
-    (should (stream-p rest))
+    (should (streamp rest))
     (should (= 5 (stream-first rest)))
     (should (= 6 (stream-first (stream-rest rest))))
     (should (stream-empty-p (stream-rest (stream-rest rest))))))
@@ -86,21 +116,21 @@
   )
 
 (ert-deftest stream-seq-into-test ()
-  (should (stream-p (seq-into (stream-empty) 'stream)))
-  (should (stream-p (seq-into '(2 4 5) 'stream)))
+  (should (streamp (seq-into (stream-empty) 'stream)))
+  (should (streamp (seq-into '(2 4 5) 'stream)))
   (should (= 2  (stream-first (seq-into '(2 4 5) 'stream))))
   (should (null (seq-into (stream-empty) 'list)))
   (should (equal '(0 1 2 3 4 5 6 7 8 9) (seq-into (stream-range 0 10) 'list))))
 
 (ert-deftest stream-seq-take-test ()
-  (should (stream-p (seq-take (stream-range) 2)))
+  (should (streamp (seq-take (stream-range) 2)))
   (should (= 0 (stream-first (seq-take (stream-range) 2))))
   (should (= 1 (stream-first (stream-rest (seq-take (stream-range) 2)))))
   (should (null (stream-first (stream-rest (stream-rest (seq-take (stream-range) 2))))))
   (should (stream-empty-p (stream-rest (stream-rest (seq-take (stream-range) 2))))))
 
 (ert-deftest stream-seq-drop-test ()
-  (should (stream-p (seq-drop (stream-range) 2)))
+  (should (streamp (seq-drop (stream-range) 2)))
   (should (= 2 (stream-first (seq-drop (stream-range) 2))))
   (should (= 3 (stream-first (stream-rest (seq-drop (stream-range) 2)))))
   (should (stream-empty-p (seq-drop (stream-empty) 2))))
@@ -108,18 +138,18 @@
 (ert-deftest stream-seq-take-while-test ()
   (let ((stream (stream '(1 3 2 5))))
     (should (stream-empty-p (seq-take-while #'identity (stream-empty))))
-    (should (stream-p (seq-take-while #'oddp stream)))
-    (should (= 1 (stream-first (seq-take-while #'oddp stream))))
-    (should (= 3 (stream-first (stream-rest (seq-take-while #'oddp stream)))))
-    (should (stream-empty-p (stream-rest (stream-rest (seq-take-while #'oddp stream)))))))
+    (should (streamp (seq-take-while #'cl-oddp stream)))
+    (should (= 1 (stream-first (seq-take-while #'cl-oddp stream))))
+    (should (= 3 (stream-first (stream-rest (seq-take-while #'cl-oddp stream)))))
+    (should (stream-empty-p (stream-rest (stream-rest (seq-take-while #'cl-oddp stream)))))))
 
 (ert-deftest stream-seq-drop-while-test ()
   (let ((stream (stream '(1 3 2 5))))
-    (should (stream-p (seq-drop-while #'evenp stream)))
+    (should (streamp (seq-drop-while #'cl-evenp stream)))
     (should (stream-empty-p (seq-drop-while #'identity (stream-empty))))
-    (should (= 2 (stream-first (seq-drop-while #'evenp stream))))
-    (should (= 5 (stream-first (stream-rest (seq-drop-while #'evenp stream)))))
-    (should (stream-empty-p (stream-rest (stream-rest (seq-drop-while #'evenp stream)))))))
+    (should (= 2 (stream-first (seq-drop-while #'cl-evenp stream))))
+    (should (= 5 (stream-first (stream-rest (seq-drop-while #'cl-evenp stream)))))
+    (should (stream-empty-p (stream-rest (stream-rest (seq-drop-while #'cl-evenp stream)))))))
 
 (ert-deftest stream-seq-map-test ()
   (should (stream-empty-p (seq-map #'- (stream-empty))))
@@ -135,14 +165,14 @@
     (should (equal result '(4 3 2 1 0)))))
 
 (ert-deftest stream-seq-filter-test ()
-  (should (stream-empty-p (seq-filter #'oddp (stream-empty))))
-  (should (stream-empty-p (seq-filter #'oddp (stream-range 0 4 2))))
-  (should (= 1 (stream-first (seq-filter #'oddp (stream-range 0 4)))))
-  (should (= 3 (stream-first (stream-rest (seq-filter #'oddp (stream-range 0 4))))))
-  (should (stream-empty-p (stream-rest (stream-rest (seq-filter #'oddp (stream-range 0 4)))))))
+  (should (stream-empty-p (seq-filter #'cl-oddp (stream-empty))))
+  (should (stream-empty-p (seq-filter #'cl-oddp (stream-range 0 4 2))))
+  (should (= 1 (stream-first (seq-filter #'cl-oddp (stream-range 0 4)))))
+  (should (= 3 (stream-first (stream-rest (seq-filter #'cl-oddp (stream-range 0 4))))))
+  (should (stream-empty-p (stream-rest (stream-rest (seq-filter #'cl-oddp (stream-range 0 4)))))))
 
 (ert-deftest stream-seq-copy-test ()
-  (should (stream-p (seq-copy (stream-range))))
+  (should (streamp (seq-copy (stream-range))))
   (should (= 0 (stream-first (seq-copy (stream-range)))))
   (should (= 1 (stream-first (stream-rest (seq-copy (stream-range)))))))
 
@@ -168,12 +198,19 @@
   (should (= (seq-length (seq-subseq (stream-range 2 10) 1 3)) 2))
   (should (= (seq-elt (seq-subseq (stream-range 2 10) 1 3) 1) 4)))
 
-(ert-deftest stream-rest-should-return-the-empty-stream-at-end-of-stream ()
-  (should (stream-empty-p (stream-rest (stream-rest (stream nil))))))
-
-(ert-deftest seq-take-should-not-signal-exceptions-at-end-of-stream ()
-  (should (equal (seq-into-sequence (seq-take (stream (list 1 2 3)) 4))
-                 '(1 2 3))))
+(ert-deftest stream-seq-map-should-not-consume-stream-elements ()
+  (let* (consumed
+         (stream (stream-cons (setq consumed t) (stream-empty))))
+    (seq-map #'identity stream)
+    (should-not consumed)))
+
+(ert-deftest stream-pop-test ()
+  (let* ((str (stream '(1 2 3)))
+         (first (stream-pop str))
+         (stream-empty (stream-empty)))
+    (should (= 1 first))
+    (should (= 2 (stream-first str)))
+    (should (null (stream-pop stream-empty)))))
 
 (provide 'stream-tests)
 ;;; stream-tests.el ends here