diff --git a/tests/test_compat.py b/tests/test_compat.py
index 23a79dfb..55487c8e 100644
--- a/tests/test_compat.py
+++ b/tests/test_compat.py
@@ -42,14 +42,14 @@
 
 
 @pytest.mark.parametrize(["data_size", "value"],
-                         itertools.product(DATA_SIZES, SEEDS))
+                         list(itertools.product(DATA_SIZES, SEEDS)))
 def test_crc32(data_size, value):
     data = DATA[:data_size]
     assert zlib.crc32(data, value) == isal_zlib.crc32(data, value)
 
 
 @pytest.mark.parametrize(["data_size", "value"],
-                         itertools.product(DATA_SIZES, SEEDS))
+                         list(itertools.product(DATA_SIZES, SEEDS)))
 def test_adler32(data_size, value):
     data = DATA[:data_size]
     assert zlib.adler32(data, value) == isal_zlib.adler32(data, value)
@@ -92,7 +92,7 @@ def test_compressobj_decompressobj_no_memory(factory):
 
 
 @pytest.mark.parametrize(["data_size", "level"],
-                         itertools.product(DATA_SIZES, range(4)))
+                         list(itertools.product(DATA_SIZES, range(4))))
 def test_compress(data_size, level):
     data = DATA[:data_size]
     compressed = isal_zlib.compress(data, level=level)
@@ -100,7 +100,7 @@ def test_compress(data_size, level):
 
 
 @pytest.mark.parametrize(["data_size", "level"],
-                         itertools.product(DATA_SIZES, range(10)))
+                         list(itertools.product(DATA_SIZES, range(10))))
 def test_decompress_zlib(data_size, level):
     data = DATA[:data_size]
     compressed = zlib.compress(data, level=level)
@@ -109,8 +109,8 @@ def test_decompress_zlib(data_size, level):
 
 
 @pytest.mark.parametrize(["data_size", "level", "wbits", "memLevel"],
-                         itertools.product([128 * 1024], range(4),
-                                           WBITS_RANGE, range(1, 10)))
+                         list(itertools.product([128 * 1024], range(4),
+                                                WBITS_RANGE, range(1, 10))))
 def test_decompress_wbits(data_size, level, wbits, memLevel):
     data = DATA[:data_size]
     compressobj = zlib.compressobj(level=level, wbits=wbits, memLevel=memLevel)
@@ -120,7 +120,7 @@ def test_decompress_wbits(data_size, level, wbits, memLevel):
 
 
 @pytest.mark.parametrize(["data_size", "level"],
-                         itertools.product(DATA_SIZES, range(4)))
+                         list(itertools.product(DATA_SIZES, range(4))))
 def test_decompress_isal_zlib(data_size, level):
     data = DATA[:data_size]
     compressed = isal_zlib.compress(data, level=level)
@@ -130,8 +130,8 @@ def test_decompress_isal_zlib(data_size, level):
 
 
 @pytest.mark.parametrize(["data_size", "level", "wbits", "memLevel"],
-                         itertools.product([128 * 1024], range(4),
-                                           WBITS_RANGE, range(1, 10)))
+                         list(itertools.product([128 * 1024], range(4),
+                                                WBITS_RANGE, range(1, 10))))
 def test_compress_compressobj(data_size, level, wbits, memLevel):
     data = DATA[:data_size]
     compressobj = isal_zlib.compressobj(level=level,
@@ -227,8 +227,8 @@ def test_compressobj_unsupported_strategy(level, strategy):
 
 
 @pytest.mark.parametrize(["data_size", "level", "wbits", "memLevel"],
-                         itertools.product([128 * 1024], range(4),
-                                           WBITS_RANGE, range(1, 10)))
+                         list(itertools.product([128 * 1024], range(4),
+                                                WBITS_RANGE, range(1, 10))))
 def test_decompress_decompressobj(data_size, level, wbits, memLevel):
     data = DATA[:data_size]
     compressobj = zlib.compressobj(level=level, wbits=wbits, memLevel=memLevel)
@@ -249,7 +249,7 @@ def test_decompressobj_unconsumed_tail():
 
 
 @pytest.mark.parametrize(["data_size", "level"],
-                         itertools.product(DATA_SIZES, range(4)))
+                         list(itertools.product(DATA_SIZES, range(4))))
 def test_igzip_compress(data_size, level):
     data = DATA[:data_size]
     compressed = igzip.compress(data, compresslevel=level)
