From 6b89da98bbe7d57f2d79012c932a1d607e119ebd Mon Sep 17 00:00:00 2001 From: Jonathan Shook Date: Fri, 10 Apr 2020 16:01:02 -0500 Subject: [PATCH] listfuncs started, needs docs, examples, unit tests --- .../shared/from_long/to_collection/List.java | 6 +- .../to_collection/ListFunctions.java | 75 +++++++++++++++ .../from_long/to_collection/ListHashed.java | 87 ++++++++++++++++++ .../from_long/to_collection/ListSized.java | 83 +++++++++++++++++ .../to_collection/ListSizedHashed.java | 91 +++++++++++++++++++ .../to_collection/ListSizedStepped.java | 84 +++++++++++++++++ .../from_long/to_collection/ListStepped.java | 83 +++++++++++++++++ .../to_collection/ListFunctionsTest.java | 21 +++++ .../to_collection/ListSizedHashedTest.java | 44 +++++++++ 9 files changed, 570 insertions(+), 4 deletions(-) create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctions.java create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListHashed.java create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSized.java create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashed.java create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedStepped.java create mode 100644 virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListStepped.java create mode 100644 virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctionsTest.java create mode 100644 virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashedTest.java diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/List.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/List.java index 947ce9ebb..23a3754f5 100644 --- a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/List.java +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/List.java @@ -1,9 +1,6 @@ package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; -import io.nosqlbench.virtdata.api.annotations.Categories; -import io.nosqlbench.virtdata.api.annotations.Category; -import io.nosqlbench.virtdata.api.annotations.Example; -import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; +import io.nosqlbench.virtdata.api.annotations.*; import java.util.ArrayList; import java.util.function.LongFunction; @@ -21,6 +18,7 @@ import java.util.function.LongToIntFunction; */ @Categories({Category.collections}) @ThreadSafeMapper +@DeprecatedFunction("Use ListSizedStepped") public class List implements LongFunction> { private final LongToIntFunction sizeFunc; diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctions.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctions.java new file mode 100644 index 000000000..9de20d7ee --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctions.java @@ -0,0 +1,75 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + +import io.nosqlbench.virtdata.api.annotations.Categories; +import io.nosqlbench.virtdata.api.annotations.Category; +import io.nosqlbench.virtdata.api.annotations.Example; +import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.function.LongFunction; +import java.util.function.LongUnaryOperator; + +/** + * Create a {@code List} from a long input + * based on two functions, the first to + * determine the list size, and the second to populate the list with + * object values. The input fed to the second function is incremented + * between elements. + * + * To directly create Lists of Strings from the String version of the same + * mapping functions, simply use {@link StringList} instead. + */ +@Categories({Category.collections}) +@ThreadSafeMapper +public class ListFunctions implements LongFunction> { + + private final java.util.List> valueFuncs; + private final int size; + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListFunctions(LongFunction... funcs) { + this.valueFuncs = Arrays.asList(funcs); + this.size = valueFuncs.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListFunctions(LongUnaryOperator... funcs) { + List> building = new ArrayList<>(funcs.length); + for (LongUnaryOperator func : funcs) { + building.add(func::applyAsLong); + } + this.valueFuncs = building; + this.size = building.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListFunctions(Function... funcs) { + List> building = new ArrayList<>(funcs.length); + for (Function func : funcs) { + building.add(func::apply); + } + this.valueFuncs = building; + this.size = building.size(); + } + + @Override + public java.util.List apply(long value) { + java.util.List list = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + list.add(valueFuncs.get(i).apply(value)); + } + return list; + } +} diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListHashed.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListHashed.java new file mode 100644 index 000000000..606e18462 --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListHashed.java @@ -0,0 +1,87 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + +import io.nosqlbench.virtdata.api.annotations.Categories; +import io.nosqlbench.virtdata.api.annotations.Category; +import io.nosqlbench.virtdata.api.annotations.Example; +import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; +import io.nosqlbench.virtdata.library.basics.shared.from_long.to_long.Hash; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.function.LongFunction; +import java.util.function.LongToIntFunction; +import java.util.function.LongUnaryOperator; + +/** + * Create a {@code List} from a long input + * based on two functions, the first to + * determine the list size, and the second to populate the list with + * object values. The input fed to the second function is incremented + * between elements. + * + * To directly create Lists of Strings from the String version of the same + * mapping functions, simply use {@link StringList} instead. + */ +@Categories({Category.collections}) +@ThreadSafeMapper +public class ListHashed implements LongFunction> { + + private final List> valueFuncs; + private final int size; + private final LongToIntFunction sizeFunc; + private final Hash hasher = new Hash(); + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListHashed(LongToIntFunction sizeFunc, LongFunction... funcs) { + this.sizeFunc = sizeFunc; + this.valueFuncs = Arrays.asList(funcs); + this.size = valueFuncs.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListHashed(LongToIntFunction sizeFunc, LongUnaryOperator... funcs) { + List> building = new ArrayList<>(funcs.length); + for (LongUnaryOperator func : funcs) { + building.add(func::applyAsLong); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListHashed(LongToIntFunction sizeFunc, Function... funcs) { + List> building = new ArrayList<>(funcs.length); + for (Function func : funcs) { + building.add(func::apply); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Override + public List apply(long value) { + long hash = value; + int size = sizeFunc.applyAsInt(value); + List list = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + int selector = Math.min(i, valueFuncs.size() - 1); + LongFunction func = valueFuncs.get(selector); + hash = hasher.applyAsLong(value); + list.add(func.apply(hash)); + } + return list; + } +} diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSized.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSized.java new file mode 100644 index 000000000..7320e2f2b --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSized.java @@ -0,0 +1,83 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + +import io.nosqlbench.virtdata.api.annotations.Categories; +import io.nosqlbench.virtdata.api.annotations.Category; +import io.nosqlbench.virtdata.api.annotations.Example; +import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.function.LongFunction; +import java.util.function.LongToIntFunction; +import java.util.function.LongUnaryOperator; + +/** + * Create a {@code List} from a long input + * based on two functions, the first to + * determine the list size, and the second to populate the list with + * object values. The input fed to the second function is incremented + * between elements. + * + * To directly create Lists of Strings from the String version of the same + * mapping functions, simply use {@link StringList} instead. + */ +@Categories({Category.collections}) +@ThreadSafeMapper +public class ListSized implements LongFunction> { + + private final List> valueFuncs; + private final int size; + private final LongToIntFunction sizeFunc; + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSized(LongToIntFunction sizeFunc, LongFunction... funcs) { + this.sizeFunc = sizeFunc; + this.valueFuncs = Arrays.asList(funcs); + this.size = valueFuncs.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSized(LongToIntFunction sizeFunc, LongUnaryOperator... funcs) { + List> building = new ArrayList<>(funcs.length); + for (LongUnaryOperator func : funcs) { + building.add(func::applyAsLong); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSized(LongToIntFunction sizeFunc, Function... funcs) { + List> building = new ArrayList<>(funcs.length); + for (Function func : funcs) { + building.add(func::apply); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Override + public List apply(long value) { + int size = sizeFunc.applyAsInt(value); + List list = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + int selector = Math.min(i, valueFuncs.size() - 1); + LongFunction func = valueFuncs.get(selector); + list.add(func.apply(value)); + } + return list; + } +} diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashed.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashed.java new file mode 100644 index 000000000..5236c578e --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashed.java @@ -0,0 +1,91 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + +import io.nosqlbench.virtdata.api.annotations.Categories; +import io.nosqlbench.virtdata.api.annotations.Category; +import io.nosqlbench.virtdata.api.annotations.Example; +import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; +import io.nosqlbench.virtdata.library.basics.shared.from_long.to_long.Hash; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.function.LongFunction; +import java.util.function.LongToIntFunction; +import java.util.function.LongUnaryOperator; + +/** + * Create a {@code List} from a long input + * based on two functions, the first to + * determine the list size, and the second to populate the list with + * object values. The input fed to the second function is incremented + * between elements. + * + * To directly create Lists of Strings from the String version of the same + * mapping functions, simply use {@link StringList} instead. + */ +@Categories({Category.collections}) +@ThreadSafeMapper +public class ListSizedHashed implements LongFunction> { + + private final List> valueFuncs; + private final int size; + private final Hash hasher = new Hash(); + private final LongToIntFunction sizeFunc; + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSizedHashed(LongToIntFunction sizeFunc, LongFunction... funcs) { + this.sizeFunc = sizeFunc; + this.valueFuncs = Arrays.asList(funcs); + this.size = valueFuncs.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSizedHashed(LongToIntFunction sizeFunc, LongUnaryOperator... funcs) { + List> building = new ArrayList<>(funcs.length); + for (LongUnaryOperator func : funcs) { + building.add(func::applyAsLong); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSizedHashed(LongToIntFunction sizeFunc, Function... funcs) { + List> building = new ArrayList<>(funcs.length); + for (Function func : funcs) { + building.add(func::apply); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Override + public List apply(long value) { + int size = sizeFunc.applyAsInt(value); + + long hashed = value; + List list = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + hashed = hasher.applyAsLong(hashed); + // Get the pair-wise function to the list index (0 based) + // if the list is longer than the functions, use the last function + + int selector = Math.min(i, valueFuncs.size() - 1); + LongFunction func = valueFuncs.get(selector); + list.add(func.apply(hashed)); + } + return list; + } +} diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedStepped.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedStepped.java new file mode 100644 index 000000000..6c150f273 --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedStepped.java @@ -0,0 +1,84 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + +import io.nosqlbench.virtdata.api.annotations.Categories; +import io.nosqlbench.virtdata.api.annotations.Category; +import io.nosqlbench.virtdata.api.annotations.Example; +import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; +import io.nosqlbench.virtdata.library.basics.shared.from_long.to_long.Hash; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.function.LongFunction; +import java.util.function.LongToIntFunction; +import java.util.function.LongUnaryOperator; + +/** + * Create a {@code List} from a long input + * based on two functions, the first to + * determine the list size, and the second to populate the list with + * object values. The input fed to the second function is incremented + * between elements. + * + * To directly create Lists of Strings from the String version of the same + * mapping functions, simply use {@link StringList} instead. + */ +@Categories({Category.collections}) +@ThreadSafeMapper +public class ListSizedStepped implements LongFunction> { + + private final List> valueFuncs; + private final int size; + private final LongToIntFunction sizeFunc; + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSizedStepped(LongToIntFunction sizeFunc, LongFunction... funcs) { + this.sizeFunc = sizeFunc; + this.valueFuncs = Arrays.asList(funcs); + this.size = valueFuncs.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSizedStepped(LongToIntFunction sizeFunc, LongUnaryOperator... funcs) { + List> building = new ArrayList<>(funcs.length); + for (LongUnaryOperator func : funcs) { + building.add(func::applyAsLong); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListSizedStepped(LongToIntFunction sizeFunc, Function... funcs) { + List> building = new ArrayList<>(funcs.length); + for (Function func : funcs) { + building.add(func::apply); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Override + public List apply(long value) { + int size = sizeFunc.applyAsInt(value); + List list = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + int selector = Math.min(i, valueFuncs.size() - 1); + LongFunction func = valueFuncs.get(selector); + list.add(func.apply(i+value)); + } + return list; + } +} diff --git a/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListStepped.java b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListStepped.java new file mode 100644 index 000000000..5ac4f222f --- /dev/null +++ b/virtdata-lib-basics/src/main/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListStepped.java @@ -0,0 +1,83 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + +import io.nosqlbench.virtdata.api.annotations.Categories; +import io.nosqlbench.virtdata.api.annotations.Category; +import io.nosqlbench.virtdata.api.annotations.Example; +import io.nosqlbench.virtdata.api.annotations.ThreadSafeMapper; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Function; +import java.util.function.LongFunction; +import java.util.function.LongToIntFunction; +import java.util.function.LongUnaryOperator; + +/** + * Create a {@code List} from a long input + * based on two functions, the first to + * determine the list size, and the second to populate the list with + * object values. The input fed to the second function is incremented + * between elements. + * + * To directly create Lists of Strings from the String version of the same + * mapping functions, simply use {@link StringList} instead. + */ +@Categories({Category.collections}) +@ThreadSafeMapper +public class ListStepped implements LongFunction> { + + private final List> valueFuncs; + private final int size; + private final LongToIntFunction sizeFunc; + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListStepped(LongToIntFunction sizeFunc, LongFunction... funcs) { + this.sizeFunc = sizeFunc; + this.valueFuncs = Arrays.asList(funcs); + this.size = valueFuncs.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListStepped(LongToIntFunction sizeFunc, LongUnaryOperator... funcs) { + List> building = new ArrayList<>(funcs.length); + for (LongUnaryOperator func : funcs) { + building.add(func::applyAsLong); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Example({ + "ListFunctions(NumberNameToString(),NumberNameToString())", + "Create a list of ['one','one']" + }) + public ListStepped(LongToIntFunction sizeFunc, Function... funcs) { + List> building = new ArrayList<>(funcs.length); + for (Function func : funcs) { + building.add(func::apply); + } + this.sizeFunc = sizeFunc; + this.valueFuncs = building; + this.size = building.size(); + } + + @Override + public List apply(long value) { + int size = sizeFunc.applyAsInt(value); + List list = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + int selector = Math.min(i, valueFuncs.size() - 1); + LongFunction func = valueFuncs.get(selector); + list.add(func.apply(value+i)); + } + return list; + } +} diff --git a/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctionsTest.java b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctionsTest.java new file mode 100644 index 000000000..e632dc96c --- /dev/null +++ b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListFunctionsTest.java @@ -0,0 +1,21 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + +import org.junit.Test; + +import java.util.List; +import java.util.function.LongFunction; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ListFunctionsTest { + + @Test + public void ListFunctions() { + LongFunction f1 = (long l) -> "long[" + l + "]"; + ListFunctions func = new ListFunctions(f1); + List value = func.apply(234L); + assertThat(value).hasSize(1); + assertThat(value.get(0)).isOfAnyClassIn(String.class); + } + +} diff --git a/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashedTest.java b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashedTest.java new file mode 100644 index 000000000..7cb372c54 --- /dev/null +++ b/virtdata-lib-basics/src/test/java/io/nosqlbench/virtdata/library/basics/shared/from_long/to_collection/ListSizedHashedTest.java @@ -0,0 +1,44 @@ +package io.nosqlbench.virtdata.library.basics.shared.from_long.to_collection; + + +import io.nosqlbench.virtdata.library.basics.shared.from_long.to_string.NumberNameToString; +import org.junit.Test; + +import java.util.List; +import java.util.function.LongFunction; +import java.util.function.LongToIntFunction; + +import static org.assertj.core.api.Assertions.assertThat; + +public class ListSizedHashedTest { + + @Test + public void testTwoPartExample() { + LongToIntFunction sizer = (l) -> (int) l; + LongFunction namer = (l) -> "L{" + l + "}"; + + ListSizedHashed f1 = new ListSizedHashed(sizer, namer); + List for37 = f1.apply(37L); + assertThat(for37).hasSize(37); + assertThat(for37.get(0)).isNotEqualTo(for37.get(36)); + for (Object o : for37) { + System.out.println(o); + } + + } + + @Test + public void testFunctionSelection() { + LongToIntFunction sizer = (l) -> (int) l; + LongFunction namer = (l) -> "L{" + l + "}"; + LongFunction brackets = (l) -> "[[" + l + "]]"; + + ListSizedHashed f2 = new ListSizedHashed(sizer, namer, namer, brackets, namer); + List for53 = f2.apply(53L); + assertThat(for53).hasSize(53); + assertThat(for53.get(2).toString()).startsWith("[["); + assertThat(for53.get(52)).isOfAnyClassIn(String.class); + + } + +}