core/api/src/test/java/org/onosproject/store/primitives/DefaultAtomicCounterMapTest.java

/*
 * Copyright 2018-present Open Networking Foundation
 *
 * 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;

import org.junit.Before;
import org.junit.Test;
import org.onosproject.store.service.ConsistentMapException;

import java.util.concurrent.CompletableFuture;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.onosproject.store.primitives.TestingCompletableFutures.ErrorState.NONE;

/**
 * Unit tests for the DefaultAtomicCounter class.
 */

public class DefaultAtomicCounterMapTest {

    private static final String KEY1 = "myKey1";
    private static final long VALUE1 = 444L;
    private static final long DELTA1 = 555L;

    private DefaultAtomicCounterMap<String> atomicCounterMap;

    private DefaultAtomicCounterMap<String> createMap() {
        AsyncAtomicCounterMapAdapter<String> asyncMap = new AsyncAtomicCounterMapAdapter<>();
        DefaultAtomicCounterMap<String> map = new DefaultAtomicCounterMap<>(asyncMap, 1000L);
        assertThat(map, notNullValue());
        assertThat(map.isEmpty(), is(true));
        return map;
    }

    @Before
    public void setUpMap() {
        atomicCounterMap = createMap();
    }

    @Test
    public void testConstruction() {
        assertThat(atomicCounterMap.size(), is(0));
    }

    @Test
    public void testPutAndGet() {
        atomicCounterMap.put(KEY1, VALUE1);
        long value = atomicCounterMap.get(KEY1);
        assertThat(value, is(VALUE1));
    }

    @Test
    public void testGetAndIncrement() {
        atomicCounterMap.put(KEY1, VALUE1);
        Long beforeIncrement = atomicCounterMap.getAndIncrement(KEY1);
        assertThat(beforeIncrement, is(VALUE1));
        Long afterIncrement = atomicCounterMap.get(KEY1);
        assertThat(afterIncrement, is(VALUE1 + 1));
    }

    @Test
    public void testIncrementAndGet() {
        atomicCounterMap.put(KEY1, VALUE1);
        Long afterIncrement = atomicCounterMap.incrementAndGet(KEY1);
        assertThat(afterIncrement, is(VALUE1 + 1));
    }

    @Test
    public void testGetAndDecrement() {
        atomicCounterMap.put(KEY1, VALUE1);
        Long beforeDecrement = atomicCounterMap.getAndDecrement(KEY1);
        assertThat(beforeDecrement, is(VALUE1));
        Long afterDecrement = atomicCounterMap.get(KEY1);
        assertThat(afterDecrement, is(VALUE1 - 1));
    }

    @Test
    public void testDecrementAndGet() {
        atomicCounterMap.put(KEY1, VALUE1);
        Long afterIncrement = atomicCounterMap.decrementAndGet(KEY1);
        assertThat(afterIncrement, is(VALUE1 - 1));
    }

    @Test
    public void testGetAndAdd() {
        atomicCounterMap.put(KEY1, VALUE1);
        Long beforeIncrement = atomicCounterMap.getAndAdd(KEY1, DELTA1);
        assertThat(beforeIncrement, is(VALUE1));
        Long afterIncrement = atomicCounterMap.get(KEY1);
        assertThat(afterIncrement, is(VALUE1 + DELTA1));
    }

    @Test
    public void testAddAndGet() {
        atomicCounterMap.put(KEY1, VALUE1);
        Long afterIncrement = atomicCounterMap.addAndGet(KEY1, DELTA1);
        assertThat(afterIncrement, is(VALUE1 + DELTA1));
    }

    @Test
    public void testPutIfAbsent() {
        atomicCounterMap.putIfAbsent(KEY1, VALUE1);
        Long afterIncrement = atomicCounterMap.addAndGet(KEY1, DELTA1);
        assertThat(afterIncrement, is(VALUE1 + DELTA1));
    }

    @Test
    public void testClear() {
        atomicCounterMap.putIfAbsent(KEY1, VALUE1);
        assertThat(atomicCounterMap.size(), is(1));
        atomicCounterMap.clear();
        assertThat(atomicCounterMap.size(), is(0));
    }

    @Test
    public void testReplace() {
        atomicCounterMap.putIfAbsent(KEY1, VALUE1);

        boolean replaced = atomicCounterMap.replace(KEY1, VALUE1, VALUE1 * 2);
        assertThat(replaced, is(true));
        Long afterReplace = atomicCounterMap.get(KEY1);
        assertThat(afterReplace, is(VALUE1 * 2));

        boolean notReplaced = atomicCounterMap.replace(KEY1, VALUE1, VALUE1 * 2);
        assertThat(notReplaced, is(false));
        Long afterNotReplaced = atomicCounterMap.get(KEY1);
        assertThat(afterNotReplaced, is(VALUE1 * 2));
    }

    @Test
    public void testRemove() {
        atomicCounterMap.putIfAbsent(KEY1, VALUE1);
        assertThat(atomicCounterMap.size(), is(1));
        atomicCounterMap.remove(KEY1);
        assertThat(atomicCounterMap.size(), is(0));
    }

    @Test
    public void testRemoveVale() {
        atomicCounterMap.putIfAbsent(KEY1, VALUE1);
        assertThat(atomicCounterMap.size(), is(1));
        atomicCounterMap.remove(KEY1, VALUE1 * 2);
        assertThat(atomicCounterMap.size(), is(1));
        atomicCounterMap.remove(KEY1, VALUE1);
        assertThat(atomicCounterMap.size(), is(0));
    }

    class AtomicCounterMapWithErrors<K> extends AsyncAtomicCounterMapAdapter<K> {

        TestingCompletableFutures.ErrorState errorState = NONE;

        void setErrorState(TestingCompletableFutures.ErrorState errorState) {
            this.errorState = errorState;
        }

        AtomicCounterMapWithErrors() {
            super();
        }

        @Override
        public CompletableFuture<Long> get(K key) {
            return TestingCompletableFutures.createFuture(errorState);
        }
    }

    @Test(expected = ConsistentMapException.Timeout.class)
    public void testTimeout() {
        AtomicCounterMapWithErrors<String> atomicCounterMap =
                new AtomicCounterMapWithErrors<>();
        atomicCounterMap.setErrorState(TestingCompletableFutures.ErrorState.TIMEOUT_EXCEPTION);
        DefaultAtomicCounterMap<String> map =
                new DefaultAtomicCounterMap<>(atomicCounterMap, 1000);

        map.get(KEY1);
    }


    @Test(expected = ConsistentMapException.Interrupted.class)
    public void testInterrupted() {
        AtomicCounterMapWithErrors<String> atomicCounterMap =
                new AtomicCounterMapWithErrors<>();
        atomicCounterMap.setErrorState(TestingCompletableFutures.ErrorState.INTERRUPTED_EXCEPTION);
        DefaultAtomicCounterMap<String> map =
                new DefaultAtomicCounterMap<>(atomicCounterMap, 1000);

        map.get(KEY1);
    }

    @Test(expected = ConsistentMapException.class)
    public void testExecutionError() {
        AtomicCounterMapWithErrors<String> atomicCounterMap =
                new AtomicCounterMapWithErrors<>();
        atomicCounterMap.setErrorState(TestingCompletableFutures.ErrorState.EXECUTION_EXCEPTION);
        DefaultAtomicCounterMap<String> map =
                new DefaultAtomicCounterMap<>(atomicCounterMap, 1000);

        map.get(KEY1);
    }

}