common/concepts/src/test/java/org/opendaylight/yangtools/concepts/CheckedValueTest.java

   1 /*
   2  * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.concepts;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertSame;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.ArgumentMatchers.any;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.mock;
  18 import static org.mockito.Mockito.verify;
  19 import static org.mockito.Mockito.verifyZeroInteractions;
  20
  21 import java.util.function.Consumer;
  22 import java.util.function.Function;
  23 import java.util.function.Supplier;
  24 import org.junit.Test;
  25
  26 public class CheckedValueTest {
  27     @Test(expected = NullPointerException.class)
  28     public void testNullValue() {
  29         CheckedValue.ofValue(null);
  30     }
  31
  32     @Test(expected = IllegalStateException.class)
  33     public void testExceptionGet() {
  34         CheckedValue.ofException(new Exception()).get();
  35     }
  36
  37     @Test(expected = IllegalStateException.class)
  38     public void testValueException() {
  39         CheckedValue.ofValue("foo").getException();
  40     }
  41
  42     @Test
  43     public void testGet() {
  44         final String value = "foo";
  45         final CheckedValue<String, ?> val = CheckedValue.ofValue(value);
  46         assertTrue(val.isPresent());
  47         assertSame(value, val.get());
  48     }
  49
  50     @Test
  51     public void testThrowableGetThrowable() {
  52         final Exception cause = new Exception();
  53         final CheckedValue<?, ?> val = CheckedValue.ofException(cause);
  54         assertFalse(val.isPresent());
  55         assertSame(cause, val.getException());
  56     }
  57
  58     @Test
  59     public void testToString() {
  60         assertEquals("CheckedValue{first=foo}", CheckedValue.ofValue("foo").toString());
  61         assertEquals("CheckedValue{second=java.lang.NullPointerException: foo}",
  62             CheckedValue.ofException(new NullPointerException("foo")).toString());
  63     }
  64
  65     @Test
  66     public void testEqualsHashCode() {
  67         final CheckedValue<String, ?> fooVal = CheckedValue.ofValue("foo");
  68         final CheckedValue<String, ?> fooVal2 = CheckedValue.ofValue("foo");
  69         final CheckedValue<Integer, ?> oneVal = CheckedValue.ofValue(1);
  70         final CheckedValue<?, ?> errBar = CheckedValue.ofException(new NullPointerException("bar"));
  71         final CheckedValue<?, ?> errFoo = CheckedValue.ofException(new NullPointerException("foo"));
  72         final CheckedValue<?, ?> errFoo2 = CheckedValue.ofException(new NullPointerException("foo"));
  73
  74         assertFalse(fooVal.equals(null));
  75         assertFalse(fooVal.equals("foo"));
  76         assertTrue(fooVal.equals(fooVal));
  77         assertTrue(fooVal.equals(fooVal2));
  78         assertFalse(fooVal.equals(oneVal));
  79         assertEquals(fooVal.hashCode(), fooVal2.hashCode());
  80
  81         assertFalse(errFoo.equals(null));
  82         assertFalse(errFoo.equals("foo"));
  83         assertTrue(errFoo.equals(errFoo));
  84
  85         assertFalse(errBar.equals(errFoo));
  86     }
  87
  88     @Test
  89     public void testIfPresent() {
  90         final String foo = "foo";
  91         final Consumer<Object> consumer = mock(Consumer.class);
  92         doNothing().when(consumer).accept(any(Object.class));
  93         CheckedValue.ofValue(foo).ifPresent(consumer);
  94         verify(consumer).accept(foo);
  95     }
  96
  97     @Test
  98     public void testThrowableIfPresent() {
  99         final Consumer<Object> consumer = mock(Consumer.class);
 100         doNothing().when(consumer).accept(any(Object.class));
 101         CheckedValue.ofException(new NullPointerException()).ifPresent(consumer);
 102         verifyZeroInteractions(consumer);
 103     }
 104
 105     @Test
 106     public void testOrElse() {
 107         final String foo = "foo";
 108         final String bar = "bar";
 109         assertSame(foo, CheckedValue.ofValue(foo).orElse(bar));
 110         assertSame(bar, CheckedValue.ofException(new NullPointerException()).orElse(bar));
 111     }
 112
 113     @Test
 114     public void testMap() {
 115         final String foo = "foo";
 116         final String bar = "bar";
 117         final CheckedValue<Object, ?> errVal = CheckedValue.ofValue(foo);
 118         final Function<Object, Object> mapper = mock(Function.class);
 119         doReturn(bar).when(mapper).apply(any(Object.class));
 120         assertSame(bar, errVal.map(mapper).get());
 121         verify(mapper).apply(foo);
 122     }
 123
 124     @Test
 125     public void testExceptionMap() {
 126         final CheckedValue<Object, ?> errVal = CheckedValue.ofException(new NullPointerException());
 127         final Function<Object, Object> mapper = mock(Function.class);
 128         doReturn(null).when(mapper).apply(any(Object.class));
 129         assertSame(errVal, errVal.map(mapper));
 130         verifyZeroInteractions(mapper);
 131     }
 132
 133     @Test
 134     public void testOrElseThrow() {
 135         final String foo = "foo";
 136         assertSame(foo, CheckedValue.ofValue(foo)
 137             .orElseThrow((Supplier<NullPointerException>)NullPointerException::new));
 138     }
 139
 140     @Test(expected = InterruptedException.class)
 141     public void testThrowableOrElseThrow() throws InterruptedException {
 142         final String foo = "foo";
 143         final Exception cause = new NullPointerException(foo);
 144         CheckedValue.ofException(cause).orElseThrow((Supplier<InterruptedException>)InterruptedException::new);
 145     }
 146
 147     @Test
 148     public void testOrElseGet() {
 149         final String foo = "foo";
 150         final Supplier<String> supplier = mock(Supplier.class);
 151         doReturn(null).when(supplier).get();
 152         assertSame(foo, CheckedValue.ofValue(foo).orElseGet(supplier));
 153         verifyZeroInteractions(supplier);
 154     }
 155
 156     @Test
 157     public void testExceptionOrElseGet() {
 158         final String bar = "bar";
 159         final Supplier<Object> supplier = mock(Supplier.class);
 160         doReturn(bar).when(supplier).get();
 161
 162         assertSame(bar, CheckedValue.ofException(new NullPointerException()).orElseGet(supplier));
 163         verify(supplier).get();
 164     }
 165 }