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.hamcrest.MatcherAssert.assertThat;
  17 import static org.junit.jupiter.api.Assertions.assertThrows;
  18
  19 import org.junit.jupiter.api.Test;
  20
  21 /**
  22  * @author Sami Salonen - Initial contribution
  23  */
  24 public class AtomicStampedKeyValueTest {
  25
  26     @Test
  27     public void testInitWithNullValue() {
  28         assertThrows(NullPointerException.class, () -> new AtomicStampedValue<>(0, null));
  29     }
  30
  31     @Test
  32     public void testGetters() {
  33         Object val = new Object();
  34         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  35         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  36         assertThat(keyValue.getValue(), is(equalTo(val)));
  37     }
  38
  39     @Test
  40     public void testUpdateWithSameStamp() {
  41         Object val = new Object();
  42         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  43         keyValue.update(42L, new Object());
  44         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  45         assertThat(keyValue.getValue(), is(not(equalTo(val))));
  46     }
  47
  48     @Test
  49     public void testUpdateWithDifferentStamp() {
  50         Object val = new Object();
  51         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  52         keyValue.update(-99L, new Object());
  53         assertThat(keyValue.getStamp(), is(equalTo(-99L)));
  54         assertThat(keyValue.getValue(), is(not(equalTo(val))));
  55     }
  56
  57     @Test
  58     public void testCopy() {
  59         Object val = new Object();
  60         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  61         AtomicStampedValue<Object> copy = keyValue.copy();
  62
  63         // unchanged
  64         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  65         assertThat(keyValue.getValue(), is(equalTo(val)));
  66
  67         // data matches
  68         assertThat(keyValue.getStamp(), is(equalTo(copy.getStamp())));
  69         assertThat(keyValue.getValue(), is(equalTo(copy.getValue())));
  70
  71         // after update they live life of their own
  72         Object val2 = new Object();
  73         copy.update(-99L, val2);
  74
  75         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  76         assertThat(keyValue.getValue(), is(equalTo(val)));
  77
  78         assertThat(copy.getStamp(), is(equalTo(-99L)));
  79         assertThat(copy.getValue(), is(equalTo(val2)));
  80     }
  81
  82     /**
  83      * instance(stamp=x).copyIfStampAfter(x)
  84      */
  85     @Test
  86     public void testCopyIfStampAfterEqual() {
  87         Object key = new Object();
  88         Object val = new Object();
  89         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
  90         AtomicStampedValue<Object> copy = keyValue.copyIfStampAfter(42L);
  91
  92         // keyValue unchanged
  93         assertThat(keyValue.getStamp(), is(equalTo(42L)));
  94         assertThat(keyValue.getValue(), is(equalTo(val)));
  95
  96         // data matches
  97         assertThat(keyValue.getStamp(), is(equalTo(copy.getStamp())));
  98         assertThat(keyValue.getValue(), is(equalTo(copy.getValue())));
  99
 100         // after update they live life of their own
 101         Object key2 = new Object();
 102         Object val2 = new Object();
 103         copy.update(-99L, val2);
 104
 105         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 106         assertThat(keyValue.getValue(), is(equalTo(val)));
 107
 108         assertThat(copy.getStamp(), is(equalTo(-99L)));
 109         assertThat(copy.getValue(), is(equalTo(val2)));
 110     }
 111
 112     /**
 113      * instance(stamp=x-1).copyIfStampAfter(x)
 114      */
 115     @Test
 116     public void testCopyIfStampAfterTooOld() {
 117         Object val = new Object();
 118         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
 119         AtomicStampedValue<Object> copy = keyValue.copyIfStampAfter(43L);
 120
 121         // keyValue unchanged
 122         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 123         assertThat(keyValue.getValue(), is(equalTo(val)));
 124
 125         // copy is null
 126         assertThat(copy, is(nullValue()));
 127     }
 128
 129     /**
 130      * instance(stamp=x).copyIfStampAfter(x-1)
 131      */
 132     @Test
 133     public void testCopyIfStampAfterFresh() {
 134         Object val = new Object();
 135         AtomicStampedValue<Object> keyValue = new AtomicStampedValue<>(42L, val);
 136         AtomicStampedValue<Object> copy = keyValue.copyIfStampAfter(41L);
 137
 138         // keyValue unchanged
 139         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 140         assertThat(keyValue.getValue(), is(equalTo(val)));
 141
 142         // data matches
 143         assertThat(keyValue.getStamp(), is(equalTo(copy.getStamp())));
 144         assertThat(keyValue.getValue(), is(equalTo(copy.getValue())));
 145
 146         // after update they live life of their own
 147         Object key2 = new Object();
 148         Object val2 = new Object();
 149         copy.update(-99L, val2);
 150
 151         assertThat(keyValue.getStamp(), is(equalTo(42L)));
 152         assertThat(keyValue.getValue(), is(equalTo(val)));
 153
 154         assertThat(copy.getStamp(), is(equalTo(-99L)));
 155         assertThat(copy.getValue(), is(equalTo(val2)));
 156     }
 157
 158     @Test
 159     public void testCompare() {
 160         // equal, smaller, larger
 161         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(42L, ""), new AtomicStampedValue<>(42L, "")),
 162                 is(equalTo(0)));
 163         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(41L, ""), new AtomicStampedValue<>(42L, "")),
 164                 is(equalTo(-1)));
 165         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(42L, ""), new AtomicStampedValue<>(41L, "")),
 166                 is(equalTo(1)));
 167
 168         // Nulls come first
 169         assertThat(AtomicStampedValue.compare(null, new AtomicStampedValue<>(42L, "")), is(equalTo(-1)));
 170         assertThat(AtomicStampedValue.compare(new AtomicStampedValue<>(42L, ""), null), is(equalTo(1)));
 171     }
 172 }