diff --git a/eclipse-collections/src/main/java/org/eclipse/collections/impl/factory/Multimaps.java b/eclipse-collections/src/main/java/org/eclipse/collections/impl/factory/Multimaps.java
index b1722c8008..081ab86439 100644
--- a/eclipse-collections/src/main/java/org/eclipse/collections/impl/factory/Multimaps.java
+++ b/eclipse-collections/src/main/java/org/eclipse/collections/impl/factory/Multimaps.java
@@ -306,21 +306,41 @@ private ImmutableSortedBagMultimapFactory()
             {
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> of()
+            {
+                return this.of(null);
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> of(Comparator<? super V> comparator)
             {
                 return new ImmutableSortedBagMultimapImpl<>(Maps.immutable.empty(), comparator);
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> with()
+            {
+                return this.of();
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> with(Comparator<? super V> comparator)
             {
                 return this.of(comparator);
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> of(K key, V value)
+            {
+                return this.with(key, value);
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> of(Comparator<? super V> comparator, K key, V value)
             {
                 return this.with(comparator, key, value);
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> with(K key, V value)
+            {
+                return this.with(null, key, value);
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> with(Comparator<? super V> comparator, K key, V value)
             {
                 TreeBagMultimap<K, V> treeBagMultimap = new TreeBagMultimap<>(comparator);
@@ -328,6 +348,15 @@ public <K, V> ImmutableSortedBagMultimap<K, V> with(Comparator<? super V> compar
                 return treeBagMultimap.toImmutable();
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> of(
+                    K key1,
+                    V value1,
+                    K key2,
+                    V value2)
+            {
+                return this.with(key1, value1, key2, value2);
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> of(
                     Comparator<? super V> comparator,
                     K key1,
@@ -338,6 +367,15 @@ public <K, V> ImmutableSortedBagMultimap<K, V> of(
                 return this.with(comparator, key1, value1, key2, value2);
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> with(
+                    K key1,
+                    V value1,
+                    K key2,
+                    V value2)
+            {
+                return this.with(null, key1, value1, key2, value2);
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> with(
                     Comparator<? super V> comparator,
                     K key1,
@@ -351,6 +389,17 @@ public <K, V> ImmutableSortedBagMultimap<K, V> with(
                 return treeBagMultimap.toImmutable();
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> of(
+                    K key1,
+                    V value1,
+                    K key2,
+                    V value2,
+                    K key3,
+                    V value3)
+            {
+                return this.with(key1, value1, key2, value2, key3, value3);
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> of(
                     Comparator<? super V> comparator,
                     K key1,
@@ -363,6 +412,17 @@ public <K, V> ImmutableSortedBagMultimap<K, V> of(
                 return this.with(comparator, key1, value1, key2, value2, key3, value3);
             }
 
+            public <K, V> ImmutableSortedBagMultimap<K, V> with(
+                    K key1,
+                    V value1,
+                    K key2,
+                    V value2,
+                    K key3,
+                    V value3)
+            {
+                return this.with(null, key1, value1, key2, value2, key3, value3);
+            }
+
             public <K, V> ImmutableSortedBagMultimap<K, V> with(
                     Comparator<? super V> comparator,
                     K key1,
@@ -664,29 +724,94 @@ public <K, V> MutableSortedBagMultimap<K, V> empty()
                 return TreeBagMultimap.newMultimap();
             }
 
+            public <K, V> MutableSortedBagMultimap<K, V> empty(Comparator<? super V> comparator)
+            {
+                return TreeBagMultimap.newMultimap(comparator);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> of()
+            {
+                return this.empty();
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> of(Comparator<? super V> comparator)
+            {
+                return this.empty(comparator);
+            }
+
             public <K, V> MutableSortedBagMultimap<K, V> with()
             {
                 return this.empty();
             }
 
+            public <K, V> MutableSortedBagMultimap<K, V> with(Comparator<? super V> comparator)
+            {
+                return this.empty(comparator);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> of(K key, V value)
+            {
+                return this.with(key, value);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> of(Comparator<? super V> comparator, K key, V value)
+            {
+                return this.with(comparator, key, value);
+            }
+
             public <K, V> MutableSortedBagMultimap<K, V> with(K key, V value)
             {
-                TreeBagMultimap<K, V> treeBagMultimap = TreeBagMultimap.newMultimap();
+                return this.with(null, key, value);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> with(Comparator<? super V> comparator, K key, V value)
+            {
+                TreeBagMultimap<K, V> treeBagMultimap = TreeBagMultimap.newMultimap(comparator);
                 treeBagMultimap.put(key, value);
                 return treeBagMultimap;
             }
 
+            public <K, V> MutableSortedBagMultimap<K, V> of(K key1, V value1, K key2, V value2)
+            {
+                return this.with(key1, value1, key2, value2);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> of(Comparator<? super V> comparator, K key1, V value1, K key2, V value2)
+            {
+                return this.with(comparator, key1, value1, key2, value2);
+            }
+
             public <K, V> MutableSortedBagMultimap<K, V> with(K key1, V value1, K key2, V value2)
             {
-                TreeBagMultimap<K, V> treeBagMultimap = TreeBagMultimap.newMultimap();
+                return this.with(null, key1, value1, key2, value2);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> with(Comparator<? super V> comparator, K key1, V value1, K key2, V value2)
+            {
+                TreeBagMultimap<K, V> treeBagMultimap = TreeBagMultimap.newMultimap(comparator);
                 treeBagMultimap.put(key1, value1);
                 treeBagMultimap.put(key2, value2);
                 return treeBagMultimap;
             }
 
+            public <K, V> MutableSortedBagMultimap<K, V> of(K key1, V value1, K key2, V value2, K key3, V value3)
+            {
+                return this.with(key1, value1, key2, value2, key3, value3);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> of(Comparator<? super V> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
+            {
+                return this.with(comparator, key1, value1, key2, value2, key3, value3);
+            }
+
             public <K, V> MutableSortedBagMultimap<K, V> with(K key1, V value1, K key2, V value2, K key3, V value3)
             {
-                TreeBagMultimap<K, V> treeBagMultimap = TreeBagMultimap.newMultimap();
+                return this.with(null, key1, value1, key2, value2, key3, value3);
+            }
+
+            public <K, V> MutableSortedBagMultimap<K, V> with(Comparator<? super V> comparator, K key1, V value1, K key2, V value2, K key3, V value3)
+            {
+                TreeBagMultimap<K, V> treeBagMultimap = TreeBagMultimap.newMultimap(comparator);
                 treeBagMultimap.put(key1, value1);
                 treeBagMultimap.put(key2, value2);
                 treeBagMultimap.put(key3, value3);
diff --git a/unit-tests/src/test/java/org/eclipse/collections/impl/factory/MultimapsTest.java b/unit-tests/src/test/java/org/eclipse/collections/impl/factory/MultimapsTest.java
index a49fea71ef..32aed36319 100644
--- a/unit-tests/src/test/java/org/eclipse/collections/impl/factory/MultimapsTest.java
+++ b/unit-tests/src/test/java/org/eclipse/collections/impl/factory/MultimapsTest.java
@@ -90,19 +90,79 @@ public void immutableSortedSet()
     @Test
     public void immutableSortedBagMultimap()
     {
-        ImmutableSortedBagMultimap<Integer, Integer> empty = Multimaps.immutable.sortedBag.of(Integer::compareTo);
         ImmutableSortedBagMultimap<Integer, Integer> emptyWith = Multimaps.immutable.sortedBag.with(Integer::compareTo);
-        Verify.assertEmpty(empty);
+        ImmutableSortedBagMultimap<Integer, Integer> emptyOf = Multimaps.immutable.sortedBag.of(Integer::compareTo);
         Verify.assertEmpty(emptyWith);
-        ImmutableSortedBagMultimap<Integer, Integer> one = Multimaps.immutable.sortedBag.of(Integer::compareTo, 1, 1);
-        Assert.assertEquals(TreeBagMultimap.newMultimap(Tuples.pair(1, 1)), one);
-        ImmutableSortedBagMultimap<Integer, Integer> two = Multimaps.immutable.sortedBag.of(Integer::compareTo, 1, 1, 2, 2);
-        ImmutableSortedBagMultimap<String, String> toStringOffTwo = Multimaps.immutable.sortedBag.of(String::compareTo, "A", "B");
-        Assert.assertEquals(TreeBagMultimap.newMultimap(Tuples.pair("A", "B")), toStringOffTwo);
-        Assert.assertEquals(TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2)), two);
-        ImmutableSortedBagMultimap<Integer, Integer> three = Multimaps.immutable.sortedBag.of(Integer::compareTo, 1, 1, 2, 2, 3, 3);
+        Assert.assertNotNull(emptyWith.comparator());
+        Verify.assertEmpty(emptyOf);
+        Assert.assertNotNull(emptyOf.comparator());
+        ImmutableSortedBagMultimap<Integer, Integer> oneOf = Multimaps.immutable.sortedBag.of(Integer::compareTo, 1, 1);
+        ImmutableSortedBagMultimap<Integer, Integer> oneWith = Multimaps.immutable.sortedBag.with(Integer::compareTo, 1, 1);
+        TreeBagMultimap<Integer, Integer> expectedOne = TreeBagMultimap.newMultimap(Tuples.pair(1, 1));
+        Assert.assertEquals(expectedOne, oneOf);
+        Assert.assertNotNull(oneOf.comparator());
+        Assert.assertEquals(expectedOne, oneWith);
+        Assert.assertNotNull(oneWith.comparator());
+        ImmutableSortedBagMultimap<String, String> toStringOfTwo = Multimaps.immutable.sortedBag.of(String::compareTo, "A", "B");
+        ImmutableSortedBagMultimap<String, String> toStringWithTwo = Multimaps.immutable.sortedBag.with(String::compareTo, "A", "B");
+        TreeBagMultimap<String, String> expectedStringOfTwo = TreeBagMultimap.newMultimap(Tuples.pair("A", "B"));
+        Assert.assertEquals(expectedStringOfTwo, toStringOfTwo);
+        Assert.assertNotNull(toStringOfTwo.comparator());
+        Assert.assertEquals(expectedStringOfTwo, toStringWithTwo);
+        Assert.assertNotNull(toStringWithTwo.comparator());
+        TreeBagMultimap<Integer, Integer> expectedTwo = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2));
+        ImmutableSortedBagMultimap<Integer, Integer> twoOf = Multimaps.immutable.sortedBag.of(Integer::compareTo, 1, 1, 2, 2);
+        ImmutableSortedBagMultimap<Integer, Integer> twoWith = Multimaps.immutable.sortedBag.with(Integer::compareTo, 1, 1, 2, 2);
+        Assert.assertEquals(expectedTwo, twoOf);
+        Assert.assertNotNull(twoOf);
+        Assert.assertEquals(expectedTwo, twoWith);
+        Assert.assertNotNull(twoWith.comparator());
+        ImmutableSortedBagMultimap<Integer, Integer> threeOf = Multimaps.immutable.sortedBag.of(Integer::compareTo, 1, 1, 2, 2, 3, 3);
+        ImmutableSortedBagMultimap<Integer, Integer> threeWith = Multimaps.immutable.sortedBag.with(Integer::compareTo, 1, 1, 2, 2, 3, 3);
         SortedBagMultimap<Integer, Integer> expectedThree = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2), Tuples.pair(3, 3));
-        Assert.assertEquals(expectedThree, three);
+        Assert.assertEquals(expectedThree, threeOf);
+        Assert.assertNotNull(threeOf.comparator());
+        Assert.assertEquals(expectedThree, threeWith);
+        Assert.assertNotNull(threeWith.comparator());
+    }
+
+    @Test
+    public void immutableSortedBagMultimapWithoutComparator()
+    {
+        ImmutableSortedBagMultimap<Integer, Integer> emptyWith = Multimaps.immutable.sortedBag.with();
+        ImmutableSortedBagMultimap<Integer, Integer> emptyOf = Multimaps.immutable.sortedBag.of();
+        Verify.assertEmpty(emptyWith);
+        Assert.assertNull(emptyWith.comparator());
+        Verify.assertEmpty(emptyOf);
+        Assert.assertNull(emptyOf.comparator());
+        ImmutableSortedBagMultimap<Integer, Integer> oneOf = Multimaps.immutable.sortedBag.of(1, 1);
+        ImmutableSortedBagMultimap<Integer, Integer> oneWith = Multimaps.immutable.sortedBag.with(1, 1);
+        TreeBagMultimap<Integer, Integer> expectedOne = TreeBagMultimap.newMultimap(Tuples.pair(1, 1));
+        Assert.assertEquals(expectedOne, oneOf);
+        Assert.assertNull(oneOf.comparator());
+        Assert.assertEquals(expectedOne, oneWith);
+        Assert.assertNull(oneWith.comparator());
+        ImmutableSortedBagMultimap<String, String> toStringOfTwo = Multimaps.immutable.sortedBag.of("A", "B");
+        ImmutableSortedBagMultimap<String, String> toStringWithTwo = Multimaps.immutable.sortedBag.with("A", "B");
+        TreeBagMultimap<String, String> expectedStringOfTwo = TreeBagMultimap.newMultimap(Tuples.pair("A", "B"));
+        Assert.assertEquals(expectedStringOfTwo, toStringOfTwo);
+        Assert.assertNull(toStringOfTwo.comparator());
+        Assert.assertEquals(expectedStringOfTwo, toStringWithTwo);
+        Assert.assertNull(toStringWithTwo.comparator());
+        TreeBagMultimap<Integer, Integer> expectedTwo = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2));
+        ImmutableSortedBagMultimap<Integer, Integer> twoOf = Multimaps.immutable.sortedBag.of(1, 1, 2, 2);
+        ImmutableSortedBagMultimap<Integer, Integer> twoWith = Multimaps.immutable.sortedBag.with(1, 1, 2, 2);
+        Assert.assertEquals(expectedTwo, twoOf);
+        Assert.assertNotNull(twoOf);
+        Assert.assertEquals(expectedTwo, twoWith);
+        Assert.assertNull(twoWith.comparator());
+        ImmutableSortedBagMultimap<Integer, Integer> threeOf = Multimaps.immutable.sortedBag.of(1, 1, 2, 2, 3, 3);
+        ImmutableSortedBagMultimap<Integer, Integer> threeWith = Multimaps.immutable.sortedBag.with(1, 1, 2, 2, 3, 3);
+        SortedBagMultimap<Integer, Integer> expectedThree = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2), Tuples.pair(3, 3));
+        Assert.assertEquals(expectedThree, threeOf);
+        Assert.assertNull(threeOf.comparator());
+        Assert.assertEquals(expectedThree, threeWith);
+        Assert.assertNull(threeWith.comparator());
     }
 
     @Test
@@ -194,18 +254,85 @@ public void mutableSortedBagMultimap()
     {
         MutableSortedBagMultimap<Object, Object> empty = Multimaps.mutable.sortedBag.empty();
         MutableSortedBagMultimap<Object, Object> emptyWith = Multimaps.mutable.sortedBag.with();
+        MutableSortedBagMultimap<Object, Object> emptyOf = Multimaps.mutable.sortedBag.of();
         Verify.assertEmpty(empty);
+        Assert.assertNull(empty.comparator());
         Verify.assertEmpty(emptyWith);
-        MutableSortedBagMultimap<Integer, Integer> one = Multimaps.mutable.sortedBag.with(1, 1);
-        Assert.assertEquals(TreeBagMultimap.newMultimap(Tuples.pair(1, 1)), one);
-        MutableSortedBagMultimap<Integer, Integer> two = Multimaps.mutable.sortedBag.with(1, 1, 2, 2);
-        MutableSortedBagMultimap<String, String> toStringOffTwo = Multimaps.mutable.sortedBag.with("A", "B");
-        Assert.assertEquals(TreeBagMultimap.newMultimap(Tuples.pair("A", "B")), toStringOffTwo);
-        Assert.assertEquals(TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2)), two);
-        MutableSortedBagMultimap<Integer, Integer> three = Multimaps.mutable.sortedBag.with(1, 1, 2, 2, 3, 3);
+        Assert.assertNull(emptyWith.comparator());
+        Verify.assertEmpty(emptyOf);
+        Assert.assertNull(emptyOf.comparator());
+        TreeBagMultimap<Integer, Integer> expectedOne = TreeBagMultimap.newMultimap(Tuples.pair(1, 1));
+        MutableSortedBagMultimap<Integer, Integer> withOne = Multimaps.mutable.sortedBag.with(1, 1);
+        Assert.assertEquals(expectedOne, withOne);
+        Assert.assertNull(withOne.comparator());
+        MutableSortedBagMultimap<Integer, Integer> ofOne = Multimaps.mutable.sortedBag.of(1, 1);
+        Assert.assertEquals(expectedOne, ofOne);
+        Assert.assertNull(ofOne.comparator());
+        TreeBagMultimap<String, String> expectedOneStrings = TreeBagMultimap.newMultimap(Tuples.pair("A", "B"));
+        MutableSortedBagMultimap<String, String> withStrings = Multimaps.mutable.sortedBag.with("A", "B");
+        Assert.assertEquals(expectedOneStrings, withStrings);
+        Assert.assertNull(withStrings.comparator());
+        MutableSortedBagMultimap<String, String> ofStrings = Multimaps.mutable.sortedBag.of("A", "B");
+        Assert.assertEquals(expectedOneStrings, ofStrings);
+        Assert.assertNull(ofStrings.comparator());
+        TreeBagMultimap<Integer, Integer> expectedTwo = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2));
+        MutableSortedBagMultimap<Integer, Integer> withTwoItems = Multimaps.mutable.sortedBag.with(1, 1, 2, 2);
+        Assert.assertEquals(expectedTwo, withTwoItems);
+        Assert.assertNull(withTwoItems.comparator());
+        MutableSortedBagMultimap<Integer, Integer> ofTwoItems = Multimaps.mutable.sortedBag.of(1, 1, 2, 2);
+        Assert.assertEquals(expectedTwo, ofTwoItems);
+        Assert.assertNull(ofTwoItems.comparator());
+        MutableSortedBagMultimap<Integer, Integer> threeWith = Multimaps.mutable.sortedBag.with(1, 1, 2, 2, 3, 3);
+        Assert.assertNull(threeWith.comparator());
+        MutableSortedBagMultimap<Integer, Integer> threeOf = Multimaps.mutable.sortedBag.of(1, 1, 2, 2, 3, 3);
+        Assert.assertNull(threeOf.comparator());
         SortedBagMultimap<Integer, Integer> expectedThree = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2), Tuples.pair(3, 3));
-        Assert.assertEquals(expectedThree, three);
-        Assert.assertEquals(expectedThree, Multimaps.mutable.sortedBag.withAll(three));
+        Assert.assertEquals(expectedThree, threeWith);
+        Assert.assertEquals(expectedThree, threeOf);
+        Assert.assertEquals(expectedThree, Multimaps.mutable.sortedBag.withAll(threeWith));
+    }
+
+    @Test
+    public void mutableSortedBagMultimapWithComparator()
+    {
+        MutableSortedBagMultimap<String, String> empty = Multimaps.mutable.sortedBag.empty(String::compareTo);
+        MutableSortedBagMultimap<String, String> emptyWith = Multimaps.mutable.sortedBag.with(String::compareTo);
+        MutableSortedBagMultimap<String, String> emptyOf = Multimaps.mutable.sortedBag.of(String::compareTo);
+        Verify.assertEmpty(empty);
+        Assert.assertNotNull(empty.comparator());
+        Verify.assertEmpty(emptyWith);
+        Assert.assertNotNull(emptyWith.comparator());
+        Verify.assertEmpty(emptyOf);
+        Assert.assertNotNull(emptyOf.comparator());
+        TreeBagMultimap<Integer, Integer> expectedOne = TreeBagMultimap.newMultimap(Tuples.pair(1, 1));
+        MutableSortedBagMultimap<Integer, Integer> withOne = Multimaps.mutable.sortedBag.with(Integer::compareTo, 1, 1);
+        Assert.assertEquals(expectedOne, withOne);
+        Assert.assertNotNull(withOne.comparator());
+        MutableSortedBagMultimap<Integer, Integer> ofOne = Multimaps.mutable.sortedBag.of(Integer::compareTo, 1, 1);
+        Assert.assertEquals(expectedOne, ofOne);
+        Assert.assertNotNull(ofOne.comparator());
+        TreeBagMultimap<String, String> expectedOneStrings = TreeBagMultimap.newMultimap(Tuples.pair("A", "B"));
+        MutableSortedBagMultimap<String, String> withStrings = Multimaps.mutable.sortedBag.with(String::compareTo, "A", "B");
+        Assert.assertEquals(expectedOneStrings, withStrings);
+        Assert.assertNotNull(withStrings.comparator());
+        MutableSortedBagMultimap<String, String> ofStrings = Multimaps.mutable.sortedBag.of(String::compareTo, "A", "B");
+        Assert.assertEquals(expectedOneStrings, ofStrings);
+        Assert.assertNotNull(ofStrings.comparator());
+        TreeBagMultimap<Integer, Integer> expectedTwo = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2));
+        MutableSortedBagMultimap<Integer, Integer> withTwoItems = Multimaps.mutable.sortedBag.with(Integer::compareTo, 1, 1, 2, 2);
+        Assert.assertEquals(expectedTwo, withTwoItems);
+        Assert.assertNotNull(withTwoItems.comparator());
+        MutableSortedBagMultimap<Integer, Integer> ofTwoItems = Multimaps.mutable.sortedBag.of(Integer::compareTo, 1, 1, 2, 2);
+        Assert.assertEquals(expectedTwo, ofTwoItems);
+        Assert.assertNotNull(ofTwoItems.comparator());
+        MutableSortedBagMultimap<Integer, Integer> threeWith = Multimaps.mutable.sortedBag.with(Integer::compareTo, 1, 1, 2, 2, 3, 3);
+        Assert.assertNotNull(threeWith.comparator());
+        MutableSortedBagMultimap<Integer, Integer> threeOf = Multimaps.mutable.sortedBag.of(Integer::compareTo, 1, 1, 2, 2, 3, 3);
+        Assert.assertNotNull(threeOf.comparator());
+        SortedBagMultimap<Integer, Integer> expectedThree = TreeBagMultimap.newMultimap(Tuples.pair(1, 1), Tuples.pair(2, 2), Tuples.pair(3, 3));
+        Assert.assertEquals(expectedThree, threeWith);
+        Assert.assertEquals(expectedThree, threeOf);
+        Assert.assertEquals(expectedThree, Multimaps.mutable.sortedBag.withAll(threeWith));
     }
 
     @Test