diff --git a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/DMNCompilerTest.java b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/DMNCompilerTest.java
index daf7518dbb9..7e9874ef7da 100644
--- a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/DMNCompilerTest.java
+++ b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/DMNCompilerTest.java
@@ -339,8 +339,8 @@ void testNestedImports(VariantTestConf conf) {
             LOG.debug("{}", message);
         }
         LOG.debug("{}", evaluateModelCDecision);
-        assertThat(evaluateModelCDecision.getDecisionResults()).size().isEqualTo(3);
-        evaluateModelCDecision.getDecisionResults().forEach(dmnDecisionResult -> assertThat(dmnDecisionResult.getEvaluationStatus()).isEqualTo(SUCCEEDED));
+        assertThat(evaluateModelCDecision.getDecisionResults()).hasSize(3);
+        assertThat(evaluateModelCDecision.getDecisionResults()).allMatch(dmnDecisionResult -> dmnDecisionResult.getEvaluationStatus().equals(SUCCEEDED));
     }
 
     @ParameterizedTest
@@ -415,13 +415,11 @@ void wrongComparisonOps(VariantTestConf conf) {
         assertThat(dmnModel.hasErrors()).as(DMNRuntimeUtil.formatMessages(dmnModel.getMessages())).isFalse();
         assertThat(dmnModel.getMessages()).as(DMNRuntimeUtil.formatMessages(dmnModel.getMessages())).hasSize(4);
         assertThat(dmnModel.getMessages(DMNMessage.Severity.WARN)).as(DMNRuntimeUtil.formatMessages(dmnModel.getMessages())).hasSize(4);
-        assertThat(dmnModel.getMessages(DMNMessage.Severity.WARN)
-                           .stream()
-                           .filter(m -> m.getSourceId().equals("_d72d6fab-1e67-4fe7-9c12-54800d6fe294") ||
+        assertThat(dmnModel.getMessages(DMNMessage.Severity.WARN)).as(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()))
+                           .filteredOn(m -> m.getSourceId().equals("_d72d6fab-1e67-4fe7-9c12-54800d6fe294") ||
                                         m.getSourceId().equals("_2390dd99-094d-4f97-aecc-9cccb697ce05") ||
                                         m.getSourceId().equals("_0c292d34-498e-4b08-ae99-3c694197b69f") ||
-                                        m.getSourceId().equals("_21c7d800-b806-4b2e-9a10-00828de7f2d2"))
-                           .count()).as(DMNRuntimeUtil.formatMessages(dmnModel.getMessages())).isEqualTo(4L);
+                                        m.getSourceId().equals("_21c7d800-b806-4b2e-9a10-00828de7f2d2")).hasSize(4);
     }
 
     @ParameterizedTest
diff --git a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/UnnamedImportUtilsTest.java b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/UnnamedImportUtilsTest.java
index f0a8e94a5a8..29d1ac343c1 100644
--- a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/UnnamedImportUtilsTest.java
+++ b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/UnnamedImportUtilsTest.java
@@ -65,11 +65,11 @@ void isInUnnamedImportFalse() {
         final DMNModelImpl importingModel = (DMNModelImpl)runtime.getModel("http://www.trisotech.com/dmn/definitions/_f79aa7a4-f9a3-410a-ac95-bea496edabgc",
                                                                            "Importing named Model");
         assertThat(importingModel).isNotNull();
-        importedModel.getDecisions().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isFalse());
-        importedModel.getBusinessKnowledgeModels().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isFalse());
-        importedModel.getDecisionServices().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isFalse());
-        importedModel.getInputs().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isFalse());
-        importedModel.getItemDefinitions().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isFalse());
+        assertThat(importedModel.getDecisions()).noneMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getBusinessKnowledgeModels()).noneMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getDecisionServices()).noneMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getInputs()).noneMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getItemDefinitions()).noneMatch(node -> isInUnnamedImport(node, importingModel));
     }
 
     @Test
