Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
268,400 | void () { StringBuilder sb = new StringBuilder(); TreeTraversal.TracingIt<Integer> it = numTraverser().withTraversal(TreeTraversal.BI_ORDER_DFS).traverse().typedIterator(); while (it.advance()) { if (sb.length() != 0) sb.append(", "); it.hasNext(); sb.append(it.current()).append(it.isDescending() ? "↓" : "↑"); } assert... | testHarderBiOrderDfs |
268,401 | void () { assertEquals(Arrays.asList(1, 2, 5, 3, 6, 4, 8, 7, 9, 11, 10, 12, 13), numTraverser().withTraversal(TreeTraversal.INTERLEAVED_DFS).toList()); } | testSimpleInterlacedDfs |
268,402 | void () { Function<Integer, JBIterable<Integer>> traversal = TreeTraversal.INTERLEAVED_DFS.traversal(Functions.fromMap( Map.of( 1, Arrays.asList(1, 2), 2, Arrays.asList(1, 2, 3), 3, Arrays.asList()))); assertEquals(Arrays.asList(1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3), traversal.fun(1).takeWhile(UP_TO(3)).toList()); } | testCyclicInterlacedDfs |
268,403 | void () { Function<Integer, JBIterable<Integer>> traversal = TreeTraversal.INTERLEAVED_DFS.traversal( integer -> { JBIterable<Integer> it = JBIterable.generate(1, INCREMENT).takeWhile(UP_TO(integer + 1)); // 1: no repeat return it; // 2: repeat indefinitely: all seq //return JBIterable.generate(it, Functions.id()).flat... | testIndefiniteCyclicInterlacedDfs |
268,404 | void () { JBIterable<Integer> dfs = num2Traverser().withTraversal(TreeTraversal.PRE_ORDER_DFS).traverse(); JBIterable<Integer> bfs = num2Traverser().withTraversal(TreeTraversal.TRACING_BFS).traverse(); JBIterable<Integer> postDfs = num2Traverser().withTraversal(TreeTraversal.POST_ORDER_DFS).traverse(); TreeTraversal.Tr... | testTreeBacktraceSimple |
268,405 | void () { Integer root = 123; JBTreeTraverser<Integer> traverser = new JBTreeTraverser<Integer>(Functions.constant(null)).withRoot(root); JBIterable<Integer> dfs = traverser.traverse(TreeTraversal.PRE_ORDER_DFS); JBIterable<Integer> bfs = traverser.traverse(TreeTraversal.TRACING_BFS); JBIterable<Integer> postDfs = trav... | testTreeBacktraceSingle |
268,406 | void () { JBIterable<String> dfs = num2Traverser().withTraversal(TreeTraversal.PRE_ORDER_DFS).traverse().map(Functions.TO_STRING()); JBIterable<String> bfs = num2Traverser().withTraversal(TreeTraversal.TRACING_BFS).traverse().map(Functions.TO_STRING()); TreeTraversal.TracingIt<String> it1 = dfs.typedIterator(); it1.ski... | testTreeBacktraceTransformed |
268,407 | void () { assertEquals(Arrays.asList(5, 6, 7, 2, 8, 9, 10, 3, 11, 12, 13, 4, 1), numTraverser().withTraversal(TreeTraversal.POST_ORDER_DFS).toList()); } | testSimplePostOrderDfs |
268,408 | void () { assertEquals(JBIterable.generate(1, INCREMENT).take(37).toList(), num2Traverser().withTraversal(TreeTraversal.PLAIN_BFS).toList()); } | testSimpleBfs |
268,409 | void () { List<Integer> result = simpleTraverseExpand(TreeTraversal.PLAIN_BFS); assertEquals(JBIterable.of(1, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8).toList(), result); } | testSimpleBfsLaziness |
268,410 | void () { List<Integer> result = simpleTraverseExpand(TreeTraversal.PRE_ORDER_DFS); assertEquals(JBIterable.of(1, 2, 4, 8, 8, 4, 8, 8, 2, 4, 8, 8, 4, 8, 8).toList(), result); } | testSimplePreDfsLaziness |
268,411 | List<Integer> (TreeTraversal traversal) { List<Integer> result = new ArrayList<>(); Function<List<Integer>, Iterable<List<Integer>>> function = integers -> JBIterable.from(integers).skip(1).transform(WRAP_TO_LIST); JBIterable<List<Integer>> iter = traversal.traversal(function).fun(new SmartList<>(1)); for (List<Integer... | simpleTraverseExpand |
268,412 | void () { List<Integer> result = new ArrayList<>(); TreeTraversal.TracingIt<List<Integer>> it = TreeTraversal.TRACING_BFS.traversal((Function<List<Integer>, Iterable<List<Integer>>>)integers -> JBIterable.from(integers).skip(1).transform(WRAP_TO_LIST)).fun(new SmartList<>(1)).typedIterator(); while (it.advance()) { Int... | testTracingBfsLaziness |
268,413 | void () { assertEquals(Arrays.asList(1, 2, 5, 6, 7, 3, 8, 9, 10, 4, 11, 12, 13), numTraverser().unique().toList()); JBTreeTraverser<Integer> t0 = numTraverser().unique(o -> o % 5); assertEquals(Arrays.asList(1, 2, 5, 3, 9), t0.toList()); assertEquals(Arrays.asList(1, 2, 5, 3, 9), t0.toList()); // same results again ass... | testTraverseUnique |
268,414 | void () { HashMap<Integer, Collection<Integer>> map1 = new HashMap<>(numbers()); JBTreeTraverser<Integer> traverser = JBTreeTraverser.from(Functions.compose(ASSERT_NUMBER, a -> map1.remove(a))).withRoot(1); JBTreeTraverser<Integer> cached = traverser.cached(); assertEquals(Arrays.asList(1, 2, 5, 6, 7, 3, 8, 9, 10, 4, 1... | testTraverseCached |
268,415 | void () { Condition<String> notEmpty = o -> !o.isEmpty(); Condition<String> isThirteen = o -> "13".equals(o); JBTreeTraverser<Integer> t = numTraverser().filter(IS_ODD).regard(IS_POSITIVE); JBTreeTraverser<String> mappedA = t.map(String::valueOf, Integer::parseInt); JBTreeTraverser<String> mappedB = t.map(String::value... | testTraverseMap |
268,416 | void () { JBTreeTraverser<Integer> t = numTraverser(); class F extends JBIterable.SFun<Integer, String> { int count; @Override public String fun(Integer o) { count++; return count + ":" + o; } } JBTreeTraverser<String> mappedA = t.map(new F(), o -> Integer.parseInt(o.substring(o.indexOf(":") + 1))); JBTreeTraverser<Str... | testTraverseMapStateful |
268,417 | String (Integer o) { count++; return count + ":" + o; } | fun |
268,418 | void () { verifyGuidedTraversal(TreeTraversal.PRE_ORDER_DFS); verifyGuidedTraversal(TreeTraversal.POST_ORDER_DFS); verifyGuidedTraversal(TreeTraversal.PLAIN_BFS); } | testGuidedDfs |
268,419 | void (TreeTraversal traversal) { assertEquals(num2Traverser().withTraversal(TreeTraversal.GUIDED_TRAVERSAL(newGuide(traversal))).toList(), num2Traverser().withTraversal(traversal).toList()); } | verifyGuidedTraversal |
268,420 | JBTreeTraverser<TextRange> () { return new JBTreeTraverser<>( r -> r.getLength() < 4 ? JBIterable.empty() : JBIterable.generate(r.getStartOffset(), i -> i += r.getLength() / 4) .takeWhile(i -> i < r.getEndOffset()) .map(i -> TextRange.from(i, r.getLength() / 4))); } | rangeTraverser |
268,421 | void () { assertEquals(Arrays.asList(1, 5, 7, 3, 9, 11, 13), numTraverser().filter(IS_ODD).toList()); } | testSimpleFilter |
268,422 | void () { int[] count = {0}; Condition<Integer> c1 = __ -> { assertEquals("incorrect order (1)", 1, count[0]++ % 3 + 1); return true; }; Condition<Integer> c2 = __ -> { assertEquals("incorrect order (2)", 2, count[0]++ % 3 + 1); return true; }; Condition<Integer> c3 = __ -> { assertEquals("incorrect order (3)", 3, coun... | testTraverserOpsOrder |
268,423 | void () { assertEquals(Arrays.asList(1, 2, 3, 8, 9, 10, 4), numTraverser().expand(IS_ODD).toList()); } | testSimpleExpand |
268,424 | void () { assertEquals(Arrays.asList(1, 3, 9), numTraverser().expand(IS_ODD).filter(IS_ODD).toList()); assertEquals(Arrays.asList(1, 3, 9), numTraverser().expandAndFilter(IS_ODD).toList()); } | testExpandFilter |
268,425 | void () { assertEquals(Arrays.asList(2, 8, 9, 10, 4), numTraverser().expand(IS_ODD).traverse(TreeTraversal.LEAVES_DFS).toList()); } | testSkipExpandedDfs |
268,426 | void () { assertEquals(13, numTraverser().onRange(o -> true).traverse().size()); JBTreeTraverser<TextRange> ranges = rangeTraverser(); assertEquals(5, ranges.withRoot(TextRange.from(0, 8)).traverse().size()); assertEquals(Arrays.asList("(0,64)", "(16,32)", "(28,32)", "(29,30)", "(30,31)", "(31,32)", "(32,48)", "(32,36)... | testOnRange |
268,427 | void () { assertEquals(Arrays.asList(5, 6, 3, 11, 12, 13), numTraverser().regard(not(inRange(7, 10))).traverse(TreeTraversal.LEAVES_DFS).toList()); } | testRangeChildrenLeavesDfs |
268,428 | void () { assertEquals(Arrays.asList(5, 6, 3, 11, 12, 13), numTraverser().regard(not(inRange(7, 10))).traverse(TreeTraversal.LEAVES_DFS).toList()); } | testRangeChildrenLeavesBfs |
268,429 | void () { assertEquals(Arrays.asList(1, 2, 5, 6, 7, 4, 11, 12, 13), numTraverser().expandAndFilter(x -> x != 3).traverse(TreeTraversal.PRE_ORDER_DFS).toList()); } | testHideOneNodeDfs |
268,430 | void () { assertEquals(Arrays.asList(1, 2, 4, 5, 6, 7, 11, 12, 13), numTraverser().expandAndFilter(x -> x != 3).traverse(TreeTraversal.PLAIN_BFS).toList()); } | testHideOneNodeCompletelyBfs |
268,431 | void () { assertEquals(Arrays.asList(2, 4, 8, 9, 10), numTraverser().expand(IS_ODD).traverse(TreeTraversal.LEAVES_BFS).toList()); } | testSkipExpandedCompletelyBfs |
268,432 | void () { assertEquals(Arrays.asList(1, 5, 7, 3, 9, 11, 13), numTraverser().expand(IS_ODD).withTraversal(TreeTraversal.LEAVES_DFS).reset().filter(IS_ODD).toList()); } | testExpandSkipFilterReset |
268,433 | void () { assertEquals(Arrays.asList(1, 2, 6, 4, 12), numTraverser().forceIgnore(IS_ODD).reset().toList()); } | testForceExcludeReset |
268,434 | void () { assertEquals(Arrays.asList(1, 2, 6, 8, 10, 4, 12), numTraverser().forceDisregard(IS_ODD).reset().toList()); } | testForceSkipReset |
268,435 | void () { assertEquals(Arrays.asList(6, 8, 10, 12), numTraverser().forceDisregard(IS_ODD).traverse(TreeTraversal.LEAVES_DFS).toList()); } | testForceSkipLeavesDfs |
268,436 | void () { assertEquals(Arrays.asList(1, 5, 7, 3, 9, 11, 13), numTraverser().regard(IS_ODD).toList()); } | testFilterChildren |
268,437 | void () { JBTreeTraverser<Integer> t = new JBTreeTraverser<>(k -> JBIterable.generate(k, INCREMENT).map(SQUARE).take(3)); assertEquals(Arrays.asList(1, 1, 4, 9, 1, 4, 9, 16, 25, 36, 81), t.withRoot(1).bfsTraversal().take(11).toList()); } | testEndlessGraph |
268,438 | void () { JBTreeTraverser<Integer> t = new JBTreeTraverser<>(k -> JBIterable.generate(1, k, FIBONACCI).skip(2).take(3)); TreeTraversal.TracingIt<Integer> it = t.withRoot(1).preOrderDfsTraversal().skip(20).typedIterator(); TreeTraversal.TracingIt<Integer> cursor = JBIterator.cursor(it).first(); assertNotNull(cursor); as... | testEndlessGraphParents |
268,439 | void () { JBTreeTraverser<Integer> t = numTraverser(); JBIterable<Integer> it = t.regard(new FilteredTraverserBase.EdgeFilter<>() { @Override public boolean value(Integer integer) { return (integer / edgeSource) % 2 == 0; } }).traverse(); assertEquals(Arrays.asList(1, 2, 5, 8, 10, 4, 11), it.toList()); assertEquals(Arr... | testEdgeFilter |
268,440 | boolean (Integer integer) { return (integer / edgeSource) % 2 == 0; } | value |
268,441 | void () { JBTreeTraverser<Integer> t = numTraverser(); class F extends JBIterable.SCond<Integer> { int count; final boolean value; F(boolean initialVal) { value = initialVal; } @Override public boolean value(Integer integer) { return count ++ > 0 == value; } } JBIterable<Integer> it = t.regard(new F(true)).traverse(); ... | testStatefulChildFilter |
268,442 | boolean (Integer integer) { return count ++ > 0 == value; } | value |
268,443 | Iterable<Object[]> () { return Arrays.asList( name("Our HashMap", HashMap::new), name("Our ConcurrentHashMap", () -> ConcurrentCollectionFactory.createConcurrentMap()), name("ConcurrentFactoryMap (on ConcurrentHashMap)", () -> ConcurrentFactoryMap.createMap(k -> "val_" + k)) ); } | parameters |
268,444 | Object[] (String name, Factory<Map<Object, Object>> fac) { return ContainerUtil.ar(name, fac); } | name |
268,445 | void () { Map<Object, Object> map = factory.create(); String val = "val"; Assume.assumeTrue("Does not support null keys", isSupported(() -> map.put(null, val))); Assert.assertEquals(1, map.size()); Assert.assertTrue("Null key not found", map.containsKey(null)); Assert.assertEquals(1, map.size()); Assert.assertEquals("V... | checkNullKeys |
268,446 | void () { Map<Object, Object> map = factory.create(); String key = "key"; Assume.assumeTrue("Does not support null values", isSupported(() -> map.put(key, null))); Assert.assertEquals(1, map.size()); Assert.assertTrue("Null val not found", map.containsValue(null)); Assert.assertTrue("Null val not found by key", map.con... | checkNullVals |
268,447 | void () { checkEntrySetImpl("key", "val"); } | checkEntrySet |
268,448 | void () { checkEntrySetImpl(null, "val"); } | checkEntrySetNullKey |
268,449 | void () { checkEntrySetImpl("key", null); } | checkEntrySetNullValue |
268,450 | void (String key, String val) { Map<Object, Object> map = factory.create(); Assume.assumeTrue("Adding (" + key + ", " + val + ") not supported", isSupported(() -> map.put(key, val))); Set<Map.Entry<Object, Object>> entries = map.entrySet(); Assert.assertEquals(1, entries.size()); Assume.assumeTrue("Entry set is readonl... | checkEntrySetImpl |
268,451 | void () { checkKeySetImpl("key"); } | checkKeySet |
268,452 | void () { checkKeySetImpl(null); } | checkKeySetNullKey |
268,453 | void (String key) { String val = "val"; Map<Object, Object> map = factory.create(); Assume.assumeTrue("Adding (" + key + ", " + val + ") not supported", isSupported(() -> map.put(key, val))); Set<Object> keys = map.keySet(); Assert.assertTrue("Key not found", keys.contains(key)); Assert.assertEquals(1, keys.size()); As... | checkKeySetImpl |
268,454 | void () { checkValuesImpl("val"); } | checkValues |
268,455 | void () { checkValuesImpl(null); } | checkValuesNullValue |
268,456 | void (String val) { String key = "key"; Map<Object, Object> map = factory.create(); Assume.assumeTrue("Adding (" + key + ", " + val + ") not supported", isSupported(() -> map.put(key, val))); Collection<Object> values = map.values(); Assert.assertTrue("Value not found", values.contains(val)); Assert.assertEquals(1, val... | checkValuesImpl |
268,457 | boolean (Runnable op) { try { op.run(); return true; } catch (RuntimeException e) { return false; } } | isSupported |
268,458 | void () { UnmodifiableHashMap<Object, Object> empty = UnmodifiableHashMap.empty(); assertEquals(0, empty.size()); assertTrue(empty.isEmpty()); //noinspection ConstantConditions assertFalse(empty.containsKey("foo")); //noinspection RedundantOperationOnEmptyContainer assertNull(empty.get("foo")); } | testEmpty |
268,459 | void () { UnmodifiableHashMap.empty().put("foo", "bar"); } | testPut |
268,460 | void () { UnmodifiableHashMap.empty().remove("foo"); } | testRemove |
268,461 | void () { //noinspection RedundantCollectionOperation UnmodifiableHashMap.empty().putAll(Collections.singletonMap("foo", "bar")); } | testPutAll |
268,462 | void () { UnmodifiableHashMap.empty().clear(); } | testClear |
268,463 | void () { UnmodifiableHashMap<Integer, String> map = UnmodifiableHashMap.empty(); for (int i = 0; i < 50; i++) { String value = String.valueOf(i); map = map.with(i, value); assertEquals(i + 1, map.size()); assertEquals(value, map.get(i)); assertTrue(map.containsKey(i)); assertTrue(map.containsValue(value)); assertFalse... | testWith |
268,464 | void () { int size = 51; UnmodifiableHashMap<Integer, String> map = create(size); for (int i = 0; i < size; i++) { map = map.without(i); assertEquals(size - 1 - i, map.size()); assertFalse(map.containsKey(i)); assertTrue(i == size - 1 || map.containsKey(i + 1)); } map = create(size); for (int i = size; i >= 0; i--) { m... | testWithout |
268,465 | void () { UnmodifiableHashMap<Long, String> map = UnmodifiableHashMap.empty(); for (int i = 0; i < 50; i++) { long key = ((long)i << 32) | i ^ 135; map = map.with(key, String.valueOf(key)); assertEquals(i + 1, map.size()); assertEquals(String.valueOf(key), map.get(key)); assertTrue(map.containsKey(key)); assertTrue(map... | testAddCollisions |
268,466 | void () { for (int size : new int[]{0, 1, 2, 3, 4, 10, 11, 12}) { UnmodifiableHashMap<Integer, String> map = create(size); assertNull(map.get(null)); } } | testGet |
268,467 | void () { for (int size : new int[]{0, 1, 2, 3, 4, 10, 11, 12}) { UnmodifiableHashMap<Integer, String> map = create(size); Set<Integer> keys = new java.util.HashSet<>(map.keySet()); assertEquals(IntStreamEx.range(size).boxed().toSet(), keys); Set<String> values = new java.util.HashSet<>(map.values()); assertEquals(IntS... | testIterate |
268,468 | void () { UnmodifiableHashMap<Integer, String> map = create(10); assertTrue(map.values().contains("9")); assertFalse(map.values().contains("11")); } | testValues |
268,469 | void () { for (int size : new int[]{0, 1, 2, 3, 4, 10, 11, 12}) { UnmodifiableHashMap<Integer, String> map = create(size); Set<Integer> keys = new java.util.HashSet<>(); Set<String> values = new java.util.HashSet<>(); map.forEach((k, v) -> { keys.add(k); values.add(v); }); assertEquals(IntStreamEx.range(size).boxed().t... | testForEach |
268,470 | void () { for (int size : new int[]{0, 1, 2, 3, 4, 10, 11, 12}) { UnmodifiableHashMap<Integer, String> map = create(size); String actual = map.toString(); assertTrue(actual.startsWith("{")); assertTrue(actual.endsWith("}")); String content = actual.substring(1, actual.length() - 1); if (size == 0) { assertTrue(content.... | testToString |
268,471 | void () { for (int size : new int[]{0, 1, 2, 3, 4, 10, 11, 12}) { UnmodifiableHashMap<Integer, String> map = create(size); assertEquals(map, map); HashMap<Integer, String> hashMap = new HashMap<>(map); assertEquals(hashMap, map); assertEquals(map, hashMap); UnmodifiableHashMap<Integer, String> map1 = map.with(0, "1"); ... | testEquals |
268,472 | void () { for (int size : new int[]{0, 1, 2, 3, 4, 10, 11, 12}) { UnmodifiableHashMap<Integer, String> map = create(size); HashMap<Integer, String> hashMap = new HashMap<>(map); assertEquals(hashMap.hashCode(), map.hashCode()); } } | testHashCode |
268,473 | void () { UnmodifiableHashMap<Integer, String> map = create(10); assertSame(map, UnmodifiableHashMap.fromMap(map)); } | testFromMap |
268,474 | void () { UnmodifiableHashMap<Integer, String> map = UnmodifiableHashMap.<Integer, String>empty() .with(1, "One").with(2, "Two").with(3, "Three"); UnmodifiableHashMap<Integer, String> map2 = map.withAll(Collections.emptyMap()); assertSame(map, map2); map2 = map.withAll(Collections.singletonMap(4, "Four")); assertEquals... | testWithAll |
268,475 | void () { fillWithObjects(20); assertEquals(20, myWeakList.listSize()); addElement(HARD_REFERENCED); assertEquals(21, myWeakList.listSize()); myHolder.clear(); while (myWeakList.toStrongList().size() == 21) { synchronized (myWeakList) { gc(); } } synchronized (myWeakList) { boolean processed = myWeakList.processQueue()... | testCompresses |
268,476 | void () { fillWithObjects(20); assertEquals(20, myWeakList.listSize()); myHolder.clear(); gc(); myWeakList.clear(); assertFalse(myWeakList.iterator().hasNext()); } | testClear |
268,477 | void () { int N = 10; fillWithInts(N); gc(); Iterator<?> iterator = myWeakList.iterator(); for (int i = 0; i < N; i++) { assertTrue(iterator.hasNext()); //noinspection ConstantConditions assertTrue(iterator.hasNext()); int element = (Integer)iterator.next(); assertEquals(i, element); } assertFalse(iterator.hasNext()); ... | testIterator |
268,478 | void () { addElement(new Object()); addElement(new Object()); addElement(new Object()); Iterator<Object> iterator = myWeakList.iterator(); assertSame(myHolder.get(0), iterator.next()); iterator.remove(); gc(); assertEquals(2, myWeakList.toStrongList().size()); iterator.next(); gc(); assertEquals(2, myWeakList.toStrongL... | testRemoveViaIterator |
268,479 | void () { int N = 10; fillWithInts(N); gc(); Iterator<Object> iterator = myWeakList.iterator(); for (int i = 0; i < N; i++) { assertTrue(iterator.hasNext()); int element = (Integer)iterator.next(); assertEquals(i, element); iterator.remove(); } assertFalse(iterator.hasNext()); assertTrue(myWeakList.toStrongList().isEmp... | testRemoveAllViaIterator |
268,480 | void () { addElement(new Object()); addElement(new Object()); Iterator<Object> iterator = myWeakList.iterator(); iterator.next(); assertTrue(iterator.hasNext()); iterator.next(); assertFalse(iterator.hasNext()); iterator.remove(); } | testRemoveLastViaIterator |
268,481 | void () { addElement(new Object()); addElement(new Object()); Iterator<Object> iterator = myWeakList.iterator(); assertTrue(iterator.hasNext()); myHolder.clear(); gc(); assertNotNull(iterator.next()); assertFalse(iterator.hasNext()); } | testIteratorKeepsFirstElement |
268,482 | void () { addElement(new Object()); addElement(new Object()); addElement(new Object()); Iterator<Object> iterator = myWeakList.iterator(); iterator.next(); assertTrue(iterator.hasNext()); myHolder.clear(); gc(); assertNotNull(iterator.next()); assertFalse(iterator.hasNext()); } | testIteratorKeepsNextElement |
268,483 | void () { Iterator<Object> iterator = myWeakList.iterator(); assertFalse(iterator.hasNext()); try { iterator.next(); fail("must not allow to next"); } catch (NoSuchElementException ignored) { } try { iterator.remove(); fail("must not allow to remove"); } catch (NoSuchElementException ignored) { } } | testIteratorRemoveEmpty |
268,484 | void () { int N = 200; fillWithObjects(N); String x = new String("xxx"); addElement(x); fillWithObjects(N); gc(); assertEquals(N + 1 + N, myWeakList.listSize()); myHolder.clear(); while (myWeakList.toStrongList().size() == N + 1 + N) { synchronized (myWeakList) { gc(); } } boolean removed = myWeakList.remove("zzz"); as... | testElementGetsCollectedInTheMiddleAndListRebuildsItself |
268,485 | void () { assertTrue(myWeakList.isEmpty()); addElement(new Object()); assertFalse(myWeakList.isEmpty()); myHolder.clear(); gc(); assertEquals(1, myWeakList.listSize()); assertTrue(myWeakList.isEmpty()); } | testIsEmpty |
268,486 | void (Object element) { myWeakList.add(element); myHolder.add(element); } | addElement |
268,487 | void (int n) { for (int i = n - 1; i >= 0; i--) { addElement(new Object()); } } | fillWithObjects |
268,488 | void (int n) { for (int i = 0; i < n; i++) { addElement(i); } } | fillWithInts |
268,489 | void () { GCUtil.tryGcSoftlyReachableObjects(); } | gc |
268,490 | void () { DisposableWrapperList<String> l = new DisposableWrapperList<>(); assertTrue(l.add("a")); assertTrue(l.add("b")); Disposable d1 = Disposer.newDisposable(); assertNotNull(l.add("c", d1)); Disposable d2 = Disposer.newDisposable(); l.add(1, "d", d2); assertEquals(0, l.indexOf("a")); assertEquals(1, l.lastIndexOf(... | testCommonMethods |
268,491 | void () { DisposableWrapperList<String> l = new DisposableWrapperList<>(); Disposable d = Disposer.newDisposable(); l.add("a", d); l.add("b", d); l.add("c", d); l.add("d", d); StringBuilder buf = new StringBuilder(); for (String s : l) { buf.append(s); if (s.equals("b")) { Disposer.dispose(d); // Remove all elements fr... | testIterator |
268,492 | void () { DisposableWrapperList<String> l = new DisposableWrapperList<>(); Disposable d1 = Disposer.newDisposable(); assertNotNull(l.add("a", d1)); assertNotNull(l.add("b", d1)); Disposable d2 = Disposer.newDisposable(); assertNotNull(l.add("a", d2)); assertNotNull(l.add("b", d2)); assertEquals(4, l.size()); assertEqua... | testDuplicateElements |
268,493 | void () { Iterator<Object> iterator = Arrays.<Object>asList(1, new ArrayList<>(), "1").iterator(); String string = ContainerUtil.findInstance(iterator, String.class); assertEquals("1", string); } | testFindInstanceWorks |
268,494 | void () { Iterable<Object> concat = ContainerUtil.concat(Collections.emptySet(), Collections.emptySet()); assertFalse(concat.iterator().hasNext()); Iterable<Object> foo = ContainerUtil.concat(Collections.emptySet(), Collections.singletonList("foo")); Iterator<Object> iterator = foo.iterator(); assertTrue(iterator.hasNe... | testConcatTwoListsMustSupportListContracts |
268,495 | void () { List<Integer> l = ContainerUtil.concat(Arrays.asList(1, 2), Collections.emptyList(), Arrays.asList(3, 4)); assertEquals(4, l.size()); assertEquals(1, (int)l.get(0)); assertEquals(2, (int)l.get(1)); assertEquals(3, (int)l.get(2)); assertEquals(4, (int)l.get(3)); try { l.get(-1); fail(); } catch (IndexOutOfBoun... | testConcatMultipleListsWorks |
268,496 | void () { List<Integer> a1 = new ArrayList<>(Arrays.asList(0, 1)); List<Integer> l = ContainerUtil.concat(a1, Arrays.asList(2, 3), ContainerUtil.emptyList()); assertEquals(4, l.size()); for (int i = 0; i < l.size(); i++) { int at = l.get(i); assertEquals(i, at); } try { a1.clear(); l.get(3); fail(); } catch (Concurrent... | testConcatedListsAfterModificationMustThrowCME |
268,497 | void () { Condition<Integer> cond = integer -> integer > 2; assertIterating(Arrays.asList(1, 4, 2, 5), cond, 4, 5); assertIterating(Arrays.asList(1, 2), cond); assertIterating(Collections.emptyList(), cond); assertIterating(Collections.singletonList(4), cond, 4); } | testIterateWithCondition |
268,498 | void (List<Integer> collection, Condition<? super Integer> condition, Integer... expected) { List<Integer> actual = ContainerUtil.filter(collection, condition); assertEquals(Arrays.asList(expected), actual); } | assertIterating |
268,499 | void () { List<String> ss = new ArrayList<>(); ss.add("a"); ss.add("b"); ss.add("c"); StringBuilder log = new StringBuilder(); for (String s : ss) { log.append(s); } for (String s : ContainerUtil.iterateBackward(ss)) { log.append(s); } assertEquals("abccba", log.toString()); } | testIteratingBackward |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.