/** * Returns a fluent iterable containing the specified elements in order. * * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#of(Object[]) * Stream.of(T...)}. * * @since 20.0 */ @Beta public static <E> FluentIterable<E> of(@Nullable E element, E... elements) { return from(Lists.asList(element, elements)); }
/** * Adds a group of objects that are supposed to be equivalent to each other and not equivalent to * objects in any other equivalence group added to this tester. */ public EquivalenceTester<T> addEquivalenceGroup(T first, T... rest) { addEquivalenceGroup(Lists.asList(first, rest)); return this; }
public TopNQueryBuilder filters(String dimensionName, String value, String... values) { dimFilter = new InDimFilter(dimensionName, Lists.asList(value, values), null); return this; }
@Override protected List<String> create(String[] elements) { String[] rest = new String[elements.length - 2]; System.arraycopy(elements, 2, rest, 0, elements.length - 2); return Lists.asList(elements[0], elements[1], rest); } })
public static QualifiedName of(String first, String... rest) { requireNonNull(first, "first is null"); return of(ImmutableList.copyOf(Lists.asList(first, rest))); }
public TimeseriesQueryBuilder filters(String dimensionName, String value, String... values) { dimFilter = new InDimFilter(dimensionName, Lists.asList(value, values), null); return this; }
@Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", "bar", new String[0]).iterator(); } }.test();
@Override protected List<String> create(String[] elements) { String[] rest = new String[elements.length - 1]; System.arraycopy(elements, 1, rest, 0, elements.length - 1); return Lists.asList(elements[0], rest); } })
@Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", new String[] {"bar", "baz"}).iterator(); } }.test();
@Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", "bar", new String[] {"baz"}).iterator(); } }.test();
@Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", new String[0]).iterator(); } }.test();
/** * Returns a fluent iterable containing the specified elements in order. * * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#of(Object[]) * Stream.of(T...)}. * * @since 20.0 */ @Beta public static <E> FluentIterable<E> of(@NullableDecl E element, E... elements) { return from(Lists.asList(element, elements)); }
/** * Returns an ordering that compares objects according to the order in which they are given to * this method. Only objects present in the argument list (according to {@link Object#equals}) may * be compared. This comparator imposes a "partial ordering" over the type {@code T}. Null values * in the argument list are not supported. * * <p>The returned comparator throws a {@link ClassCastException} when it receives an input * parameter that isn't among the provided values. * * <p>The generated comparator is serializable if all the provided values are serializable. * * @param leastValue the value which the returned comparator should consider the "least" of all * values * @param remainingValuesInOrder the rest of the values that the returned comparator will be able * to compare, in the order the comparator should follow * @return the comparator described above * @throws NullPointerException if any of the provided values is null * @throws IllegalArgumentException if any duplicate values (according to {@link * Object#equals(Object)}) are present among the method arguments */ // TODO(kevinb): provide replacement @GwtCompatible(serializable = true) public static <T> Ordering<T> explicit(T leastValue, T... remainingValuesInOrder) { return explicit(Lists.asList(leastValue, remainingValuesInOrder)); }
private DimFilter toInFilterWithFn(String dim, ExtractionFn fn, String value, String... values) { return new InDimFilter(dim, Lists.asList(value, values), fn); } }
private DimFilter toInFilter(String dim, String value, String... values) { return new InDimFilter(dim, Lists.asList(value, values), null); }
public void testAsList2() { List<String> list = Lists.asList("foo", "bar", new String[] {"baz"}); checkFooBarBazList(list); assertTrue(list instanceof RandomAccess); new IteratorTester<String>( 5, UNMODIFIABLE, asList("foo", "bar", "baz"), IteratorTester.KnownOrder.KNOWN_ORDER) { @Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", "bar", new String[] {"baz"}).iterator(); } }.test(); }
TypeVariableEqualsTester addEqualityGroup(Type jvmType, Type... types) { if (Types.NativeTypeVariableEquals.NATIVE_TYPE_VARIABLE_ONLY) { tester.addEqualityGroup(jvmType); tester.addEqualityGroup((Object[]) types); } else { tester.addEqualityGroup(Lists.asList(jvmType, types).toArray()); } return this; }
public void testAsList1Small() { List<String> list = Lists.asList("foo", new String[0]); assertThat(list).contains("foo"); assertEquals(1, list.size()); assertIndexIsOutOfBounds(list, -1); assertEquals("foo", list.get(0)); assertIndexIsOutOfBounds(list, 1); assertTrue(list instanceof RandomAccess); new IteratorTester<String>( 3, UNMODIFIABLE, singletonList("foo"), IteratorTester.KnownOrder.KNOWN_ORDER) { @Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", new String[0]).iterator(); } }.test(); }
@GwtIncompatible // SerializableTester public void testAsList1() { List<String> list = Lists.asList("foo", new String[] {"bar", "baz"}); checkFooBarBazList(list); SerializableTester.reserializeAndAssert(list); assertTrue(list instanceof RandomAccess); new IteratorTester<String>( 5, UNMODIFIABLE, asList("foo", "bar", "baz"), IteratorTester.KnownOrder.KNOWN_ORDER) { @Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", new String[] {"bar", "baz"}).iterator(); } }.test(); }
@GwtIncompatible // SerializableTester public void testAsList2Small() { List<String> list = Lists.asList("foo", "bar", new String[0]); assertThat(list).containsExactly("foo", "bar").inOrder(); assertEquals(2, list.size()); assertIndexIsOutOfBounds(list, -1); assertEquals("foo", list.get(0)); assertEquals("bar", list.get(1)); assertIndexIsOutOfBounds(list, 2); SerializableTester.reserializeAndAssert(list); assertTrue(list instanceof RandomAccess); new IteratorTester<String>( 5, UNMODIFIABLE, asList("foo", "bar"), IteratorTester.KnownOrder.KNOWN_ORDER) { @Override protected Iterator<String> newTargetIterator() { return Lists.asList("foo", "bar", new String[0]).iterator(); } }.test(); }