You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by ah...@apache.org on 2020/02/22 06:29:57 UTC
[isis] branch master updated: ISIS-2297: covers _Arrays
This is an automated email from the ASF dual-hosted git repository.
ahuber pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/isis.git
The following commit(s) were added to refs/heads/master by this push:
new 0606b7f ISIS-2297: covers _Arrays
0606b7f is described below
commit 0606b7fcdfe83910e17b3cd143e8397f1ccf12c5
Author: Andi Huber <ah...@apache.org>
AuthorDate: Sat Feb 22 07:29:46 2020 +0100
ISIS-2297: covers _Arrays
---
.../core/commons/internal/collections/_Arrays.java | 13 +-
.../commons/internal/collections/_ArraysTest.java | 358 ++++++++++++++++++++-
.../metamodel/services/ServiceInjectorLegacy.java | 2 +-
3 files changed, 362 insertions(+), 11 deletions(-)
diff --git a/core/commons/src/main/java/org/apache/isis/core/commons/internal/collections/_Arrays.java b/core/commons/src/main/java/org/apache/isis/core/commons/internal/collections/_Arrays.java
index 88d718a..6ce6c79 100644
--- a/core/commons/src/main/java/org/apache/isis/core/commons/internal/collections/_Arrays.java
+++ b/core/commons/src/main/java/org/apache/isis/core/commons/internal/collections/_Arrays.java
@@ -36,6 +36,7 @@ import org.apache.isis.core.commons.internal.base._With;
import lombok.NonNull;
import lombok.val;
+import lombok.experimental.UtilityClass;
/**
* <h1>- internal use only -</h1>
@@ -49,10 +50,9 @@ import lombok.val;
*
* @since 2.0
*/
+@UtilityClass
public final class _Arrays {
- private _Arrays(){}
-
// -- PREDICATES
/**
@@ -179,7 +179,7 @@ public final class _Arrays {
* @return (non-null)
*/
@SafeVarargs
- public static <T, X extends T, Y extends T> T[] combine(Class<T> type, X first, @Nullable Y... rest) {
+ public static <T, X extends T, Y extends T> T[] combineWithExplicitType(Class<T> type, X first, @Nullable Y... rest) {
_With.requires(type, "type");
_With.requires(first, "first");
final int restLength = _NullSafe.size(rest);
@@ -237,9 +237,10 @@ public final class _Arrays {
*/
public static <T> T[] toArray(@Nullable final Iterable<? extends T> iterable, final Class<T> componentType) {
_With.requires(componentType, "componentType");
- if(iterable!=null && (iterable instanceof Collection)) {
- return toArray((Collection<? extends T>) iterable, componentType);
- }
+// unnecessary optimization
+// if(iterable!=null && (iterable instanceof Collection)) {
+// return toArray((Collection<? extends T>) iterable, componentType);
+// }
return _NullSafe.stream(iterable)
.collect(toArray(componentType));
}
diff --git a/core/commons/src/test/java/org/apache/isis/core/commons/internal/collections/_ArraysTest.java b/core/commons/src/test/java/org/apache/isis/core/commons/internal/collections/_ArraysTest.java
index d2e3c1d..780f5e2 100644
--- a/core/commons/src/test/java/org/apache/isis/core/commons/internal/collections/_ArraysTest.java
+++ b/core/commons/src/test/java/org/apache/isis/core/commons/internal/collections/_ArraysTest.java
@@ -18,15 +18,293 @@
*/
package org.apache.isis.core.commons.internal.collections;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.apache.isis.core.commons.internal.base._NullSafe;
import lombok.val;
+/**
+ * @since Feb 22, 2020
+ *
+ */
class _ArraysTest {
+ private List<Integer[]> inputSamples;
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @BeforeEach
+ void setUp() throws Exception {
+
+ inputSamples = _Lists.of(
+ null,
+ new Integer[] {},
+ new Integer[] {0, 1, 2, 3},
+ new Integer[] {1, 2, 3, 4}
+ );
+
+ }
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @AfterEach
+ void tearDown() throws Exception {
+ }
+
+ @FunctionalInterface
+ public interface IndexedBiConsumer<T, U> {
+ void accept(int i, int j, T t, U u);
+ }
+
+ static class FiniteSpace2 {
+
+ static void visit(
+ List<Integer[]> as,
+ List<Integer[]> bs,
+ IndexedBiConsumer<Integer[], Integer[]> probe) {
+ int i=0;
+ for(val a : as) {
+ int j=0;
+ for(val b : bs) {
+ probe.accept(i, j++, a, b);
+ }
+ i++;
+ }
+ }
+ }
+
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#testAnyMatch(T[], T[], java.util.function.BiPredicate)}.
+ */
+ @Test
+ void testTestAnyMatch() {
+
+ FiniteSpace2.visit(inputSamples, inputSamples, (i, j, a, b)->{
+ if(_NullSafe.size(a) != _NullSafe.size(b)) {
+
+ assertThrows(IllegalArgumentException.class,
+ ()->_Arrays.testAnyMatch(a, b, Objects::equals));
+
+ } else if(_NullSafe.size(a) * _NullSafe.size(b) == 0
+ || i!=j) {
+ assertFalse(_Arrays.testAnyMatch(a, b, Objects::equals));
+ } else {
+ // i==j
+ assertEquals(i, j);
+ assertTrue(_Arrays.testAnyMatch(a, b, Objects::equals));
+ }
+ });
+
+ assertTrue(_Arrays.testAnyMatch(
+ new Integer[] {0, 1, 2, 9},
+ new Integer[] {1, 2, 3, 9},
+ Objects::equals));
+
+ assertFalse(_Arrays.testAnyMatch(
+ new Integer[] {0, 1, 2, 3},
+ new Integer[] {1, 2, 3, 4},
+ Objects::equals));
+
+
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#testAllMatch(T[], T[], java.util.function.BiPredicate)}.
+ */
+ @Test
+ void testTestAllMatch() {
+
+ FiniteSpace2.visit(inputSamples, inputSamples, (i, j, a, b)->{
+ if(_NullSafe.size(a) != _NullSafe.size(b)) {
+
+ assertThrows(IllegalArgumentException.class,
+ ()->_Arrays.testAllMatch(a, b, Objects::equals));
+
+ } else if(_NullSafe.size(a) * _NullSafe.size(b) == 0) {
+ assertTrue(_Arrays.testAllMatch(a, b, Objects::equals));
+ } else if(i!=j) {
+ assertFalse(_Arrays.testAllMatch(a, b, Objects::equals));
+ } else {
+ // i==j
+ assertEquals(i, j);
+ assertTrue(_Arrays.testAllMatch(a, b, Objects::equals));
+ }
+ });
+
+ assertFalse(_Arrays.testAllMatch(
+ new Integer[] {0, 1, 2, 9},
+ new Integer[] {1, 2, 3, 9},
+ Objects::equals));
+
+ assertFalse(_Arrays.testAllMatch(
+ new Integer[] {0, 1, 2, 3},
+ new Integer[] {1, 2, 3, 4},
+ Objects::equals));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#isArrayType(java.lang.Class)}.
+ */
+ @Test
+ void testIsArrayType() {
+ assertFalse(_Arrays.isArrayType(null));
+ assertFalse(_Arrays.isArrayType(Integer.class));
+ assertFalse(_Arrays.isArrayType(Enum.class));
+ assertFalse(_Arrays.isArrayType(Collection.class));
+ assertFalse(_Arrays.isArrayType(List.class));
+ assertFalse(_Arrays.isArrayType(Set.class));
+
+ assertTrue(_Arrays.isArrayType(int[].class));
+ assertTrue(_Arrays.isArrayType(int[][].class));
+ assertTrue(_Arrays.isArrayType(Object[][].class));
+
+ IntStream.of(1,2,3)
+ .mapToObj(inputSamples::get)
+ .map(Object::getClass)
+ .forEach(type->assertTrue(_Arrays.isArrayType(type)));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#isCollectionOrArrayType(java.lang.Class)}.
+ */
+ @Test
+ void testIsCollectionOrArrayType() {
+ assertFalse(_Arrays.isCollectionOrArrayType(null));
+ assertFalse(_Arrays.isCollectionOrArrayType(Integer.class));
+ assertFalse(_Arrays.isCollectionOrArrayType(Enum.class));
+
+ assertTrue(_Arrays.isCollectionOrArrayType(Collection.class));
+ assertTrue(_Arrays.isCollectionOrArrayType(List.class));
+ assertTrue(_Arrays.isCollectionOrArrayType(Set.class));
+ assertTrue(_Arrays.isCollectionOrArrayType(int[].class));
+ assertTrue(_Arrays.isCollectionOrArrayType(int[][].class));
+ assertTrue(_Arrays.isCollectionOrArrayType(Object[][].class));
+
+ IntStream.of(1,2,3)
+ .mapToObj(inputSamples::get)
+ .map(Object::getClass)
+ .forEach(type->assertTrue(_Arrays.isCollectionOrArrayType(type)));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#toArray(java.lang.Class, int)}.
+ */
+ @Test
+ void testToArrayClassOfTInt() {
+
+ assertArrayEquals( new Integer[] {1, 2, 3},
+ Stream.of(1,2,3)
+ .collect(_Arrays.toArray(Integer.class, 3)));
+
+ assertArrayEquals( new Integer[] {1, 2, 3, null},
+ Stream.of(1,2,3)
+ .collect(_Arrays.toArray(Integer.class, 4)));
+
+ assertThrows(Exception.class, ()->
+ Stream.of(1,2,3)
+ .collect(_Arrays.toArray(Integer.class, 2)));
+
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#toArray(java.lang.Class)}.
+ */
+ @Test
+ void testToArrayClassOfT() {
+
+ assertArrayEquals( new Integer[] {1, 2, 3},
+ Stream.of(1,2,3)
+ .collect(_Arrays.toArray(Integer.class)));
+
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#combine(java.lang.Object, T[])}.
+ */
+ @Test
+ void testCombineTTArray() {
+
+ assertArrayEquals(new Integer[]{1}, _Arrays.combine(1));
+ assertArrayEquals(new Integer[]{1, 2}, _Arrays.combine(1, 2));
+ assertArrayEquals(new Integer[]{1, 2, 3}, _Arrays.combine(1, 2, 3));
+ assertArrayEquals(new Integer[]{1, 2, 3, 4}, _Arrays.combine(1, 2, 3, 4));
+
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#combineWithExplicitType(java.lang.Class, java.lang.Object, Y[])}.
+ */
+ @Test
+ void testCombineClassOfTXYArray() {
+ assertArrayEquals(new Number[]{1L, 2L}, _Arrays.combineWithExplicitType(Number.class, 1L, 2L));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#combine(T[], T[])}.
+ */
+ @Test
+ void testCombineTArrayTArray() {
+
+ assertArrayEquals(new Integer[]{}, _Arrays.combine(new Integer[]{}));
+ assertArrayEquals(new Integer[]{1, 2}, _Arrays.combine(new Integer[]{1, 2}));
+ assertArrayEquals(new Integer[]{1, 2, 3}, _Arrays.combine(new Integer[]{1, 2}, 3));
+ assertArrayEquals(new Integer[]{1, 2, 3, 4}, _Arrays.combine(new Integer[]{1, 2}, 3, 4));
+
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#toArray(java.util.Collection, java.lang.Class)}.
+ */
+ @Test
+ void testToArrayCollectionOfQextendsTClassOfT() {
+
+ assertArrayEquals( new Integer[] {1, 2, 3},
+ _Arrays.toArray(Arrays.asList(1,2,3), Integer.class) );
+
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#toArray(java.lang.Iterable, java.lang.Class)}.
+ */
+ @Test
+ void testToArrayIterableOfQextendsTClassOfT() {
+
+ val iterable = new Iterable<Integer>() {
+ @Override
+ public Iterator<Integer> iterator() {
+ return Arrays.asList(1,2,3).iterator();
+ }
+ };
+
+ assertArrayEquals( new Integer[] {1, 2, 3},
+ _Arrays.toArray(iterable, Integer.class) );
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#removeByIndex(T[], int)}.
+ */
@Test
void removeByIndex_head() {
val input = new Integer[] {0, 1, 2, 3};
@@ -68,7 +346,79 @@ class _ArraysTest {
assertThrows(IllegalArgumentException.class,
()->_Arrays.removeByIndex(input, 0));
}
-
-
-
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#emptyToNull(T[])}.
+ */
+ @Test
+ void testEmptyToNull() {
+ assertEquals(null, _Arrays.emptyToNull(null));
+ assertEquals(null, _Arrays.emptyToNull(new Integer[] {}));
+ assertArrayEquals(new Integer[] {1}, _Arrays.emptyToNull(new Integer[] {1}));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#inferComponentTypeIfAny(java.lang.Class)}.
+ */
+ @Test
+ void testInferComponentTypeIfAny() {
+ assertEquals(null, _Arrays.inferComponentTypeIfAny(null));
+ assertEquals(int.class, _Arrays.inferComponentTypeIfAny(int[].class));
+ assertEquals(Integer.class, _Arrays.inferComponentTypeIfAny(Integer[].class));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#get(T[], int)}.
+ */
+ @Test
+ void testGet() {
+
+ assertEquals(Optional.empty(), _Arrays.get(null, 99));
+ assertEquals(Optional.empty(), _Arrays.get(new Integer[] {}, 0));
+
+ assertEquals(Optional.empty(), _Arrays.get(new Integer[] {1}, 99));
+ assertEquals(Optional.of(1), _Arrays.get(new Integer[] {1}, 0));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#map(T[], java.lang.Class, java.util.function.Function)}.
+ */
+ @Test
+ void testMapTArrayClassOfRFunctionOfTR() {
+ assertEquals(null, _Arrays.map((Integer[])null, Long.class, Long::valueOf));
+ assertArrayEquals(new Long[] {}, _Arrays.map(new Integer[] {}, Long.class, Long::valueOf));
+ assertArrayEquals(new Long[] {1L, 2L, 3L}, _Arrays.map(new Integer[] {1, 2, 3}, Long.class, Long::valueOf));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#map(T[], java.util.function.Function)}.
+ */
+ @Test
+ void testMapTArrayFunctionOfTQ() {
+ assertEquals(null, _Arrays.map((Integer[])null, Long::valueOf));
+ assertArrayEquals(new Long[] {}, _Arrays.map(new Integer[] {}, Long::valueOf));
+ assertArrayEquals(new Long[] {1L, 2L, 3L}, _Arrays.map(new Integer[] {1, 2, 3}, Long::valueOf));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#mapCollection(java.util.Collection, java.lang.Class, java.util.function.Function)}.
+ */
+ @Test
+ void testMapCollectionCollectionOfTClassOfRFunctionOfTR() {
+ assertEquals(null, _Arrays.mapCollection((List<Integer>)null, Long.class, Long::valueOf));
+ assertArrayEquals(new Long[] {}, _Arrays.mapCollection(Arrays.<Integer>asList(), Long.class, Long::valueOf));
+ assertArrayEquals(new Long[] {1L, 2L, 3L}, _Arrays.mapCollection(Arrays.asList(1,2,3), Long.class, Long::valueOf));
+ }
+
+ /**
+ * Test method for {@link org.apache.isis.core.commons.internal.collections._Arrays#mapCollection(java.util.Collection, java.util.function.Function)}.
+ */
+ @Test
+ void testMapCollectionCollectionOfTFunctionOfTQ() {
+ assertEquals(null, _Arrays.mapCollection((List<Integer>)null, Long::valueOf));
+ assertArrayEquals(new Long[] {}, _Arrays.mapCollection(Arrays.<Integer>asList(), Long::valueOf));
+ assertArrayEquals(new Long[] {1L, 2L, 3L}, _Arrays.mapCollection(Arrays.asList(1,2,3), Long::valueOf));
+
+ }
+
}
diff --git a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServiceInjectorLegacy.java b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServiceInjectorLegacy.java
index 37139d0..36cdea4 100644
--- a/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServiceInjectorLegacy.java
+++ b/core/metamodel/src/test/java/org/apache/isis/core/metamodel/services/ServiceInjectorLegacy.java
@@ -135,7 +135,7 @@ public class ServiceInjectorLegacy implements ServiceInjector {
invokeInjectorField(field, targetPojo, bean);
} else {
- val requiredAnnotations = _Arrays.combine(
+ val requiredAnnotations = _Arrays.combineWithExplicitType(
Annotation.class,
_Constants.ANNOTATION_PRIMARY,
field.getAnnotations());