@@ -80,11 +80,11 @@ void addIfNotPresentTrue() throws IOException {
         try (InputStream is = importedModelFileResource.openStream()) {
             String xml = new String(is.readAllBytes(), StandardCharsets.UTF_8);
             Definitions definitions = DMNMarshallerFactory.newDefaultMarshaller().unmarshal(xml);
-            definitions.getDecisionService().forEach(definition ->  assertThat(added(definition)).isTrue());
-            definitions.getBusinessContextElement().forEach(definition ->  assertThat(added(definition)).isTrue());
-            definitions.getDrgElement().forEach(definition ->  assertThat(added(definition)).isTrue());
-            definitions.getImport().forEach(definition ->  assertThat(added(definition)).isTrue());
-            definitions.getItemDefinition().forEach(definition ->  assertThat(added(definition)).isTrue());
+            assertThat(definitions.getDecisionService()).allMatch(definition -> added(definition));
+            assertThat(definitions.getBusinessContextElement()).allMatch(definition -> added(definition));
+            assertThat(definitions.getDrgElement()).allMatch(definition -> added(definition));
+            assertThat(definitions.getImport()).allMatch(definition -> added(definition));
+            assertThat(definitions.getItemDefinition()).allMatch(definition -> added(definition));
         }
     }
 
@@ -114,11 +114,11 @@ private void commonIsInUnnamedImportTrue(String importingModelRef, String import
                                                                                     "-f9a3-410a-ac95-bea496edabgc",
                                                                             "Importing empty-named Model");
         assertThat(importingModel).isNotNull();
-        importedModel.getDecisions().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isTrue());
-        importedModel.getBusinessKnowledgeModels().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isTrue());
-        importedModel.getDecisionServices().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isTrue());
-        importedModel.getInputs().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isTrue());
-        importedModel.getItemDefinitions().forEach(node -> assertThat(isInUnnamedImport(node, importingModel)).isTrue());
+        assertThat(importedModel.getDecisions()).allMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getBusinessKnowledgeModels()).allMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getDecisionServices()).allMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getInputs()).allMatch(node -> isInUnnamedImport(node, importingModel));
+        assertThat(importedModel.getItemDefinitions()).allMatch(node -> isInUnnamedImport(node, importingModel));
     }
 
     private void commonAddIfNotPresentFalse(String importingModelRef, String importedModelRef) throws IOException {
@@ -136,12 +136,11 @@ private void commonAddIfNotPresentFalse(String importingModelRef, String importe
         try (InputStream is = importedModelFileResource.openStream()) {
             String importedXml = new String(is.readAllBytes(), StandardCharsets.UTF_8);
             Definitions importedDefinitions = DMNMarshallerFactory.newDefaultMarshaller().unmarshal(importedXml);
-            importedDefinitions.getDecisionService().forEach(definition -> assertThat(added(importingDefinitions.getDecisionService(), definition)).isFalse());
-            importedDefinitions.getBusinessContextElement().forEach(definition -> assertThat(added(importingDefinitions.getBusinessContextElement(), definition)).isFalse());
-            importedDefinitions.getDrgElement().forEach(definition -> assertThat(added(importingDefinitions.getDrgElement(), definition)).isFalse());
-            importedDefinitions.getImport().forEach(definition -> assertThat(added(importingDefinitions.getImport(),
-                                                                                    definition)).isFalse());
-            importedDefinitions.getItemDefinition().forEach(definition -> assertThat(added(importingDefinitions.getItemDefinition(), definition)).isFalse());
+            assertThat(importedDefinitions.getDecisionService()).noneMatch(definition -> added(importingDefinitions.getDecisionService(), definition));
+            assertThat(importedDefinitions.getBusinessContextElement()).noneMatch(definition -> added(importingDefinitions.getBusinessContextElement(), definition));
+            assertThat(importedDefinitions.getDrgElement()).noneMatch(definition -> added(importingDefinitions.getDrgElement(), definition));
+            assertThat(importedDefinitions.getImport()).noneMatch(definition -> added(importingDefinitions.getImport(), definition));
+            assertThat(importedDefinitions.getItemDefinition()).noneMatch(definition -> added(importingDefinitions.getItemDefinition(), definition));
         }
     }
 
diff --git a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNModelImplTest.java b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNModelImplTest.java
index 7663612df49..8ec9697fa07 100644
--- a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNModelImplTest.java
+++ b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNModelImplTest.java
@@ -53,7 +53,7 @@ void addDecisionSameModel() {
             decisionNodeList.add(toAdd);
         });
 
