git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2020 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.modbus.internal;
  14
  15 import static org.hamcrest.CoreMatchers.*;
  16 import static org.junit.Assert.assertThat;
  17
  18 import org.junit.Test;
  19 import org.junit.runner.RunWith;
  20 import org.mockito.junit.MockitoJUnitRunner;
  21
  22 /**
  23  * @author Sami Salonen - Initial contribution
  24  */
  25 @RunWith(MockitoJUnitRunner.class)
  26 public class AtomicStampedKeyValueTest {
  27
  28     @Test(expected = NullPointerException.class)
  29     public void testInitWithNullValue() {
  30         new AtomicStampedValue<>(0, null);
  31     }
  32
  33     @Test
  34     public void testGetters() {
  35         Object val = new Object();
  36         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  37         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  38         assertThat(keyValue.getValue(), is(equalTo(val)));
  39     }
  40
  41     @Test
  42     public void testUpdateWithSameStamp() {
  43         Object val = new Object();
  44         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  45         keyValue.update(42L, new Object());
  46         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  47         assertThat(keyValue.getValue(), is(not(equalTo(val))));
  48     }
  49
  50     @Test
  51     public void testUpdateWithDifferentStamp() {
  52         Object val = new Object();
  53         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  54         keyValue.update(-99L, new Object());
  55         assertThat(keyValue.getStamp(), is(equalTo(-99L)));
  56         assertThat(keyValue.getValue(), is(not(equalTo(val))));
  57     }
  58
  59     @Test
  60     public void testCopy() {
  61         Object val = new Object();
  62         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  63         AtomicStampedValue<Object> copy = keyValue.copy();
  64
  65         // unchanged
  66         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  67         assertThat(keyValue.getValue(), is(equalTo(val)));
  68
  69         // data matches
  70         assertThat(keyValue.getStamp(), is(equalTo(copy.getStamp())));
  71         assertThat(keyValue.getValue(), is(equalTo(copy.getValue())));
  72
  73         // after update they live life of their own
  74         Object val2 = new Object();
  75         copy.update(-99L, val2);
  76
  77         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  78         assertThat(keyValue.getValue(), is(equalTo(val)));
  79
  80         assertThat(copy.getStamp(), is(equalTo(-99L)));
  81         assertThat(copy.getValue(), is(equalTo(val2)));
  82     }
  83
  84     /**
  85      * instance(stamp=x).copyIfStampAfter(x)
  86      */
  87     @Test
  88     public void testCopyIfStampAfterEqual() {
  89         Object key = new Object();
  90         Object val = new Object();
  91         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  92         AtomicStampedValue<Object> copy = keyValue.copyIfStampAfter(42L);
  93
  94         // keyValue unchanged
  95         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  96         assertThat(keyValue.getValue(), is(equalTo(val)));
  97
  98         // data matches
  99         assertThat(keyValue.getStamp(), is(equalTo(copy.getStamp())));
 100         assertThat(keyValue.getValue(), is(equalTo(copy.getValue())));
 101
 102         // after update they live life of their own
 103         Object key2 = new Object();
 104         Object val2 = new Object();
 105         copy.update(-99L, val2);
 106
 107         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 108         assertThat(keyValue.getValue(), is(equalTo(val)));
 109
 110         assertThat(copy.getStamp(), is(equalTo(-99L)));
 111         assertThat(copy.getValue(), is(equalTo(val2)));
 112     }
 113
 114     /**
 115      * instance(stamp=x-1).copyIfStampAfter(x)
 116      */
 117     @Test
 118     public void testCopyIfStampAfterTooOld() {
 119         Object val = new Object();
 120         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
 121         AtomicStampedValue<Object> copy = keyValue.copyIfStampAfter(43L);
 122
 123         // keyValue unchanged
 124         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 125         assertThat(keyValue.getValue(), is(equalTo(val)));
 126
 127         // copy is null
 128         assertThat(copy, is(nullValue()));
 129     }
 130
 131     /**
 132      * instance(stamp=x).copyIfStampAfter(x-1)
 133      */
 134     @Test
 135     public void testCopyIfStampAfterFresh() {
 136         Object val = new Object();
 137         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
 138         AtomicStampedValue<Object> copy = keyValue.copyIfStampAfter(41L);
 139
 140         // keyValue unchanged
 141         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 142         assertThat(keyValue.getValue(), is(equalTo(val)));
 143
 144         // data matches
 145         assertThat(keyValue.getStamp(), is(equalTo(copy.getStamp())));
 146         assertThat(keyValue.getValue(), is(equalTo(copy.getValue())));
 147
 148         // after update they live life of their own
 149         Object key2 = new Object();
 150         Object val2 = new Object();
 151         copy.update(-99L, val2);
 152
 153         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 154         assertThat(keyValue.getValue(), is(equalTo(val)));
 155
 156         assertThat(copy.getStamp(), is(equalTo(-99L)));
 157         assertThat(copy.getValue(), is(equalTo(val2)));
 158     }
 159
 160     @Test
 161     public void testCompare() {
 162         // equal, smaller, larger
 163         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(42L, ""), new AtomicStampedValue<>(42L, "")),
 164                 is(equalTo(0)));
 165         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(41L, ""), new AtomicStampedValue<>(42L, "")),
 166                 is(equalTo(-1)));
 167         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(42L, ""), new AtomicStampedValue<>(41L, "")),
 168                 is(equalTo(1)));
 169
 170         // Nulls come first
 171         assertThat(AtomicStampedValue.compare(null, new AtomicStampedValue<>(42L, "")), is(equalTo(-1)));
 172         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(42L, ""), null), is(equalTo(1)));
 173     }
 174 }