add rewrite-maven-plugin

Signed-off-by: dbulahov <bulahovdenis@gmail.com>

Author: dbulahov

common/src/test/java/org/eclipse/daanse/olap/calc/base/type/tuplebase/ArrayTupleListTest.java

@@ -13,9 +13,9 @@
  */
 package org.eclipse.daanse.olap.calc.base.type.tuplebase;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.ListAssert.assertThatList;
-import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.eclipse.daanse.olap.api.element.Member;
 import org.eclipse.daanse.olap.common.ResourceLimitExceededException;
@@ -29,7 +29,7 @@
 class ArrayTupleListTest {
 
     @AfterEach
-    public void afterEach() {
+    void afterEach() {
         SystemWideProperties.instance().populateInitial();
     }
 
@@ -48,8 +48,8 @@ void addOverInitialCapacity() {
         atlList = new ArrayTupleList(2, 10);
         addTuplesToList(atlList, count);
 
-        assertThatList(atlList).hasSize(count).anySatisfy(tuple -> assertEquals(tuple.get(0), m1))
-                .anySatisfy(tuple -> assertEquals(tuple.get(1), m2));
+        assertThatList(atlList).hasSize(count).anySatisfy(tuple -> assertThat(m1).isEqualTo(tuple.get(0)))
+                .anySatisfy(tuple -> assertThat(m2).isEqualTo(tuple.get(1)));
     }
 
     @Test

common/src/test/java/org/eclipse/daanse/olap/fun/sort/PartialSortTest.java

@@ -29,8 +29,7 @@
 
 package org.eclipse.daanse.olap.fun.sort;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.Arrays;
 import java.util.Comparator;
@@ -164,7 +163,7 @@ private static <T> boolean isPartiallySorted(T[] vec, int limit, Comparator<? su
 
     // validate the predicate isPartiallySorted()
     @Test
-    void testPredicate1() {
+    void predicate1() {
         int errct = 0;
         int size = 10 * 1000;
         int[] vec = new int[size];
@@ -229,12 +228,12 @@ void testPredicate1() {
             errct++;
         }
 
-        assertTrue(errct == 0);
+        assertThat(errct).isEqualTo(0);
     }
 
     // same as testPredicate() but boxed
     @Test
-    void testPredicate2() {
+    void predicate2() {
         int errct = 0;
         int size = 10 * 1000;
         Integer[] vec = new Integer[size];
@@ -300,21 +299,21 @@ void testPredicate2() {
             errct++;
         }
 
-        assertTrue(errct == 0);
+        assertThat(errct).isEqualTo(0);
     }
 
     @Test
-    void testQuick() {
+    void quick() {
         final int length = 40;
         final int limit = 4;
         Integer[] vec = newRandomIntegers(length, 0, length);
         // sort descending
         doPartialSort(vec, true, limit);
-        assertTrue(isPartiallySorted(vec, limit, true));
+        assertThat(isPartiallySorted(vec, limit, true)).isTrue();
     }
 
     @Test
-    void testOnAlreadySorted() {
+    void onAlreadySorted() {
         final int length = 200;
         final int limit = 8;
         Integer[] vec = new Integer[length];
@@ -323,11 +322,11 @@ void testOnAlreadySorted() {
         }
         // sort ascending
         doPartialSort(vec, false, limit);
-        assertTrue(isPartiallySorted(vec, limit, false));
+        assertThat(isPartiallySorted(vec, limit, false)).isTrue();
     }
 
     @Test
-    void testOnAlreadyReverseSorted() {
+    void onAlreadyReverseSorted() {
         final int length = 200;
         final int limit = 8;
         Integer[] vec = new Integer[length];
@@ -336,43 +335,43 @@ void testOnAlreadyReverseSorted() {
         }
         // sort ascending
         doPartialSort(vec, false, limit);
-        assertTrue(isPartiallySorted(vec, limit, false));
+        assertThat(isPartiallySorted(vec, limit, false)).isTrue();
     }
 
     // tests partial sort on arras of random integers
     private void randomIntegerTests(int length, int limit) {
         Integer[] vec = newRandomIntegers(length, 0, length);
         // sort descending
         doPartialSort(vec, true, limit);
-        assertTrue(isPartiallySorted(vec, limit, true));
+        assertThat(isPartiallySorted(vec, limit, true)).isTrue();
 
         // sort ascending
         vec = newRandomIntegers(length, 0, length);
         doPartialSort(vec, false, limit);
-        assertTrue(isPartiallySorted(vec, limit, false));
+        assertThat(isPartiallySorted(vec, limit, false)).isTrue();
 
         // both again with a wider range of values
         vec = newRandomIntegers(length, 10, 4 * length);
         doPartialSort(vec, true, limit);
-        assertTrue(isPartiallySorted(vec, limit, true));
+        assertThat(isPartiallySorted(vec, limit, true)).isTrue();
 
         vec = newRandomIntegers(length, 10, 4 * length);
         doPartialSort(vec, false, limit);
-        assertTrue(isPartiallySorted(vec, limit, false));
+        assertThat(isPartiallySorted(vec, limit, false)).isTrue();
 
         // and again with a narrower range values
         vec = newRandomIntegers(length, 0, length / 10);
         doPartialSort(vec, true, limit);
-        assertTrue(isPartiallySorted(vec, limit, true));
+        assertThat(isPartiallySorted(vec, limit, true)).isTrue();
 
         vec = newRandomIntegers(length, 0, length / 10);
         doPartialSort(vec, false, limit);
-        assertTrue(isPartiallySorted(vec, limit, false));
+        assertThat(isPartiallySorted(vec, limit, false)).isTrue();
     }
 
     // test correctness
     @Test
-    void testOnRandomIntegers() {
+    void onRandomIntegers() {
         randomIntegerTests(100, 20);
         randomIntegerTests(50000, 10);
         randomIntegerTests(50000, 500);
@@ -381,7 +380,7 @@ void testOnRandomIntegers() {
 
     // test with large vector
     @Test
-    void testOnManyRandomIntegers() {
+    void onManyRandomIntegers() {
         randomIntegerTests(1000 * 1000, 5000);
         randomIntegerTests(1000 * 1000, 10);
     }
@@ -445,64 +444,64 @@ private Item[] doStablePartialSort(Item[] vec, boolean desc, int limit) {
     }
 
     @Test
-    void testPredicateIsStablySorted() {
+    void predicateIsStablySorted() {
         Item[] vec = newPartlySortedItems(24, 4, false);
-        assertTrue(Item.isStablySorted(vec, 4, false));
-        assertFalse(Item.isStablySorted(vec, 4, true));
+        assertThat(Item.isStablySorted(vec, 4, false)).isTrue();
+        assertThat(Item.isStablySorted(vec, 4, true)).isFalse();
 
         vec = newPartlySortedItems(24, 8, true);
-        assertTrue(Item.isStablySorted(vec, 4, true));
-        assertFalse(Item.isStablySorted(vec, 4, false));
+        assertThat(Item.isStablySorted(vec, 4, true)).isTrue();
+        assertThat(Item.isStablySorted(vec, 4, false)).isFalse();
 
         vec = newPartlySortedItems(1000, 100, true);
-        assertTrue(Item.isStablySorted(vec, 100, true));
-        assertTrue(Item.isStablySorted(vec, 20, true));
-        assertTrue(Item.isStablySorted(vec, 4, true));
+        assertThat(Item.isStablySorted(vec, 100, true)).isTrue();
+        assertThat(Item.isStablySorted(vec, 20, true)).isTrue();
+        assertThat(Item.isStablySorted(vec, 4, true)).isTrue();
     }
 
     @Test
-    void testStableQuick() {
+    void stableQuick() {
         final int length = 40;
         final int limit = 4;
         Item[] vec = newRandomItems(length, 0, length);
         // sort descending
         vec = doStablePartialSort(vec, true, limit);
-        assertTrue(Item.isStablySorted(vec, limit, true));
+        assertThat(Item.isStablySorted(vec, limit, true)).isTrue();
     }
 
     // tests stable partial sort on arras of random Items
     private void randomItemTests(int length, int limit) {
         Item[] vec = newRandomItems(length, 0, length);
         // sort descending
         vec = doStablePartialSort(vec, true, limit);
-        assertTrue(Item.isStablySorted(vec, limit, true));
+        assertThat(Item.isStablySorted(vec, limit, true)).isTrue();
 
         // sort ascending
         vec = newRandomItems(length, 0, length);
         vec = doStablePartialSort(vec, false, limit);
-        assertTrue(Item.isStablySorted(vec, limit, false));
+        assertThat(Item.isStablySorted(vec, limit, false)).isTrue();
 
         // both again with a wider range of values
         vec = newRandomItems(length, 10, 4 * length);
         vec = doStablePartialSort(vec, true, limit);
-        assertTrue(Item.isStablySorted(vec, limit, true));
+        assertThat(Item.isStablySorted(vec, limit, true)).isTrue();
 
         vec = newRandomItems(length, 10, 4 * length);
         vec = doStablePartialSort(vec, false, limit);
-        assertTrue(Item.isStablySorted(vec, limit, false));
+        assertThat(Item.isStablySorted(vec, limit, false)).isTrue();
 
         // and again with a narrower range values
         vec = newRandomItems(length, 0, length / 10);
         vec = doStablePartialSort(vec, true, limit);
-        assertTrue(Item.isStablySorted(vec, limit, true));
+        assertThat(Item.isStablySorted(vec, limit, true)).isTrue();
 
         vec = newRandomItems(length, 0, length / 10);
         vec = doStablePartialSort(vec, false, limit);
-        assertTrue(Item.isStablySorted(vec, limit, false));
+        assertThat(Item.isStablySorted(vec, limit, false)).isTrue();
     }
 
     @Test
-    void testStableOnRandomItems() {
+    void stableOnRandomItems() {
         randomItemTests(100, 20);
         randomItemTests(50000, 10);
         randomItemTests(50000, 500);
@@ -553,7 +552,7 @@ private void speedTest(Logger logger, int length, int limit) {
 
     // compare speed on different sizes of input
     @Test
-    void testSpeed() {
+    void speed() {
         if (!LOGGER.isDebugEnabled()) {
             return;
         }

common/src/test/java/org/eclipse/daanse/olap/fun/sort/SorterTest.java

@@ -31,7 +31,6 @@
 import static java.util.Arrays.asList;
 import static java.util.stream.IntStream.range;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
@@ -56,6 +55,7 @@
 import org.eclipse.daanse.olap.function.def.member.memberorderkey.MemberOrderKeyCalc;
 import org.eclipse.daanse.olap.query.component.QueryImpl;
 import org.eclipse.daanse.olap.server.ExecutionImpl;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
@@ -65,6 +65,8 @@
 
 class SorterTest {
 
+    private AutoCloseable mocks;
+
     @Mock
     Evaluator evaluator;
     @Mock
@@ -103,9 +105,9 @@ class SorterTest {
     ArgumentCaptor<Comparator<?>> comparatorCaptor;
 
     @BeforeEach
-    public void setUp() throws Exception {
+    void setUp() throws Exception {
 
-        MockitoAnnotations.initMocks(this);
+        mocks = MockitoAnnotations.openMocks(this);
         when(sortKeySpec1.getKey()).thenReturn(calc1);
         when(sortKeySpec2.getKey()).thenReturn(calc2);
         when(evaluator.getQuery()).thenReturn(query);
@@ -129,7 +131,7 @@ public void setUp() throws Exception {
     // |Not-OrderByKey| BreakTupleComparator|HierarchicalTupleComparator |
     // +--------------+---------------------+------------------------------+
     @Test
-    void testComparatorSelectionBrkOrderByKey() {
+    void comparatorSelectionBrkOrderByKey() {
         setupSortKeyMocks(true, Sorter.SorterFlag.BASC, Sorter.SorterFlag.BDESC);
         Sorter.applySortSpecToComparator(evaluator, 2, comparatorChain, sortKeySpec1);
         Sorter.applySortSpecToComparator(evaluator, 2, comparatorChain, sortKeySpec2);
@@ -144,7 +146,7 @@ void testComparatorSelectionBrkOrderByKey() {
     }
 
     @Test
-    void testComparatorSelectionBrkNotOrderByKey() {
+    void comparatorSelectionBrkNotOrderByKey() {
         setupSortKeyMocks(false, Sorter.SorterFlag.BASC, Sorter.SorterFlag.BDESC);
         Sorter.applySortSpecToComparator(evaluator, 2, comparatorChain, sortKeySpec1);
         Sorter.applySortSpecToComparator(evaluator, 2, comparatorChain, sortKeySpec2);
@@ -160,7 +162,7 @@ void testComparatorSelectionBrkNotOrderByKey() {
     }
 
     @Test
-    void testComparatorSelectionNotBreakingOrderByKey() {
+    void comparatorSelectionNotBreakingOrderByKey() {
         calc1 = mock(MemberOrderKeyCalc.class);
         calc2 = mock(MemberOrderKeyCalc.class);
         when(sortKeySpec1.getKey()).thenReturn(calc1);
@@ -180,19 +182,19 @@ void testComparatorSelectionNotBreakingOrderByKey() {
     }
 
     @Test
-    void testComparatorSelectionNotBreaking() {
+    void comparatorSelectionNotBreaking() {
         setupSortKeyMocks(false, Sorter.SorterFlag.ASC, Sorter.SorterFlag.DESC);
         Sorter.applySortSpecToComparator(evaluator, 2, comparatorChain, sortKeySpec1);
         Sorter.applySortSpecToComparator(evaluator, 2, comparatorChain, sortKeySpec2);
         verify(comparatorChain, times(2)).thenComparing(comparatorCaptor.capture());
 
 //    verify( comparatorChain, times( 2 ) ).addComparator( comparatorCaptor.capture(), eq( false ) );
-        assertTrue(comparatorCaptor.getAllValues().get(0) instanceof HierarchicalTupleComparator);
-        assertTrue(comparatorCaptor.getAllValues().get(1) instanceof HierarchicalTupleComparator);
+        assertThat(comparatorCaptor.getAllValues().get(0)).isInstanceOf(HierarchicalTupleComparator.class);
+        assertThat(comparatorCaptor.getAllValues().get(1)).isInstanceOf(HierarchicalTupleComparator.class);
     }
 
     @Test
-    void testSortTuplesBreakingByKey() {
+    void sortTuplesBreakingByKey() {
         TupleList tupleList = genList();
         setupSortKeyMocks(true, Sorter.SorterFlag.BASC, Sorter.SorterFlag.BDESC);
 
@@ -203,11 +205,11 @@ void testSortTuplesBreakingByKey() {
         verify(calc1, atLeastOnce()).dependsOn(hierarchy2);
         verify(calc2, atLeastOnce()).dependsOn(hierarchy2);
         verify(calc2, atLeastOnce()).dependsOn(hierarchy1);
-        assertTrue(result.size() == 1000);
+        assertThat(result.size()).isEqualTo(1000);
     }
 
     @Test
-    void testCancel() {
+    void cancel() {
         setupSortKeyMocks(true, Sorter.SorterFlag.ASC, Sorter.SorterFlag.DESC);
         // pass in a null tupleList, and an iterable. cancel should be checked while
         // generating the list
@@ -244,4 +246,9 @@ private TupleList genList() {
         return tupleList;
     }
 
+    @AfterEach
+    void tearDown() throws Exception {
+        mocks.close();
+    }
+
 }