Debian Codegraph @

serialization-tests/src/test/java/org/eclipse/collections/impl/lazy/primitive/LazyIterableTestHelper.java

raw
1 /*
2 * Copyright (c) 2021 Goldman Sachs and others.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * and Eclipse Distribution License v. 1.0 which accompany this distribution.
6 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
7 * and the Eclipse Distribution License is available at
8 * http://www.eclipse.org/org/documents/edl-v10.php.
9 */
10
11 package org.eclipse.collections.impl.lazy.primitive;
12
13 import java.util.Collection;
14 import java.util.Comparator;
15 import java.util.Iterator;
16 import java.util.Map;
17 import java.util.Optional;
18
19 import org.eclipse.collections.api.LazyBooleanIterable;
20 import org.eclipse.collections.api.LazyByteIterable;
21 import org.eclipse.collections.api.LazyCharIterable;
22 import org.eclipse.collections.api.LazyDoubleIterable;
23 import org.eclipse.collections.api.LazyFloatIterable;
24 import org.eclipse.collections.api.LazyIntIterable;
25 import org.eclipse.collections.api.LazyIterable;
26 import org.eclipse.collections.api.LazyLongIterable;
27 import org.eclipse.collections.api.LazyShortIterable;
28 import org.eclipse.collections.api.RichIterable;
29 import org.eclipse.collections.api.bag.MutableBag;
30 import org.eclipse.collections.api.bag.sorted.MutableSortedBag;
31 import org.eclipse.collections.api.bimap.MutableBiMap;
32 import org.eclipse.collections.api.block.function.Function;
33 import org.eclipse.collections.api.block.function.Function0;
34 import org.eclipse.collections.api.block.function.Function2;
35 import org.eclipse.collections.api.block.function.primitive.BooleanFunction;
36 import org.eclipse.collections.api.block.function.primitive.ByteFunction;
37 import org.eclipse.collections.api.block.function.primitive.CharFunction;
38 import org.eclipse.collections.api.block.function.primitive.DoubleFunction;
39 import org.eclipse.collections.api.block.function.primitive.DoubleObjectToDoubleFunction;
40 import org.eclipse.collections.api.block.function.primitive.FloatFunction;
41 import org.eclipse.collections.api.block.function.primitive.FloatObjectToFloatFunction;
42 import org.eclipse.collections.api.block.function.primitive.IntFunction;
43 import org.eclipse.collections.api.block.function.primitive.IntObjectToIntFunction;
44 import org.eclipse.collections.api.block.function.primitive.LongFunction;
45 import org.eclipse.collections.api.block.function.primitive.LongObjectToLongFunction;
46 import org.eclipse.collections.api.block.function.primitive.ShortFunction;
47 import org.eclipse.collections.api.block.predicate.Predicate;
48 import org.eclipse.collections.api.block.predicate.Predicate2;
49 import org.eclipse.collections.api.block.procedure.Procedure;
50 import org.eclipse.collections.api.block.procedure.Procedure2;
51 import org.eclipse.collections.api.block.procedure.primitive.ObjectIntProcedure;
52 import org.eclipse.collections.api.collection.primitive.MutableBooleanCollection;
53 import org.eclipse.collections.api.collection.primitive.MutableByteCollection;
54 import org.eclipse.collections.api.collection.primitive.MutableCharCollection;
55 import org.eclipse.collections.api.collection.primitive.MutableDoubleCollection;
56 import org.eclipse.collections.api.collection.primitive.MutableFloatCollection;
57 import org.eclipse.collections.api.collection.primitive.MutableIntCollection;
58 import org.eclipse.collections.api.collection.primitive.MutableLongCollection;
59 import org.eclipse.collections.api.collection.primitive.MutableShortCollection;
60 import org.eclipse.collections.api.list.MutableList;
61 import org.eclipse.collections.api.map.MapIterable;
62 import org.eclipse.collections.api.map.MutableMap;
63 import org.eclipse.collections.api.map.MutableMapIterable;
64 import org.eclipse.collections.api.map.primitive.MutableObjectDoubleMap;
65 import org.eclipse.collections.api.map.primitive.MutableObjectLongMap;
66 import org.eclipse.collections.api.map.sorted.MutableSortedMap;
67 import org.eclipse.collections.api.multimap.Multimap;
68 import org.eclipse.collections.api.multimap.MutableMultimap;
69 import org.eclipse.collections.api.partition.PartitionIterable;
70 import org.eclipse.collections.api.set.MutableSet;
71 import org.eclipse.collections.api.set.sorted.MutableSortedSet;
72 import org.eclipse.collections.api.tuple.Pair;
73 import org.eclipse.collections.impl.test.Verify;
74
75 public class LazyIterableTestHelper<T> implements LazyIterable<T>
76 {
77 private final String serializedForm;
78
79 public LazyIterableTestHelper(String serializedForm)
80 {
81 this.serializedForm = serializedForm;
82 }
83
84 @Override
85 public int size()
86 {
87 return 0;
88 }
89
90 @Override
91 public boolean isEmpty()
92 {
93 return false;
94 }
95
96 @Override
97 public boolean notEmpty()
98 {
99 return false;
100 }
101
102 @Override
103 public T getFirst()
104 {
105 return null;
106 }
107
108 @Override
109 public T getLast()
110 {
111 return null;
112 }
113
114 @Override
115 public T getOnly()
116 {
117 return null;
118 }
119
120 @Override
121 public boolean contains(Object object)
122 {
123 return false;
124 }
125
126 @Override
127 public boolean containsAllIterable(Iterable<?> source)
128 {
129 return false;
130 }
131
132 @Override
133 public boolean containsAll(Collection<?> source)
134 {
135 return false;
136 }
137
138 @Override
139 public boolean containsAllArguments(Object... elements)
140 {
141 return false;
142 }
143
144 @Override
145 public LazyIterable<T> select(Predicate<? super T> predicate)
146 {
147 return null;
148 }
149
150 @Override
151 public <R extends Collection<T>> R select(Predicate<? super T> predicate, R target)
152 {
153 return null;
154 }
155
156 @Override
157 public <P> LazyIterable<T> selectWith(Predicate2<? super T, ? super P> predicate, P parameter)
158 {
159 return null;
160 }
161
162 @Override
163 public <P, R extends Collection<T>> R selectWith(Predicate2<? super T, ? super P> predicate, P parameter, R targetCollection)
164 {
165 return null;
166 }
167
168 @Override
169 public <S> LazyIterable<S> selectInstancesOf(Class<S> clazz)
170 {
171 return null;
172 }
173
174 @Override
175 public LazyIterable<T> reject(Predicate<? super T> predicate)
176 {
177 return null;
178 }
179
180 @Override
181 public <P> LazyIterable<T> rejectWith(Predicate2<? super T, ? super P> predicate, P parameter)
182 {
183 return null;
184 }
185
186 @Override
187 public <R extends Collection<T>> R reject(Predicate<? super T> predicate, R target)
188 {
189 return null;
190 }
191
192 @Override
193 public <P, R extends Collection<T>> R rejectWith(Predicate2<? super T, ? super P> predicate, P parameter, R targetCollection)
194 {
195 return null;
196 }
197
198 @Override
199 public PartitionIterable<T> partition(Predicate<? super T> predicate)
200 {
201 return null;
202 }
203
204 @Override
205 public <P> PartitionIterable<T> partitionWith(Predicate2<? super T, ? super P> predicate, P parameter)
206 {
207 return null;
208 }
209
210 @Override
211 public <V> LazyIterable<V> collect(Function<? super T, ? extends V> function)
212 {
213 return null;
214 }
215
216 @Override
217 public <P, V> LazyIterable<V> collectWith(Function2<? super T, ? super P, ? extends V> function, P parameter)
218 {
219 return null;
220 }
221
222 @Override
223 public <P, V, R extends Collection<V>> R collectWith(Function2<? super T, ? super P, ? extends V> function, P parameter, R targetCollection)
224 {
225 return null;
226 }
227
228 @Override
229 public <V> LazyIterable<V> collectIf(Predicate<? super T> predicate, Function<? super T, ? extends V> function)
230 {
231 return null;
232 }
233
234 @Override
235 public <V, R extends Collection<V>> R collectIf(Predicate<? super T> predicate, Function<? super T, ? extends V> function, R target)
236 {
237 return null;
238 }
239
240 @Override
241 public LazyIterable<T> take(int count)
242 {
243 return null;
244 }
245
246 @Override
247 public LazyIterable<T> drop(int count)
248 {
249 return null;
250 }
251
252 @Override
253 public LazyIterable<T> takeWhile(Predicate<? super T> predicate)
254 {
255 return null;
256 }
257
258 @Override
259 public LazyIterable<T> dropWhile(Predicate<? super T> predicate)
260 {
261 return null;
262 }
263
264 @Override
265 public LazyIterable<T> distinct()
266 {
267 return null;
268 }
269
270 @Override
271 public <V> LazyIterable<V> flatCollect(Function<? super T, ? extends Iterable<V>> function)
272 {
273 return null;
274 }
275
276 @Override
277 public <V, R extends Collection<V>> R flatCollect(Function<? super T, ? extends Iterable<V>> function, R target)
278 {
279 return null;
280 }
281
282 @Override
283 public T detect(Predicate<? super T> predicate)
284 {
285 return null;
286 }
287
288 @Override
289 public <P> T detectWith(Predicate2<? super T, ? super P> predicate, P parameter)
290 {
291 return null;
292 }
293
294 @Override
295 public Optional<T> detectOptional(Predicate<? super T> predicate)
296 {
297 return Optional.empty();
298 }
299
300 @Override
301 public <P> Optional<T> detectWithOptional(Predicate2<? super T, ? super P> predicate, P parameter)
302 {
303 return Optional.empty();
304 }
305
306 @Override
307 public T detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function)
308 {
309 return null;
310 }
311
312 @Override
313 public <P> T detectWithIfNone(Predicate2<? super T, ? super P> predicate, P parameter, Function0<? extends T> function)
314 {
315 return null;
316 }
317
318 @Override
319 public int count(Predicate<? super T> predicate)
320 {
321 return 0;
322 }
323
324 @Override
325 public <P> int countWith(Predicate2<? super T, ? super P> predicate, P parameter)
326 {
327 return 0;
328 }
329
330 @Override
331 public boolean anySatisfy(Predicate<? super T> predicate)
332 {
333 return false;
334 }
335
336 @Override
337 public <P> boolean anySatisfyWith(Predicate2<? super T, ? super P> predicate, P parameter)
338 {
339 return false;
340 }
341
342 @Override
343 public boolean allSatisfy(Predicate<? super T> predicate)
344 {
345 return false;
346 }
347
348 @Override
349 public <P> boolean allSatisfyWith(Predicate2<? super T, ? super P> predicate, P parameter)
350 {
351 return false;
352 }
353
354 @Override
355 public boolean noneSatisfy(Predicate<? super T> predicate)
356 {
357 return false;
358 }
359
360 @Override
361 public <P> boolean noneSatisfyWith(Predicate2<? super T, ? super P> predicate, P parameter)
362 {
363 return false;
364 }
365
366 @Override
367 public <IV> IV injectInto(IV injectedValue, Function2<? super IV, ? super T, ? extends IV> function)
368 {
369 return null;
370 }
371
372 @Override
373 public int injectInto(int injectedValue, IntObjectToIntFunction<? super T> function)
374 {
375 return 0;
376 }
377
378 @Override
379 public long injectInto(long injectedValue, LongObjectToLongFunction<? super T> function)
380 {
381 return 0;
382 }
383
384 @Override
385 public float injectInto(float injectedValue, FloatObjectToFloatFunction<? super T> function)
386 {
387 return 0;
388 }
389
390 @Override
391 public double injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super T> function)
392 {
393 return 0;
394 }
395
396 @Override
397 public MutableList<T> toList()
398 {
399 return null;
400 }
401
402 @Override
403 public MutableList<T> toSortedList()
404 {
405 return null;
406 }
407
408 @Override
409 public MutableList<T> toSortedList(Comparator<? super T> comparator)
410 {
411 return null;
412 }
413
414 @Override
415 public <V extends Comparable<? super V>> MutableList<T> toSortedListBy(Function<? super T, ? extends V> function)
416 {
417 return null;
418 }
419
420 @Override
421 public MutableSet<T> toSet()
422 {
423 return null;
424 }
425
426 @Override
427 public MutableSortedSet<T> toSortedSet()
428 {
429 return null;
430 }
431
432 @Override
433 public MutableSortedSet<T> toSortedSet(Comparator<? super T> comparator)
434 {
435 return null;
436 }
437
438 @Override
439 public <V extends Comparable<? super V>> MutableSortedSet<T> toSortedSetBy(Function<? super T, ? extends V> function)
440 {
441 return null;
442 }
443
444 @Override
445 public MutableBag<T> toBag()
446 {
447 return null;
448 }
449
450 @Override
451 public MutableSortedBag<T> toSortedBag()
452 {
453 return null;
454 }
455
456 @Override
457 public MutableSortedBag<T> toSortedBag(Comparator<? super T> comparator)
458 {
459 return null;
460 }
461
462 @Override
463 public <V extends Comparable<? super V>> MutableSortedBag<T> toSortedBagBy(Function<? super T, ? extends V> function)
464 {
465 return null;
466 }
467
468 @Override
469 public <NK, NV> MutableMap<NK, NV> toMap(Function<? super T, ? extends NK> keyFunction, Function<? super T, ? extends NV> valueFunction)
470 {
471 return null;
472 }
473
474 @Override
475 public <NK, NV, R extends Map<NK, NV>> R toMap(Function<? super T, ? extends NK> keyFunction, Function<? super T, ? extends NV> valueFunction, R target)
476 {
477 return null;
478 }
479
480 @Override
481 public <NK, NV> MutableSortedMap<NK, NV> toSortedMap(Function<? super T, ? extends NK> keyFunction, Function<? super T, ? extends NV> valueFunction)
482 {
483 return null;
484 }
485
486 @Override
487 public <NK, NV> MutableSortedMap<NK, NV> toSortedMap(Comparator<? super NK> comparator, Function<? super T, ? extends NK> keyFunction, Function<? super T, ? extends NV> valueFunction)
488 {
489 return null;
490 }
491
492 @Override
493 public <KK extends Comparable<? super KK>, NK, NV> MutableSortedMap<NK, NV> toSortedMapBy(Function<? super NK, KK> sortBy, Function<? super T, ? extends NK> keyFunction, Function<? super T, ? extends NV> valueFunction)
494 {
495 return null;
496 }
497
498 @Override
499 public <NK, NV> MutableBiMap<NK, NV> toBiMap(Function<? super T, ? extends NK> keyFunction, Function<? super T, ? extends NV> valueFunction)
500 {
501 return null;
502 }
503
504 @Override
505 public LazyIterable<T> asLazy()
506 {
507 return null;
508 }
509
510 @Override
511 public Object[] toArray()
512 {
513 return new Object[0];
514 }
515
516 @Override
517 public <T1> T1[] toArray(T1[] target)
518 {
519 return null;
520 }
521
522 @Override
523 public T min(Comparator<? super T> comparator)
524 {
525 return null;
526 }
527
528 @Override
529 public T max(Comparator<? super T> comparator)
530 {
531 return null;
532 }
533
534 @Override
535 public T min()
536 {
537 return null;
538 }
539
540 @Override
541 public T max()
542 {
543 return null;
544 }
545
546 @Override
547 public <V extends Comparable<? super V>> T minBy(Function<? super T, ? extends V> function)
548 {
549 return null;
550 }
551
552 @Override
553 public <V extends Comparable<? super V>> T maxBy(Function<? super T, ? extends V> function)
554 {
555 return null;
556 }
557
558 @Override
559 public long sumOfInt(IntFunction<? super T> function)
560 {
561 return 0;
562 }
563
564 @Override
565 public double sumOfFloat(FloatFunction<? super T> function)
566 {
567 return 0;
568 }
569
570 @Override
571 public long sumOfLong(LongFunction<? super T> function)
572 {
573 return 0;
574 }
575
576 @Override
577 public double sumOfDouble(DoubleFunction<? super T> function)
578 {
579 return 0;
580 }
581
582 @Override
583 public <V> MutableObjectLongMap<V> sumByInt(Function<? super T, ? extends V> groupBy, IntFunction<? super T> function)
584 {
585 return null;
586 }
587
588 @Override
589 public <V> MutableObjectDoubleMap<V> sumByFloat(Function<? super T, ? extends V> groupBy, FloatFunction<? super T> function)
590 {
591 return null;
592 }
593
594 @Override
595 public <V> MutableObjectLongMap<V> sumByLong(Function<? super T, ? extends V> groupBy, LongFunction<? super T> function)
596 {
597 return null;
598 }
599
600 @Override
601 public <V> MutableObjectDoubleMap<V> sumByDouble(Function<? super T, ? extends V> groupBy, DoubleFunction<? super T> function)
602 {
603 return null;
604 }
605
606 @Override
607 public String makeString()
608 {
609 return null;
610 }
611
612 @Override
613 public String makeString(String separator)
614 {
615 return null;
616 }
617
618 @Override
619 public String makeString(String start, String separator, String end)
620 {
621 return null;
622 }
623
624 @Override
625 public void appendString(Appendable appendable)
626 {
627 }
628
629 @Override
630 public void appendString(Appendable appendable, String separator)
631 {
632 }
633
634 @Override
635 public void appendString(Appendable appendable, String start, String separator, String end)
636 {
637 }
638
639 @Override
640 public <V> Multimap<V, T> groupBy(Function<? super T, ? extends V> function)
641 {
642 return null;
643 }
644
645 @Override
646 public <V, R extends MutableMultimap<V, T>> R groupBy(Function<? super T, ? extends V> function, R target)
647 {
648 return null;
649 }
650
651 @Override
652 public <V> Multimap<V, T> groupByEach(Function<? super T, ? extends Iterable<V>> function)
653 {
654 return null;
655 }
656
657 @Override
658 public <V, R extends MutableMultimap<V, T>> R groupByEach(Function<? super T, ? extends Iterable<V>> function, R target)
659 {
660 return null;
661 }
662
663 @Override
664 public <V> MapIterable<V, T> groupByUniqueKey(Function<? super T, ? extends V> function)
665 {
666 return null;
667 }
668
669 @Override
670 public <V, R extends MutableMapIterable<V, T>> R groupByUniqueKey(Function<? super T, ? extends V> function, R target)
671 {
672 return null;
673 }
674
675 @Override
676 public LazyIterable<T> concatenate(Iterable<T> iterable)
677 {
678 return null;
679 }
680
681 @Override
682 public <S> LazyIterable<Pair<T, S>> zip(Iterable<S> that)
683 {
684 return null;
685 }
686
687 @Override
688 public <S, R extends Collection<Pair<T, S>>> R zip(Iterable<S> that, R target)
689 {
690 return null;
691 }
692
693 @Override
694 public LazyIterable<Pair<T, Integer>> zipWithIndex()
695 {
696 return null;
697 }
698
699 @Override
700 public <R extends Collection<Pair<T, Integer>>> R zipWithIndex(R target)
701 {
702 return null;
703 }
704
705 @Override
706 public LazyIterable<RichIterable<T>> chunk(int size)
707 {
708 return null;
709 }
710
711 @Override
712 public LazyIterable<T> tap(Procedure<? super T> procedure)
713 {
714 return null;
715 }
716
717 @Override
718 public <K, V> MapIterable<K, V> aggregateInPlaceBy(Function<? super T, ? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V, ? super T> mutatingAggregator)
719 {
720 return null;
721 }
722
723 @Override
724 public <K, V> MapIterable<K, V> aggregateBy(Function<? super T, ? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V, ? super T, ? extends V> nonMutatingAggregator)
725 {
726 return null;
727 }
728
729 @Override
730 public <R extends Collection<T>> R into(R target)
731 {
732 return null;
733 }
734
735 @Override
736 public LazyBooleanIterable collectBoolean(BooleanFunction<? super T> booleanFunction)
737 {
738 return null;
739 }
740
741 @Override
742 public <R extends MutableBooleanCollection> R collectBoolean(BooleanFunction<? super T> booleanFunction, R target)
743 {
744 return null;
745 }
746
747 @Override
748 public LazyByteIterable collectByte(ByteFunction<? super T> byteFunction)
749 {
750 return null;
751 }
752
753 @Override
754 public <R extends MutableByteCollection> R collectByte(ByteFunction<? super T> byteFunction, R target)
755 {
756 return null;
757 }
758
759 @Override
760 public LazyCharIterable collectChar(CharFunction<? super T> charFunction)
761 {
762 return null;
763 }
764
765 @Override
766 public <R extends MutableCharCollection> R collectChar(CharFunction<? super T> charFunction, R target)
767 {
768 return null;
769 }
770
771 @Override
772 public LazyDoubleIterable collectDouble(DoubleFunction<? super T> doubleFunction)
773 {
774 return null;
775 }
776
777 @Override
778 public <R extends MutableDoubleCollection> R collectDouble(DoubleFunction<? super T> doubleFunction, R target)
779 {
780 return null;
781 }
782
783 @Override
784 public LazyFloatIterable collectFloat(FloatFunction<? super T> floatFunction)
785 {
786 return null;
787 }
788
789 @Override
790 public <R extends MutableFloatCollection> R collectFloat(FloatFunction<? super T> floatFunction, R target)
791 {
792 return null;
793 }
794
795 @Override
796 public LazyIntIterable collectInt(IntFunction<? super T> intFunction)
797 {
798 return null;
799 }
800
801 @Override
802 public <R extends MutableIntCollection> R collectInt(IntFunction<? super T> intFunction, R target)
803 {
804 return null;
805 }
806
807 @Override
808 public LazyLongIterable collectLong(LongFunction<? super T> longFunction)
809 {
810 return null;
811 }
812
813 @Override
814 public <R extends MutableLongCollection> R collectLong(LongFunction<? super T> longFunction, R target)
815 {
816 return null;
817 }
818
819 @Override
820 public LazyShortIterable collectShort(ShortFunction<? super T> shortFunction)
821 {
822 return null;
823 }
824
825 @Override
826 public <R extends MutableShortCollection> R collectShort(ShortFunction<? super T> shortFunction, R target)
827 {
828 return null;
829 }
830
831 @Override
832 public <V, R extends Collection<V>> R collect(Function<? super T, ? extends V> function, R target)
833 {
834 return null;
835 }
836
837 @Override
838 public void forEach(Procedure<? super T> procedure)
839 {
840 }
841
842 @Override
843 public void each(Procedure<? super T> procedure)
844 {
845 }
846
847 @Override
848 public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)
849 {
850 }
851
852 @Override
853 public <P> void forEachWith(Procedure2<? super T, ? super P> procedure, P parameter)
854 {
855 Verify.assertSerializedForm(1L, this.serializedForm, procedure);
856 }
857
858 @Override
859 public Iterator<T> iterator()
860 {
861 return null;
862 }
863 }