Esempio n. 1
0
 @Test
 public void newBagWithBag() {
   ImmutableBag<String> bag = Bags.immutable.of();
   HashBag<String> hashBag = HashBag.newBagWith("1");
   Assert.assertEquals(bag = bag.newWith("1"), hashBag.toImmutable());
   hashBag.add("2");
   Assert.assertEquals(bag = bag.newWith("2"), hashBag.toImmutable());
   hashBag.add("3");
   Assert.assertEquals(bag = bag.newWith("3"), hashBag.toImmutable());
   hashBag.add("4");
   Assert.assertEquals(bag = bag.newWith("4"), hashBag.toImmutable());
   hashBag.add("5");
   Assert.assertEquals(bag = bag.newWith("5"), hashBag.toImmutable());
   hashBag.add("6");
   Assert.assertEquals(bag = bag.newWith("6"), hashBag.toImmutable());
   hashBag.add("7");
   Assert.assertEquals(bag = bag.newWith("7"), hashBag.toImmutable());
   hashBag.add("8");
   Assert.assertEquals(bag = bag.newWith("8"), hashBag.toImmutable());
   hashBag.add("9");
   Assert.assertEquals(bag = bag.newWith("9"), hashBag.toImmutable());
   hashBag.add("10");
   Assert.assertEquals(bag = bag.newWith("10"), hashBag.toImmutable());
   hashBag.add("11");
   Assert.assertEquals(bag = bag.newWith("11"), hashBag.toImmutable());
 }
 @Test
 public void selectByOccurrences() {
   MutableBag<Integer> integers =
       UnmodifiableBag.of(HashBag.newBagWith(1, 1, 1, 1, 2, 2, 2, 3, 3, 4));
   Assert.assertEquals(
       iBag(1, 1, 1, 1, 3, 3), integers.selectByOccurrences(IntPredicates.isEven()));
 }
 @Test
 public void forEachValue() {
   MutableBag<String> collection = Bags.mutable.of();
   Multimap<Integer, String> multimap = this.newMultimapWithKeysValues(1, "1", 2, "2", 3, "3");
   multimap.forEachValue(CollectionAddProcedure.on(collection));
   Assert.assertEquals(HashBag.newBagWith("1", "2", "3"), collection);
 }
 @Override
 @Test
 public void collectShort() {
   MutableBag<Integer> integers = UnmodifiableBag.of(HashBag.newBagWith(1, 2, 2, 3, 3, 3));
   Assert.assertEquals(
       ShortHashBag.newBagWith((short) 1, (short) 2, (short) 2, (short) 3, (short) 3, (short) 3),
       integers.collectShort(PrimitiveFunctions.unboxIntegerToShort()));
 }
 @Override
 @Test
 public void collectLong() {
   MutableBag<Integer> integers = UnmodifiableBag.of(HashBag.newBagWith(1, 2, 2, 3, 3, 3));
   Assert.assertEquals(
       LongHashBag.newBagWith(1L, 2L, 2L, 3L, 3L, 3L),
       integers.collectLong(PrimitiveFunctions.unboxIntegerToLong()));
 }
 @Override
 @Test
 public void collectFloat() {
   MutableBag<Integer> integers = UnmodifiableBag.of(HashBag.newBagWith(1, 2, 2, 3, 3, 3));
   Assert.assertEquals(
       FloatHashBag.newBagWith(1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 3.0f),
       integers.collectFloat(PrimitiveFunctions.unboxIntegerToFloat()));
 }
 @Override
 @Test
 public void collectDouble() {
   MutableBag<Integer> integers = UnmodifiableBag.of(HashBag.newBagWith(1, 2, 2, 3, 3, 3));
   Assert.assertEquals(
       DoubleHashBag.newBagWith(1.0d, 2.0d, 2.0d, 3.0d, 3.0d, 3.0d),
       integers.collectDouble(PrimitiveFunctions.unboxIntegerToDouble()));
 }
 @Override
 @Test
 public void collectByte() {
   MutableBag<Integer> integers = UnmodifiableBag.of(HashBag.newBagWith(1, 2, 2, 3, 3, 3));
   Assert.assertEquals(
       ByteHashBag.newBagWith((byte) 1, (byte) 2, (byte) 2, (byte) 3, (byte) 3, (byte) 3),
       integers.collectByte(PrimitiveFunctions.unboxIntegerToByte()));
 }
 @Override
 @Test
 public void collectBoolean() {
   MutableBag<Integer> integers = UnmodifiableBag.of(HashBag.newBagWith(0, 1, 2, 2));
   Assert.assertEquals(
       BooleanHashBag.newBagWith(false, true, true, true),
       integers.collectBoolean(PrimitiveFunctions.integerIsPositive()));
 }
 @Test
 public void forEachKeyValue() {
   MutableBag<String> collection = Bags.mutable.of();
   Multimap<Integer, String> multimap =
       this.newMultimapWithKeysValues(1, "One", 2, "Two", 3, "Three");
   multimap.forEachKeyValue((key, value) -> collection.add(key + value));
   Assert.assertEquals(HashBag.newBagWith("1One", "2Two", "3Three"), collection);
 }
 @Override
 @Test
 public void collectChar() {
   MutableBag<Integer> integers = UnmodifiableBag.of(HashBag.newBagWith(1, 2, 2, 3, 3, 3));
   Assert.assertEquals(
       CharHashBag.newBagWith('A', 'B', 'B', 'C', 'C', 'C'),
       integers.collectChar(
           new CharFunction<Integer>() {
             public char charValueOf(Integer integer) {
               return (char) (integer.intValue() + 64);
             }
           }));
 }