-        decisionNodeList.forEach(decisionNode -> {
+        assertThat(decisionNodeList).allSatisfy(decisionNode -> {
             assertThat(model.getDecisionByName(decisionNode.getName()))
                     .isNotNull()
                     .isEqualTo(decisionNode);
@@ -72,7 +72,7 @@ void addDecisionWithoutIdSameModel() {
             decisionNodeList.add(toAdd);
         });
 
-        decisionNodeList.forEach(decisionNode ->
+        assertThat(decisionNodeList).allSatisfy(decisionNode ->
                                          assertThat(model.getDecisionByName(decisionNode.getName()))
                                                  .isNotNull()
                                                  .isEqualTo(decisionNode));
@@ -86,7 +86,7 @@ void addDecisionWithoutNameSameModel() {
             model.addDecision(toAdd);
             decisionNodeList.add(toAdd);
         });
-        decisionNodeList.forEach(decisionNode ->
+        assertThat(decisionNodeList).allSatisfy(decisionNode ->
                                          assertThat(model.getDecisionById(decisionNode.getId()))
                                                  .isNotNull()
                                                  .isEqualTo(decisionNode));
@@ -104,7 +104,7 @@ void addDecisionImportedModel() {
             decisionNodeList.add(toAdd);
         });
 
-        decisionNodeList.forEach(decisionNode -> {
+        assertThat(decisionNodeList).allSatisfy(decisionNode -> {
             assertThat(model.getDecisionByName(String.format("%s.%s", importedNameSpace, decisionNode.getName())))
                     .isNotNull()
                     .isEqualTo(decisionNode);
@@ -126,7 +126,7 @@ void addDecisionWithoutIdImportedModel() {
             decisionNodeList.add(toAdd);
         });
 
-        decisionNodeList.forEach(decisionNode ->
+        assertThat(decisionNodeList).allSatisfy(decisionNode ->
                                          assertThat(model.getDecisionByName(String.format("%s.%s", importedNameSpace, decisionNode.getName())))
                                                  .isNotNull()
                                                  .isEqualTo(decisionNode));
@@ -143,7 +143,7 @@ void addDecisionWithoutNameImportedModel() {
             model.addDecision(toAdd);
             decisionNodeList.add(toAdd);
         });
-        decisionNodeList.forEach(decisionNode ->
+        assertThat(decisionNodeList).allSatisfy(decisionNode ->
                                          assertThat(model.getDecisionById(String.format("%s#%s", importedNameSpace, decisionNode.getId())))
                                                  .isNotNull()
                                                  .isEqualTo(decisionNode));
diff --git a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/stronglytyped/DMNRuntimeTypesTest.java b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/stronglytyped/DMNRuntimeTypesTest.java
index 2e14a803bc3..f090219c183 100644
--- a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/stronglytyped/DMNRuntimeTypesTest.java
+++ b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/stronglytyped/DMNRuntimeTypesTest.java
@@ -1035,11 +1035,11 @@ void collectionOfCollectionOfCollection(VariantTestConf conf) {
             Map<String, Object> allProperties = outputSet.allFEELProperties();
             List<List<List<FEELPropertyAccessible>>> colCOut = (List<List<List<FEELPropertyAccessible>>>) allProperties.get("Decision-1");
             List<FEELPropertyAccessible>  personOutList = colCOut.stream().flatMap(colB -> colB.stream()).flatMap(colA -> colA.stream()).collect(Collectors.toList());
-            personOutList.stream().forEach(person -> assertPersonInDeepCol(person));
+            assertThat(personOutList).allSatisfy(person -> assertPersonInDeepCol(person));
         } else {
             List<List<List<Map<String, Object>>>> colCOut = (List<List<List<Map<String, Object>>>>)dmnResult.getContext().get("Decision-1");
             List<Map<String, Object>>  personOutList = colCOut.stream().flatMap(colB -> colB.stream()).flatMap(colA -> colA.stream()).collect(Collectors.toList());
-            personOutList.stream().forEach(person -> assertPersonMapInDeepCol(person));
+            assertThat(personOutList).allSatisfy(person -> assertPersonMapInDeepCol(person));
         }
     }
 
diff --git a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/BigDecimalRangeIteratorTest.java b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/BigDecimalRangeIteratorTest.java
index aec84884a5d..261e10bd5f9 100644
--- a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/BigDecimalRangeIteratorTest.java
+++ b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/BigDecimalRangeIteratorTest.java
@@ -19,9 +19,6 @@
 package org.kie.dmn.feel.lang.ast.forexpressioniterators;
 
 import java.math.BigDecimal;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.IntStream;
 
 import org.junit.jupiter.api.Test;
 
@@ -61,18 +58,17 @@ void hasNextDescendantTest() {
     void nextAscendantTest() {
         BigDecimal start = BigDecimal.valueOf(1);
         BigDecimal end = BigDecimal.valueOf(3);
-        List<BigDecimal> expected = Arrays.asList(BigDecimal.valueOf(1), BigDecimal.valueOf(2), BigDecimal.valueOf(3));
         BigDecimalRangeIterator iterator = new BigDecimalRangeIterator(start, end);
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iterator.next()));
+        
+        assertThat(iterator).toIterable().containsExactly(BigDecimal.valueOf(1), BigDecimal.valueOf(2), BigDecimal.valueOf(3));
     }
 
     @Test
     void nextDescendantTest() {
         BigDecimal start = BigDecimal.valueOf(3);
         BigDecimal end = BigDecimal.valueOf(1);
-        List<BigDecimal> expected = Arrays.asList(BigDecimal.valueOf(3), BigDecimal.valueOf(2), BigDecimal.valueOf(1));
         BigDecimalRangeIterator iterator = new BigDecimalRangeIterator(start, end);
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iterator.next()));
+        assertThat(iterator).toIterable().containsExactly(BigDecimal.valueOf(3), BigDecimal.valueOf(2), BigDecimal.valueOf(1));
     }
 
 
diff --git a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ForIterationTest.java b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ForIterationTest.java
index b9980f6f119..89ecdf56300 100644
--- a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ForIterationTest.java
+++ b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ForIterationTest.java
@@ -20,9 +20,6 @@
 
 import java.math.BigDecimal;
 import java.time.LocalDate;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.IntStream;
 
 import org.junit.jupiter.api.Test;
 
@@ -62,19 +59,21 @@ void hasNextValueLocalDateTest() {
     void getNextValueBigDecimalTest() {
         BigDecimal start = BigDecimal.valueOf(1);
         BigDecimal end = BigDecimal.valueOf(3);
-        List<BigDecimal> expected = Arrays.asList(BigDecimal.valueOf(1), BigDecimal.valueOf(2), BigDecimal.valueOf(3));
         ForIteration iteration = new ForIteration("iteration", start, end);
-        iteration.hasNextValue();
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iteration.getNextValue()));
+        assertThat(iteration.hasNextValue()).isTrue();
+        assertThat(iteration.getNextValue()).isEqualTo(BigDecimal.valueOf(1));
+        assertThat(iteration.getNextValue()).isEqualTo(BigDecimal.valueOf(2));
+        assertThat(iteration.getNextValue()).isEqualTo(BigDecimal.valueOf(3));
     }
 
     @Test
     void getNextValueLocalDateTest() {
         LocalDate start = LocalDate.of(2021, 1, 3);
         LocalDate end = LocalDate.of(2021, 1, 1);
-        List<LocalDate> expected = Arrays.asList(LocalDate.of(2021, 1, 3), LocalDate.of(2021, 1, 2), LocalDate.of(2021, 1, 1));
         ForIteration iteration = new ForIteration("iteration", start, end);
-        iteration.hasNextValue();
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iteration.getNextValue()));
+        assertThat(iteration.hasNextValue()).isTrue();
+        assertThat(iteration.getNextValue()).isEqualTo(LocalDate.of(2021, 1, 3));
+        assertThat(iteration.getNextValue()).isEqualTo(LocalDate.of(2021, 1, 2));
+        assertThat(iteration.getNextValue()).isEqualTo(LocalDate.of(2021, 1, 1));
     }
 }
