diff --git a/.github/workflows/ct.yml b/.github/workflows/ct.yml
index f71d25fa..2b03ed9b 100644
--- a/.github/workflows/ct.yml
+++ b/.github/workflows/ct.yml
@@ -18,4 +18,4 @@ jobs:
         nix_path: nixpkgs=channel:nixos-unstable
     - uses: DeterminateSystems/magic-nix-cache-action@v3
     - run: nix-shell --arg full false --run "echo Dependencies OK…"
-    - run: nix-shell --arg full false --run "make -C code/jasmin/mlkem_${{matrix.dir}}/ ct"
+    - run: nix-shell --arg full false --run "make -C code/jasmin/mlkem_${{matrix.dir}}/ check-constant-time"
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 00000000..80432fb1
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,21 @@
+name: "Tests"
+on:
+  pull_request:
+  push:
+
+jobs:
+  tests:
+    name: tests
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        dir: [ 'ref']
+    steps:
+    - uses: actions/checkout@v4
+    - uses: cachix/install-nix-action@v25
+      with:
+        nix_path: nixpkgs=channel:nixos-unstable
+    - uses: DeterminateSystems/magic-nix-cache-action@v3
+    - run: nix-shell --arg full false --run "echo Dependencies OK…"
+    - run: nix-shell --arg full false --run "make -C code/jasmin/mlkem_${{matrix.dir}}/ run-tests"
diff --git a/code/Makefile.conf b/code/Makefile.conf
index c9c59546..c9fa6822 100644
--- a/code/Makefile.conf
+++ b/code/Makefile.conf
@@ -1,8 +1,9 @@
 # -*- Makefile -*-
 
 # --------------------------------------------------------------------
-current_dir := $(dir $(realpath $(lastword $(MAKEFILE_LIST))))
+CURRENT_DIR := $(dir $(realpath $(lastword $(MAKEFILE_LIST))))
+PROJECT_DIR := $(abspath $(CURRENT_DIR)/../)
 
 # --------------------------------------------------------------------
-JASMINC ?=  $(current_dir)/../jasmin/compiler/jasminc
-JAZZCT ?=  $(current_dir)/../jasmin/compiler/jazzct
+JASMINC   ?= $(abspath $(PROJECT_DIR)/jasmin/compiler/jasminc)
+JASMIN_CT ?= $(abspath $(PROJECT_DIR)/jasmin/compiler/jasmin-ct)
diff --git a/code/jasmin/mlkem_ref/Makefile b/code/jasmin/mlkem_ref/Makefile
index 97655c26..94e6644c 100644
--- a/code/jasmin/mlkem_ref/Makefile
+++ b/code/jasmin/mlkem_ref/Makefile
@@ -7,114 +7,167 @@ CFLAGS := -Wall -Wextra -g -O3 -fomit-frame-pointer
 JFLAGS := ${JADDFLAGS}
 OS     := $(shell uname -s)
 
-.SECONDARY: jpoly.s jpolyvec.s jfips203.s jindcpa.s jkem.s
-
-default: test speed
-
-test: test/test_poly_compress \
-		  test/test_poly_decompress \
-			test/test_poly_tobytes \
-			test/test_poly_frombytes \
-			test/test_poly_tomsg \
-			test/test_poly_frommsg \
-			test/test_poly_add2 \
-			test/test_poly_sub \
-			test/test_poly_ntt \
-			test/test_poly_invntt \
-			test/test_poly_basemul \
-			test/test_poly_frommont \
-			test/test_poly_reduce \
-			test/test_poly_csubq \
-			test/test_poly_getnoise \
-			test/test_polyvec_compress\
-			test/test_polyvec_decompress\
-			test/test_polyvec_tobytes \
-			test/test_polyvec_frombytes \
-			test/test_polyvec_add2 \
-			test/test_polyvec_ntt \
-			test/test_polyvec_invntt \
-			test/test_polyvec_pointwise_acc \
-			test/test_polyvec_reduce\
-			test/test_polyvec_csubq \
-			test/test_fips202 \
-			test/test_indcpa \
-			test/test_kem
+default: run-tests run-speed
+
+# --
+TESTS_POLY := \
+  test/test_poly_compress \
+  test/test_poly_decompress \
+  test/test_poly_tobytes \
+  test/test_poly_frombytes \
+  test/test_poly_tomsg \
+  test/test_poly_frommsg \
+  test/test_poly_add2 \
+  test/test_poly_sub \
+  test/test_poly_ntt \
+  test/test_poly_invntt \
+  test/test_poly_basemul \
+  test/test_poly_frommont \
+  test/test_poly_reduce \
+  test/test_poly_csubq \
+  test/test_poly_getnoise
+
+TESTS_POLYVEC := \
+  test/test_polyvec_compress \
+  test/test_polyvec_decompress\
+  test/test_polyvec_tobytes \
+  test/test_polyvec_frombytes \
+  test/test_polyvec_add2 \
+  test/test_polyvec_ntt \
+  test/test_polyvec_invntt \
+  test/test_polyvec_pointwise_acc \
+  test/test_polyvec_reduce\
+  test/test_polyvec_csubq
+
+TESTS := \
+  $(TESTS_POLY) \
+  $(TESTS_POLYVEC) \
+  test/test_fips202 \
+  test/test_indcpa \
+  test/test_kem
+
+test: $(TESTS)
 
 speed: test/speed_indcpa
 
-HEADERS = params.h poly.h fips202.h kem.h
+#-- 
 
+HEADERS := \
+  params.h \
+  poly.h \
+  fips202.h \
+  kem.h
 
-JHEADERS = params.jinc \
-				   reduce.jinc \
-           			fips202.jinc \
-					 kem.jinc \
-					 verify.jinc
+C_SOURCES := \
+  poly.c \
+  polyvec.c \
+  cbd.c \
+  fips202.c \
+  ntt.c \
+  reduce.c \
+  symmetric-fips202.c \
+  indcpa.c \
+  kem.c
 
-POLYHEADERS = poly.jinc \
-				zetas.jinc \
+JHEADERS := \
+  params.jinc \
+  reduce.jinc \
+  fips202.jinc \
+  kem.jinc \
+  verify.jinc
 
-POLYVECHEADERS = polyvec.jinc \
-                 gen_matrix.jinc \
+POLYHEADERS := \
+  poly.jinc \
+	zetas.jinc
 
-SOURCES = poly.c polyvec.c cbd.c fips202.c ntt.c reduce.c symmetric-fips202.c indcpa.c kem.c \
+POLYVECHEADERS := \
+  polyvec.jinc \
+  gen_matrix.jinc
 
-test/test_indcpa: test/test_indcpa.c $(HEADERS) $(SOURCES) jindcpa.o
-	$(CC) $(CFLAGS) -o $@ $(SOURCES) jindcpa.o $<
+# --
 
-test/test_kem: test/test_kem.c $(HEADERS) $(SOURCES) $(INCS) jkem.o
-	$(CC) $(CFLAGS) -o $@ $(SOURCES) ~/Desktop/Repos/jasmin/compiler/syscall/jasmin_syscall.o jkem.o $<
+JASMIN_SOURCES := \
+  jpoly.jazz \
+  jpolyvec.jazz \
+  jfips203.jazz \
+  jindcpa.jazz \
+  jkem.jazz
 
-test/speed_indcpa: test/speed_indcpa.c $(HEADERS) $(SOURCES) jindcpa.o
-	$(CC) $(CFLAGS) -o $@ $(SOURCES) jindcpa.o $<
+JASMIN_ASSEMBLY := $(JASMIN_SOURCES:%.jazz=%.s)
 
-test/test_fips202: test/test_fips202.c $(HEADERS) $(SOURCES) jfips202.s
-	$(CC) $(CFLAGS) -o $@ $(SOURCES) jfips202.s $<
+# --
 
-test/test_poly_%: test/test_poly_%.c $(HEADERS) $(SOURCES) jpoly.s
-	$(CC) $(CFLAGS) -o $@ $(SOURCES) jpoly.s $<
+RANDOMBYTES := $(PROJECT_DIR)/jasmin/compiler/syscall/jasmin_syscall.o
 
-test/test_polyvec_%: test/test_polyvec_%.c $(HEADERS) $(SOURCES) jpolyvec.s
-	$(CC) $(CFLAGS) -o $@ $(SOURCES) jpolyvec.s $<
+$(RANDOMBYTES): $(PROJECT_DIR)/jasmin/compiler/syscall/jasmin_syscall.c $(PROJECT_DIR)/jasmin/compiler/syscall/jasmin_syscall.h
+	$(MAKE) -C $(@D)
 
+$(JASMIN_ASSEMBLY):
 %.s: %.jazz