@@ -257,7 +257,7 @@ def test_igzip_compress(data_size, level):
 
 
 @pytest.mark.parametrize(["data_size", "level"],
-                         itertools.product(DATA_SIZES, range(10)))
+                         list(itertools.product(DATA_SIZES, range(10))))
 def test_decompress_gzip(data_size, level):
     data = DATA[:data_size]
     compressed = gzip.compress(data, compresslevel=level)
@@ -266,7 +266,7 @@ def test_decompress_gzip(data_size, level):
 
 
 @pytest.mark.parametrize(["data_size", "level"],
-                         itertools.product(DATA_SIZES, range(4)))
+                         list(itertools.product(DATA_SIZES, range(4))))
 def test_decompress_igzip(data_size, level):
     data = DATA[:data_size]
     compressed = igzip.compress(data, compresslevel=level)
@@ -276,7 +276,7 @@ def test_decompress_igzip(data_size, level):
 
 
 @pytest.mark.parametrize(["unused_size", "wbits"],
-                         itertools.product([26], [-15, 15, 31]))
+                         list(itertools.product([26], [-15, 15, 31])))
 def test_unused_data(unused_size, wbits):
     unused_data = b"abcdefghijklmnopqrstuvwxyz"[:unused_size]
     compressor = zlib.compressobj(wbits=wbits)
diff --git a/tests/test_igzip_lib.py b/tests/test_igzip_lib.py
index f2ccce1b..523f7156 100644
--- a/tests/test_igzip_lib.py
+++ b/tests/test_igzip_lib.py
@@ -59,8 +59,8 @@ class Flag(NamedTuple):
 
 
 @pytest.mark.parametrize(["level", "flag", "mem_level", "hist_bits"],
-                         itertools.product(
-                             COMPRESS_LEVELS, FLAGS, MEM_LEVELS, HIST_BITS))
+                         list(itertools.product(
+                             COMPRESS_LEVELS, FLAGS, MEM_LEVELS, HIST_BITS)))
 def test_compress_decompress(level, flag: Flag, mem_level, hist_bits):
     comp = igzip_lib.compress(DATA, level, flag.comp, mem_level, hist_bits)
     decomp = igzip_lib.decompress(comp, flag.decomp, hist_bits)
@@ -349,8 +349,8 @@ def test_igzip_decompressor_decompress_no_memory():
 
 
 @pytest.mark.parametrize(["unused_size", "flag_pair", "data_size"],
-                         itertools.product([26], FLAGS,
-                                           [128 * 1024 - 3, 874, 81923, 9111]))
+                         list(itertools.product(
+                             [26], FLAGS, [128 * 1024 - 3, 874, 81923, 9111])))
 def test_decompression_flags(unused_size, flag_pair, data_size):
     comp_flag, decomp_flag = flag_pair
     unused_data = b"abcdefghijklmnopqrstuvwxyz"[:unused_size]
diff --git a/tests/test_igzip_threaded.py b/tests/test_igzip_threaded.py
index 572ece53..31650f4b 100644
--- a/tests/test_igzip_threaded.py
+++ b/tests/test_igzip_threaded.py
@@ -105,7 +105,8 @@ def test_threaded_write_oversized_block_no_error(threads):
 
 @pytest.mark.timeout(5)
 @pytest.mark.parametrize(["threads", "block_size"],
-                         itertools.product([1, 3], [8 * 1024, 1024 * 1024]))
+                         list(itertools.product([1, 3],
+                                                [8 * 1024, 1024 * 1024])))
 def test_threaded_write_incompressible_level_0(tmp_path, threads, block_size):
     # Level 0 codes all data with one precomputed Huffman table and never
     # falls back to stored blocks, so random bytes grow by more than 20%.
@@ -333,7 +334,7 @@ def test_threaded_writer_does_not_close_stream():
 
 @pytest.mark.timeout(5)
 @pytest.mark.parametrize(
-    ["mode", "threads"], itertools.product(["rb", "wb"], [1, 2]))
+    ["mode", "threads"], list(itertools.product(["rb", "wb"], [1, 2])))
 def test_threaded_program_can_exit_on_error(tmp_path, mode, threads):
     program = tmp_path / "no_context_manager.py"
     test_file = tmp_path / "output.gz"