\ No newline at end of file
diff --git a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/LocalDateRangeIteratorTest.java b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/LocalDateRangeIteratorTest.java
index 4add411f7f5..6f932c15d24 100644
--- a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/LocalDateRangeIteratorTest.java
+++ b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/LocalDateRangeIteratorTest.java
@@ -19,9 +19,6 @@
 package org.kie.dmn.feel.lang.ast.forexpressioniterators;
 
 import java.time.LocalDate;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.IntStream;
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -65,16 +62,14 @@ void hasNextDescendantTest() {
 
     @Test
     void nextAscendantTest() {
-        List<LocalDate> expected = Arrays.asList(LocalDate.of(2021, 1, 1), LocalDate.of(2021, 1, 2), LocalDate.of(2021, 1, 3));
         LocalDateRangeIterator iterator = new LocalDateRangeIterator(before, after);
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iterator.next()));
+        assertThat(iterator).toIterable().containsExactly(LocalDate.of(2021, 1, 1), LocalDate.of(2021, 1, 2), LocalDate.of(2021, 1, 3));
     }
 
     @Test
     void nextDescendantTest() {
-        List<LocalDate> expected = Arrays.asList(LocalDate.of(2021, 1, 3), LocalDate.of(2021, 1, 2), LocalDate.of(2021, 1, 1));
         LocalDateRangeIterator iterator = new LocalDateRangeIterator(after, before);
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iterator.next()));
+        assertThat(iterator).toIterable().containsExactly(LocalDate.of(2021, 1, 3), LocalDate.of(2021, 1, 2), LocalDate.of(2021, 1, 1));
     }
 
 