-	$(JASMINC) -o $@ $(JFLAGS) $^ 
+	$(JASMINC) -nowarning -o $@ $(JFLAGS) $^ 
 
+#--
 
-.PHONY: ct clean
+compile-tests-poly: $(TESTS_POLY)
+$(TESTS_POLY):
+test/test_poly_%: test/test_poly_%.c $(HEADERS) $(C_SOURCES) jpoly.s
+	$(CC) $(CFLAGS) -o $@ $(C_SOURCES) jpoly.s $<
 
-ct:
-	$(JAZZCT) --infer jkem.jazz
+compile-tests-polyvec: $(TESTS_POLYVEC)
+$(TESTS_POLYVEC):
+test/test_polyvec_%: test/test_polyvec_%.c $(HEADERS) $(C_SOURCES) jpolyvec.s
+	$(CC) $(CFLAGS) -o $@ $(C_SOURCES) jpolyvec.s $<
+
+test/test_fips202: test/test_fips202.c $(HEADERS) $(C_SOURCES) jfips202.s
+	$(CC) $(CFLAGS) -o $@ $(C_SOURCES) jfips202.s $<
+
+test/test_indcpa: test/test_indcpa.c $(HEADERS) $(C_SOURCES) jindcpa.o
+	$(CC) $(CFLAGS) -o $@ $(C_SOURCES) jindcpa.o $<
+
+test/test_kem: test/test_kem.c $(HEADERS) $(C_SOURCES) $(RANDOMBYTES) jkem.o
+	$(CC) $(CFLAGS) -o $@ $(C_SOURCES) $(RANDOMBYTES) jkem.o $<
+
+compile-tests: test
+
+# --
+# note: to improve speed, remove for loop and define *.out targets
+
+run-tests-poly: compile-tests-poly
+	for i in $(TESTS_POLY); do ./$$i; done
+
+run-tests-polyvec: compile-tests-polyvec
+	for i in $(TESTS_POLYVEC); do ./$$i; done
+
+run-tests: compile-tests
+	for i in $(TESTS); do ./$$i; done
+
+#--
+
+test/speed_indcpa: test/speed_indcpa.c $(HEADERS) $(C_SOURCES) jindcpa.o
+	$(CC) $(CFLAGS) -o $@ $(C_SOURCES) jindcpa.o $<
+
+compile-speed: test/speed_indcpa
+
+run-speed: compile-speed
+	./test/speed_indcpa
+
+# --
+
+.PHONY: check-ct
+
+check-constant-time:
+	$(JASMIN_CT) --infer jkem.jazz
+
+# --
+
+.PHONY: clean
 
 clean:
 	-rm -f *.s
 	-rm -f jindcpa.o
 	-rm -f jkem.o
-	-rm -f test/test_poly_compress
-	-rm -f test/test_poly_decompress
-	-rm -f test/test_poly_tobytes
-	-rm -f test/test_poly_frombytes
-	-rm -f test/test_poly_tomsg
-	-rm -f test/test_poly_frommsg
-	-rm -f test/test_poly_add2
-	-rm -f test/test_poly_sub
-	-rm -f test/test_poly_ntt
-	-rm -f test/test_poly_invntt
-	-rm -f test/test_poly_basemul
-	-rm -f test/test_poly_frommont
-	-rm -f test/test_poly_reduce
-	-rm -f test/test_poly_csubq
-	-rm -f test/test_poly_getnoise
-	-rm -f test/test_polyvec_compress
-	-rm -f test/test_polyvec_decompress
-	-rm -f test/test_polyvec_tobytes
-	-rm -f test/test_polyvec_frombytes
-	-rm -f test/test_polyvec_add2
-	-rm -f test/test_polyvec_ntt
-	-rm -f test/test_polyvec_invntt
-	-rm -f test/test_polyvec_pointwise_acc
-	-rm -f test/test_polyvec_reduce
-	-rm -f test/test_polyvec_csubq
+	-rm -f $(TESTS_POLY)
+	-rm -f $(TESTS_POLYVEC)
 	-rm -f test/test_fips202
 	-rm -f test/test_indcpa
 	-rm -f test/test_kem
