Reversed parameter positions in ExtensionValuesStore according to tea…

…m decision
junit-team · Jan 19, 2016 · c59bfae · c59bfae
1 parent affc4be
commit c59bfae
Show file tree

Hide file tree

Showing 3 changed files with 63 additions and 63 deletions.
diff --git a/...tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStoreTest.java b/...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,22 +102,22 @@ 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
 		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/...t5-engine/src/main/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStore.java b/...t5-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<Object, Object> defaultCreator, Namespace namespace) {
-		StoredValue storedValue = getStoredValue(key, namespace);
+	public Object getOrComputeIfAbsent(Namespace namespace, Object key, Function<Object, Object> 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
@@ -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<Object, Object> 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);
 	}
 }