diff --git a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ZonedDateTimeRangeIteratorTest.java b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ZonedDateTimeRangeIteratorTest.java
index d8a1e8769ea..c11f203619a 100644
--- a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ZonedDateTimeRangeIteratorTest.java
+++ b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/lang/ast/forexpressioniterators/ZonedDateTimeRangeIteratorTest.java
@@ -21,9 +21,6 @@
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.IntStream;
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -68,20 +65,18 @@ void hasNextDescendantTest() {
 
     @Test
     void nextAscendantTest() {
-        List<ZonedDateTime> expected = Arrays.asList(getZonedDateTime(2021, 1, 1, 10, 15),
+        ZonedDateTimeRangeIterator iterator = new ZonedDateTimeRangeIterator(before, after);
+        assertThat(iterator).toIterable().containsExactly(getZonedDateTime(2021, 1, 1, 10, 15),
                 getZonedDateTime(2021, 1, 2, 10, 15),
                 getZonedDateTime(2021, 1, 3, 10, 15));
-        ZonedDateTimeRangeIterator iterator = new ZonedDateTimeRangeIterator(before, after);
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iterator.next()));
     }
 
     @Test
     void nextDescendantTest() {
-        List<ZonedDateTime> expected = Arrays.asList(getZonedDateTime(2021, 1, 3, 10, 15),
+        ZonedDateTimeRangeIterator iterator = new ZonedDateTimeRangeIterator(after, before);
+        assertThat(iterator).toIterable().containsExactly(getZonedDateTime(2021, 1, 3, 10, 15),
                 getZonedDateTime(2021, 1, 2, 10, 15),
                 getZonedDateTime(2021, 1, 1, 10, 15));
-        ZonedDateTimeRangeIterator iterator = new ZonedDateTimeRangeIterator(after, before);
-        IntStream.range(0, 3).forEach(i -> assertThat(expected.get(i)).isEqualTo(iterator.next()));
     }
 
 
diff --git a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/custom/ZoneTimeTest.java b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/custom/ZoneTimeTest.java
index f602e091051..26c49b8317c 100644
--- a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/custom/ZoneTimeTest.java
+++ b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/custom/ZoneTimeTest.java
@@ -30,7 +30,6 @@
 import java.time.temporal.TemporalAdjuster;
 import java.time.temporal.TemporalAmount;
 import java.time.temporal.TemporalQueries;
-import java.util.Arrays;
 
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -133,22 +132,18 @@ void until() {
 
     @Test
     void isSupportedTemporalUnit() {
-        for (ChronoUnit unit : ChronoUnit.values()) {
-            assertThat(zoneTime.isSupported(unit)).isEqualTo(offsetTime.isSupported(unit));
-        }
+    	assertThat(ChronoUnit.values()).allMatch(unit -> zoneTime.isSupported(unit) == offsetTime.isSupported(unit));
     }
 
     @Test
     void isSupportedTemporalField() {
-        for (ChronoField field : ChronoField.values()) {
-            assertThat(zoneTime.isSupported(field)).isEqualTo(offsetTime.isSupported(field));
-        }
+    	assertThat(ChronoField.values()).allMatch(field -> zoneTime.isSupported(field) == offsetTime.isSupported(field));
     }
 
     @Test
     void getLong() {
-        Arrays.stream(ChronoField.values()).filter(offsetTime::isSupported)
-                .forEach(field -> assertThat(offsetTime.getLong(field)).isEqualTo(zoneTime.getLong(field)));
+        assertThat(ChronoField.values()).filteredOn(offsetTime::isSupported)
+                .allMatch(field -> offsetTime.getLong(field) == (zoneTime.getLong(field)));
     }
 
     @Test
@@ -167,16 +162,16 @@ void query() {
 
     @Test
     void range() {
-        Arrays.stream(ChronoField.values()).filter(offsetTime::isSupported)
-                .forEach(field -> assertThat(offsetTime.range(field)).isEqualTo(zoneTime.range(field)));
+        assertThat(ChronoField.values()).filteredOn(offsetTime::isSupported)
+                .allMatch(field -> offsetTime.range(field).equals(zoneTime.range(field)));
     }
 
     @Test
     void get() {
-        Arrays.stream(ChronoField.values())
-                .filter(offsetTime::isSupported)
-                .filter(field -> field != ChronoField.NANO_OF_DAY && field != ChronoField.MICRO_OF_DAY) // Unsupported by offsettime.get()
-                .forEach(field -> assertThat(offsetTime.get(field)).isEqualTo(zoneTime.get(field)));
+    	assertThat(ChronoField.values())
+                .filteredOn(offsetTime::isSupported)
+                .filteredOn(field -> field != ChronoField.NANO_OF_DAY && field != ChronoField.MICRO_OF_DAY) // Unsupported by offsettime.get()
+                .allMatch(field -> offsetTime.get(field) == zoneTime.get(field));
     }
 
     @Test
diff --git a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/functions/BaseFEELFunctionTest.java b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/functions/BaseFEELFunctionTest.java
index 6b221f7a30b..f5deff2214d 100644
--- a/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/functions/BaseFEELFunctionTest.java
+++ b/kie-dmn/kie-dmn-feel/src/test/java/org/kie/dmn/feel/runtime/functions/BaseFEELFunctionTest.java
@@ -101,8 +101,8 @@ void getAllFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         Parameter[] parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(1);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(List.class);
+        assertThat(parametersRetrieved).hasSize(1);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(List.class);
 
         // invoke(@ParameterName( "b" ) Object[] list)
         parameters = new Object[]{true, false};
@@ -114,8 +114,8 @@ void getAllFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(1);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(Object.class.arrayType());
+        assertThat(parametersRetrieved).hasSize(1);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(Object.class.arrayType());
     }
 
     @Test
@@ -132,8 +132,8 @@ void getDateAndTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         Parameter[] parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(1);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(String.class);
+        assertThat(parametersRetrieved).hasSize(1);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(String.class);
 
         // invoke(@ParameterName( "date" ) TemporalAccessor date, @ParameterName( "time" ) TemporalAccessor time)
         parameters = new Object[]{LocalDate.of(2017, 6, 12), LocalTime.of(10, 6, 20)};
@@ -145,8 +145,8 @@ void getDateAndTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(2);
-        Arrays.stream(parametersRetrieved).forEach(parameter -> assertThat(TemporalAccessor.class).isEqualTo(parameter.getType()));
+        assertThat(parametersRetrieved).hasSize(2);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(TemporalAccessor.class, TemporalAccessor.class);
 
 
 //        invoke(@ParameterName( "year" ) Number year, @ParameterName( "month" ) Number month, @ParameterName( "day"
@@ -162,8 +162,9 @@ void getDateAndTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(6);
-        Arrays.stream(parametersRetrieved).forEach(parameter -> assertThat(Number.class).isEqualTo(parameter.getType()));
+        assertThat(parametersRetrieved).hasSize(6);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(Number.class, Number.class, Number.class, 
+        		Number.class, Number.class, Number.class);
 
 //        invoke(@ParameterName( "year" ) Number year, @ParameterName( "month" ) Number month, @ParameterName( "day"
 //        ) Number day,
@@ -179,8 +180,9 @@ void getDateAndTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(7);
-        Arrays.stream(parametersRetrieved).forEach(parameter -> assertThat(Number.class).isEqualTo(parameter.getType()));
+        assertThat(parametersRetrieved).hasSize(7);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(Number.class, Number.class, Number.class, 
+        		Number.class, Number.class, Number.class, Number.class);
 
 //        invoke(@ParameterName( "year" ) Number year, @ParameterName( "month" ) Number month, @ParameterName( "day"
 //        ) Number day,
@@ -196,11 +198,9 @@ void getDateAndTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(7);
-        for (int i = 0; i < 6; i++) {
-            assertThat(parametersRetrieved[i].getType()).isEqualTo(Number.class);
-        }
-        assertThat(parametersRetrieved[6].getType()).isEqualTo(String.class);
+        assertThat(parametersRetrieved).hasSize(7);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(Number.class, Number.class, Number.class, 
+        		Number.class, Number.class, Number.class, String.class);
     }
 
     @Test
@@ -217,8 +217,8 @@ void getExtendedTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         Parameter[] parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(1);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(String.class);
+        assertThat(parametersRetrieved).hasSize(1);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(String.class);
 
 //      invoke(
 //            @ParameterName("hour") Number hour, @ParameterName("minute") Number minute,
@@ -232,8 +232,8 @@ void getExtendedTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(3);
-        Arrays.stream(parametersRetrieved).forEach(parameter -> assertThat(Number.class).isEqualTo(parameter.getType()));
+        assertThat(parametersRetrieved).hasSize(3);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(Number.class, Number.class, Number.class);
 
 //     invoke(
 //            @ParameterName("hour") Number hour, @ParameterName("minute") Number minute,
@@ -247,11 +247,10 @@ void getExtendedTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(4);
-        for (int i = 0; i < 3; i++) {
-            assertThat(parametersRetrieved[i].getType()).isEqualTo(Number.class);
-        }
-        assertThat(parametersRetrieved[3].getType()).isEqualTo(Duration.class);
+        assertThat(parametersRetrieved).hasSize(4);
+        
+        assertThat(parametersRetrieved).extracting("type").containsExactly(Number.class, Number.class, Number.class, Duration.class);
+
 
 //      invoke(@ParameterName("from") TemporalAccessor date
         parameters = new Object[]{LocalTime.of(10, 6, 20)};
@@ -263,8 +262,8 @@ void getExtendedTimeFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(1);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(TemporalAccessor.class);
+        assertThat(parametersRetrieved).hasSize(1);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(TemporalAccessor.class);
     }
 
     @Test
