Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add Java 10 Collectors APIs #9860

Merged
merged 5 commits into from
Dec 23, 2023
Merged

Add Java 10 Collectors APIs #9860

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
e25559d
Tests for unmodifiable Collectors methods
niloc132 Jun 20, 2023
da3c491
Added missing impls, stuck on another branch
niloc132 Jun 24, 2023
62e0d87
Add extra imports added/removed upstream
niloc132 Jun 28, 2023
0ea22cf
Review feedback
niloc132 Dec 23, 2023
20a0add
Merge branch 'main' into java10-streams-test
niloc132 Dec 23, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
33 changes: 33 additions & 0 deletions user/super/com/google/gwt/emul/java/util/stream/Collectors.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.DoubleSummaryStatistics;
import java.util.HashMap;
Expand All @@ -27,6 +28,7 @@
import java.util.List;
import java.util.LongSummaryStatistics;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.StringJoiner;
Expand Down Expand Up @@ -339,6 +341,11 @@ public static <T> Collector<T,?,List<T>> toList() {
return toCollection(ArrayList::new);
}

public static <T> Collector<T, ?, List<T>> toUnmodifiableList() {
Collector<T, ?, List<T>> mapping = mapping(Objects::requireNonNull, toList());
return collectingAndThen(mapping, Collections::unmodifiableList);
}