@@ -122,3 +175,5 @@ clean:
 ifeq ($(OS),Darwin)
 	-rm -rf test/*.dSYM
 endif
+
+
diff --git a/code/jasmin/mlkem_ref/jpoly.jazz b/code/jasmin/mlkem_ref/jpoly.jazz
index 7d72519d..4ccd1492 100644
--- a/code/jasmin/mlkem_ref/jpoly.jazz
+++ b/code/jasmin/mlkem_ref/jpoly.jazz
@@ -7,9 +7,7 @@ export fn poly_compress_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_N] a;
-  stack u8[128] r;
 
   for i = 0 to MLKEM_N {
     t = (u16)[ap + 2*i];
@@ -23,9 +21,7 @@ export fn poly_decompress_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_N] r;
-  stack u8[128] a;
 
   r = _poly_decompress(r, ap);
 
@@ -39,7 +35,6 @@ export fn poly_tobytes_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_N] a;
 
   for i = 0 to MLKEM_N {
@@ -54,7 +49,6 @@ export fn poly_frombytes_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_N] r;
 
   r = _poly_frombytes(r, ap);
@@ -69,9 +63,7 @@ export fn poly_tomsg_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_N] a;
-  stack u8[32] r;
 
   for i = 0 to MLKEM_N {
     t = (u16)[ap + 2*i];
@@ -85,7 +77,6 @@ export fn poly_frommsg_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_N] r;
 
   r = _poly_frommsg(r, ap);
diff --git a/code/jasmin/mlkem_ref/jpolyvec.jazz b/code/jasmin/mlkem_ref/jpolyvec.jazz
index d4080f03..b34cce62 100644
--- a/code/jasmin/mlkem_ref/jpolyvec.jazz
+++ b/code/jasmin/mlkem_ref/jpolyvec.jazz
@@ -7,7 +7,6 @@ export fn polyvec_tobytes_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_VECN] a;
 
   for i = 0 to MLKEM_VECN {
@@ -23,7 +22,6 @@ export fn polyvec_decompress_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_VECN] r;
 
   r = __polyvec_decompress(ap);
@@ -39,7 +37,6 @@ export fn polyvec_compress_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_VECN] a;
 
   for i = 0 to MLKEM_VECN {
@@ -55,7 +52,6 @@ export fn polyvec_frombytes_jazz(reg u64 rp, reg u64 ap)
 {
   inline int i;
   reg u16 t;
-  reg u8 c;
   stack u16[MLKEM_VECN] r;
 
   r = __polyvec_frombytes(ap);
diff --git a/code/jasmin/mlkem_ref/test/test_fips202.c b/code/jasmin/mlkem_ref/test/test_fips202.c
index ae7a59e3..ce97b6bb 100644
--- a/code/jasmin/mlkem_ref/test/test_fips202.c
+++ b/code/jasmin/mlkem_ref/test/test_fips202.c
@@ -1,11 +1,19 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../fips202.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 #define MAXINLEN 33
 #define MAXOUTLEN 168
 
 int main(void)
 {
+  int test_ok = 1, test_ok_shake256_128_33 = 1, test_ok_sha3512_32 = 1,
+      test_ok_shake128_absorb34 = 1, test_ok_shake128_squeezeblock = 1;
+  size_t test_iteration = 0;
   unsigned char in[MAXINLEN];
   unsigned char out0[MAXOUTLEN];
   unsigned char out1[MAXOUTLEN];
@@ -14,35 +22,83 @@ int main(void)
   int k;
 
   FILE *urandom = fopen("/dev/urandom", "r");
-  fread(in, 1, sizeof(in), urandom);
 
-  shake256(out0, 128, in, 33);
-  shake256_128_33_jazz(out1, in);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    size_t ri = fread(in, 1, sizeof(in), urandom);
+    assert(ri == sizeof(in));
+
+    //
+    shake256(out0, 128, in, 33);
+    shake256_128_33_jazz(out1, in);
 
-  for(k=0;k<128;k++)
-    if(out0[k] != out1[k]) printf("error shake256 at %d: %d %d\n", k, out0[k], out1[k]);
+    for(k=0;k<128;k++)
+    { if(out0[k] != out1[k])
+      { fprintf(stderr, "ERROR: shake256_128_33 at %d: %d %d\n", k, out0[k], out1[k]);
+        test_ok_shake256_128_33 = 0;
+        test_ok = 0;
+      }
+    }
 
-  sha3_512(out0, in, 32);
-  sha3512_32_jazz(out1, in);
+    //
+    sha3_512(out0, in, 32);
+    sha3512_32_jazz(out1, in);
 
-  for(k=0;k<64;k++)
-    if(out0[k] != out1[k]) printf("error sha3512 at %d: %d %d\n", k, out0[k], out1[k]);
+    for(k=0;k<64;k++)
+    { if(out0[k] != out1[k])
+      { fprintf(stderr, "ERROR: sha3512 at %d: %d %d\n", k, out0[k], out1[k]);
+        test_ok_sha3512_32 = 0;
+        test_ok = 0;
+      }
+    }
 
-  shake128_absorb(state0, in, 34);
-  shake128_absorb34_jazz(state1, in);
+    //
+    shake128_absorb(state0, in, 34);
+    shake128_absorb34_jazz(state1, in);
 
-  for(k=0;k<25;k++)
-    if(state0[k] != state1[k]) printf("error shake128_absorb at %d: %lu %lu\n", k, state0[k], state1[k]);
+    for(k=0;k<25;k++)
+    { if(state0[k] != state1[k])
+      { fprintf(stderr, "ERROR: shake128_absorb at %d: %lu %lu\n", k, state0[k], state1[k]);
+        test_ok_shake128_absorb34 = 0;
+        test_ok = 0;
+      }
+    }
 
-  shake128_squeezeblocks(out0, 1, state0);
-  shake128_squeezeblock_jazz(out1, state1);
+    //
+    shake128_squeezeblocks(out0, 1, state0);
+    shake128_squeezeblock_jazz(out1, state1);
 
-  for(k=0;k<25;k++)
-    if(state0[k] != state1[k]) printf("error shake128_squeezeblock (state) at %d: %lu %lu\n", k, state0[k], state1[k]);
+    for(k=0;k<25;k++)
+    { if(state0[k] != state1[k])
+      { fprintf(stderr, "ERROR: shake128_squeezeblock (state) at %d: %lu %lu\n", k, state0[k], state1[k]);
+        test_ok_shake128_squeezeblock = 0;
+        test_ok = 0;
+      }
+    }
 
-  for(k=0;k<SHAKE128_RATE;k++)
-    if(out0[k] != out1[k]) printf("error shake128_squeezeblock (out) at %d: %d %d\n", k, out0[k], out1[k]);
+    for(k=0;k<SHAKE128_RATE;k++)
+    { if(out0[k] != out1[k])
+      { fprintf(stderr, "ERROR: shake128_squeezeblock (out) at %d: %d %d\n", k, out0[k], out1[k]);
+        test_ok_shake128_squeezeblock = 0;
+        test_ok = 0;
+      }
+    }
 
+    test_iteration += 1;
+  }
 
   fclose(urandom);
+
+  //
+  if(test_ok_shake256_128_33 == 1)
+  { printf("OK: shake256_128_33\n"); }
+
+  if(test_ok_sha3512_32 == 1)
+  { printf("OK: sha3512_32\n"); }
+
+  if(test_ok_shake128_absorb34 == 1)
+  { printf("OK: shake128_absorb34\n"); }
+
+  if(test_ok_shake128_squeezeblock == 1)
+  { printf("OK: shake128_squeezeblock\n"); }
 }
diff --git a/code/jasmin/mlkem_ref/test/test_indcpa.c b/code/jasmin/mlkem_ref/test/test_indcpa.c
index de45edc5..9d68440f 100644
--- a/code/jasmin/mlkem_ref/test/test_indcpa.c
+++ b/code/jasmin/mlkem_ref/test/test_indcpa.c
@@ -1,11 +1,20 @@
 #include <stdio.h>
-
+#include <assert.h>
 #include "../params.h"
 #include "../ntt.h"
 #include "../indcpa.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 int main(void)
 {
+  int test_ok = 1, test_ok_indcpa_keypair_sk = 1, test_ok_indcpa_keypair_pk = 1,
+      test_ok_indcpa_enc = 1, test_ok_indcpa_dec = 1, test_ok_decryption = 1;
+  size_t test_iteration = 0;
+  size_t ri;
+
   unsigned char sk0[MLKEM_INDCPA_SECRETKEYBYTES];
   unsigned char sk1[MLKEM_INDCPA_SECRETKEYBYTES];
   unsigned char pk0[MLKEM_INDCPA_PUBLICKEYBYTES];
@@ -25,38 +34,88 @@ int main(void)
   unsigned char outmsg1[MLKEM_POLYVECBYTES];
 
   FILE *urandom = fopen("/dev/urandom", "r");
-  fread(randomness0, MLKEM_SYMBYTES, 1, urandom);
-  fread(randomness1, MLKEM_SYMBYTES, 1, urandom);
-  fread(message, MLKEM_SYMBYTES, 1, urandom);
-  fclose(urandom);
 
-  /* TEST KEYPAIR */
-  indcpa_keypair_jazz(pk1, sk1, randomness0);
-  indcpa_keypair(pk0, sk0, randomness0);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    ri = fread(randomness0, MLKEM_SYMBYTES, 1, urandom);
+    assert(ri == 1);
 
-  for(int i=0;i<MLKEM_INDCPA_SECRETKEYBYTES;i++)
-    if(sk0[i] != sk1[i]) printf("error indcpa_keypair sk: %d\n", i);
+    ri = fread(randomness1, MLKEM_SYMBYTES, 1, urandom);
+    assert(ri == 1);
 
-  for(int i=0;i<MLKEM_INDCPA_PUBLICKEYBYTES;i++)
-    if(pk0[i] != pk1[i]) printf("error indcpa_keypair pk: %d\n", i);
+    ri = fread(message, MLKEM_SYMBYTES, 1, urandom);
+    assert(ri == 1);
 
+    /* TEST KEYPAIR */
+    indcpa_keypair_jazz(pk1, sk1, randomness0);
+    indcpa_keypair(pk0, sk0, randomness0);
 
-  /* TEST ENCRYPTION */
-  indcpa_enc(ct0, message, pk0, randomness1);
-  indcpa_enc_jazz(ct1, message, pk1, randomness1);
+    for(int i=0;i<MLKEM_INDCPA_SECRETKEYBYTES;i++)
+    { if(sk0[i] != sk1[i])
+      { fprintf(stderr, "ERROR: indcpa_keypair sk: %d\n", i);
+        test_ok_indcpa_keypair_sk = 0;
+        test_ok = 0;
+      }
+    }
 
-  for(int i=0;i<MLKEM_INDCPA_BYTES;i++)
-    if(ct0[i] != ct1[i]) printf("error indcpa_enc: %d\n", i);
+    for(int i=0;i<MLKEM_INDCPA_PUBLICKEYBYTES;i++)
+    { if(pk0[i] != pk1[i])
+      { fprintf(stderr, "ERROR: indcpa_keypair pk: %d\n", i);
+        test_ok_indcpa_keypair_pk = 0;
+        test_ok = 0;
+      }
+    }
 
-  /* TEST DECRYPTION */
-  indcpa_dec(outmsg0, ct0, sk0);
-  indcpa_dec_jazz(outmsg1, ct0, sk0);
+    /* TEST ENCRYPTION */
+    indcpa_enc(ct0, message, pk0, randomness1);
+    indcpa_enc_jazz(ct1, message, pk1, randomness1);
 