@@ -283,10 +282,8 @@ void getSortFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         Parameter[] parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(3);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(EvaluationContext.class);
-        assertThat(parametersRetrieved[1].getType()).isEqualTo(List.class);
-        assertThat(parametersRetrieved[2].getType()).isEqualTo(FEELFunction.class);
+        assertThat(parametersRetrieved).hasSize(3);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(EvaluationContext.class, List.class, FEELFunction.class);
 
         // invoke(@ParameterName("list") List list)
         parameters = new Object[]{List.of(1, 3, 5)};
@@ -298,8 +295,8 @@ void getSortFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(1);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(List.class);
+        assertThat(parametersRetrieved).hasSize(1);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(List.class);
     }
 
     @Test
@@ -317,8 +314,8 @@ void getStddevFunctionCandidateMethod() {
         assertThat(retrieved.getName()).isEqualTo("invoke");
         Parameter[] parametersRetrieved = retrieved.getParameters();
         assertThat(parametersRetrieved).isNotNull();
-        assertThat(parametersRetrieved.length).isEqualTo(1);
-        assertThat(parametersRetrieved[0].getType()).isEqualTo(List.class);
+        assertThat(parametersRetrieved).hasSize(1);
+        assertThat(parametersRetrieved).extracting("type").containsExactly(List.class);
     }
 
 }
