DefaultAsyncAtomicValue testing
Change-Id: Ie9ee38ca21e54d6a2ae3c6a6dc16cb37e03740b0
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValue.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValue.java
index cd27a5b..87823e5 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValue.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValue.java
@@ -65,6 +65,16 @@
this.monitor = new MeteringAgent(COMPONENT_NAME, name, true);
}
+ //Bypass osgi error with 'activated' MeteringAgent parameter set to false
+ DefaultAsyncAtomicValue(String name, Serializer serializer, AsyncConsistentMap<String, byte[]> backingMap,
+ MeteringAgent meteringAgent) {
+ this.name = checkNotNull(name, "name must not be null");
+ this.serializer = checkNotNull(serializer, "serializer must not be null");
+ this.backingMap = checkNotNull(backingMap, "backingMap must not be null");
+ this.monitor = meteringAgent;
+
+ }
+
@Override
public String name() {
return name;
diff --git a/core/store/primitives/src/test/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValueTest.java b/core/store/primitives/src/test/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValueTest.java
new file mode 100644
index 0000000..86db3a3
--- /dev/null
+++ b/core/store/primitives/src/test/java/org/onosproject/store/primitives/impl/DefaultAsyncAtomicValueTest.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.
+ */
+package org.onosproject.store.primitives.impl;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.util.Tools;
+import org.onosproject.store.primitives.MapUpdate;
+import org.onosproject.store.primitives.TransactionId;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.AsyncConsistentMap;
+import org.onosproject.store.service.MapEventListener;
+import org.onosproject.store.service.Serializer;
+import org.onosproject.store.service.TransactionLog;
+import org.onosproject.store.service.Version;
+import org.onosproject.store.service.Versioned;
+import org.onosproject.utils.MeteringAgent;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+
+
+public class DefaultAsyncAtomicValueTest {
+ DefaultAsyncAtomicValue defaultAsyncAtomicValue;
+ DefaultAsyncAtomicValue defaultAsyncAtomicValue1;
+
+
+ private AsyncConsistentMap<String, byte[]> asyncMap;
+ private Map<String, Versioned<byte[]>> map;
+
+ private Serializer serializer;
+ private MeteringAgent meteringAgent;
+
+
+ private static final String NAME = "atomicValue";
+ private static final String NAME1 = "atomicValue1";
+ private static final String TEST = "foo";
+ private static final String TEST1 = "bar";
+ private static final int INTNAME = 20;
+ private static final long VERSION1 = 1;
+
+ private final byte[] value1 = Tools.getBytesUtf8(NAME);
+ private final byte[] value2 = Tools.getBytesUtf8(NAME1);
+ private final byte[] value3 = Tools.getBytesUtf8("tester");
+ private final byte[] defaultValue = Tools.getBytesUtf8("default");
+
+ @Before
+ public void setUp() throws Exception {
+ map = new HashMap<>();
+ asyncMap = new AsyncConsistentMap<String, byte[]>() {
+ @Override
+ public CompletableFuture<Integer> size() {
+ return CompletableFuture.completedFuture(map.size());
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsKey(String key) {
+ return CompletableFuture.completedFuture(map.containsKey(key));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> containsValue(byte[] value) {
+ return CompletableFuture.completedFuture(map.containsValue(value));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> get(String key) {
+ return CompletableFuture.completedFuture(map.get(key));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> getOrDefault(String key, byte[] defaultValue) {
+ return CompletableFuture.completedFuture(map.getOrDefault(key, new Versioned<byte[]>(defaultValue,
+ VERSION1)));
+ }
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> computeIf(String key, Predicate<? super byte[]> condition,
+ BiFunction<? super String, ? super byte[],
+ ? extends byte[]> remappingFunction) {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> put(String key, byte[] value) {
+ return CompletableFuture.completedFuture(map.put(key, new Versioned<byte[]>(value, VERSION1)));
+ }
+
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> putAndGet(String key, byte[] value) {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> remove(String key) {
+ return CompletableFuture.completedFuture(map.remove(key));
+ }
+
+ @Override
+ public CompletableFuture<Void> clear() {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Set<String>> keySet() {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Collection<Versioned<byte[]>>> values() {
+ return CompletableFuture.completedFuture(map.values());
+ }
+
+ @Override
+ public CompletableFuture<Set<Map.Entry<String, Versioned<byte[]>>>> entrySet() {
+ return CompletableFuture.completedFuture(map.entrySet());
+ }
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> putIfAbsent(String key, byte[] value) {
+ return CompletableFuture.completedFuture(map.putIfAbsent(key, new Versioned<byte[]>(value, 2)));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(String key, byte[] value) {
+ return CompletableFuture.completedFuture(map.remove(key, value));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> remove(String key, long version) {
+ Versioned versioned = map.get(key);
+ if (versioned.version() == version) {
+ map.remove(key);
+ return CompletableFuture.completedFuture(true);
+ }
+ return CompletableFuture.completedFuture(false);
+ }
+
+ @Override
+ public CompletableFuture<Versioned<byte[]>> replace(String key, byte[] value) {
+ return CompletableFuture.completedFuture(map.replace(key, new Versioned<byte[]>(value, VERSION1)));
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(String key, byte[] oldValue, byte[] newValue) {
+ Versioned<byte[]> currentValue = map.get(key);
+ if (currentValue == null) {
+ return CompletableFuture.completedFuture(false);
+ }
+
+ if (Arrays.equals(currentValue.value(), oldValue)) {
+ map.put(key, new Versioned<>(newValue, VERSION1));
+ return CompletableFuture.completedFuture(true);
+ }
+ return CompletableFuture.completedFuture(false);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> replace(String key, long oldVersion, byte[] newValue) {
+ Versioned versioned = map.get(key);
+ if (versioned != null && versioned.version() == oldVersion) {
+ map.put(key, new Versioned<byte[]>(newValue, VERSION1));
+ return CompletableFuture.completedFuture(true);
+ }
+ return CompletableFuture.completedFuture(false);
+ }
+
+ @Override
+ public CompletableFuture<Void> addListener(MapEventListener<String, byte[]> listener, Executor executor) {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Void> removeListener(MapEventListener<String, byte[]> listener) {
+ return null;
+ }
+
+ @Override
+ public String name() {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Version> begin(TransactionId transactionId) {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepare(TransactionLog<MapUpdate<String, byte[]>> transactionLog) {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Boolean> prepareAndCommit(TransactionLog<MapUpdate<String,
+ byte[]>> transactionLog) {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Void> commit(TransactionId transactionId) {
+ return null;
+ }
+
+ @Override
+ public CompletableFuture<Void> rollback(TransactionId transactionId) {
+ return null;
+ }
+ };
+
+ serializer = Serializer.using(KryoNamespaces.BASIC);
+ meteringAgent = new MeteringAgent(NAME, "*", false);
+ defaultAsyncAtomicValue = new DefaultAsyncAtomicValue(NAME, serializer,
+ asyncMap, meteringAgent);
+ defaultAsyncAtomicValue1 = new DefaultAsyncAtomicValue(NAME1, serializer,
+ asyncMap, meteringAgent);
+
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ defaultAsyncAtomicValue.destroy();
+ }
+
+ @Test
+ public void testAsyncMapping() {
+ assertThat(asyncMap.size().join(), is(0));
+ asyncMap.put(TEST, value1);
+ asyncMap.put(TEST1, value2);
+ asyncMap.put("default", defaultValue);
+
+ assertThat(asyncMap.getOrDefault("noMatch", defaultValue).join().value(),
+ is(asyncMap.get("default").join().value()));
+
+ assertThat(asyncMap.size().join(), is(3));
+ assertThat(asyncMap.get(TEST).join().value(), is(value1));
+
+ assertThat(asyncMap.getOrDefault(TEST, Tools.getBytesUtf8("newTest")).join().value(),
+ is(asyncMap.get(TEST).join().value()));
+
+ assertThat(asyncMap.containsKey(TEST).join(), is(true));
+
+ asyncMap.put(TEST, value3);
+ assertThat(asyncMap.get(TEST).join().value(), is(value3));
+ asyncMap.putIfAbsent(TEST, value3);
+ assertThat(asyncMap.size().join(), is(3));
+
+ asyncMap.replace(TEST, value3, value1);
+ assertThat(asyncMap.get(TEST).join().value(), is(value1));
+
+ asyncMap.replace(TEST, VERSION1, value3);
+ assertThat(asyncMap.get(TEST).join().value(), is(value3));
+
+ asyncMap.replace(TEST, value3, defaultValue);
+ assertThat(asyncMap.get(TEST).join().value(), is(defaultValue));
+ asyncMap.replace(TEST, value1);
+ assertThat(asyncMap.get(TEST).join().value(), is(value1));
+
+ asyncMap.remove(TEST, value2);
+
+ assertThat(asyncMap.size().join(), is(3));
+ }
+
+ @Test
+ public void testAsync() {
+ asyncMap.put(TEST, value1);
+ asyncMap.put(TEST1, value2);
+
+ assertNull(defaultAsyncAtomicValue.get().join());
+ defaultAsyncAtomicValue = new DefaultAsyncAtomicValue(NAME, serializer,
+ asyncMap, meteringAgent);
+ assertThat(defaultAsyncAtomicValue.name(), is(NAME));
+ defaultAsyncAtomicValue.set(null);
+ assertNull(defaultAsyncAtomicValue.get().join());
+
+ defaultAsyncAtomicValue.set(INTNAME);
+ assertThat(defaultAsyncAtomicValue.get().join(), is(INTNAME));
+
+ defaultAsyncAtomicValue.set(value1);
+ assertThat(defaultAsyncAtomicValue.get().join(), is(value1));
+
+ defaultAsyncAtomicValue.compareAndSet(value1, value3).join();
+ assertThat(defaultAsyncAtomicValue.get().join(), is(value3));
+
+ assertThat(defaultAsyncAtomicValue.compareAndSet(value3, value1).join(),
+ is(true));
+ assertThat(defaultAsyncAtomicValue.get().join(), is(value1));
+
+ defaultAsyncAtomicValue.getAndSet(null);
+ assertNull(defaultAsyncAtomicValue.get().join());
+
+ defaultAsyncAtomicValue.getAndSet(value3);
+ assertThat(defaultAsyncAtomicValue.get().join(), is(value3));
+ }
+}
\ No newline at end of file