From c59bfae8162a8a1049a45edfe6613357c625770e Mon Sep 17 00:00:00 2001 From: Johannes Link Date: Tue, 19 Jan 2016 15:45:13 +0100 Subject: [PATCH] Reversed parameter positions in ExtensionValuesStore according to team decision --- .../descriptor/ExtensionValuesStoreTest.java | 88 +++++++++---------- .../descriptor/ExtensionValuesStore.java | 30 +++---- .../junit5/descriptor/NamespacedStore.java | 8 +- 3 files changed, 63 insertions(+), 63 deletions(-) diff --git a/junit-tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStoreTest.java b/junit-tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStoreTest.java index 4c9488b7845..0b2efd466d1 100644 --- a/junit-tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStoreTest.java +++ b/junit-tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStoreTest.java @@ -42,56 +42,56 @@ class StoringValuesTests { @Test void getWithUnknownKeyReturnsNull() { - assertNull(store.get("unknown key", namespace)); + assertNull(store.get(namespace, "unknown key")); } @Test void putAndGetWithSameKey() { - store.put(key, value, namespace); - assertEquals(value, store.get(key, namespace)); + store.put(namespace, key, value); + assertEquals(value, store.get(namespace, key)); } @Test void valueCanBeReplaced() { - store.put(key, value, namespace); + store.put(namespace, key, value); Object newValue = new Object(); - store.put(key, newValue, namespace); + store.put(namespace, key, newValue); - assertEquals(newValue, store.get(key, namespace)); + assertEquals(newValue, store.get(namespace, key)); } @Test void valueIsComputedIfAbsent() { - assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> value, namespace)); - assertEquals(value, store.get(key, namespace)); + assertEquals(value, store.getOrComputeIfAbsent(namespace, key, innerKey -> value)); + assertEquals(value, store.get(namespace, key)); } @Test void valueIsNotComputedIfPresent() { - store.put(key, value, namespace); + store.put(namespace, key, value); - assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> "a different value", namespace)); - assertEquals(value, store.get(key, namespace)); + assertEquals(value, store.getOrComputeIfAbsent(namespace, key, innerKey -> "a different value")); + assertEquals(value, store.get(namespace, key)); } @Test void nullIsAValidValueToPut() { - store.put(key, null, namespace); + store.put(namespace, key, null); - assertEquals(null, store.getOrComputeIfAbsent(key, innerKey -> "a different value", namespace)); - assertEquals(null, store.get(key, namespace)); + assertEquals(null, store.getOrComputeIfAbsent(namespace, key, innerKey -> "a different value")); + assertEquals(null, store.get(namespace, key)); } @Test void keysCanBeRemoved() { - store.put(key, value, namespace); - assertEquals(value, store.remove(key, namespace)); + store.put(namespace, key, value); + assertEquals(value, store.remove(namespace, key)); - assertNull(store.get(key, namespace)); + assertNull(store.get(namespace, key)); assertEquals("a different value", - store.getOrComputeIfAbsent(key, innerKey -> "a different value", namespace)); + store.getOrComputeIfAbsent(namespace, key, innerKey -> "a different value")); } @Test @@ -102,11 +102,11 @@ void sameKeyWithDifferentNamespaces() { Object value2 = createObject("value2"); Namespace namespace2 = Namespace.of("ns2"); - store.put(key, value1, namespace1); - store.put(key, value2, namespace2); + store.put(namespace1, key, value1); + store.put(namespace2, key, value2); - assertEquals(value1, store.get(key, namespace1)); - assertEquals(value2, store.get(key, namespace2)); + assertEquals(value1, store.get(namespace1, key)); + assertEquals(value2, store.get(namespace2, key)); } @Test @@ -114,10 +114,10 @@ void valueIsComputedIfAbsentInDifferentNamespace() { Namespace namespace1 = Namespace.of("ns1"); Namespace namespace2 = Namespace.of("ns2"); - assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> value, namespace1)); - assertEquals(value, store.get(key, namespace1)); + assertEquals(value, store.getOrComputeIfAbsent(namespace1, key, innerKey -> value)); + assertEquals(value, store.get(namespace1, key)); - assertNull(store.get(key, namespace2)); + assertNull(store.get(namespace2, key)); } @Test @@ -128,12 +128,12 @@ void keyIsOnlyRemovedInGivenNamespace() { Object value1 = createObject("value1"); Object value2 = createObject("value2"); - store.put(key, value1, namespace1); - store.put(key, value2, namespace2); - store.remove(key, namespace1); + store.put(namespace1, key, value1); + store.put(namespace2, key, value2); + store.remove(namespace1, key); - assertNull(store.get(key, namespace1)); - assertEquals(value2, store.get(key, namespace2)); + assertNull(store.get(namespace1, key)); + assertEquals(value2, store.get(namespace2, key)); } } @@ -143,19 +143,19 @@ class InheritedValuesTests { @Test void valueFromParentIsVisible() { - parentStore.put(key, value, namespace); - assertEquals(value, store.get(key, namespace)); + parentStore.put(namespace, key, value); + assertEquals(value, store.get(namespace, key)); } @Test void valueFromParentCanBeOverriddenInChild() { - parentStore.put(key, value, namespace); + parentStore.put(namespace, key, value); Object otherValue = new Object(); - store.put(key, otherValue, namespace); - assertEquals(otherValue, store.get(key, namespace)); + store.put(namespace, key, otherValue); + assertEquals(otherValue, store.get(namespace, key)); - assertEquals(value, parentStore.get(key, namespace)); + assertEquals(value, parentStore.get(namespace, key)); } } @@ -171,12 +171,12 @@ void additionNamespacePartMakesADifferenc() { Object value2 = createObject("value2"); - parentStore.put(key, value, ns1); - parentStore.put(key, value2, ns2); + parentStore.put(ns1, key, value); + parentStore.put(ns2, key, value2); - assertEquals(value, store.get(key, ns1)); - assertEquals(value, store.get(key, ns3)); - assertEquals(value2, store.get(key, ns2)); + assertEquals(value, store.get(ns1, key)); + assertEquals(value, store.get(ns3, key)); + assertEquals(value2, store.get(ns2, key)); } @Test @@ -185,10 +185,10 @@ void orderOfNamespacePartsDoesNotMatter() { Namespace ns1 = Namespace.of("part1", "part2"); Namespace ns2 = Namespace.of("part2", "part1"); - parentStore.put(key, value, ns1); + parentStore.put(ns1, key, value); - assertEquals(value, store.get(key, ns1)); - assertEquals(value, store.get(key, ns2)); + assertEquals(value, store.get(ns1, key)); + assertEquals(value, store.get(ns2, key)); } } diff --git a/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStore.java b/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStore.java index 97eebf2235a..b8fd206e063 100644 --- a/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStore.java +++ b/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStore.java @@ -34,44 +34,44 @@ public ExtensionValuesStore(ExtensionValuesStore parentStore) { this.parentStore = parentStore; } - public Object get(Object key, Namespace namespace) { - StoredValue storedValue = getStoredValue(key, namespace); + public Object get(Namespace namespace, Object key) { + StoredValue storedValue = getStoredValue(namespace, key); if (storedValue != null) return storedValue.value; else if (parentStore != null) - return parentStore.get(key, namespace); + return parentStore.get(namespace, key); else return null; } - private StoredValue getStoredValue(Object key, Namespace namespace) { - ComposedKey composedKey = new ComposedKey(key, namespace); + private StoredValue getStoredValue(Namespace namespace, Object key) { + ComposedKey composedKey = new ComposedKey(namespace, key); return storedValues.get(composedKey); } - public void put(Object key, Object value, Namespace namespace) { + public void put(Namespace namespace, Object key, Object value) { Preconditions.notNull(key, "A key must not be null"); Preconditions.notNull(namespace, "A namespace must not be null"); - putStoredValue(key, namespace, new StoredValue(value)); + putStoredValue(namespace, key, new StoredValue(value)); } - private void putStoredValue(Object key, Namespace namespace, StoredValue storedValue) { - ComposedKey composedKey = new ComposedKey(key, namespace); + private void putStoredValue(Namespace namespace, Object key, StoredValue storedValue) { + ComposedKey composedKey = new ComposedKey(namespace, key); storedValues.put(composedKey, storedValue); } - public Object getOrComputeIfAbsent(Object key, Function defaultCreator, Namespace namespace) { - StoredValue storedValue = getStoredValue(key, namespace); + public Object getOrComputeIfAbsent(Namespace namespace, Object key, Function defaultCreator) { + StoredValue storedValue = getStoredValue(namespace, key); if (storedValue == null) { storedValue = new StoredValue(defaultCreator.apply(key)); - putStoredValue(key, namespace, storedValue); + putStoredValue(namespace, key, storedValue); } return storedValue.value; } - public Object remove(Object key, Namespace namespace) { - ComposedKey composedKey = new ComposedKey(key, namespace); + public Object remove(Namespace namespace, Object key) { + ComposedKey composedKey = new ComposedKey(namespace, key); StoredValue previous = storedValues.remove(composedKey); return (previous != null ? previous.value : null); } @@ -81,7 +81,7 @@ private static class ComposedKey { private final Object key; private final Namespace namespace; - private ComposedKey(Object key, Namespace namespace) { + private ComposedKey(Namespace namespace, Object key) { this.key = key; this.namespace = namespace; } diff --git a/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/NamespacedStore.java b/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/NamespacedStore.java index 6e0ba62515b..1a5fa914ebc 100644 --- a/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/NamespacedStore.java +++ b/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/NamespacedStore.java @@ -26,21 +26,21 @@ public NamespacedStore(ExtensionValuesStore valuesStore, Namespace namespace) { @Override public Object get(Object key) { - return valuesStore.get(key, namespace); + return valuesStore.get(namespace, key); } @Override public void put(Object key, Object value) { - valuesStore.put(key, value, namespace); + valuesStore.put(namespace, key, value); } @Override public Object getOrComputeIfAbsent(Object key, Function defaultCreator) { - return valuesStore.getOrComputeIfAbsent(key, defaultCreator, namespace); + return valuesStore.getOrComputeIfAbsent(namespace, key, defaultCreator); } @Override public Object remove(Object key) { - return valuesStore.remove(key, namespace); + return valuesStore.remove(namespace, key); } }