\ No newline at end of file
diff --git a/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/EnumGenerationTest.java b/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/EnumGenerationTest.java
index f0604cd5000..9c2c11accb8 100644
--- a/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/EnumGenerationTest.java
+++ b/kie-dmn/kie-dmn-openapi/src/test/java/org/kie/dmn/openapi/EnumGenerationTest.java
@@ -60,7 +60,8 @@ void numberAllowedValues() {
         ArrayNode arrayNode = (ArrayNode) node.get("enum");
         assertThat(arrayNode).isNotNull();
         List<BigDecimal> expected = Arrays.asList(BigDecimal.ZERO, BigDecimal.ONE, BigDecimal.valueOf(2));
-        arrayNode.iterator().forEachRemaining(e -> {
+        
+        assertThat(arrayNode).allSatisfy(e -> {
             assertThat(e).isInstanceOf(DecimalNode.class);
             assertThat(expected).contains(e.decimalValue());
         });
@@ -75,7 +76,7 @@ void stringAllowedValues() {
         ArrayNode arrayNode = (ArrayNode) node.get("enum");
         assertThat(arrayNode).isNotNull();
         List<String> expected = Arrays.asList("a", "b", "c");
-        arrayNode.iterator().forEachRemaining(e -> {
+        assertThat(arrayNode).allSatisfy(e -> {
             assertThat(e).isInstanceOf(TextNode.class);
             assertThat(expected).contains(e.textValue());
         });
@@ -90,7 +91,7 @@ void stringNullableAllowedValues() {
         ArrayNode arrayNode = (ArrayNode) node.get("enum");
         assertThat(arrayNode).isNotNull();
         List<String> expected = Arrays.asList("a", "b", "c", null);
-        arrayNode.iterator().forEachRemaining(e -> {
+        assertThat(arrayNode).allSatisfy(e -> {
             assertThat(expected).contains(e.textValue());
         });
         assertThat(node.get("nullable")).isNotNull().isInstanceOf(BooleanNode.class);
@@ -104,7 +105,7 @@ void numberTypeConstraint() {
         ArrayNode arrayNode = (ArrayNode) node.get("enum");
         assertThat(arrayNode).isNotNull();
         List<BigDecimal> expected = Arrays.asList(BigDecimal.ZERO, BigDecimal.ONE, BigDecimal.valueOf(2));
-        arrayNode.iterator().forEachRemaining(e -> {
+        assertThat(arrayNode).allSatisfy(e -> {
             assertThat(e).isInstanceOf(DecimalNode.class);
             assertThat(expected).contains(e.decimalValue());
         });
@@ -119,7 +120,7 @@ void stringTypeConstraint() {
         ArrayNode arrayNode = (ArrayNode) node.get("enum");
         assertThat(arrayNode).isNotNull();
         List<String> expected = Arrays.asList("a", "b", "c");
-        arrayNode.iterator().forEachRemaining(e -> {
+        assertThat(arrayNode).allSatisfy(e -> {
             assertThat(e).isInstanceOf(TextNode.class);
             assertThat(expected).contains(e.textValue());
         });
@@ -133,10 +134,9 @@ void stringNullableTypeConstraint() {
         assertThat(node).isNotNull();
         ArrayNode arrayNode = (ArrayNode) node.get("enum");
         assertThat(arrayNode).isNotNull();
-        List<String> expected = Arrays.asList("a", "b", "c", null);
-        arrayNode.iterator().forEachRemaining(e -> {
-            assertThat(expected).contains(e.textValue());
-        });
+        
+        assertThat(arrayNode).extracting(node1 -> node1.textValue()).containsExactlyInAnyOrder("a", "b", "c", null);
+
         assertThat(node.get("nullable")).isNotNull().isInstanceOf(BooleanNode.class);
         assertThat(node.get("nullable").asBoolean()).isTrue();
     }