Esempio n. 12
0
 @Test
 public void immutables() {
   ImmutableBagFactory bagFactory = Bags.immutable;
   Assert.assertEquals(HashBag.newBag(), bagFactory.of());
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of());
   Assert.assertEquals(HashBag.newBagWith(1), bagFactory.of(1));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1));
   Assert.assertEquals(HashBag.newBagWith(1, 2), bagFactory.of(1, 2));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2));
   Assert.assertEquals(HashBag.newBagWith(1, 2, 3), bagFactory.of(1, 2, 3));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3));
   Assert.assertEquals(HashBag.newBagWith(1, 2, 3, 4), bagFactory.of(1, 2, 3, 4));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3, 4));
   Assert.assertEquals(HashBag.newBagWith(1, 2, 3, 4, 5), bagFactory.of(1, 2, 3, 4, 5));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3, 4, 5));
   Assert.assertEquals(HashBag.newBagWith(1, 2, 3, 4, 5, 6), bagFactory.of(1, 2, 3, 4, 5, 6));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3, 4, 5, 6));
   Assert.assertEquals(
       HashBag.newBagWith(1, 2, 3, 4, 5, 6, 7), bagFactory.of(1, 2, 3, 4, 5, 6, 7));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3, 4, 5, 6, 7));
   Assert.assertEquals(
       HashBag.newBagWith(1, 2, 3, 4, 5, 6, 7, 8), bagFactory.of(1, 2, 3, 4, 5, 6, 7, 8));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3, 4, 5, 6, 7, 8));
   Assert.assertEquals(
       HashBag.newBagWith(1, 2, 3, 4, 5, 6, 7, 8, 9), bagFactory.of(1, 2, 3, 4, 5, 6, 7, 8, 9));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3, 4, 5, 6, 7, 8, 9));
   Assert.assertEquals(
       HashBag.newBagWith(1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
       bagFactory.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
   Assert.assertEquals(HashBag.newBagWith(3, 2, 1), bagFactory.ofAll(HashBag.newBagWith(1, 2, 3)));
   Verify.assertInstanceOf(ImmutableBag.class, bagFactory.ofAll(HashBag.newBagWith(1, 2, 3)));
 }
 @Test
 public void selectInstancesOf() {
   MutableBag<Number> numbers = UnmodifiableBag.of(HashBag.<Number>newBagWith(1, 2.0, 3, 4.0, 5));
   Assert.assertEquals(iBag(1, 3, 5), numbers.selectInstancesOf(Integer.class));
   Assert.assertEquals(iBag(1, 2.0, 3, 4.0, 5), numbers.selectInstancesOf(Number.class));
 }