summaryrefslogtreecommitdiffstats
path: root/model/utilities
diff options
context:
space:
mode:
Diffstat (limited to 'model/utilities')
-rw-r--r--model/utilities/src/main/java/org/onap/policy/apex/model/utilities/TreeMapUtils.java48
-rw-r--r--model/utilities/src/test/java/org/onap/policy/apex/model/utilities/TreeMapUtilsTest.java99
2 files changed, 133 insertions, 14 deletions
diff --git a/model/utilities/src/main/java/org/onap/policy/apex/model/utilities/TreeMapUtils.java b/model/utilities/src/main/java/org/onap/policy/apex/model/utilities/TreeMapUtils.java
index 6daa6864a..3f369c0e0 100644
--- a/model/utilities/src/main/java/org/onap/policy/apex/model/utilities/TreeMapUtils.java
+++ b/model/utilities/src/main/java/org/onap/policy/apex/model/utilities/TreeMapUtils.java
@@ -23,7 +23,9 @@ package org.onap.policy.apex.model.utilities;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
+import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import lombok.AccessLevel;
@@ -75,4 +77,50 @@ public final class TreeMapUtils {
}
return foundNodes;
}
+
+ /**
+ * Compares two maps.
+ * @param <K> Key type
+ * @param <V> Value type
+ * @param leftMap left map
+ * @param rightMap right map
+ * @return an integer indicating how different the maps are
+ */
+ @SuppressWarnings("unchecked")
+ public static <K, V> int compareMaps(Map<? extends Comparable<K>, ? extends Comparable<V>> leftMap,
+ Map<? extends Comparable<K>, ? extends Comparable<V>> rightMap) {
+ if (leftMap == rightMap) {
+ return 0;
+ }
+
+ Iterator<?> leftIt = leftMap.entrySet().iterator();
+ Iterator<?> rightIt = rightMap.entrySet().iterator();
+
+ while (leftIt.hasNext() && rightIt.hasNext()) {
+ Map.Entry<?, ?> leftEntry = (Entry<?, ?>) leftIt.next();
+ Map.Entry<?, ?> rightEntry = (Entry<?, ?>) rightIt.next();
+
+ K leftKey = (K) leftEntry.getKey();
+ K rightKey = (K) rightEntry.getKey();
+ int result = ((Comparable<K>) leftKey).compareTo(rightKey);
+ if (result != 0) {
+ return result;
+ }
+
+ V leftValue = (V) leftEntry.getValue();
+ V rightValue = (V) rightEntry.getValue();
+ result = ((Comparable<V>) leftValue).compareTo(rightValue);
+ if (result != 0) {
+ return result;
+ }
+ }
+
+ if (leftIt.hasNext()) {
+ return 1;
+ } else if (rightIt.hasNext()) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
}
diff --git a/model/utilities/src/test/java/org/onap/policy/apex/model/utilities/TreeMapUtilsTest.java b/model/utilities/src/test/java/org/onap/policy/apex/model/utilities/TreeMapUtilsTest.java
index 7da3f9c47..c3a36b7b9 100644
--- a/model/utilities/src/test/java/org/onap/policy/apex/model/utilities/TreeMapUtilsTest.java
+++ b/model/utilities/src/test/java/org/onap/policy/apex/model/utilities/TreeMapUtilsTest.java
@@ -1,28 +1,31 @@
/*
* ============LICENSE_START=======================================================
* Copyright (C) 2016-2018 Ericsson. All rights reserved.
+ * Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* 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
* ============LICENSE_END=========================================================
*/
package org.onap.policy.apex.model.utilities;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import org.junit.Test;
@@ -33,8 +36,16 @@ import org.junit.Test;
*/
public class TreeMapUtilsTest {
+ private static final int KEY1 = 10;
+ private static final int KEY2 = 20;
+ private static final int KEY3 = 30;
+ private static final String VALUE1 = "a-one";
+ private static final String VALUE2 = "b-two";
+ private static final String VALUE3 = "c-three";
+ private static final String VALUE4 = "d-four";
+
@Test
- public void test() {
+ public void testFindMatchingEntries() {
TreeMap<String, String> testTreeMap = new TreeMap<String, String>();
testTreeMap.put("G", "G");
testTreeMap.put("H", "H");
@@ -43,7 +54,7 @@ public class TreeMapUtilsTest {
testTreeMap.put("JOE", "JOE");
testTreeMap.put("JOSH", "JOSH");
testTreeMap.put("K", "K");
-
+
List<Entry<String, String>> foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "F");
assertEquals(0, foundKeyList.size());
@@ -52,35 +63,95 @@ public class TreeMapUtilsTest {
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "H");
assertEquals("H", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "I");
assertEquals(0, foundKeyList.size());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "J");
assertEquals("JA", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "JA");
assertEquals("JA", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "JB");
assertEquals(0, foundKeyList.size());
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "JO");
assertEquals("JOE", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "JOE");
assertEquals("JOE", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "JOS");
assertEquals("JOSH", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "JOSH");
assertEquals("JOSH", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "K");
assertEquals("K", foundKeyList.get(0).getKey());
-
+
foundKeyList = TreeMapUtils.findMatchingEntries(testTreeMap, "L");
assertEquals(0, foundKeyList.size());
}
+
+ @Test
+ public void testCompareMaps() {
+ Map<Integer, String> map1 = Map.of();
+ Map<Integer, String> map2 = Map.of();
+
+ // note: using TreeMap so we can control the ordering of the entries
+
+ // compare with self
+ assertThat(TreeMapUtils.compareMaps(map1, map1)).isZero();
+
+ // two empty maps
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isZero();
+
+ // same content
+ map1 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2, KEY3, VALUE3));
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2, KEY3, VALUE3));
+ assertThat(TreeMapUtils.compareMaps(map1, map1)).isZero();
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isZero();
+
+ // one is shorter than the other
+ map1 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2, KEY3, VALUE3));
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1));
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isPositive();
+ assertThat(TreeMapUtils.compareMaps(map2, map1)).isNegative();
+
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2));
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isPositive();
+ assertThat(TreeMapUtils.compareMaps(map2, map1)).isNegative();
+
+ // first key is different
+ map1 = new TreeMap<>(Map.of(KEY3, VALUE1, KEY2, VALUE2));
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2));
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isPositive();
+ assertThat(TreeMapUtils.compareMaps(map2, map1)).isNegative();
+
+ // second key is different
+ map1 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY3, VALUE2));
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2));
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isPositive();
+ assertThat(TreeMapUtils.compareMaps(map2, map1)).isNegative();
+
+ // first value is different
+ map1 = new TreeMap<>(Map.of(KEY1, VALUE4, KEY2, VALUE2, KEY3, VALUE3));
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2, KEY3, VALUE3));
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isPositive();
+ assertThat(TreeMapUtils.compareMaps(map2, map1)).isNegative();
+
+ // second value is different
+ map1 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE4, KEY3, VALUE3));
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2, KEY3, VALUE3));
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isPositive();
+ assertThat(TreeMapUtils.compareMaps(map2, map1)).isNegative();
+
+ // third value is different
+ map1 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2, KEY3, VALUE4));
+ map2 = new TreeMap<>(Map.of(KEY1, VALUE1, KEY2, VALUE2, KEY3, VALUE3));
+ assertThat(TreeMapUtils.compareMaps(map1, map2)).isPositive();
+ assertThat(TreeMapUtils.compareMaps(map2, map1)).isNegative();
+ }
}