-  for(int i=0;i<MLKEM_INDCPA_MSGBYTES;i++)
-  {
-    if(outmsg0[i] != outmsg1[i]) printf("error indcpa_dec: %d %d %d\n", i, outmsg0[i], outmsg1[i]);
-    if(outmsg0[i] != message[i]) printf("decryption error: %d\n", i);
+    for(int i=0;i<MLKEM_INDCPA_BYTES;i++)
+    { if(ct0[i] != ct1[i])
+      { fprintf(stderr, "ERROR: indcpa_enc: %d\n", i);
+        test_ok_indcpa_enc = 0;
+        test_ok = 0;
+      }
+    }
+
+    /* TEST DECRYPTION */
+    indcpa_dec(outmsg0, ct0, sk0);
+    indcpa_dec_jazz(outmsg1, ct0, sk0);
+
+    for(int i=0;i<MLKEM_INDCPA_MSGBYTES;i++)
+    {
+      if(outmsg0[i] != outmsg1[i])
+      { fprintf(stderr, "ERROR: indcpa_dec: %d %d %d\n", i, outmsg0[i], outmsg1[i]);
+        test_ok_indcpa_dec = 0;
+        test_ok = 0;
+      }
+
+      if(outmsg0[i] != message[i])
+      { fprintf(stderr, "ERROR: decryption: %d\n", i);
+        test_ok_decryption = 0;
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
+  fclose(urandom);
+
+
+  if(test_ok_indcpa_keypair_sk == 1)
+  { printf("OK: indcpa_keypair sk\n"); }
+
+  if(test_ok_indcpa_keypair_pk == 1)
+  { printf("OK: indcpa_keypair pk\n"); }
+
+  if(test_ok_indcpa_enc == 1)
+  { printf("OK: indcpa_enc\n"); }
+
+  if(test_ok_indcpa_dec == 1)
+  { printf("OK: indcpa_dec\n"); }
+
+  if(test_ok_decryption == 1)
+  { printf("OK: indcpa_decryption\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_kem.c b/code/jasmin/mlkem_ref/test/test_kem.c
index 4748717a..b1ca29cd 100644
--- a/code/jasmin/mlkem_ref/test/test_kem.c
+++ b/code/jasmin/mlkem_ref/test/test_kem.c
@@ -1,12 +1,23 @@
 #include <stdio.h>
-#include <strings.h>
+#include <assert.h>
+#include <string.h>
 
 #include "../params.h"
 #include "../ntt.h"
 #include "../kem.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 int main(void)
 {
+  int test_ok = 1, test_ok_kem_keypair_sk = 1, test_ok_kem_keypair_pk = 1,
+      test_ok_kem_enc_ct = 1, test_ok_kem_enc_ss = 1,
+      test_ok_kem_dec_success = 1, test_ok_kem_dec_failure = 1;
+  size_t test_iteration = 0;
+  size_t ri;
+
   unsigned char sk0[MLKEM_SECRETKEYBYTES];
   unsigned char sk1[MLKEM_SECRETKEYBYTES];
   unsigned char pk0[MLKEM_PUBLICKEYBYTES];
@@ -20,52 +31,108 @@ int main(void)
   unsigned char randomness1[2*MLKEM_SYMBYTES];
   
   FILE *urandom = fopen("/dev/urandom", "r");
-  fread(randomness0, 2*MLKEM_SYMBYTES, 1, urandom);
-  fread(randomness1, 2*MLKEM_SYMBYTES, 1, urandom);
-  fclose(urandom);
-
-  /* TEST KEYPAIR */
-  jade_kem_mlkem_mlkem768_amd64_ref_keypair_derand(pk1, sk1, randomness0);
-  crypto_kem_keypair(pk0, sk0, randomness0);
-
-  for(int i=0;i<MLKEM_SECRETKEYBYTES;i++)
-    if(sk0[i] != sk1[i]) printf("error crypto_kem_keypair sk: %d\n", i);
 
-  for(int i=0;i<MLKEM_PUBLICKEYBYTES;i++)
-    if(pk0[i] != pk1[i]) printf("error crypto_kem_keypair pk: %d\n", i);
-
-  /* TEST ENCAPSULATION */
-  crypto_kem_enc(ct0, shk0, pk0, randomness1);
-  jade_kem_mlkem_mlkem768_amd64_ref_enc_derand(ct1, shk1, pk1, randomness1);
-
-  for(int i=0;i<MLKEM_CIPHERTEXTBYTES;i++)
-    if(ct0[i] != ct1[i]) printf("error crypto_kem_enc ct: %d\n", i);
-
-  for(int i=0;i<MLKEM_SSBYTES;i++)
-    if(shk0[i] != shk1[i]) printf("error crypto_kem_enc ss: %d\n", i);
-  
-  /* TEST DECAPSULATION */
-  memset(shk0, 0, MLKEM_SSBYTES);
-  memset(shk1, 0, MLKEM_SSBYTES);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    ri = fread(randomness0, 2*MLKEM_SYMBYTES, 1, urandom);
+    assert(ri == 1);
+    ri = fread(randomness1, 2*MLKEM_SYMBYTES, 1, urandom);
+    assert(ri == 1);
+
+    /* TEST KEYPAIR */
+    jade_kem_mlkem_mlkem768_amd64_ref_keypair_derand(pk1, sk1, randomness0);
+    crypto_kem_keypair(pk0, sk0, randomness0);
+
+    for(int i=0;i<MLKEM_SECRETKEYBYTES;i++)
+    { if(sk0[i] != sk1[i])
+      { fprintf(stderr, "ERROR: crypto_kem_keypair sk: %d\n", i);
+        test_ok_kem_keypair_sk = 0;
+        test_ok = 0;
+      }
+    }
+
+    for(int i=0;i<MLKEM_PUBLICKEYBYTES;i++)
+    { if(pk0[i] != pk1[i])
+      { fprintf(stderr, "ERROR: crypto_kem_keypair pk: %d\n", i);
+        test_ok_kem_keypair_pk = 0;
+        test_ok = 0;
+      }
+    }
+
+    /* TEST ENCAPSULATION */
+    crypto_kem_enc(ct0, shk0, pk0, randomness1);
+    jade_kem_mlkem_mlkem768_amd64_ref_enc_derand(ct1, shk1, pk1, randomness1);
+
+    for(int i=0;i<MLKEM_CIPHERTEXTBYTES;i++)
+    { if(ct0[i] != ct1[i])
+      { fprintf(stderr, "ERROR: crypto_kem_enc ct: %d\n", i);
+        test_ok_kem_enc_ct = 0;
+        test_ok = 0;
+      }
+    }
+
+    for(int i=0;i<MLKEM_SSBYTES;i++)
+    { if(shk0[i] != shk1[i])
+      { fprintf(stderr, "ERROR: crypto_kem_enc ss: %d\n", i);
+        test_ok_kem_enc_ss = 0;
+        test_ok = 0;
+      }
+    }
+
+    /* TEST DECAPSULATION */
+    memset(shk0, 0, MLKEM_SSBYTES);
+    memset(shk1, 0, MLKEM_SSBYTES);
+
+    crypto_kem_dec(shk0, ct0, sk0);
+    jade_kem_mlkem_mlkem768_amd64_ref_dec(shk1, ct1, sk1);
+
+    for(int i=0;i<MLKEM_SSBYTES;i++)
+    { if(shk0[i] != shk1[i])
+      { fprintf(stderr, "ERROR: crypto_kem_dec (suc): %d %d %d\n", i, shk0[i], shk1[i]);
+        test_ok_kem_dec_success = 0;
+        test_ok = 0;
+      }
+    }
+
+    /* TEST DECAPSULATION FAILURE */
+    memset(shk0, 0, MLKEM_SSBYTES);
+    memset(shk1, 0, MLKEM_SSBYTES);
+
+    ct0[0] = !ct0[0]; // corrupt a single byte
+    ct1[0] = ct0[0];
+
+    crypto_kem_dec(shk0, ct0, sk0);
+    jade_kem_mlkem_mlkem768_amd64_ref_dec(shk1, ct1, sk1);
+
+    for(int i=0;i<MLKEM_SSBYTES;i++)
+    { if(shk0[i] != shk1[i])
+      { fprintf(stderr, "ERROR: crypto_kem_dec (fail -- corrupt byte): %d %d %d\n", i, shk0[i], shk1[i]);
+        test_ok_kem_dec_failure = 0;
+        test_ok = 0;  
+      }
+    }
+
+    test_iteration += 1;
+  }
+  fclose(urandom);
 
-  crypto_kem_dec(shk0, ct0, sk0);
-  jade_kem_mlkem_mlkem768_amd64_ref_dec(shk1, ct1, sk1);
+  if(test_ok_kem_keypair_sk == 1)
+  { printf("OK: kem_keypair sk\n"); }
 
-  for(int i=0;i<MLKEM_SSBYTES;i++)
-    if(shk0[i] != shk1[i]) printf("error crypto_kem_dec (suc): %d %d %d\n", i, shk0[i], shk1[i]);
+  if(test_ok_kem_keypair_pk == 1)
+  { printf("OK: kem_keypair pk\n"); }
 
-  /* TEST DECAPSULATION FAILURE */
-  memset(shk0, 0, MLKEM_SSBYTES);
-  memset(shk1, 0, MLKEM_SSBYTES);
+  if(test_ok_kem_enc_ct == 1)
+  { printf("OK: indcpa_enc_ct\n"); }
 
-  ct0[0] = !ct0[0]; // corrupt a single byte
-  ct1[0] = ct0[0];
+  if(test_ok_kem_enc_ss == 1)
+  { printf("OK: indcpa_enc_ss\n"); }
 
-  crypto_kem_dec(shk0, ct0, sk0);
-  jade_kem_mlkem_mlkem768_amd64_ref_dec(shk1, ct1, sk1);
+  if(test_ok_kem_dec_success == 1)
+  { printf("OK: kem_dec_success\n"); }
 
-  for(int i=0;i<MLKEM_SSBYTES;i++)
-    if(shk0[i] != shk1[i]) printf("error crypto_kem_dec (fail): %d %d %d\n", i, shk0[i], shk1[i]);
+  if(test_ok_kem_dec_failure == 1)
+  { printf("OK: kem_dec_failure (corrupting byte)\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_add2.c b/code/jasmin/mlkem_ref/test/test_poly_add2.c
index dddd191e..c673ce4d 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_add2.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_add2.c
@@ -1,29 +1,39 @@
 #include <stdio.h>
 #include "../poly.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_N;i++)
-    r->coeffs[i] %= MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly a, b, r0;
 
-  poly_setrandom(&a);
-  poly_setrandom(&b);
-  
-  poly_add(&r0, &a, &b);
-  
-  poly_add2_jazz(&a, &b);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom(&a);
+    poly_setrandom(&b);
+    
+    poly_add(&r0, &a, &b);
+    
+    poly_add2_jazz(&a, &b);
+
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != a.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_add: %d, %d, %d\n", i, r0.coeffs[i], a.coeffs[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_N;i++)
-    if(r0.coeffs[i] != a.coeffs[i])
-      printf("error %d, %d, %d\n", i, r0.coeffs[i], a.coeffs[i]);
+  if(test_ok == 1)
+  { printf("OK: poly_add\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_basemul.c b/code/jasmin/mlkem_ref/test/test_poly_basemul.c
index c6766b97..e6c4c435 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_basemul.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_basemul.c
@@ -2,29 +2,39 @@
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_N;i++)
-    r->coeffs[i] %= MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly a, b, r0, r1;
 
-  poly_setrandom(&a);
-  poly_setrandom(&b);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom(&a);
+    poly_setrandom(&b);
+
+    poly_basemul(&r0, &a, &b);
+    
+    poly_basemul_jazz(&r1, &a, &b);
+
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_basemul: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
 
-  poly_basemul(&r0, &a, &b);
-  
-  poly_basemul_jazz(&r1, &a, &b);
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_N;i++)
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+  if(test_ok == 1)
+  { printf("OK: poly_basemul\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_compress.c b/code/jasmin/mlkem_ref/test/test_poly_compress.c
index 9f66b03d..2bf2e36d 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_compress.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_compress.c
@@ -1,31 +1,41 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  fclose(urandom);
-  poly_reduce(r);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   unsigned char out0[128];
   unsigned char out1[128];
   poly a;
   
-  poly_setrandom(&a);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom_nomodq(&a);
 
-  poly_compress(out0, &a);
-  poly_compress_jazz(out1, &a);
+    poly_compress(out0, &a);
+    poly_compress_jazz(out1, &a);
 
-  for(int i=0;i<128;i++)
-  {
-    if(out0[i] != out1[i])
-      printf("error compress %d, %d, %d\n", i, out0[i], out1[i]);
+    for(int i=0;i<128;i++)
+    { if(out0[i] != out1[i])
+      { fprintf(stderr, "ERROR: poly_compress: %d, %d, %d\n", i, out0[i], out1[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_compress\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_csubq.c b/code/jasmin/mlkem_ref/test/test_poly_csubq.c
index fbaf8478..aa56ba63 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_csubq.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_csubq.c
@@ -1,32 +1,42 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  fclose(urandom);
-  poly_reduce(r);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly r0, r1;
 
-  poly_setrandom(&r0);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom_nomodq(&r0);
 
-  for(int i=0;i<MLKEM_N;i++)
-    r1.coeffs[i] = r0.coeffs[i];
- 
-  poly_csubq(&r0);
-  poly_csubq_jazz(&r1);
+    for(int i=0;i<MLKEM_N;i++)
+      r1.coeffs[i] = r0.coeffs[i];
+   
+    poly_csubq(&r0);
+    poly_csubq_jazz(&r1);
 
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error csubq %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_csubq: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_csubq\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_decompress.c b/code/jasmin/mlkem_ref/test/test_poly_decompress.c
index 915b4a75..32f3fbd2 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_decompress.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_decompress.c
@@ -1,24 +1,43 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
+  size_t ri;
   unsigned char in[MLKEM_POLYCOMPRESSEDBYTES];
   poly r0, r1;
- 
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(in, 1, MLKEM_POLYCOMPRESSEDBYTES, urandom);
-  fclose(urandom);
 
-  poly_decompress(&r0, in);
-  poly_decompress_jazz(&r1, in);
+  FILE *urandom = fopen("/dev/urandom", "r");
 
-  for(int i=0;i<MLKEM_N;i++)
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
   {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error decompress %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    ri = fread(in, 1, MLKEM_POLYCOMPRESSEDBYTES, urandom);
+    assert(ri == MLKEM_POLYCOMPRESSEDBYTES);
+
+    poly_decompress(&r0, in);
+    poly_decompress_jazz(&r1, in);
+
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_decompress: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
+  
+    test_iteration += 1;
   }
+  fclose(urandom);
+
+  if(test_ok == 1)
+  { printf("OK: poly_decompress\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_frombytes.c b/code/jasmin/mlkem_ref/test/test_poly_frombytes.c
index 8ad04ee3..2ec9b5d7 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_frombytes.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_frombytes.c
@@ -1,24 +1,43 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
+  size_t ri;
   unsigned char in[MLKEM_POLYBYTES];
   poly r0, r1;
- 
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(in, 1, MLKEM_POLYBYTES, urandom);
-  fclose(urandom);
 
-  poly_frombytes(&r0, in);
-  poly_frombytes_jazz(&r1, in);
+  FILE *urandom = fopen("/dev/urandom", "r");
 
-  for(int i=0;i<MLKEM_N;i++)
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
   {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error frombytes %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    ri = fread(in, 1, MLKEM_POLYBYTES, urandom);
+    assert(ri == MLKEM_POLYBYTES);
+
+    poly_frombytes(&r0, in);
+    poly_frombytes_jazz(&r1, in);
+
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_frombytes %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
+  fclose(urandom);
+
+  if(test_ok == 1)
+  { printf("OK: poly_frombytes\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_frommont.c b/code/jasmin/mlkem_ref/test/test_poly_frommont.c
index 55ce85ee..9ec720ac 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_frommont.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_frommont.c
@@ -1,36 +1,42 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    r->coeffs[i] %= MLKEM_Q;
-  }
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly r0, r1;
 
-  poly_setrandom(&r0);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom(&r0);
 
+    for(int i=0;i<MLKEM_N;i++)
+      r1.coeffs[i] = r0.coeffs[i];
+   
+    poly_frommont(&r0);
+    poly_frommont_jazz(&r1);
 
-  for(int i=0;i<MLKEM_N;i++)
-    r1.coeffs[i] = r0.coeffs[i];
- 
-  poly_frommont(&r0);
-  poly_frommont_jazz(&r1);
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_frommont: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
 
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_frommont\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_frommsg.c b/code/jasmin/mlkem_ref/test/test_poly_frommsg.c
index 334336d4..a2d59a76 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_frommsg.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_frommsg.c
@@ -1,24 +1,44 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
+  size_t ri;
   unsigned char in[32];
   poly r0, r1;
- 
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(in, 1, 32, urandom);
-  fclose(urandom);
 
-  poly_frommsg(&r0, in);
-  poly_frommsg_jazz(&r1, in);
+  FILE *urandom = fopen("/dev/urandom", "r");
 
-  for(int i=0;i<MLKEM_N;i++)
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
   {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error frombytes %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    ri = fread(in, 1, 32, urandom);
+    assert(ri == 32);
+
+    poly_frommsg(&r0, in);
+    poly_frommsg_jazz(&r1, in);
+
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+       { fprintf(stderr, "ERROR: poly_frommsg: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+         test_ok = 0;
+       }
+    }
+
+    test_iteration += 1;
   }
 
+  fclose(urandom);
+
+  if(test_ok == 1)
+  { printf("OK: poly_frommsg\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_getnoise.c b/code/jasmin/mlkem_ref/test/test_poly_getnoise.c
index a1e3a9ee..87f448c2 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_getnoise.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_getnoise.c
@@ -1,29 +1,47 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 #include "../params.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
+  size_t ri;
   poly r0, r1;
   unsigned char seed[MLKEM_SYMBYTES];
 
   FILE *urandom = fopen("/dev/urandom", "r");
-  fread(seed, 1, MLKEM_SYMBYTES, urandom);
-  fclose(urandom);
 
-  for(int i = 0; i < 1; i++)
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
   {
-    poly_getnoise(&r0, seed, i);
-    poly_getnoise_jazz(&r1, seed, i);
+    ri = fread(seed, 1, MLKEM_SYMBYTES, urandom);
+    assert(ri == MLKEM_SYMBYTES);
 
-    for(int j=0;j<MLKEM_N;j++)
+    for(int i = 0; i < 1; i++)
     {
-      if(r0.coeffs[j] != r1.coeffs[j])
-        printf("error getnoise %d, %d, %d\n", j, r0.coeffs[j], r1.coeffs[j]);
+      poly_getnoise(&r0, seed, i);
+      poly_getnoise_jazz(&r1, seed, i);
+
+      for(int j=0;j<MLKEM_N;j++)
+      { if(r0.coeffs[j] != r1.coeffs[j])
+        { fprintf(stderr, "ERROR: poly_getnoise: %d, %d, %d\n", j, r0.coeffs[j], r1.coeffs[j]);
+          test_ok = 0;
+        }
+      }
     }
+
+    test_iteration += 1;
   }
+  fclose(urandom);
+
+  if(test_ok == 1)
+  { printf("OK: poly_getnoise\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_invntt.c b/code/jasmin/mlkem_ref/test/test_poly_invntt.c
index 8f05554f..2a147f13 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_invntt.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_invntt.c
@@ -1,36 +1,42 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    r->coeffs[i] %= 2*MLKEM_Q;
-  }
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly r0, r1;
 
-  poly_setrandom(&r0);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom_mod2q(&r0);
 
+    for(int i=0;i<MLKEM_N;i++)
+      r1.coeffs[i] = r0.coeffs[i];
+   
+    poly_invntt(&r0);
+    poly_invntt_jazz(&r1);
 
-  for(int i=0;i<MLKEM_N;i++)
-    r1.coeffs[i] = r0.coeffs[i];
- 
-  poly_invntt(&r0);
-  poly_invntt_jazz(&r1);
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_invntt: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
 
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_invntt\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_ntt.c b/code/jasmin/mlkem_ref/test/test_poly_ntt.c
index 2f21e985..186e57be 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_ntt.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_ntt.c
@@ -1,35 +1,42 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    r->coeffs[i] %= 2*MLKEM_Q;
-  }
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly r0, r1;
 
-  poly_setrandom(&r0);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom_mod2q(&r0);
 
-  for(int i=0;i<MLKEM_N;i++)
-    r1.coeffs[i] = r0.coeffs[i];
- 
-  poly_ntt(&r0);
-  poly_ntt_jazz(&r1);
+    for(int i=0;i<MLKEM_N;i++)
+      r1.coeffs[i] = r0.coeffs[i];
+   
+    poly_ntt(&r0);
+    poly_ntt_jazz(&r1);
 
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_ntt: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_ntt\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_reduce.c b/code/jasmin/mlkem_ref/test/test_poly_reduce.c
index 9a2a4286..879cb197 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_reduce.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_reduce.c
@@ -1,31 +1,42 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly r0, r1;
 
-  poly_setrandom(&r0);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom_nomodq(&r0);
 
-  for(int i=0;i<MLKEM_N;i++)
-    r1.coeffs[i] = r0.coeffs[i];
- 
-  poly_reduce(&r0);
-  poly_reduce_jazz(&r1);
+    for(int i=0;i<MLKEM_N;i++)
+      r1.coeffs[i] = r0.coeffs[i];
+   
+    poly_reduce(&r0);
+    poly_reduce_jazz(&r1);
 
-  for(int i=0;i<MLKEM_N;i++)
-  {
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error reduce %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_reduce: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_reduce\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_setrandom.c b/code/jasmin/mlkem_ref/test/test_poly_setrandom.c
new file mode 100644
index 00000000..b50a52b0
--- /dev/null
+++ b/code/jasmin/mlkem_ref/test/test_poly_setrandom.c
@@ -0,0 +1,40 @@
+#ifndef TEST_POLY_SETRANDOM
+#define TEST_POLY_SETRANDOM
+
+#include <stdio.h>
+#include <assert.h>
+#include "../poly.h"
+
+// note: extend to *_setrandom_open; *_setrandom; *_setrandom_close;
+// to not open the file so many times
+
+void poly_setrandom(poly *r)
+{
+  FILE *urandom = fopen("/dev/urandom", "r");
+  size_t ri = fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
+  assert(ri == MLKEM_N);
+  for(int i=0;i<MLKEM_N;i++)
+  { r->coeffs[i] %= MLKEM_Q; }
+  fclose(urandom);
+}
+
+void poly_setrandom_mod2q(poly *r)
+{
+  FILE *urandom = fopen("/dev/urandom", "r");
+  size_t ri = fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
+  assert(ri == MLKEM_N);
+  for(int i=0;i<MLKEM_N;i++)
+  { r->coeffs[i] %= 2*MLKEM_Q; }
+  fclose(urandom);
+}
+
+void poly_setrandom_nomodq(poly *r)
+{
+  FILE *urandom = fopen("/dev/urandom", "r");
+  size_t ri = fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
+  assert(ri == MLKEM_N);
+  fclose(urandom);
+  poly_reduce(r);
+}
+
+#endif
diff --git a/code/jasmin/mlkem_ref/test/test_poly_sub.c b/code/jasmin/mlkem_ref/test/test_poly_sub.c
index f46326f2..08510804 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_sub.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_sub.c
@@ -1,29 +1,40 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_N;i++)
-    r->coeffs[i] %= MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   poly a, b, r0, r1;
 
-  poly_setrandom(&a);
-  poly_setrandom(&b);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    poly_setrandom(&a);
+    poly_setrandom(&b);
+
+    poly_sub(&r0, &a, &b);
+    
+    poly_sub_jazz(&r1, &a, &b);
+
+    for(int i=0;i<MLKEM_N;i++)
+    { if(r0.coeffs[i] != r1.coeffs[i])
+      { fprintf(stderr, "ERROR: poly_sub: %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+        test_ok = 0;
+      }
+    }
 
-  poly_sub(&r0, &a, &b);
-  
-  poly_sub_jazz(&r1, &a, &b);
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_N;i++)
-    if(r0.coeffs[i] != r1.coeffs[i])
-      printf("error %d, %d, %d\n", i, r0.coeffs[i], r1.coeffs[i]);
+  if(test_ok == 1)
+  { printf("OK: poly_sub\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_tobytes.c b/code/jasmin/mlkem_ref/test/test_poly_tobytes.c
index 27f05abc..011cf495 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_tobytes.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_tobytes.c
@@ -1,31 +1,41 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  fclose(urandom);
-  poly_reduce(r);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   unsigned char out0[MLKEM_POLYBYTES];
   unsigned char out1[MLKEM_POLYBYTES];
   poly a;
-  
-  poly_setrandom(&a);
-
-  poly_tobytes(out0, &a);
-  poly_tobytes_jazz(out1, &a);
 
-  for(int i=0;i<MLKEM_POLYBYTES;i++)
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
   {
-    if(out0[i] != out1[i])
-      printf("error poly_tobytes %d, %d, %d\n", i, out0[i], out1[i]);
+    poly_setrandom_nomodq(&a);
+
+    poly_tobytes(out0, &a);
+    poly_tobytes_jazz(out1, &a);
+
+    for(int i=0;i<MLKEM_POLYBYTES;i++)
+    { if(out0[i] != out1[i])
+      { fprintf(stderr, "ERROR: poly_tobytes: %d, %d, %d\n", i, out0[i], out1[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_tobytes\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_poly_tomsg.c b/code/jasmin/mlkem_ref/test/test_poly_tomsg.c
index 70b1cb5f..a04c5c26 100644
--- a/code/jasmin/mlkem_ref/test/test_poly_tomsg.c
+++ b/code/jasmin/mlkem_ref/test/test_poly_tomsg.c
@@ -1,31 +1,41 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../ntt.h"
 
-void poly_setrandom(poly *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  fread(r->coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  fclose(urandom);
-  poly_reduce(r);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_poly_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   unsigned char out0[MLKEM_INDCPA_MSGBYTES];
   unsigned char out1[MLKEM_INDCPA_MSGBYTES];
   poly a;
-  
-  poly_setrandom(&a);
-
-  poly_tomsg(out0, &a);
-  poly_tomsg_jazz(out1, &a);
 
-  for(int i=0;i<MLKEM_INDCPA_MSGBYTES;i++)
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
   {
-    if(out0[i] != out1[i])
-      printf("error tomsg %d, %d, %d\n", i, out0[i], out1[i]);
+    poly_setrandom_nomodq(&a);
+
+    poly_tomsg(out0, &a);
+    poly_tomsg_jazz(out1, &a);
+
+    for(int i=0;i<MLKEM_INDCPA_MSGBYTES;i++)
+    { if(out0[i] != out1[i])
+      { fprintf(stderr, "ERROR: poly_tomsg %d, %d, %d\n", i, out0[i], out1[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: poly_tomsg\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_add2.c b/code/jasmin/mlkem_ref/test/test_polyvec_add2.c
index 0967edda..34a30604 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_add2.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_add2.c
@@ -1,31 +1,41 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../polyvec.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      r->vec[i].coeffs[j] %= MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   polyvec a, b, r0;
 
-  polyvec_setrandom(&a);
-  polyvec_setrandom(&b);
-  
-  polyvec_add(&r0, &a, &b);
-  polyvec_add2_jazz(&a, &b);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    polyvec_setrandom(&a);
+    polyvec_setrandom(&b);
+    
+    polyvec_add(&r0, &a, &b);
+    polyvec_add2_jazz(&a, &b);
+
+    for(int i=0;i<MLKEM_K;i++)
+    { for(int j=0;j<MLKEM_N;j++)
+      { if(r0.vec[i].coeffs[j] != a.vec[i].coeffs[j])
+        { fprintf(stderr, "ERROR: polyvec_add: %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], a.vec[i].coeffs[j]);
+          test_ok = 0;
+        }
+      }
+    }
+
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      if(r0.vec[i].coeffs[j] != a.vec[i].coeffs[j])
-        printf("error polyvec_add %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], a.vec[i].coeffs[j]);
+  if(test_ok == 1)
+  { printf("OK: polyvec_add\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_compress.c b/code/jasmin/mlkem_ref/test/test_polyvec_compress.c
index 8088aea9..c4a67c0a 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_compress.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_compress.c
@@ -1,33 +1,41 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../polyvec.h"
 #include "../ntt.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
 
-  polyvec_reduce(r);
-  fclose(urandom);
-}
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   unsigned char out0[MLKEM_POLYVECCOMPRESSEDBYTES];
   unsigned char out1[MLKEM_POLYVECCOMPRESSEDBYTES];
   polyvec a;
   
-  polyvec_setrandom(&a);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    polyvec_setrandom_reduce(&a);
 
-  polyvec_compress(out0, &a);
-  polyvec_compress_jazz(out1, &a);
+    polyvec_compress(out0, &a);
+    polyvec_compress_jazz(out1, &a);
 
-  for(int i=0;i<MLKEM_POLYVECCOMPRESSEDBYTES;i++)
-  {
-    if(out0[i] != out1[i])
-      printf("error polyvec_compress %d, %d, %d\n", i, out0[i], out1[i]);
+    for(int i=0;i<MLKEM_POLYVECCOMPRESSEDBYTES;i++)
+    { if(out0[i] != out1[i])
+      { fprintf(stderr, "ERROR: polyvec_compress: %d, %d, %d\n", i, out0[i], out1[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: polyvec_compress\n"); }
+
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_csubq.c b/code/jasmin/mlkem_ref/test/test_polyvec_csubq.c
index 1568e31d..60dd6a98 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_csubq.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_csubq.c
@@ -1,33 +1,45 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../polyvec.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  fclose(urandom);
-  polyvec_reduce(r);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   polyvec r0, r1;
 
-  polyvec_setrandom(&r0);
-  
-  for(int i = 0;i<MLKEM_K;i++)
-    for(int j = 0;j<MLKEM_N;j++)
-      r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    polyvec_setrandom_reduce(&r0);
+    
+    for(int i = 0;i<MLKEM_K;i++)
+      for(int j = 0;j<MLKEM_N;j++)
+        r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+
+    polyvec_csubq(&r0);
+    polyvec_csubq_jazz(&r1);
+
+    for(int i=0;i<MLKEM_K;i++)
+    { for(int j=0;j<MLKEM_N;j++)
+      { if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
+        { fprintf(stderr, "ERROR: polyvec_csubq: %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+          test_ok = 0;
+        }
+      }
+    }
 
-  polyvec_csubq(&r0);
-  polyvec_csubq_jazz(&r1);
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
-        printf("error polyvec_csubq %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+  if(test_ok == 1)
+  { printf("OK: polyvec_csubq\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_decompress.c b/code/jasmin/mlkem_ref/test/test_polyvec_decompress.c
index 1e7fa4e0..0a1fc8c2 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_decompress.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_decompress.c
@@ -1,22 +1,45 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../polyvec.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
+  size_t ri;
+
   unsigned char in[MLKEM_POLYVECCOMPRESSEDBYTES];
   polyvec r0, r1;
- 
+
   FILE *urandom = fopen("/dev/urandom", "r");
-  fread(in, 1, MLKEM_POLYVECCOMPRESSEDBYTES, urandom);
-  fclose(urandom);
 
-  polyvec_decompress(&r0, in);
-  polyvec_decompress_jazz(&r1, in);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    ri = fread(in, 1, MLKEM_POLYVECCOMPRESSEDBYTES, urandom);
+    assert(ri == MLKEM_POLYVECCOMPRESSEDBYTES);
+
+    polyvec_decompress(&r0, in);
+    polyvec_decompress_jazz(&r1, in);
+
+    for(int i=0;i<MLKEM_K;i++)
+    { for(int j=0;j<MLKEM_N;j++)
+      { if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
+        { fprintf(stderr, "ERROR: polyvec_decompress: %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+          test_ok = 0;
+        }
+      }
+    }
+
+    test_iteration += 1;
+  }
+  fclose(urandom);
 
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
-        printf("error polyvec_decompress %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+  if(test_ok == 1)
+  { printf("OK: polyvec_decompress\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_frombytes.c b/code/jasmin/mlkem_ref/test/test_polyvec_frombytes.c
index 55efba81..a5f252be 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_frombytes.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_frombytes.c
@@ -1,22 +1,44 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../polyvec.h"
 
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
+  size_t ri;
   unsigned char in[MLKEM_POLYVECBYTES];
   polyvec r0, r1;
- 
+
   FILE *urandom = fopen("/dev/urandom", "r");
-  fread(in, 1, MLKEM_POLYVECBYTES, urandom);
-  fclose(urandom);
 
-  polyvec_frombytes(&r0, in);
-  polyvec_frombytes_jazz(&r1, in);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    ri = fread(in, 1, MLKEM_POLYVECBYTES, urandom);
+    assert(ri == MLKEM_POLYVECBYTES);
+
+    polyvec_frombytes(&r0, in);
+    polyvec_frombytes_jazz(&r1, in);
+
+    for(int i=0;i<MLKEM_K;i++)
+    { for(int j=0;j<MLKEM_N;j++)
+      { if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
+        { fprintf(stderr, "ERROR: polyvec_frombytes: %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+          test_ok = 0;
+        }
+      }
+    }
+
+    test_iteration += 1;
+  }
+  fclose(urandom);
 
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
-        printf("error polyvec_frombytes %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+  if(test_ok == 1)
+  { printf("OK: polyvec_frombytes\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_invntt.c b/code/jasmin/mlkem_ref/test/test_polyvec_invntt.c
index 4b4ae457..469e16c2 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_invntt.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_invntt.c
@@ -1,36 +1,46 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../ntt.h"
 #include "../poly.h"
 #include "../polyvec.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      r->vec[i].coeffs[j] %= 2*MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   polyvec r0, r1;
 
-  polyvec_setrandom(&r0);
-  
-  for(int i = 0;i<MLKEM_K;i++)
-    for(int j = 0;j<MLKEM_N;j++)
-      r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    polyvec_setrandom_mod2q(&r0);
+    
+    for(int i = 0;i<MLKEM_K;i++)
+      for(int j = 0;j<MLKEM_N;j++)
+        r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+
+    polyvec_invntt(&r0);
+    polyvec_invntt_jazz(&r1);
+
+    for(int i=0;i<MLKEM_K;i++)
+    { for(int j=0;j<MLKEM_N;j++)
+      { if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
+        { fprintf(stderr, "ERROR: polyvec_invntt %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+          test_ok = 0;
+        }
+      }
+    }
 
-  polyvec_invntt(&r0);
-  polyvec_invntt_jazz(&r1);
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
-        printf("error polyvec_invntt %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+  if(test_ok == 1)
+  { printf("OK: polyvec_invntt\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_ntt.c b/code/jasmin/mlkem_ref/test/test_polyvec_ntt.c
index 351055ff..f5a0ae73 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_ntt.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_ntt.c
@@ -1,36 +1,46 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../ntt.h"
 #include "../poly.h"
 #include "../polyvec.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      r->vec[i].coeffs[j] %= 2*MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   polyvec r0, r1;
 
-  polyvec_setrandom(&r0);
-  
-  for(int i = 0;i<MLKEM_K;i++)
-    for(int j = 0;j<MLKEM_N;j++)
-      r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    polyvec_setrandom_mod2q(&r0);
+    
+    for(int i = 0;i<MLKEM_K;i++)
+      for(int j = 0;j<MLKEM_N;j++)
+        r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+
+    polyvec_ntt(&r0);
+    polyvec_ntt_jazz(&r1);
+
+    for(int i=0;i<MLKEM_K;i++)
+    { for(int j=0;j<MLKEM_N;j++)
+      { if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
+        { fprintf(stderr, "ERROR: polyvec_ntt: %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+          test_ok = 0;
+        }
+      }
+    }
 
-  polyvec_ntt(&r0);
-  polyvec_ntt_jazz(&r1);
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
-        printf("error polyvec_ntt %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+  if(test_ok == 1)
+  { printf("OK: polyvec_ntt\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_pointwise_acc.c b/code/jasmin/mlkem_ref/test/test_polyvec_pointwise_acc.c
index b4e4fced..055cc6b7 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_pointwise_acc.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_pointwise_acc.c
@@ -1,32 +1,40 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../ntt.h"
 #include "../polyvec.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      r->vec[i].coeffs[j] %= MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   polyvec a, b;
   poly r0, r1;
 
-  polyvec_setrandom(&a);
-  polyvec_setrandom(&b);
-  
-  polyvec_pointwise_acc(&r0, &a, &b);
-  polyvec_pointwise_acc_jazz(&r1, &a, &b);
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    polyvec_setrandom(&a);
+    polyvec_setrandom(&b);
+    
+    polyvec_pointwise_acc(&r0, &a, &b);
+    polyvec_pointwise_acc_jazz(&r1, &a, &b);
 
     for(int j=0;j<MLKEM_N;j++)
-      if(r0.coeffs[j] != r1.coeffs[j])
-        printf("error polyvec_pointwise_acc %d: %d, %d\n", j, r0.coeffs[j], r1.coeffs[j]);
+    { if(r0.coeffs[j] != r1.coeffs[j])
+      { fprintf(stderr, "ERROR: polyvec_pointwise_acc %d: %d, %d\n", j, r0.coeffs[j], r1.coeffs[j]);
+        test_ok = 0;
+      }
+    }
+    test_iteration += 1;
+  }
+
+  if(test_ok == 1)
+  { printf("OK: polyvec_pointwise_acc\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_reduce.c b/code/jasmin/mlkem_ref/test/test_polyvec_reduce.c
index f19cbc92..f94ac616 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_reduce.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_reduce.c
@@ -1,32 +1,45 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../poly.h"
 #include "../polyvec.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   polyvec r0, r1;
 
-  polyvec_setrandom(&r0);
-  
-  for(int i = 0;i<MLKEM_K;i++)
-    for(int j = 0;j<MLKEM_N;j++)
-      r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
+  {
+    polyvec_setrandom_nomodq(&r0);
+    
+    for(int i = 0;i<MLKEM_K;i++)
+      for(int j = 0;j<MLKEM_N;j++)
+        r1.vec[i].coeffs[j] = r0.vec[i].coeffs[j];
+
+    polyvec_reduce(&r0);
+    polyvec_reduce_jazz(&r1);
+
+    for(int i=0;i<MLKEM_K;i++)
+    { for(int j=0;j<MLKEM_N;j++)
+      { if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
+        { fprintf(stderr, "ERROR: polyvec_reduce: %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+          test_ok = 0;
+        }
+      }
+    }
 
-  polyvec_reduce(&r0);
-  polyvec_reduce_jazz(&r1);
+    test_iteration += 1;
+  }
 
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      if(r0.vec[i].coeffs[j] != r1.vec[i].coeffs[j])
-        printf("error polyvec_reduce %d,%d: %d, %d\n", i, j, r0.vec[i].coeffs[j], r1.vec[i].coeffs[j]);
+  if(test_ok == 1)
+  { printf("OK: polyvec_reduce\n"); }
 
   return 0;
 }
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_setrandom.c b/code/jasmin/mlkem_ref/test/test_polyvec_setrandom.c
new file mode 100644
index 00000000..6179bc77
--- /dev/null
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_setrandom.c
@@ -0,0 +1,58 @@
+#ifndef TEST_POLYVEC_SETRANDOM
+#define TEST_POLYVEC_SETRANDOM
+
+#include <stdio.h>
+#include <assert.h>
+#include "../polyvec.h"
+
+// note: extend to *_setrandom_open; *_setrandom; *_setrandom_close;
+// to not open the file so many times
+
+void polyvec_setrandom(polyvec *r)
+{
+  FILE *urandom = fopen("/dev/urandom", "r");
+  for(int i=0;i<MLKEM_K;i++)
+  { size_t ri = fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
+    assert(ri == MLKEM_N);
+  }
+  for(int i=0;i<MLKEM_K;i++)
+    for(int j=0;j<MLKEM_N;j++)
+      r->vec[i].coeffs[j] %= MLKEM_Q;
+  fclose(urandom);
+}
+
+void polyvec_setrandom_reduce(polyvec *r)
+{
+  FILE *urandom = fopen("/dev/urandom", "r");
+  for(int i=0;i<MLKEM_K;i++)
+  { size_t ri = fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
+    assert(ri == MLKEM_N);
+  }
+  polyvec_reduce(r);
+  fclose(urandom);
+}
+
+void polyvec_setrandom_mod2q(polyvec *r)
+{
+  FILE *urandom = fopen("/dev/urandom", "r");
+  for(int i=0;i<MLKEM_K;i++)
+  { size_t ri = fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
+    assert(ri == MLKEM_N);
+  }
+  for(int i=0;i<MLKEM_K;i++)
+    for(int j=0;j<MLKEM_N;j++)
+      r->vec[i].coeffs[j] %= 2*MLKEM_Q;
+  fclose(urandom);
+}
+
+void polyvec_setrandom_nomodq(polyvec *r)
+{
+  FILE *urandom = fopen("/dev/urandom", "r");
+  for(int i=0;i<MLKEM_K;i++)
+  { size_t ri = fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
+    assert(ri == MLKEM_N);
+  }
+  fclose(urandom);
+}
+
+#endif
diff --git a/code/jasmin/mlkem_ref/test/test_polyvec_tobytes.c b/code/jasmin/mlkem_ref/test/test_polyvec_tobytes.c
index d23acb49..d17f8941 100644
--- a/code/jasmin/mlkem_ref/test/test_polyvec_tobytes.c
+++ b/code/jasmin/mlkem_ref/test/test_polyvec_tobytes.c
@@ -1,34 +1,42 @@
 #include <stdio.h>
+#include <assert.h>
 #include "../polyvec.h"
 #include "../ntt.h"
 
-void polyvec_setrandom(polyvec *r)
-{
-  FILE *urandom = fopen("/dev/urandom", "r");
-  for(int i=0;i<MLKEM_K;i++)
-    fread(r->vec[i].coeffs, sizeof(int16_t), MLKEM_N, urandom);
-  for(int i=0;i<MLKEM_K;i++)
-    for(int j=0;j<MLKEM_N;j++)
-      r->vec[i].coeffs[j] %= MLKEM_Q;
-  fclose(urandom);
-}
+#ifndef TEST_ITERATIONS
+#define TEST_ITERATIONS 10000
+#endif
+
+#include "test_polyvec_setrandom.c"
 
 int main(void)
 {
+  int test_ok = 1;
+  size_t test_iteration = 0;
   unsigned char out0[MLKEM_POLYVECBYTES];
   unsigned char out1[MLKEM_POLYVECBYTES];
   polyvec a;
-  
-  polyvec_setrandom(&a);
 
-  polyvec_tobytes(out0, &a);
-  polyvec_tobytes_jazz(out1, &a);
-
-  for(int i=0;i<MLKEM_POLYVECBYTES;i++)
+  while(test_ok == 1 && test_iteration < TEST_ITERATIONS)
   {
-    if(out0[i] != out1[i])
-      printf("error poly_tobytes %d, %d, %d\n", i, out0[i], out1[i]);
+    polyvec_setrandom(&a);
+
+    polyvec_tobytes(out0, &a);
+    polyvec_tobytes_jazz(out1, &a);
+
+    for(int i=0;i<MLKEM_POLYVECBYTES;i++)
+    { if(out0[i] != out1[i])
+      { fprintf(stderr, "ERROR: poly_tobytes: %d, %d, %d\n", i, out0[i], out1[i]);
+        test_ok = 0;
+      }
+    }
+
+    test_iteration += 1;
   }
 
+  if(test_ok == 1)
+  { printf("OK: polyvec_tobytes\n"); }
+
+
   return 0;
 }
diff --git a/shell.nix b/shell.nix
index 7f98f533..81ca9434 100644
--- a/shell.nix
+++ b/shell.nix
@@ -36,7 +36,7 @@ in
 
 mkShell ({
   JASMINC = "${jasmin-compiler.bin}/bin/jasminc";
-  JAZZCT = "${jasmin-compiler.bin}/bin/jazzct";
+  JASMIN_CT = "${jasmin-compiler.bin}/bin/jazzct";
 } // lib.optionalAttrs full {
   packages = [
     ec