def expected = DB['select b from (values (true), (false)) bs(b)'].to_a
compare_with(expected)

USING: arrays kernel math math.order prettyprint tools.testest transducers ;
QUALIFIED-WITH: sequences s
IN: transducers.tests

ERROR: not-lazy-enough ;

: into-vector ( -- finalizer initializer step: ( a x -- a' ) )
  [ ] [ V{ } clone f ] [ s:suffix! f ] ;

: run-tests ( -- )
  "reduce-seq" describe#{
    "immutable accumulator" it#{
      <{ { 1 2 3 4 5 6 } [ ] [ 10 f ] [ + f ] reduce-seq -> 31 }>
    }#
    "mutable accumulator" it#{
      <{ { 1 2 3 4 5 6 } into-vector reduce-seq -> V{ 1 2 3 4 5 6 } }>
    }#
  }#
  "reduce-seq with transducers" describe#{
    "map" it#{
      <{ { 1 2 3 4 5 6 } into-vector [ 1 + 2 * ] map reduce-seq -> V{ 4 6 8 10 12 14 } }>
    }#
    "map <- map" it#{
      <{ { 1 2 3 4 5 6 } into-vector [ 2 * ] map [ 1 + ] map reduce-seq -> V{ 4 6 8 10 12 14 } }>
    }#
    "filter" it#{
      <{ { 1 2 3 4 5 6 } into-vector [ even? ] filter reduce-seq -> V{ 2 4 6 } }>
    }#
    "map <- filter <- map" it#{
      <{ { 1 2 3 4 5 6 } into-vector [ 2 * ] map [ even? ] filter [ 1 - ] map reduce-seq -> V{ 0 4 8 } }>
    }#
    "take-while" it#{
      <{ { 1 2 3 4 5 6 } into-vector [ 4 = not ] take-while reduce-seq -> V{ 1 2 3 } }>
    }#
    "take-n" describe#{
      "simple" it#{
        <{ { 1 2 3 4 5 6 } into-vector 3 take-n reduce-seq -> V{ 1 2 3 } }>
      }#
      "0" it#{
        <{ { 1 2 3 4 5 6 } into-vector 0 take-n reduce-seq -> V{ } }>
      }#
      "take-n <- take-n" it#{
        <{ { 1 2 3 4 5 6 } into-vector 3 take-n 3 take-n reduce-seq -> V{ 1 2 3 } }>
      }#
      "early termination" it#{
        <{ { [ 1 ] [ 2 ] [ not-lazy-enough ] } into-vector 2 take-n [ call ] map reduce-seq -> V{ 1 2 } }>
      }#
      "0, early termination" it#{
        <{ { [ not-lazy-enough ] } into-vector 0 take-n [ call ] map reduce-seq -> V{ } }>
      }#
    }#
    "drop-while" it#{
      <{ { 1 2 3 4 5 6 } into-vector [ 4 = not ] drop-while reduce-seq -> V{ 4 5 6 } }>
    }#
    "drop-n" it#{
      <{ { 1 2 3 4 5 6 } into-vector 3 drop-n reduce-seq -> V{ 4 5 6 } }>
    }#
    "group-using-arrays" describe#{
      "exact" it#{
        <{ { 1 2 3 4 5 6 } into-vector 3 group-using-arrays reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } } }>
      }#
      "with remainder" it#{
        <{ { 1 2 3 4 5 6 7 } into-vector 3 group-using-arrays reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } V{ 7 } } }>
      }#
      "exact, cut source" it#{
        <{ { 1 2 3 4 5 6 7 8 } into-vector 3 group-using-arrays 6 take-n reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } } }>
      }#
      "with remainder, cut source" it#{
        <{ { 1 2 3 4 5 6 7 8 } into-vector 3 group-using-arrays 7 take-n reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } V{ 7 } } }>
      }#
      "cut destination at end, full" it#{
        <{ { 1 2 3 4 5 6 } into-vector 2 take-n 3 group-using-arrays reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } } }>
      }#
      "cut destination at end, partial (avoid leaking `reduced`)" it#{
        <{ { 1 2 3 4 5 6 7 } into-vector 3 take-n 3 group-using-arrays reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } V{ 7 } } }>
      }#
      "cut destination, dropping partial" it#{
        <{ { 1 2 3 4 5 6 7 } into-vector 2 take-n 3 group-using-arrays reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } } }>
      }#
      "cut destination, dropping full" it#{
        <{ { 1 2 3 4 5 6 7 8 9 } into-vector 2 take-n 3 group-using-arrays reduce-seq -> V{ V{ 1 2 3 } V{ 4 5 6 } } }>
      }#
    }#
  }#
  "reduce-seq* with transducers" describe#{
    "map <- filter <- map" it#{
      <{ { 1 2 3 4 5 6 } into-vector [ 2 * ] map [ even? ] filter [ 1 - ] map reduce-seq -> V{ 0 4 8 } }>
    }#
  }#
  "iterate (0->1 arity)" describe#{
    "low-level" describe#{
      "lazy enough (1, cut to 0)" it#{
        <{ [ "x" t ] [ not-lazy-enough ] 1 [ not-lazy-enough ] iterate drop call -> "x" t }>
      }#
      "lazy enough (1)" it#{
        <{ [ "x" f ] [ nip f ] 1 [ not-lazy-enough ] iterate drop call -> 1 f }>
      }#
      "lazy enough (2)" it#{
        <{ [ "x" f ] [ nip f ] 1 [ 1 = [ 2 ] [ not-lazy-enough ] if ] iterate [ call drop ] dip call -> 2 f }>
      }#
    }#
    "reduce" describe#{
      "take-n <- iterate" describe#{
        "works" it#{
          <{ into-vector 6 take-n 1 [ 1 + ] iterate reduce -> V{ 1 2 3 4 5 6 } }>
        }#
        "lazy enough (0)" it#{
          <{ into-vector 0 take-n 1 [ not-lazy-enough ] iterate reduce -> V{ } }>
        }#
        "lazy enough (1)" it#{
          <{ into-vector 1 take-n 1 [ not-lazy-enough ] iterate reduce -> V{ 1 } }>
        }#
        "lazy enough (2)" it#{
          <{ into-vector 2 take-n 1 [ 1 = [ 2 ] [ not-lazy-enough ] if ] iterate reduce -> V{ 1 2 } }>
        }#
      }#
      "number to digits" it#{
        <{ into-vector [ 10 mod ] map [ 0 > ] take-while 123456789 [ 10 /i ] iterate reduce -> V{ 9 8 7 6 5 4 3 2 1 } }>
      }#
    }#
  }#
  "multiary intermediates" describe#{
    "map(2->1) <- map(1->2) with-index-from" it#{
      <{ V{ 10 20 30 } into-vector [ 2array ] map 1 count-from reduce-seq -> V{ { 10 1 } { 20 2 } { 30 3 } } }>
    }#
    "map(2->1) <- ...(0->0 and 1->1) <- map(1->2) with-index-from" it#{
      <{ V{ 10 20 30 40 50 60 } into-vector
        [ 2array ] map
        3 take-n
        [ [ 3 + ] [ 1 + ] bi* ] map
        [ 1 + ] map ! any arity
        [ [ drop ] [ 4 = not ] bi* ] filter ! must be able to drop inputs and keep accumulators
        [ [ 20 = not ] [ 2 = not ] bi* and ] filter
        1 count-from
        reduce-seq
        -> V{ { 13 3 } { 33 5 } { 53 7 } } }>
    }#
    "multiple accumulators" it#{
      <{ { 10 35 20 5 30 } [ ] [ 99 -99 f ] [ [ min ] [ max ] bi-curry bi* f ] reduce-seq* -> 5 35 }>
      <{ { 10 35 20 5 30 } [ [ { } s:like ] 3dip [ { } s:like ] dip ] [ V{ } clone 99 V{ } clone -99 f ] [ f ]
        [ [ min [ s:suffix! ] keep ] [ max [ s:suffix! ] keep ] bi-curry 2bi* ] map
        reduce-seq*
        -> { 10 10 10 5 5 } 5 { 10 35 35 35 35 } 35 }>
    }#
  }#
  "user-controlled state below reducers" describe#{
    "into-vector <- count-from for comparison" it#{
      <{ into-vector 3 take-n 1 count-from reduce -> V{ 1 2 3 } }>
    }#
    "into-vector <- map" it#{
      ! map with 0 inputs, so only accumulator below, finalizer hidden by reduce;
      ! the state could be in an accumulator as well, but this way doesn't involve initializers/finalizers
      <{ 1 into-vector 3 take-n [ over [ 1 + ] 2dip ] map reduce -> 4 V{ 1 2 3 } }>
    }#
    "reduce-seq should hide finalizers too" it#{
      <{ 1 { 7 8 9 } into-vector 3 take-n [ drop over [ 1 + ] 2dip ] map reduce-seq -> 4 V{ 1 2 3 } }>
    }#
  }#
