*/
package org.opendaylight.yangtools.concepts;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class CheckedValueTest {
- @Test(expected = NullPointerException.class)
+ @Test
public void testNullValue() {
- CheckedValue.ofValue(null);
+ assertThrows(NullPointerException.class, () -> CheckedValue.ofValue(null));
}
- @Test(expected = IllegalStateException.class)
public void testExceptionGet() {
- CheckedValue.ofException(new Exception()).get();
+ final CheckedValue<?, ?> value = CheckedValue.ofException(new Exception());
+ assertThrows(IllegalStateException.class, () -> value.get());
}
- @Test(expected = IllegalStateException.class)
+ @Test
public void testValueException() {
- CheckedValue.ofValue("foo").getException();
+ final CheckedValue<?, ?> value = CheckedValue.ofValue("foo");
+ assertThrows(IllegalStateException.class, () -> value.getException());
}
@Test
final Consumer<Object> consumer = mock(Consumer.class);
doNothing().when(consumer).accept(any(Object.class));
CheckedValue.ofException(new NullPointerException()).ifPresent(consumer);
- verifyZeroInteractions(consumer);
+ verifyNoInteractions(consumer);
}
@Test
final Function<Object, Object> mapper = mock(Function.class);
doReturn(null).when(mapper).apply(any(Object.class));
assertSame(errVal, errVal.map(mapper));
- verifyZeroInteractions(mapper);
+ verifyNoInteractions(mapper);
}
@Test
.orElseThrow((Supplier<NullPointerException>)NullPointerException::new));
}
- @Test(expected = InterruptedException.class)
- public void testThrowableOrElseThrow() throws InterruptedException {
- final String foo = "foo";
- final Exception cause = new NullPointerException(foo);
- CheckedValue.ofException(cause).orElseThrow((Supplier<InterruptedException>)InterruptedException::new);
+ @Test
+ public void testThrowableOrElseThrow() {
+ final CheckedValue<?, ?> value = CheckedValue.ofException(new NullPointerException("foo"));
+ final Exception mock = mock(Exception.class);
+ assertThrows(mock.getClass(), () -> value.orElseThrow(() -> mock));
}
@Test
final Supplier<String> supplier = mock(Supplier.class);
doReturn(null).when(supplier).get();
assertSame(foo, CheckedValue.ofValue(foo).orElseGet(supplier));
- verifyZeroInteractions(supplier);
+ verifyNoInteractions(supplier);
}
@Test