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         @SuppressWarnings("unchecked")
  92         final Consumer<Object> consumer = mock(Consumer.class);
  93         doNothing().when(consumer).accept(any(Object.class));
  94         CheckedValue.ofValue(foo).ifPresent(consumer);
  95         verify(consumer).accept(foo);
  96     }
  97
  98     @Test
  99     public void testThrowableIfPresent() {
 100         @SuppressWarnings("unchecked")
 101         final Consumer<Object> consumer = mock(Consumer.class);
 102         doNothing().when(consumer).accept(any(Object.class));
 103         CheckedValue.ofException(new NullPointerException()).ifPresent(consumer);
 104         verifyZeroInteractions(consumer);
 105     }
 106
 107     @Test
 108     public void testOrElse() {
 109         final String foo = "foo";
 110         final String bar = "bar";
 111         assertSame(foo, CheckedValue.ofValue(foo).orElse(bar));
 112         assertSame(bar, CheckedValue.ofException(new NullPointerException()).orElse(bar));
 113     }
 114
 115     @Test
 116     public void testMap() {
 117         final String foo = "foo";
 118         final String bar = "bar";
 119         final CheckedValue<Object, ?> errVal = CheckedValue.ofValue(foo);
 120         @SuppressWarnings("unchecked")
 121         final Function<Object, Object> mapper = mock(Function.class);
 122         doReturn(bar).when(mapper).apply(any(Object.class));
 123         assertSame(bar, errVal.map(mapper).get());
 124         verify(mapper).apply(foo);
 125     }
 126
 127     @Test
 128     public void testExceptionMap() {
 129         final CheckedValue<Object, ?> errVal = CheckedValue.ofException(new NullPointerException());
 130         @SuppressWarnings("unchecked")
 131         final Function<Object, Object> mapper = mock(Function.class);
 132         doReturn(null).when(mapper).apply(any(Object.class));
 133         assertSame(errVal, errVal.map(mapper));
 134         verifyZeroInteractions(mapper);
 135     }
 136
 137     @Test
 138     public void testOrElseThrow() {
 139         final String foo = "foo";
 140         assertSame(foo, CheckedValue.ofValue(foo)
 141             .orElseThrow((Supplier<NullPointerException>)NullPointerException::new));
 142     }
 143
 144     @Test(expected = InterruptedException.class)
 145     public void testThrowableOrElseThrow() throws InterruptedException {
 146         final String foo = "foo";
 147         final Exception cause = new NullPointerException(foo);
 148         CheckedValue.ofException(cause).orElseThrow((Supplier<InterruptedException>)InterruptedException::new);
 149     }
 150
 151     @Test
 152     public void testOrElseGet() {
 153         final String foo = "foo";
 154         @SuppressWarnings("unchecked")
 155         final Supplier<String> supplier = mock(Supplier.class);
 156         doReturn(null).when(supplier).get();
 157         assertSame(foo, CheckedValue.ofValue(foo).orElseGet(supplier));
 158         verifyZeroInteractions(supplier);
 159     }
 160
 161     @Test
 162     public void testExceptionOrElseGet() {
 163         final String bar = "bar";
 164         @SuppressWarnings("unchecked")
 165         final Supplier<Object> supplier = mock(Supplier.class);
 166         doReturn(bar).when(supplier).get();
 167
 168         assertSame(bar, CheckedValue.ofException(new NullPointerException()).orElseGet(supplier));
 169         verify(supplier).get();
 170     }
 171 }