Improve OffsetMapTemplate error reporting

Include a human-readable message when we throw an IAE.

JIRA: YANGTOOLS-1550
Change-Id: I7acb3e9b23ed20a00551435ce68c68d138a052e6
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableMapTemplate.java b/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableMapTemplate.java
index fb74c31244dee1b79b9ac1ac54ffa0f67991eb27..089b6011450c95d2ef5ff7fd17e2886bdc21e74e 100644 (file)
--- a/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableMapTemplate.java
+++ b/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableMapTemplate.java
@@ -113,4 +113,10 @@ public abstract sealed class ImmutableMapTemplate<K> implements Immutable
         checkArgument(value != null, "Transformer returned null for input %s at key %s", input, key);
         return value;
     }
+
+    static void checkSize(final int expected, final int encountered) {
+        if (expected != encountered) {
+            throw new IllegalArgumentException("Expected " + expected + " items, " + encountered + " encountered");
+        }
+    }
 }

diff --git a/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableOffsetMapTemplate.java b/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableOffsetMapTemplate.java
index 438c38aaa62ea84a22ad6273d24c7e981e3d7092..553641eef5db3dbe6dd59be6a3123499af043a3c 100644 (file)
--- a/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableOffsetMapTemplate.java
+++ b/common/util/src/main/java/org/opendaylight/yangtools/util/ImmutableOffsetMapTemplate.java
@@ -7,16 +7,13 @@
  */
 package org.opendaylight.yangtools.util;
 
-import static com.google.common.base.Preconditions.checkArgument;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableMap;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Set;
 import java.util.function.BiFunction;
@@ -71,7 +68,7 @@ public abstract sealed class ImmutableOffsetMapTemplate<K> extends ImmutableMapT
      * @throws IllegalArgumentException if {@code keys} is does not have at least two keys
      */
     public static <K> @NonNull ImmutableOffsetMapTemplate<K> ordered(final Collection<K> keys) {
-        checkArgument(keys.size() > 1);
+        checkTwoKeys(keys);
         return new Ordered<>(keys);
     }
 
@@ -87,7 +84,7 @@ public abstract sealed class ImmutableOffsetMapTemplate<K> extends ImmutableMapT
      * @throws IllegalArgumentException if {@code keys} is does not have at least two keys
      */
     public static <K> @NonNull ImmutableOffsetMapTemplate<K> unordered(final Collection<K> keys) {
-        checkArgument(keys.size() > 1);
+        checkTwoKeys(keys);
         return new Unordered<>(keys);
     }
 
@@ -100,31 +97,31 @@ public abstract sealed class ImmutableOffsetMapTemplate<K> extends ImmutableMapT
     public final <T, V> @NonNull ImmutableOffsetMap<K, V> instantiateTransformed(final Map<K, T> fromMap,
             final BiFunction<K, T, V> valueTransformer) {
         final int size = offsets.size();
-        checkArgument(fromMap.size() == size);
+        checkSize(size, fromMap.size());
 
         @SuppressWarnings("unchecked")
-        final V[] objects = (V[]) new Object[size];
-        for (Entry<K, T> entry : fromMap.entrySet()) {
-            final K key = requireNonNull(entry.getKey());
+        final var objects = (V[]) new Object[size];
+        for (var entry : fromMap.entrySet()) {
+            final var key = requireNonNull(entry.getKey());
             objects[offsetOf(key)] = transformValue(key, entry.getValue(), valueTransformer);
         }
 
         return createMap(offsets, objects);
     }
 
-    @SuppressFBWarnings(value = "NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE",
-        justification = "SpotBugs does not grok checkArgument()")
     private int offsetOf(final K key) {
-        final Integer offset = offsets.get(key);
-        checkArgument(offset != null, "Key %s present in input, but not in offsets %s", key, offsets);
+        final var offset = offsets.get(key);
+        if (offset == null) {
+            throw new IllegalArgumentException("Key " + key + " present in input, but not in offsets " + offsets);
+        }
         return offset;
     }
 
     @Override
     @SafeVarargs
-    public final <V> @NonNull ImmutableOffsetMap<K, V> instantiateWithValues(final V... values) {
-        checkArgument(values.length == offsets.size());
-        final V[] copy = values.clone();
+    public final <V> ImmutableOffsetMap<K, V> instantiateWithValues(final V... values) {
+        checkSize(offsets.size(), values.length);
+        final var copy = values.clone();
         Arrays.stream(copy).forEach(Objects::requireNonNull);
         return createMap(offsets, values);
     }
@@ -135,4 +132,11 @@ public abstract sealed class ImmutableOffsetMapTemplate<K> extends ImmutableMapT
     }
 
     abstract <V> @NonNull ImmutableOffsetMap<K, V> createMap(ImmutableMap<K, Integer> offsets, V[] objects);
+
+    private static void checkTwoKeys(final Collection<?> keys) {
+        final var size = keys.size();
+        if (size < 2) {
+            throw new IllegalArgumentException("Expected at least 2 keys, " + size + " supplied");
+        }
+    }
 }