;

MAIN: run-tests

#include <criterion/criterion.h>

typedef double v4d __attribute__((__vector_size__(32)));
v4d add(v4d xs, v4d ys);
  
Test(add_function, should_add_vectors_of_doubles) {
  v4d xs = (v4d){1, 2, 3, 4}, ys = (v4d){10, 20, 30, 40};
  v4d e = xs + ys, a = add(xs, ys);
  cr_assert_eq(a[0], e[0]);
}

Describe(add_function) {
  It(should_add_vectors_of_doubles) {
    auto xs = v4d{1, 2, 3, 4}, ys = v4d{10, 20, 30, 40};
    auto e = xs + ys, a = add(xs, ys);
    Assert::That(a[0], Equals(e[0]));
  }
};

ref_add(X, Y, R) :- R is X + Y.

fixed_test(x = 1, y = 2, expected = 3).
fixed_test(x = 3, y = 4, expected = 7).
fixed_test(x = X, y = Y, expected = E) :-
  member((X, Y, E), [(1, 2, 3), (3, 4, 7)]).

random_test(x = X, y = Y, expected = E) :-
  random_between(-100, 100, X),
  random_between(-100, 100, Y),
  ref_add(X, Y, E).

repeated_random_test(X, Y, E) :-
  between(1, 5, _),
  random_test(X, Y, E).

