From 4850b90426e672eb313caf8c1e1ab936e6140b49 Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Fri, 27 Sep 2024 17:42:50 +0200 Subject: [PATCH 1/8] test(shf): add extensive test --- .../zktracer/module/shf/ShfExtensiveTest.java | 111 ++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java new file mode 100644 index 0000000000..ab7bb9cdd5 --- /dev/null +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -0,0 +1,111 @@ +/* + * Copyright Consensys Software Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ + +package net.consensys.linea.zktracer.module.shf; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +import net.consensys.linea.testing.BytecodeCompiler; +import net.consensys.linea.testing.BytecodeRunner; +import net.consensys.linea.zktracer.opcode.OpCode; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +public class ShfExtensiveTest { + + @ParameterizedTest + @MethodSource("shfExtensiveTestSource") + void shfExtensiveTest(String shift, String value, OpCode opCode) { + BytecodeRunner.of(BytecodeCompiler.newProgram().push(value).push(shift).op(opCode).compile()) + .run(); + } + + private static Stream shfExtensiveTestSource() { + List arguments = new ArrayList<>(); + for (String shift : shifts) { + for (int k = 0; k < 32; k++) { + for (int l = 1; l <= 8; l++) { + String value = value(k, l); + arguments.add(Arguments.of(shift, value, OpCode.SHL)); + arguments.add(Arguments.of(shift, value, OpCode.SHR)); + arguments.add(Arguments.of(shift, value, OpCode.SAR)); + + // Adding additional cases for SAR + for (String XY : XYs) { + String mask = XY + "00".repeat(31); + String maskXorValue = + String.format("%064X", new BigInteger(mask, 16).xor(new BigInteger(value, 16))); + arguments.add(Arguments.of(shift, maskXorValue, OpCode.SAR)); + } + } + } + } + return arguments.stream(); + } + + static final String[] shifts = + Stream.concat( + IntStream.rangeClosed(0, 257) // Generates numbers 0 to 257 + .mapToObj(BigInteger::valueOf), + Stream.of( + BigInteger.valueOf(511), + BigInteger.valueOf(512), + BigInteger.valueOf(513), + BigInteger.valueOf(65535), + BigInteger.valueOf(65536), + BigInteger.valueOf(65537), + BigInteger.ONE.shiftLeft(128).subtract(BigInteger.ONE), // (1 << 128) - 1 + BigInteger.ONE.shiftLeft(128), // (1 << 128) + BigInteger.ONE.shiftLeft(128).add(BigInteger.ONE), // (1 << 128) + 1 + BigInteger.ONE.shiftLeft(256).subtract(BigInteger.ONE) // (1 << 256) - 1 + )) + .map(bigInteger -> bigInteger.toString(16)) + .toArray(String[]::new); + + static final String[] p = { + "DF", "D5", "A2", "E7", "6E", "9D", "3A", "20", + "96", "2D", "17", "48", "19", "7F", "0D", "4C", + "FF", "3D", "57", "A4", "A8", "87", "45", "B9", + "C9", "34", "1A", "F3", "57", "84", "D3", "EE" + }; // big-endian (from the least significant byte to the most significant byte) + + static final String[] XYs = new String[] {"80", "90", "A0", "B0", "C0", "D0", "E0", "F0"}; + + public static String value(int k, int l) { + String[] v = new String[32]; + // 0 to k - 1 + if (k >= 0) System.arraycopy(p, 0, v, 0, k); + // k + v[k] = String.format("%02X", (1 << l) - 1); + // k + 1 to 31 + for (int i = k + 1; i < 32; i++) { + v[i] = "00"; + } + return String.join("", java.util.Arrays.asList(v).reversed()); + } + + @Test + void testValue() { + Assertions.assertEquals( + "0000000000000000000000003F573DFF4C0D7F1948172D96203A9D6EE7A2D5DF", value(19, 6)); + } +} From f46c2842712cac52e08ac95b3eff278274e320fd Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Fri, 27 Sep 2024 18:25:32 +0200 Subject: [PATCH 2/8] docs(shf): add TODO --- .../zktracer/module/shf/ShfExtensiveTest.java | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java index ab7bb9cdd5..ecd7b971e9 100644 --- a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -32,6 +32,8 @@ public class ShfExtensiveTest { + // This test should be executed only occasionally since very long. We will batch test cases as + // described below @ParameterizedTest @MethodSource("shfExtensiveTestSource") void shfExtensiveTest(String shift, String value, OpCode opCode) { @@ -48,7 +50,6 @@ private static Stream shfExtensiveTestSource() { arguments.add(Arguments.of(shift, value, OpCode.SHL)); arguments.add(Arguments.of(shift, value, OpCode.SHR)); arguments.add(Arguments.of(shift, value, OpCode.SAR)); - // Adding additional cases for SAR for (String XY : XYs) { String mask = XY + "00".repeat(31); @@ -62,6 +63,17 @@ private static Stream shfExtensiveTestSource() { return arguments.stream(); } + // TODO: splits tests into: + // - SHL + // - SHR + // - SAR + // - SAR with mask + // The program should consist in a concatenation of all the possible shifts for a given value and + // opCode + // It means that shift is not a parameter anymore since all shifts are tested within the same + // program. + + // Inputs and support methods static final String[] shifts = Stream.concat( IntStream.rangeClosed(0, 257) // Generates numbers 0 to 257 @@ -103,6 +115,7 @@ public static String value(int k, int l) { return String.join("", java.util.Arrays.asList(v).reversed()); } + // Testing support methods @Test void testValue() { Assertions.assertEquals( From cce1b110af98477a1601141522e33a4028316145 Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Sat, 28 Sep 2024 23:37:39 +0200 Subject: [PATCH 3/8] feat(shf): batch test cases --- .../zktracer/module/shf/ShfExtensiveTest.java | 127 +++++++++++++----- 1 file changed, 90 insertions(+), 37 deletions(-) diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java index ecd7b971e9..5b6333b5c5 100644 --- a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -21,10 +21,13 @@ import java.util.stream.IntStream; import java.util.stream.Stream; +import lombok.Getter; import net.consensys.linea.testing.BytecodeCompiler; import net.consensys.linea.testing.BytecodeRunner; import net.consensys.linea.zktracer.opcode.OpCode; import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; @@ -32,49 +35,66 @@ public class ShfExtensiveTest { - // This test should be executed only occasionally since very long. We will batch test cases as - // described below - @ParameterizedTest - @MethodSource("shfExtensiveTestSource") - void shfExtensiveTest(String shift, String value, OpCode opCode) { - BytecodeRunner.of(BytecodeCompiler.newProgram().push(value).push(shift).op(opCode).compile()) - .run(); - } + @Getter private static Stream shfTestSource; + @Getter private static Stream shfWithMaskTestSource; - private static Stream shfExtensiveTestSource() { - List arguments = new ArrayList<>(); - for (String shift : shifts) { - for (int k = 0; k < 32; k++) { - for (int l = 1; l <= 8; l++) { - String value = value(k, l); - arguments.add(Arguments.of(shift, value, OpCode.SHL)); - arguments.add(Arguments.of(shift, value, OpCode.SHR)); - arguments.add(Arguments.of(shift, value, OpCode.SAR)); - // Adding additional cases for SAR - for (String XY : XYs) { - String mask = XY + "00".repeat(31); - String maskXorValue = - String.format("%064X", new BigInteger(mask, 16).xor(new BigInteger(value, 16))); - arguments.add(Arguments.of(shift, maskXorValue, OpCode.SAR)); - } + @BeforeAll + public static void init() { + List shfTestSourceList = new ArrayList<>(); + List shfWithMaskTestSourceList = new ArrayList<>(); + for (int k = 0; k < 32; k++) { + for (int l = 1; l <= 8; l++) { + String value = value(k, l); + shfTestSourceList.add(Arguments.of(value)); + for (String XY : XYs) { + String mask = XY + "00".repeat(31); + String maskXorValue = + String.format("%064X", new BigInteger(mask, 16).xor(new BigInteger(value, 16))); + shfWithMaskTestSourceList.add(Arguments.of(maskXorValue)); } } } - return arguments.stream(); + shfTestSource = shfTestSourceList.stream(); + shfWithMaskTestSource = shfWithMaskTestSourceList.stream(); + } + + @ParameterizedTest + @MethodSource("getShfTestSource") + void shlTest(String value) { + shfProgramOf(value, OpCode.SHL).run(); } - // TODO: splits tests into: - // - SHL - // - SHR - // - SAR - // - SAR with mask - // The program should consist in a concatenation of all the possible shifts for a given value and - // opCode - // It means that shift is not a parameter anymore since all shifts are tested within the same - // program. + @ParameterizedTest + @MethodSource("getShfTestSource") + void shrTest(String value) { + shfProgramOf(value, OpCode.SHR).run(); + } + + @ParameterizedTest + @MethodSource("getShfTestSource") + void sarTest(String value) { + shfProgramOf(value, OpCode.SAR).run(); + } + + @ParameterizedTest + @MethodSource("getShfWithMaskTestSource") + void sarWithMaskTest(String value) { + shfProgramOf(value, OpCode.SAR).run(); + } // Inputs and support methods - static final String[] shifts = + + // Creates a program that concatenates shifts operations (with different relevant shift values) + // for a given value and opcode + private BytecodeRunner shfProgramOf(String value, OpCode opCode) { + BytecodeCompiler program = BytecodeCompiler.newProgram(); + for (String shift : SHIFTS) { + program.push(value).push(shift).op(opCode); + } + return BytecodeRunner.of(program.compile()); + } + + static final String[] SHIFTS = Stream.concat( IntStream.rangeClosed(0, 257) // Generates numbers 0 to 257 .mapToObj(BigInteger::valueOf), @@ -93,7 +113,7 @@ private static Stream shfExtensiveTestSource() { .map(bigInteger -> bigInteger.toString(16)) .toArray(String[]::new); - static final String[] p = { + static final String[] P = { "DF", "D5", "A2", "E7", "6E", "9D", "3A", "20", "96", "2D", "17", "48", "19", "7F", "0D", "4C", "FF", "3D", "57", "A4", "A8", "87", "45", "B9", @@ -105,7 +125,7 @@ private static Stream shfExtensiveTestSource() { public static String value(int k, int l) { String[] v = new String[32]; // 0 to k - 1 - if (k >= 0) System.arraycopy(p, 0, v, 0, k); + if (k >= 0) System.arraycopy(P, 0, v, 0, k); // k v[k] = String.format("%02X", (1 << l) - 1); // k + 1 to 31 @@ -121,4 +141,37 @@ void testValue() { Assertions.assertEquals( "0000000000000000000000003F573DFF4C0D7F1948172D96203A9D6EE7A2D5DF", value(19, 6)); } + + // ################################################################################################################### + + // This test should be executed only occasionally since very long. Run below batched tests instead + @Disabled + @ParameterizedTest + @MethodSource("shfExtensiveTestSource") + void shfExtensiveTest(String shift, String value, OpCode opCode) { + BytecodeRunner.of(BytecodeCompiler.newProgram().push(value).push(shift).op(opCode).compile()) + .run(); + } + + private static Stream shfExtensiveTestSource() { + List arguments = new ArrayList<>(); + for (String shift : SHIFTS) { + for (int k = 0; k < 32; k++) { + for (int l = 1; l <= 8; l++) { + String value = value(k, l); + arguments.add(Arguments.of(shift, value, OpCode.SHL)); + arguments.add(Arguments.of(shift, value, OpCode.SHR)); + arguments.add(Arguments.of(shift, value, OpCode.SAR)); + // Adding additional cases for SAR + for (String XY : XYs) { + String mask = XY + "00".repeat(31); + String maskXorValue = + String.format("%064X", new BigInteger(mask, 16).xor(new BigInteger(value, 16))); + arguments.add(Arguments.of(shift, maskXorValue, OpCode.SAR)); + } + } + } + } + return arguments.stream(); + } } From 06ef9bfbe674b5b0bef67a2f9ed6574f36a3b45d Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Sat, 28 Sep 2024 23:42:15 +0200 Subject: [PATCH 4/8] fix(shf): reorder methods --- .../zktracer/module/shf/ShfExtensiveTest.java | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java index 5b6333b5c5..a26fb443cc 100644 --- a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -84,16 +84,6 @@ void sarWithMaskTest(String value) { // Inputs and support methods - // Creates a program that concatenates shifts operations (with different relevant shift values) - // for a given value and opcode - private BytecodeRunner shfProgramOf(String value, OpCode opCode) { - BytecodeCompiler program = BytecodeCompiler.newProgram(); - for (String shift : SHIFTS) { - program.push(value).push(shift).op(opCode); - } - return BytecodeRunner.of(program.compile()); - } - static final String[] SHIFTS = Stream.concat( IntStream.rangeClosed(0, 257) // Generates numbers 0 to 257 @@ -122,6 +112,16 @@ private BytecodeRunner shfProgramOf(String value, OpCode opCode) { static final String[] XYs = new String[] {"80", "90", "A0", "B0", "C0", "D0", "E0", "F0"}; + // Creates a program that concatenates shifts operations (with different relevant shift values) + // for a given value and opcode + private BytecodeRunner shfProgramOf(String value, OpCode opCode) { + BytecodeCompiler program = BytecodeCompiler.newProgram(); + for (String shift : SHIFTS) { + program.push(value).push(shift).op(opCode); + } + return BytecodeRunner.of(program.compile()); + } + public static String value(int k, int l) { String[] v = new String[32]; // 0 to k - 1 From ac45cde94b303c626299d1b41c005f9ccbabba42 Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Mon, 30 Sep 2024 10:45:16 +0200 Subject: [PATCH 5/8] feat(shf): add parameters to test name --- .../linea/zktracer/module/shf/ShfExtensiveTest.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java index a26fb443cc..f6fe4cafc9 100644 --- a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -45,12 +45,12 @@ public static void init() { for (int k = 0; k < 32; k++) { for (int l = 1; l <= 8; l++) { String value = value(k, l); - shfTestSourceList.add(Arguments.of(value)); + shfTestSourceList.add(Arguments.of(value, k, l)); for (String XY : XYs) { String mask = XY + "00".repeat(31); String maskXorValue = String.format("%064X", new BigInteger(mask, 16).xor(new BigInteger(value, 16))); - shfWithMaskTestSourceList.add(Arguments.of(maskXorValue)); + shfWithMaskTestSourceList.add(Arguments.of(maskXorValue, k, l, XY)); } } } @@ -60,25 +60,25 @@ public static void init() { @ParameterizedTest @MethodSource("getShfTestSource") - void shlTest(String value) { + void shlTest(String value, int k, int l) { shfProgramOf(value, OpCode.SHL).run(); } @ParameterizedTest @MethodSource("getShfTestSource") - void shrTest(String value) { + void shrTest(String value, int k, int l) { shfProgramOf(value, OpCode.SHR).run(); } @ParameterizedTest @MethodSource("getShfTestSource") - void sarTest(String value) { + void sarTest(String value, int k, int l) { shfProgramOf(value, OpCode.SAR).run(); } @ParameterizedTest @MethodSource("getShfWithMaskTestSource") - void sarWithMaskTest(String value) { + void sarWithMaskTest(String value, int k, int l, String XY) { shfProgramOf(value, OpCode.SAR).run(); } From 1e14973816348c0532eb2f0a08e7b5a091b45aee Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Mon, 30 Sep 2024 11:50:56 +0200 Subject: [PATCH 6/8] fix(shf): fix test stream usage --- .../zktracer/module/shf/ShfExtensiveTest.java | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java index f6fe4cafc9..1637e3d35b 100644 --- a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -35,12 +35,11 @@ public class ShfExtensiveTest { - @Getter private static Stream shfTestSource; + private static final List shfTestSourceList = new ArrayList<>(); @Getter private static Stream shfWithMaskTestSource; @BeforeAll public static void init() { - List shfTestSourceList = new ArrayList<>(); List shfWithMaskTestSourceList = new ArrayList<>(); for (int k = 0; k < 32; k++) { for (int l = 1; l <= 8; l++) { @@ -54,8 +53,12 @@ public static void init() { } } } - shfTestSource = shfTestSourceList.stream(); shfWithMaskTestSource = shfWithMaskTestSourceList.stream(); + // shfWithMaskTestSource inputs are used only once, so it is fine to generate the corresponding + // stream here. + // Note that whenever a stream is used, it is also consumed, + // that is why in the case of shfTestSourceList inputs, + // we generate a new stream every time it is needed. } @ParameterizedTest @@ -82,6 +85,11 @@ void sarWithMaskTest(String value, int k, int l, String XY) { shfProgramOf(value, OpCode.SAR).run(); } + private static Stream getShfTestSource() { + return shfTestSourceList.stream(); + // A new stream is generated whenever it is necessary, starting from the same list + } + // Inputs and support methods static final String[] SHIFTS = From 70092db471e8066b71087df906aaef0756cdb534 Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Mon, 30 Sep 2024 11:56:10 +0200 Subject: [PATCH 7/8] fix(shf): make accessors fluent --- .../linea/zktracer/module/shf/ShfExtensiveTest.java | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java index 1637e3d35b..5571be8a97 100644 --- a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -22,6 +22,7 @@ import java.util.stream.Stream; import lombok.Getter; +import lombok.experimental.Accessors; import net.consensys.linea.testing.BytecodeCompiler; import net.consensys.linea.testing.BytecodeRunner; import net.consensys.linea.zktracer.opcode.OpCode; @@ -33,6 +34,7 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +@Accessors(fluent = true) public class ShfExtensiveTest { private static final List shfTestSourceList = new ArrayList<>(); @@ -62,30 +64,30 @@ public static void init() { } @ParameterizedTest - @MethodSource("getShfTestSource") + @MethodSource("shfTestSource") void shlTest(String value, int k, int l) { shfProgramOf(value, OpCode.SHL).run(); } @ParameterizedTest - @MethodSource("getShfTestSource") + @MethodSource("shfTestSource") void shrTest(String value, int k, int l) { shfProgramOf(value, OpCode.SHR).run(); } @ParameterizedTest - @MethodSource("getShfTestSource") + @MethodSource("shfTestSource") void sarTest(String value, int k, int l) { shfProgramOf(value, OpCode.SAR).run(); } @ParameterizedTest - @MethodSource("getShfWithMaskTestSource") + @MethodSource("shfWithMaskTestSource") void sarWithMaskTest(String value, int k, int l, String XY) { shfProgramOf(value, OpCode.SAR).run(); } - private static Stream getShfTestSource() { + private static Stream shfTestSource() { return shfTestSourceList.stream(); // A new stream is generated whenever it is necessary, starting from the same list } From 3a44312bbecec96803b458098e657d5aeb7334c2 Mon Sep 17 00:00:00 2001 From: Lorenzo Gentile Date: Mon, 30 Sep 2024 14:08:22 +0200 Subject: [PATCH 8/8] test(shf): set nightly --- .../consensys/linea/zktracer/module/shf/ShfExtensiveTest.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java index 5571be8a97..6558df184f 100644 --- a/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java +++ b/arithmetization/src/test/java/net/consensys/linea/zktracer/module/shf/ShfExtensiveTest.java @@ -29,12 +29,14 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; @Accessors(fluent = true) +@Tag("weekly") public class ShfExtensiveTest { private static final List shfTestSourceList = new ArrayList<>();