(import (scheme base)
        (only (csc format) printf)
        (only (csc testing)
          assert-equal
          test)
        (csc loop))


(test loop-for-collect
  (assert-equal
    '(1 2 3 4 5)
    (loop for x in '(1 2 3 4 5)
          collect x)))


(test loop-for-collect-add
  (assert-equal
    '(2 3 4 5 6)
    (loop for x in '(1 2 3 4 5)
          collect (+ 1 x))))


(test loop-for-arithmetic
  (assert-equal
    '(1 2 3 4 5)
    (loop for x from 1 to 5
          collect x)))


(test loop-for-arithmetic-step
  (assert-equal
    '(1 3 5 7 9)
    (loop for x from 1 to 10 by 2
          collect x)))


(test loop-finally-noop
  (assert-equal
    '(1 2 3)
    (loop for x from 1 to 3
          finally (if #f #f)
          collect x)))


(test loop-collect-into
  (assert-equal
    '((1 2 3) (1 2 3) (1 2 3))
    (loop for x from 1 to 3
          collect x into l
          collect l)))


(test loop-finally-set
  (assert-equal
    '(1 2 3)
    (let ((res #f))
      (loop for x from 1 to 3
            collect x into l
            finally (set! res l))
      res)))


(test loop-do
  (assert-equal
    '(3 2 1)
    (let ((res '()))
      (loop for x from 1 to 3
            do (set! res (cons x res)))
      res)))


(test loop-return
  (assert-equal
    '(1 2 3)
    (loop do (return '(1 2 3)))))


(test loop-finally-return
  (assert-equal
    '(1 2 3)
    (loop for x from 1 to 3
          collect x into l
          finally (return l))))


(test loop-for-as-equals-then
  (assert-equal
    '((1 2 3) (2 3) (3))
    (loop for i from 1 to 3
          for tail = '(1 2 3) then (cdr tail)
          collect tail)))


(test loop-for-as-equals
  (assert-equal
    '((1) (2) (3))
    (loop for i from 1 to 3
          for j = (list i)
          collect j)))


(test loop-return-multiple-values
  (let-values (((x1 x2) (loop do (return (values 1 2)))))
    (assert-equal
      1
      x1)
    (assert-equal
      2
      x2)))


(test nested-loops
  (assert-equal
    '(1 2 3)
    (loop do (define x (loop do (return '(1 2 3))))
             (return x))))


(test loop-with-return
  (assert-equal
    5
    (loop with x = 5
          return x)))


(test loop-for-x-on-l
  (assert-equal
    '((1 2 3) (2 3) (3))
    (loop for x on '(1 2 3)
          collect x)))


(test loop-for-across
  (assert-equal
    '(1 2 3)
    (loop for x across #(1 2 3)
          collect x)))


(test loop-for-downfrom
  (assert-equal
    '(3 2 1)
    (loop for x to 1 downfrom 3
          collect x)))


(test loop-for-to
  (assert-equal
    '(0 1 2 3)
    (loop for x to 3
          collect x)))


(test loop-for-downto
  (assert-equal
    '(3 2 1)
    (loop for x downto 1 from 3
          collect x)))


(test loop-for-below
  (assert-equal
    '(0 1 2)
    (loop for x below 3
          collect x)))


(test loop-for-above
  (assert-equal
    '(3 2 1)
    (loop for x above 0 from 3
          collect x)))


(test loop-for-by
  (assert-equal
    '(0 2 4)
    (loop for x by 2 to 4
          collect x)))


(test loop-append
  (assert-equal
    '(1 2 3 4)
    (loop for x in '((1 2) (3 4))
          append x)))


(test loop-count
  (assert-equal
    50
    (loop for x from 1 to 100
          count (even? x))))


(test loop-sum
  (assert-equal
    15
    (loop for x from 1 to 5
          sum x)))


(test loop-maximize
  (assert-equal
    10
    (loop for x in '(3 10 1 4)
          maximize x)))


(test loop-minimize
  (assert-equal
    1
    (loop for x in '(3 10 1 4)
          minimize x)))


(test loop-if
  (assert-equal
    5
    (loop for x from 0
          if (>= x 5) return x)))


(test loop-when
  (assert-equal
    5
    (loop for x from 0
          when (>= x 5) return x)))


(test loop-else
  (assert-equal
    '((0 2 4) . (1 3 5))
    (loop for x to 5
          if (even? x) collect x into evens
          else collect x into odds
          finally (return (cons evens odds)))))


(test loop-if-compound
  (assert-equal
    '((0 2 4) . (1 3 5))
    (loop for x to 5
          if (even? x) collect x into list1
          and collect (+ 1 x) into list2
          finally (return (cons list1 list2)))))


(test loop-if-end
  (assert-equal
    5
    (loop for x from 0
          if (>= x 5) return x end)))