@Test
 public void shouldConvertToJavaStream() {
   final Value<Integer> value = of(1, 2, 3);
   final java.util.stream.Stream<Integer> s1 = value.toJavaStream();
   if (value.isSingleValued()) {
     final java.util.stream.Stream<Integer> s2 = java.util.stream.Stream.of(1);
     assertThat(List.ofAll(s1::iterator)).isEqualTo(List.ofAll(s2::iterator));
   } else {
     final java.util.stream.Stream<Integer> s2 = java.util.stream.Stream.of(1, 2, 3);
     assertThat(List.ofAll(s1::iterator)).isEqualTo(List.ofAll(s2::iterator));
   }
 }
 @Test
 public void shouldPerformsActionOnEachElement() {
   final int[] consumer = new int[1];
   final Value<Integer> value = of(1, 2, 3);
   value.forEach(i -> consumer[0] += i);
   assertThat(consumer[0]).isEqualTo(value.isSingleValued() ? 1 : 6);
 }
 @Test
 public void shouldBeAwareOfExistingElement() {
   final Value<Integer> value = of(1, 2);
   if (value.isSingleValued()) {
     assertThat(value.exists(i -> i == 1)).isTrue();
   } else {
     assertThat(value.exists(i -> i == 2)).isTrue();
   }
 }
 @Test
 public void shouldConvertToJavaSet() {
   final Value<Integer> value = of(1, 2, 3);
   final java.util.Set<Integer> set = value.toJavaSet();
   if (value.isSingleValued()) {
     assertThat(set).isEqualTo(JavaCollections.javaSet(1));
   } else {
     assertThat(set).isEqualTo(JavaCollections.javaSet(1, 2, 3));
   }
 }
 @Test
 public void shouldConvertToJavaMap() {
   final Value<Integer> value = of(1, 2, 3);
   final java.util.Map<Integer, Integer> map = value.toJavaMap(v -> Tuple.of(v, v));
   if (value.isSingleValued()) {
     assertThat(map).isEqualTo(JavaCollections.javaMap(1, 1));
   } else {
     assertThat(map).isEqualTo(JavaCollections.javaMap(1, 1, 2, 2, 3, 3));
   }
 }
 @Test
 public void shouldConvertToJavaList() {
   final Value<Integer> value = of(1, 2, 3);
   final java.util.List<Integer> list = value.toJavaList();
   if (value.isSingleValued()) {
     assertThat(list).isEqualTo(Arrays.asList(1));
   } else {
     assertThat(list).isEqualTo(Arrays.asList(1, 2, 3));
   }
 }
 @Test
 public void shouldConvertToJavaArray() {
   final Value<Integer> value = of(1, 2, 3);
   final Integer[] ints = value.toJavaArray(Integer.class);
   if (value.isSingleValued()) {
     assertThat(ints).isEqualTo(new int[] {1});
   } else {
     assertThat(ints).isEqualTo(new int[] {1, 2, 3});
   }
 }
 @Test
 public void shouldConvertToVector() {
   final Value<Integer> value = of(1, 2, 3);
   final Vector<Integer> vector = value.toVector();
   if (value.isSingleValued()) {
     assertThat(vector).isEqualTo(Vector.of(1));
   } else {
     assertThat(vector).isEqualTo(Vector.of(1, 2, 3));
   }
 }
 @Test
 public void shouldConvertToStream() {
   final Value<Integer> value = of(1, 2, 3);
   final Stream<Integer> stream = value.toStream();
   if (value.isSingleValued()) {
     assertThat(stream).isEqualTo(Stream.of(1));
   } else {
     assertThat(stream).isEqualTo(Stream.of(1, 2, 3));
   }
 }
 @Test
 public void shouldConvertToSet() {
   final Value<Integer> value = of(1, 2, 3);
   final Set<Integer> set = value.toSet();
   if (value.isSingleValued()) {
     assertThat(set).isEqualTo(HashSet.of(1));
   } else {
     assertThat(set).isEqualTo(HashSet.of(1, 2, 3));
   }
 }
 @Test
 public void shouldConvertToQueue() {
   final Value<Integer> value = of(1, 2, 3);
   final Queue<Integer> queue = value.toQueue();
   if (value.isSingleValued()) {
     assertThat(queue).isEqualTo(Queue.of(1));
   } else {
     assertThat(queue).isEqualTo(Queue.of(1, 2, 3));
   }
 }
 @Test
 public void shouldConvertToMap() {
   final Value<Integer> value = of(1, 2, 3);
   final Map<Integer, Integer> map = value.toMap(v -> Tuple.of(v, v));
   if (value.isSingleValued()) {
     assertThat(map).isEqualTo(HashMap.of(1, 1));
   } else {
     assertThat(map).isEqualTo(HashMap.empty().put(1, 1).put(2, 2).put(3, 3));
   }
 }
 @Test
 public void shouldConvertToList() {
   final Value<Integer> value = of(1, 2, 3);
   final List<Integer> list = value.toList();
   if (value.isSingleValued()) {
     assertThat(list).isEqualTo(List.of(1));
   } else {
     assertThat(list).isEqualTo(List.of(1, 2, 3));
   }
 }
 @Test
 public void shouldConvertToArray() {
   final Value<Integer> value = of(1, 2, 3);
   final Array<Integer> array = value.toArray();
   if (value.isSingleValued()) {
     assertThat(array).isEqualTo(Array.of(1));
   } else {
     assertThat(array).isEqualTo(Array.of(1, 2, 3));
   }
 }