\ No newline at end of file

diff --git a/common/util/src/main/java/org/opendaylight/yangtools/util/SharedSingletonMapTemplate.java b/common/util/src/main/java/org/opendaylight/yangtools/util/SharedSingletonMapTemplate.java
index dd12b65264ec25a82878f5a7d692bd445b8fef1b..b3f97539f0d58f8b0bdfa0784436a25a91c6339b 100644 (file)
--- a/common/util/src/main/java/org/opendaylight/yangtools/util/SharedSingletonMapTemplate.java
+++ b/common/util/src/main/java/org/opendaylight/yangtools/util/SharedSingletonMapTemplate.java
@@ -7,12 +7,8 @@
  */
 package org.opendaylight.yangtools.util;
 
-import static com.google.common.base.Preconditions.checkArgument;
-
 import com.google.common.base.MoreObjects;
-import java.util.Iterator;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.function.BiFunction;
 import org.eclipse.jdt.annotation.NonNull;
 
@@ -49,7 +45,7 @@ public abstract sealed class SharedSingletonMapTemplate<K> extends ImmutableMapT
     private final @NonNull SingletonSet<K> keySet;
 
     private SharedSingletonMapTemplate(final K key) {
-        this.keySet = SharedSingletonMap.cachedSet(key);
+        keySet = SharedSingletonMap.cachedSet(key);
     }
 
     /**
@@ -86,23 +82,29 @@ public abstract sealed class SharedSingletonMapTemplate<K> extends ImmutableMapT
     @Override
     public final <T, V> @NonNull SharedSingletonMap<K, V> instantiateTransformed(final Map<K, T> fromMap,
             final BiFunction<K, T, V> valueTransformer) {
-        final Iterator<Entry<K, T>> it = fromMap.entrySet().iterator();
-        checkArgument(it.hasNext(), "Input is empty while expecting 1 item");
+        final var it = fromMap.entrySet().iterator();
+        if (!it.hasNext()) {
+            throw new IllegalArgumentException("Input is empty while expecting 1 item");
+        }
 
-        final Entry<K, T> entry = it.next();
-        final K expected = keySet.getElement();
-        final K actual = entry.getKey();
-        checkArgument(expected.equals(actual), "Unexpected key %s, expecting %s", actual, expected);
+        final var entry = it.next();
+        final var expected = keySet.getElement();
+        final var actual = entry.getKey();
+        if (!expected.equals(actual)) {
+            throw new IllegalArgumentException("Unexpected key " + actual + ", expecting " + expected);
+        }
 
-        final V value = transformValue(actual, entry.getValue(), valueTransformer);
-        checkArgument(!it.hasNext(), "Input has more than one item");
+        final var value = transformValue(actual, entry.getValue(), valueTransformer);
+        if (it.hasNext()) {
+            throw new IllegalArgumentException("Input has more than one item");
+        }
         return instantiateWithValue(value);
     }
 
     @Override
     @SafeVarargs
     public final <V> @NonNull SharedSingletonMap<K, V> instantiateWithValues(final V... values) {
-        checkArgument(values.length == 1);
+        checkSize(1, values.length);
         return instantiateWithValue(values[0]);
     }