31
32 import org.testng.annotations.DataProvider;
33 import org.testng.annotations.Test;
34
35 import java.util.ArrayDeque;
36 import java.util.ArrayList;
37 import java.util.Arrays;
38 import java.util.Collection;
39 import java.util.Collections;
40 import java.util.Deque;
41 import java.util.HashMap;
42 import java.util.HashSet;
43 import java.util.LinkedHashMap;
44 import java.util.LinkedHashSet;
45 import java.util.List;
46 import java.util.Map;
47 import java.util.Spliterator;
48 import java.util.TreeSet;
49 import java.util.function.Consumer;
50 import java.util.function.Function;
51 import java.util.function.LongConsumer;
52 import java.util.function.Supplier;
53 import java.util.function.UnaryOperator;
54
55 import static org.testng.Assert.*;
56 import static org.testng.Assert.assertEquals;
57
58 @Test
59 public class SpliteratorCollisions {
60
61 private static List<Integer> SIZES = Arrays.asList(0, 1, 10, 100, 1000);
62
63 private static class SpliteratorDataBuilder<T> {
64 List<Object[]> data;
65 List<T> exp;
66 Map<T, T> mExp;
67
68 SpliteratorDataBuilder(List<Object[]> data, List<T> exp) {
69 this.data = data;
70 this.exp = exp;
71 this.mExp = createMap(exp);
660 } catch (IllegalStateException e) {
661 assertFalse(s.hasCharacteristics(Spliterator.SORTED));
662 }
663 }
664
665 private static<T> void assertContents(Collection<T> actual, Collection<T> expected, boolean isOrdered) {
666 if (isOrdered) {
667 assertEquals(actual, expected);
668 }
669 else {
670 assertContentsUnordered(actual, expected);
671 }
672 }
673
674 private static<T> void assertContentsUnordered(Iterable<T> actual, Iterable<T> expected) {
675 assertEquals(toBoxedMultiset(actual), toBoxedMultiset(expected));
676 }
677
678 private static <T> Map<T, HashableInteger> toBoxedMultiset(Iterable<T> c) {
679 Map<T, HashableInteger> result = new HashMap<>();
680 c.forEach((Consumer) e -> {
681 if (result.containsKey((T)e)) {
682 result.put((T)e, new HashableInteger(((HashableInteger)result.get(e)).value + 1, 10));
683 } else {
684 result.put((T)e, new HashableInteger(1, 10));
685 }
686 });
687 return result;
688 }
689
690 private void executeAndCatch(Class<? extends Exception> expected, Runnable r) {
691 Exception caught = null;
692 try {
693 r.run();
694 }
695 catch (Exception e) {
696 caught = e;
697 }
698
699 assertNotNull(caught,
700 String.format("No Exception was thrown, expected an Exception of %s to be thrown",
701 expected.getName()));
702 assertTrue(expected.isInstance(caught),
703 String.format("Exception thrown %s not an instance of %s",
704 caught.getClass().getName(), expected.getName()));
|
31
32 import org.testng.annotations.DataProvider;
33 import org.testng.annotations.Test;
34
35 import java.util.ArrayDeque;
36 import java.util.ArrayList;
37 import java.util.Arrays;
38 import java.util.Collection;
39 import java.util.Collections;
40 import java.util.Deque;
41 import java.util.HashMap;
42 import java.util.HashSet;
43 import java.util.LinkedHashMap;
44 import java.util.LinkedHashSet;
45 import java.util.List;
46 import java.util.Map;
47 import java.util.Spliterator;
48 import java.util.TreeSet;
49 import java.util.function.Consumer;
50 import java.util.function.Function;
51 import java.util.function.Supplier;
52 import java.util.function.UnaryOperator;
53
54 import static org.testng.Assert.*;
55 import static org.testng.Assert.assertEquals;
56
57 @Test
58 public class SpliteratorCollisions {
59
60 private static List<Integer> SIZES = Arrays.asList(0, 1, 10, 100, 1000);
61
62 private static class SpliteratorDataBuilder<T> {
63 List<Object[]> data;
64 List<T> exp;
65 Map<T, T> mExp;
66
67 SpliteratorDataBuilder(List<Object[]> data, List<T> exp) {
68 this.data = data;
69 this.exp = exp;
70 this.mExp = createMap(exp);
659 } catch (IllegalStateException e) {
660 assertFalse(s.hasCharacteristics(Spliterator.SORTED));
661 }
662 }
663
664 private static<T> void assertContents(Collection<T> actual, Collection<T> expected, boolean isOrdered) {
665 if (isOrdered) {
666 assertEquals(actual, expected);
667 }
668 else {
669 assertContentsUnordered(actual, expected);
670 }
671 }
672
673 private static<T> void assertContentsUnordered(Iterable<T> actual, Iterable<T> expected) {
674 assertEquals(toBoxedMultiset(actual), toBoxedMultiset(expected));
675 }
676
677 private static <T> Map<T, HashableInteger> toBoxedMultiset(Iterable<T> c) {
678 Map<T, HashableInteger> result = new HashMap<>();
679 c.forEach(e -> {
680 if (result.containsKey(e)) {
681 result.put(e, new HashableInteger(result.get(e).value + 1, 10));
682 } else {
683 result.put(e, new HashableInteger(1, 10));
684 }
685 });
686 return result;
687 }
688
689 private void executeAndCatch(Class<? extends Exception> expected, Runnable r) {
690 Exception caught = null;
691 try {
692 r.run();
693 }
694 catch (Exception e) {
695 caught = e;
696 }
697
698 assertNotNull(caught,
699 String.format("No Exception was thrown, expected an Exception of %s to be thrown",
700 expected.getName()));
701 assertTrue(expected.isInstance(caught),
702 String.format("Exception thrown %s not an instance of %s",
703 caught.getClass().getName(), expected.getName()));
|