return cartesianProduct(Arrays.asList(lists));
return cartesianProduct(Arrays.asList(lists));
@SuppressWarnings("unchecked") // varargs! public void testCartesianProductTooBig() { List<String> list = Collections.nCopies(10000, "foo"); try { Lists.cartesianProduct(list, list, list, list, list); fail("Expected IAE"); } catch (IllegalArgumentException expected) { } }
return cartesianProduct(Arrays.asList(lists));
/** * Returns a list of parameters for invoking an overload of checkState, checkArgument or * checkNotNull * * @param predicateType The first parameter to the method (boolean or Object) */ private static ImmutableList<ImmutableList<Class<?>>> allSignatures(Class<?> predicateType) { ImmutableSet.Builder<ImmutableList<Class<?>>> allOverloads = ImmutableSet.builder(); // The first two are for the overloads that don't take formatting args, e.g. // checkArgument(boolean) and checkArgument(boolean, Object) allOverloads.add(ImmutableList.<Class<?>>of(predicateType)); allOverloads.add(ImmutableList.<Class<?>>of(predicateType, Object.class)); List<List<Class<?>>> typesLists = new ArrayList<>(); for (int i = 0; i < 2; i++) { typesLists.add(possibleParamTypes); for (List<Class<?>> curr : Lists.cartesianProduct(typesLists)) { allOverloads.add( ImmutableList.<Class<?>>builder() .add(predicateType) .add(String.class) // the format string .addAll(curr) .build()); } } return allOverloads.build().asList(); }
/** * Returns a list of objects with the same hash code, of size 2^power, counting calls to equals, * hashCode, and compareTo in counter. */ static List<CountsHashCodeAndEquals> createAdversarialInput(int power, CallsCounter counter) { String str1 = "Aa"; String str2 = "BB"; assertEquals(str1.hashCode(), str2.hashCode()); List<String> haveSameHashes2 = Arrays.asList(str1, str2); List<CountsHashCodeAndEquals> result = Lists.newArrayList( Lists.transform( Lists.cartesianProduct(Collections.nCopies(power, haveSameHashes2)), strs -> new CountsHashCodeAndEquals( String.join("", strs), () -> counter.hashCode++, () -> counter.equals++, () -> counter.compareTo++))); assertEquals( result.get(0).delegateString.hashCode(), result.get(result.size() - 1).delegateString.hashCode()); return result; }
/** * Returns a list of objects with the same hash code, of size 2^power, counting calls to equals, * hashCode, and compareTo in counter. */ static List<CountsHashCodeAndEquals> createAdversarialInput(int power, CallsCounter counter) { String str1 = "Aa"; String str2 = "BB"; assertEquals(str1.hashCode(), str2.hashCode()); List<String> haveSameHashes2 = Arrays.asList(str1, str2); List<CountsHashCodeAndEquals> result = Lists.newArrayList( Lists.transform( Lists.cartesianProduct(Collections.nCopies(power, haveSameHashes2)), strs -> new CountsHashCodeAndEquals( String.join("", strs), () -> counter.hashCode++, () -> counter.equals++, () -> counter.compareTo++))); assertEquals( result.get(0).delegateString.hashCode(), result.get(result.size() - 1).delegateString.hashCode()); return result; }
/** * Returns a list of objects with the same hash code, of size 2^power, counting calls to equals, * hashCode, and compareTo in counter. */ static List<CountsHashCodeAndEquals> createAdversarialInput(int power, CallsCounter counter) { String str1 = "Aa"; String str2 = "BB"; assertEquals(str1.hashCode(), str2.hashCode()); List<String> haveSameHashes2 = Arrays.asList(str1, str2); List<CountsHashCodeAndEquals> result = Lists.newArrayList( Lists.transform( Lists.cartesianProduct(Collections.nCopies(power, haveSameHashes2)), strs -> new CountsHashCodeAndEquals( String.join("", strs), () -> counter.hashCode++, () -> counter.equals++, () -> counter.compareTo++))); assertEquals( result.get(0).delegateString.hashCode(), result.get(result.size() - 1).delegateString.hashCode()); return result; }
/** * Returns a list of objects with the same hash code, of size 2^power, counting calls to equals, * hashCode, and compareTo in counter. */ static List<CountsHashCodeAndEquals> createAdversarialObjects(int power, CallsCounter counter) { String str1 = "Aa"; String str2 = "BB"; assertEquals(str1.hashCode(), str2.hashCode()); List<String> haveSameHashes2 = Arrays.asList(str1, str2); List<CountsHashCodeAndEquals> result = Lists.newArrayList( Lists.transform( Lists.cartesianProduct(Collections.nCopies(power, haveSameHashes2)), strs -> new CountsHashCodeAndEquals( String.join("", strs), () -> counter.hashCode++, () -> counter.equals++, () -> counter.compareTo++))); assertEquals( result.get(0).delegateString.hashCode(), result.get(result.size() - 1).delegateString.hashCode()); return result; }
separatedValues.add(vals); List<List<Object>> valueLists = Lists.cartesianProduct(separatedValues); for (List<Object> valueList : valueLists) { Map<Property<?>, Object> valueMap = Maps.newTreeMap(Comparator.comparing(Property::getName));
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_binary1x1() { assertThat(Lists.cartesianProduct(list(1), list(2))).contains(list(1, 2)); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_contains() { List<List<Integer>> actual = Lists.cartesianProduct(list(1, 2), list(3, 4)); assertTrue(actual.contains(list(1, 3))); assertTrue(actual.contains(list(1, 4))); assertTrue(actual.contains(list(2, 3))); assertTrue(actual.contains(list(2, 4))); assertFalse(actual.contains(list(3, 1))); }
public void testCartesianProduct_indexOf() { List<List<Integer>> actual = Lists.cartesianProduct(list(1, 2), list(3, 4)); assertEquals(actual.indexOf(list(1, 3)), 0); assertEquals(actual.indexOf(list(1, 4)), 1); assertEquals(actual.indexOf(list(2, 3)), 2); assertEquals(actual.indexOf(list(2, 4)), 3); assertEquals(actual.indexOf(list(3, 1)), -1); assertEquals(actual.indexOf(list(1)), -1); assertEquals(actual.indexOf(list(1, 1, 1)), -1); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_binary1x2() { assertThat(Lists.cartesianProduct(list(1), list(2, 3))) .containsExactly(list(1, 2), list(1, 3)) .inOrder(); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_binary2x2() { assertThat(Lists.cartesianProduct(list(1, 2), list(3, 4))) .containsExactly(list(1, 3), list(1, 4), list(2, 3), list(2, 4)) .inOrder(); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_unrelatedTypes() { List<Integer> x = list(1, 2); List<String> y = list("3", "4"); List<Object> exp1 = list((Object) 1, "3"); List<Object> exp2 = list((Object) 1, "4"); List<Object> exp3 = list((Object) 2, "3"); List<Object> exp4 = list((Object) 2, "4"); assertThat(Lists.<Object>cartesianProduct(x, y)) .containsExactly(exp1, exp2, exp3, exp4) .inOrder(); }
@SuppressWarnings("unchecked") // varargs! public void testCartesianProduct_2x2x2() { assertThat(Lists.cartesianProduct(list(0, 1), list(0, 1), list(0, 1))) .containsExactly( list(0, 0, 0), list(0, 0, 1), list(0, 1, 0), list(0, 1, 1), list(1, 0, 0), list(1, 0, 1), list(1, 1, 0), list(1, 1, 1)) .inOrder(); }
@SuppressWarnings("unchecked") @Parameters(name = "Map<{0}, {1}>, checked={2}, {3}, {4}") public static Iterable<Object[]> parameters() { List<Boolean> checked = ImmutableList.of(false, true); List<NamingConvention> conventions = Arrays.asList(NamingConvention.values()); List<FeatureSet> features = FeatureSets.ALL; return () -> Lists .cartesianProduct(TYPES, TYPES, checked, conventions, features) .stream() .map(List::toArray) .iterator(); }
@SuppressWarnings("unchecked") @Parameters(name = "Multiset<{0}>, checked={1}, {2}, {3}") public static Iterable<Object[]> featureSets() { List<Boolean> checkedAndInterned = ImmutableList.of(false, true); List<NamingConvention> conventions = Arrays.asList(NamingConvention.values()); List<FeatureSet> features = FeatureSets.WITH_GUAVA; return () -> Lists .cartesianProduct(TYPES, checkedAndInterned, conventions, features) .stream() .map(List::toArray) .iterator(); }
@SuppressWarnings("unchecked") @Parameters(name = "List<{0}>, {1}, {2}") public static Iterable<Object[]> parameters() { List<NamingConvention> conventions = Arrays.asList(NamingConvention.values()); List<FeatureSet> features = FeatureSets.ALL; return () -> Lists .cartesianProduct(TYPES, conventions, features) .stream() .map(List::toArray) .iterator(); }