public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(
final Function<? super T, ? extends K> keyMapper,
final Function<? super T, ? extends U> valueMapper) {
Expand All @@ -357,6 +364,27 @@ public static <T> Collector<T,?,List<T>> toList() {
return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}

public static <T, K, U> Collector<T, ?, Map<K, U>> toUnmodifiableMap(Function<? super T, ?
niloc132 marked this conversation as resolved.
Show resolved Hide resolved
extends K> keyMapper, Function<? super T, ? extends U> valueMapper) {
return collectingAndThen(
toMap(disallowNulls(keyMapper), disallowNulls(valueMapper)),
Collections::unmodifiableMap
);
}

public static <T, K, U> Collector<T, ?, Map<K, U>> toUnmodifiableMap(Function<? super T, ?
extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U>
mergeFunction) {
return collectingAndThen(
toMap(disallowNulls(keyMapper), disallowNulls(valueMapper), mergeFunction),
Collections::unmodifiableMap
);
}

private static <T, R> Function<T, R> disallowNulls(Function<T, R> func) {
return func.andThen(Objects::requireNonNull);
}

public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(
final Function<? super T, ? extends K> keyMapper,
final Function<? super T, ? extends U> valueMapper,
Expand Down Expand Up @@ -389,6 +417,11 @@ public static <T> Collector<T,?,Set<T>> toSet() {
);
}

public static <T> Collector<T, ?, Set<T>> toUnmodifiableSet() {
Collector<T, ?, Set<T>> mapping = mapping(Objects::requireNonNull, toSet());
return collectingAndThen(mapping, Collections::unmodifiableSet);
}

private static <T, D, A> D streamAndCollect(Collector<? super T, A, D> downstream, List<T> list) {
A a = downstream.supplier().get();
for (T t : list) {
Expand Down
2 changes: 2 additions & 0 deletions user/test/com/google/gwt/emultest/EmulJava10Suite.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,13 +19,15 @@
import com.google.gwt.emultest.java10.util.OptionalIntTest;
import com.google.gwt.emultest.java10.util.OptionalLongTest;
import com.google.gwt.emultest.java10.util.OptionalTest;
import com.google.gwt.emultest.java10.util.stream.CollectorsTest;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

/** Test JRE emulations. */
@RunWith(Suite.class)
@SuiteClasses({
CollectorsTest.class,
OptionalDoubleTest.class,
OptionalIntTest.class,
OptionalLongTest.class,
Expand Down
172 changes: 172 additions & 0 deletions user/test/com/google/gwt/emultest/java10/util/stream/CollectorsTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,172 @@
/*
* Copyright 2023 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.emultest.java10.util.stream;

import static com.google.gwt.emultest.java8.util.stream.CollectorsTest.applyItems;
import static java.util.stream.Collectors.toUnmodifiableList;
import static java.util.stream.Collectors.toUnmodifiableMap;
import static java.util.stream.Collectors.toUnmodifiableSet;

import com.google.gwt.emultest.java.util.EmulTestBase;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Stream;

/**
* Tests for java.util.stream.Collectors Java 10 API emulation.
*/
public class CollectorsTest extends EmulTestBase {
private static <T> boolean unmodifiableCollection(Collection<T> c, T existingSample, T newSample) {
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It misses a lot of cases. Maybe we should refactor a bit in a follow up commit that introduces a helper class to check immutability of collections/sets, lists, maps. We now have many tests that need it: CollectionsTest, ListTest, SetTest, MapTest, CollectorsTest. Each doing it a bit differently and not covering everything.

Copy link
Member Author

@niloc132 niloc132 Dec 23, 2023 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Good call, I'll file a followup. At least for the List-verification method, the simplest answer might be to make CollectionsTest.doTestModificationsToList public and static, and lean on it from here.

Note that I didn't work especially hard on fully validating every method, since the emulation depends on existing code that I assumed was well tested (or at least verified in real use) - at some point we have to assume that the levels below us are roughly sane...

#9882

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

at some point we have to assume that the levels below us are roughly sane

Yes, I had the thought that it might be good to just make the emulated immutable collection classes public and then simply do an instanceof check. If Collections.unmodifiableList/List.of and friends all use the same implementations, that would be fine I guess. Then we could make one test for the immutable implementations and all other tests check if that implementation has been used.

try {
c.remove(existingSample);
return false;
} catch (Exception ignore) {
niloc132 marked this conversation as resolved.
Show resolved Hide resolved
// expected
}
try {
c.add(newSample);
return false;
} catch (Exception ignore) {
// expected
}
Iterator<T> itr = c.iterator();
itr.next();
try {
itr.remove();
return false;
} catch (Exception e) {
// expected
}
return true;
}

public void testToUnmodifiableList() {
applyItems(List.of("a", "b"), toUnmodifiableList(), "a", "b", (a, b) -> {
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

All these tests are fine but a bit difficult to review/read. applyItems isn't a great name as it also executes tests using the provided equals function. I had to lookup what applyItems actually does. Also using (a, b) was a bit distracting as a and b are used as values as well. Using expected and actual would probably make more sense. Then we also don't need to test immutability of expected.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Happy to have a proposed name change for applyItems(), but this has gone through 4ish patches now, and I think the Javadoc is fairly clear - this method applies the collector to the items specified in a way that validates that the Collector instance functions according to its contract. A more accurate name would probably be too unwieldy, and still require that the test author/reader check for themselves what it does (applyCollectorToItemsWithAndWithoutSplittingAndValidateResultsMatchExpected?), or we could make it only marginally more clear - but this would still require the reader to actually check the code to understand the implications (applyCollectorToItemsAndValidate, applyCollectorAndValidate, validateCollectorBehavior?)

I'll rename the lambda args.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

applyCollectorToItemsWithAndWithoutSplittingAndValidateResultsMatchExpected
Hehe..

I thought about unwrapping it, e.g.

var list1 = collectItemsWithSplitting(collector, items...)
var list2 = collectItemsWithoutSplitting(collector, items...)
assertAllImmutable(list1, list2);
assertAllEqual(expected, list1, list2)

or

var result = collectItems(collector, items...)
assertAllImmutable(result.withSplitting, result.withoutSplitting);
assertAllEqual(expected, result.withSplitting, result.withoutSplitting)

if (!a.equals(b)) {
return false;
}

// check both, so it is obvious we got the right one
if (!unmodifiableCollection(a, "a", "z")) {
return false;
}
if (!unmodifiableCollection(b, "a", "z")) {
return false;
}

return true;
});

// verify nulls fail
try {
Stream.of("a").map(ignore -> null).collect(toUnmodifiableList());
fail("Expected NPE");
} catch (NullPointerException ignore) {
// expected
}
}

public void testToUnmodifiableMap() {
// verify simple cases copy all values and results are unmodifiable
applyItems(Map.of("a", 0, "b", 1), toUnmodifiableMap(Function.identity(),
k -> k.charAt(0) - 'a'), "a", "b", (a, b) -> {
if (!a.equals(b)) {
return false;
}

// check both, so it is obvious we got the right one
if (!unmodifiableMap(a, "a", 0, "z", 100)) {
return false;
}
if (!unmodifiableMap(b, "a", 0, "z", 100)) {
return false;
}

return true;
});

// verify merge works with only one key (but this is just passing through to the toMap func anyway...)
applyItems(Map.of("a", 2), toUnmodifiableMap(Function.identity(), ignore -> 1, Integer::sum),
"a", "a");

// verify nulls blow up for both keys and values
try {
Stream.of("a").collect(toUnmodifiableMap(obj -> null, Function.identity()));
fail("Expected NPE");
} catch (NullPointerException ignore) {
// expected
}
try {
Stream.of("a").collect(toUnmodifiableMap(Function.identity(), obj -> null));
fail("Expected NPE");
} catch (Exception ignore) {
// expected
}
}

private <K, V> boolean unmodifiableMap(Map<K, V> a, K existingKey, V existingValue, K newKey,
niloc132 marked this conversation as resolved.
Show resolved Hide resolved
V newValue) {
if (!unmodifiableCollection(a.keySet(), existingKey, newKey)) {
return false;
}
if (!unmodifiableCollection(a.values(), existingValue, newValue)) {
return false;
}

try {
a.put(newKey, newValue);
return false;
} catch (Exception ignore) {
// expected
}
try {
a.remove(existingKey);
return false;
} catch (Exception ignore) {
// expected
}

return true;
}

public void testToUnmodifiableSet() {
applyItems(Set.of("a", "b"), toUnmodifiableSet(), "a", "b", (a, b) -> {
if (!a.equals(b)) {
return false;
}
if (!unmodifiableCollection(a, "a", "z")) {
return false;
}
if (!unmodifiableCollection(b, "a", "z")) {
return false;
}
return true;
});

// verify nulls fail
try {
Stream.of("a").map(ignore -> null).collect(toUnmodifiableSet());
fail("Expected NPE");
} catch (NullPointerException ignore) {
// expected
}
}
}
Loading