:- begin_tests(adder).
:- include(adder).

do_test(x = X, y = Y, expected = E) :-
  findall(R, add(X, Y, R), R),
  assertion(R == [E]).

test(fixed, [forall(fixed_test(X, Y, E))]) :- do_test(X, Y, E).
test(random, [forall(repeated_random_test(X, Y, E))]) :- do_test(X, Y, E).

:- end_tests(adder).

with(_ : C) :- C.

:- begin_tests(adder).
:- include(adder).

test(showing_input) :-
  X = 1, Y = 2, E = 3,
  add(X, Y, R),
  assertion(with((x = X, y = Y, expected = E): (R == E))).

:- end_tests(adder).

:- include(foo).

:- begin_tests(foo).

test(add_assertion) :- add(1, 2, R), assertion(R == 4).
test(add_true, [true(R == 4)]) :- add(1, 2, R).
test(add_true_a, [true(R =:= 4)]) :- add(1, 2, R).

test(add0_assertion) :- add0(1, 2, S), assertion(R == 4).
test(add0_true, [true(R == 4)]) :- add0(1, 2, R).
test(add0_true_a, [true(R =:= 4)]) :- add0(1, 2, R).

test(add_fail_not) :- \+ add(1, 2, 3).
test(add_fail_fail, [fail]) :- add(1, 2, 3).

test(add_or_sub_all, all(R == [-1, 3])) :- add_or_sub(1, 2, R).
test(add_or_sub_all, set(R == [-1, 4])) :- add_or_sub(1, 2, R).

:- end_tests(foo).