diff --git a/compile_output.txt b/compile_output.txt new file mode 100644 index 00000000..d91dcbf1 --- /dev/null +++ b/compile_output.txt @@ -0,0 +1,37 @@ +[info] welcome to sbt 1.12.4 (Homebrew Java 25.0.2) +[info] loading settings for project cats-collections-build from plugins.sbt... +[info] loading project definition from /Users/krrish/Documents/cats-collections/project +[info] loading settings for project root from build.sbt, mima.sbt... +[info] resolving key references (18540 settings) ... +[info] set scmInfo to https://github.com/typelevel/cats-collections +[info] set current project to root (in build file:/Users/krrish/Documents/cats-collections/) +[info] Executing in batch mode. For better performance use sbt's shell +[info] compiling 27 Scala sources to /Users/krrish/Documents/cats-collections/core/.js/target/scala-2.12/classes ... +[info] compiling 27 Scala sources to /Users/krrish/Documents/cats-collections/core/.jvm/target/scala-2.12/classes ... +[info] compiling 27 Scala sources to /Users/krrish/Documents/cats-collections/core/.native/target/scala-2.12/classes ... +[info] Non-compiled module 'compiler-bridge_2.12' for Scala 2.12.21. Compiling... +[info] Compilation completed in 2.898s. +[info] done compiling +[info] compiling 9 Scala sources to /Users/krrish/Documents/cats-collections/scalacheck/.jvm/target/scala-2.12/classes ... +[info] compiling 2 Scala sources to /Users/krrish/Documents/cats-collections/laws/.jvm/target/scala-2.12/classes ... +[info] compiling 10 Scala sources to /Users/krrish/Documents/cats-collections/bench/target/scala-2.12/classes ... +[info] done compiling +[info] done compiling +[info] done compiling +[info] done compiling +[info] compiling 9 Scala sources to /Users/krrish/Documents/cats-collections/scalacheck/.js/target/scala-2.12/classes ... +[info] compiling 2 Scala sources to /Users/krrish/Documents/cats-collections/laws/.js/target/scala-2.12/classes ... +[info] done compiling +[info] compiling 2 Scala sources to /Users/krrish/Documents/cats-collections/laws/.native/target/scala-2.12/classes ... +[info] compiling 9 Scala sources to /Users/krrish/Documents/cats-collections/scalacheck/.native/target/scala-2.12/classes ... +[info] done compiling +[info] done compiling +[info] done compiling +[info] done compiling +[info] compiling 1 Scala source to /Users/krrish/Documents/cats-collections/tests/.js/target/scala-2.12/classes ... +[info] done compiling +[info] compiling 1 Scala source to /Users/krrish/Documents/cats-collections/tests/.jvm/target/scala-2.12/classes ... +[info] done compiling +[info] compiling 1 Scala source to /Users/krrish/Documents/cats-collections/tests/.native/target/scala-2.12/classes ... +[info] done compiling +[success] Total time: 56 s, completed 27 Feb 2026, 1:39:29 am diff --git a/scalacheck/src/main/scala/cats/collections/arbitrary/ArbitraryDequeue.scala b/scalacheck/src/main/scala/cats/collections/arbitrary/ArbitraryDequeue.scala new file mode 100644 index 00000000..8930f8d6 --- /dev/null +++ b/scalacheck/src/main/scala/cats/collections/arbitrary/ArbitraryDequeue.scala @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2015 Typelevel + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +package cats.collections +package arbitrary + +import org.scalacheck.{Arbitrary, Gen} + +trait ArbitraryDequeue { + implicit def arbitraryDequeue[A](implicit A: Arbitrary[A]): Arbitrary[Dequeue[A]] = + Arbitrary( + for { + left <- Gen.listOf(A.arbitrary) + right <- Gen.listOf(A.arbitrary) + } yield { + val withLeft = left.foldLeft(Dequeue.empty[A])((q, a) => q.cons(a)) + right.foldLeft(withLeft)((q, a) => q.snoc(a)) + } + ) +} + +object ArbitraryDequeue extends ArbitraryDequeue diff --git a/scalacheck/src/main/scala/cats/collections/arbitrary/all.scala b/scalacheck/src/main/scala/cats/collections/arbitrary/all.scala index f539e0c4..c8e7d3c6 100644 --- a/scalacheck/src/main/scala/cats/collections/arbitrary/all.scala +++ b/scalacheck/src/main/scala/cats/collections/arbitrary/all.scala @@ -27,4 +27,6 @@ trait AllArbitrary with ArbitraryMap with ArbitraryHashMap with ArbitraryPredicate + with ArbitraryTreeList + with ArbitraryDequeue with CogenInstances diff --git a/scalacheck/src/main/scala/cats/collections/arbitrary/package.scala b/scalacheck/src/main/scala/cats/collections/arbitrary/package.scala index df327980..7a587793 100644 --- a/scalacheck/src/main/scala/cats/collections/arbitrary/package.scala +++ b/scalacheck/src/main/scala/cats/collections/arbitrary/package.scala @@ -29,5 +29,7 @@ package object arbitrary { object map extends ArbitraryMap object hashmap extends ArbitraryHashMap object predicate extends ArbitraryPredicate + object treelist extends ArbitraryTreeList + object dequeue extends ArbitraryDequeue object cogen extends CogenInstances } diff --git a/test_output.txt b/test_output.txt new file mode 100644 index 00000000..a8e3c72d --- /dev/null +++ b/test_output.txt @@ -0,0 +1,815 @@ +[info] welcome to sbt 1.12.4 (Homebrew Java 25.0.2) +[info] loading settings for project cats-collections-build from plugins.sbt... +[info] loading project definition from /Users/krrish/Documents/cats-collections/project +[info] loading settings for project root from build.sbt, mima.sbt... +[info] resolving key references (18540 settings) ... +[info] set scmInfo to https://github.com/typelevel/cats-collections +[info] set current project to root (in build file:/Users/krrish/Documents/cats-collections/) +[info] compiling 19 Scala sources to /Users/krrish/Documents/cats-collections/tests/.jvm/target/scala-2.12/test-classes ... +[info] done compiling +cats.collections.PredicateSuite: + + Monoid[Predicate[Int]]: serializable.can serialize and deserialize 0.011s + + MonoidK[Predicate]: serializable.can serialize and deserialize 0.001s + + Serializable[ContravariantMonoidal[Predicate]]: serializable.can serialize and deserialize 0.001s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.contravariant composition 0.015s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.contravariant identity 0.004s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.contravariantMonoidal contramap2 compatible contramap left 0.027s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.contravariantMonoidal contramap2 compatible contramap right 0.007s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.contravariantMonoidal left unit 0.004s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.contravariantMonoidal right unit 0.004s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.contravariantSemigroupal contramap2 delta associates 0.006s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.invariant composition 0.007s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.invariant identity 0.004s + + ContravariantMonoidal[Predicate]: contravariantMonoidal.semigroupal associativity 0.007s + + intersection works 0.006s + + union works 0.005s + + difference works 0.005s + + negation works 0.006s +cats.collections.DisjointSetsSuite: + + union-find operations using state/stator monad 0.272s + + build unions with disjoint sets as if a set of sets were used 0.051s +cats.collections.MapShowSuite: + + show empty 0.001s + + show mappings 0.0s +cats.collections.MapSuite: + + we can add things to a Map, then find them 0.25s + + we can add things to a Map, then remove them 0.029s + + we can remove things from a Map with alter 0.024s + + we can combine maps 0.038s + + map works 0.015s + + flatMap works 0.037s +cats.collections.DiscreteSuite: + + succ 0.006s + + pred 0.003s + + adj 0.003s + + non adj 0.004s + + inverse succ 0.002s + + inverse pred 0.009s + + inverse adj 0.003s + + inverse non adj 0.003s +cats.collections.SetSuite: + + set is always sorted 0.041s + + iterator works 0.005s + + equality 0.004s + + inequality 0.003s + + set is always balanced 0.005s + + set can delete 0.005s + + contains works 0.003s + + find works 0.004s + + intersect is correct 0.028s + + union is correct 0.023s + + we can take the difference of sets 0.021s + + map works 0.007s + + fromFoldable works 0.006s + + Show instance is consistent with toString 0.012s +cats.collections.MapLawsSuite: + + Map[String,A]: flatMap.apply composition 0.011s + + Map[String,A]: flatMap.covariant composition 0.011s + + Map[String,A]: flatMap.covariant identity 0.006s + + Map[String,A]: flatMap.flatMap associativity 0.295s + + Map[String,A]: flatMap.flatMap consistent apply 0.026s + + Map[String,A]: flatMap.flatMap from tailRecM consistency 0.036s + + Map[String,A]: flatMap.invariant composition 0.019s + + Map[String,A]: flatMap.invariant identity 0.005s + + Map[String,A]: flatMap.map2/map2Eval consistency 0.011s + + Map[String,A]: flatMap.map2/product-map consistency 0.008s + + Map[String,A]: flatMap.mapOrKeepToMapEquivalence 0.022s + + Map[String,A]: flatMap.mproduct consistent flatMap 0.03s + + Map[String,A]: flatMap.productL consistent map2 0.007s + + Map[String,A]: flatMap.productR consistent map2 0.009s + + Map[String,A]: flatMap.semigroupal associativity 0.012s + + Map[String,A]: flatMap.tailRecM consistent flatMap 0.056s +cats.collections.PairingHeapDisciplineSuite: + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.add increases size 0.006s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.add is consisten with foldMap 0.01s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.add to empty is singleton 0.009s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.addAll + toSortedList same as sorting 0.151s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.addAll matches default impl 0.02s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.addAllLargest matches default impl 0.007s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.addIfLarger matches default impl 0.006s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.build matches default impl 0.003s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.compare 0.008s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.contains all elements from itself 0.004s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.contains consistent with exists 0.006s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.contains consistent with forall 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.contains matches toSortedList 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.empty is Monoid.empty 0.0s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.exists is lazy 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.forall consistent with exists 0.004s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.forall is lazy 0.003s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.forall true if empty 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.max 0.007s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.min 0.009s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.minimumOption is the min 0.006s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.nonEmpty reference 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.pop matches default impl 0.006s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.remove decreases size 0.003s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.remove min never decreases min 0.003s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.size matches unorderedFoldMap 0.008s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.sortedFoldLeft matches default impl 0.014s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.takeLargest matches default impl 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.toSortedList matches default impl 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.totality 0.005s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.unadd matches default impl 0.004s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.unorderedFold consistent with unorderedFoldMap 0.004s + + PartiallyOrderedSet[PairingHeap]: partiallyOrderedSet.unorderedFoldMapA identity 0.008s + + Order[PairingHeap[Int]]: order.antisymmetry 0.009s + + Order[PairingHeap[Int]]: order.antisymmetry eq 0.006s + + Order[PairingHeap[Int]]: order.compare 0.008s + + Order[PairingHeap[Int]]: order.gt 0.007s + + Order[PairingHeap[Int]]: order.gteqv 0.007s + + Order[PairingHeap[Int]]: order.lt 0.009s + + Order[PairingHeap[Int]]: order.max 0.009s + + Order[PairingHeap[Int]]: order.min 0.007s + + Order[PairingHeap[Int]]: order.partialCompare 0.01s + + Order[PairingHeap[Int]]: order.pmax 0.008s + + Order[PairingHeap[Int]]: order.pmin 0.009s + + Order[PairingHeap[Int]]: order.reflexivity eq 0.004s + + Order[PairingHeap[Int]]: order.reflexivity gt 0.004s + + Order[PairingHeap[Int]]: order.reflexivity lt 0.004s + + Order[PairingHeap[Int]]: order.symmetry eq 0.007s + + Order[PairingHeap[Int]]: order.totality 0.006s + + Order[PairingHeap[Int]]: order.transitivity 0.01s + + Order[PairingHeap[Int]]: order.transitivity eq 0.008s + + PairingHeap[Int]: commutativeMonoid.associative 0.012s + + PairingHeap[Int]: commutativeMonoid.collect0 0.001s + + PairingHeap[Int]: commutativeMonoid.combine all 0.01s + + PairingHeap[Int]: commutativeMonoid.combineAllOption 0.012s + + PairingHeap[Int]: commutativeMonoid.commutative 0.008s + + PairingHeap[Int]: commutativeMonoid.intercalateCombineAllOption 0.015s + + PairingHeap[Int]: commutativeMonoid.intercalateIntercalates 0.009s + + PairingHeap[Int]: commutativeMonoid.intercalateRepeat1 0.009s + + PairingHeap[Int]: commutativeMonoid.intercalateRepeat2 0.005s + + PairingHeap[Int]: commutativeMonoid.is id 0.004s + + PairingHeap[Int]: commutativeMonoid.left identity 0.003s + + PairingHeap[Int]: commutativeMonoid.repeat0 0.005s + + PairingHeap[Int]: commutativeMonoid.repeat1 0.005s + + PairingHeap[Int]: commutativeMonoid.repeat2 0.005s + + PairingHeap[Int]: commutativeMonoid.reverseCombineAllOption 0.013s + + PairingHeap[Int]: commutativeMonoid.reverseRepeat1 0.006s + + PairingHeap[Int]: commutativeMonoid.reverseRepeat2 0.009s + + PairingHeap[Int]: commutativeMonoid.reverseReverses 0.012s + + PairingHeap[Int]: commutativeMonoid.right identity 0.019s +cats.collections.HashMapSuite: + + HashMap[Int, String]: hash.antisymmetry eq 0.039s + + HashMap[Int, String]: hash.hash compatibility 0.016s + + HashMap[Int, String]: hash.reflexivity eq 0.006s + + HashMap[Int, String]: hash.symmetry eq 0.018s + + HashMap[Int, String]: hash.transitivity eq 0.019s + + Hash[HashMap[Int, String]]: serializable.can serialize and deserialize 0.003s + + HashMap[Int, Int] with Option: unorderedTraverse.contains all elements from itself 0.008s + + HashMap[Int, Int] with Option: unorderedTraverse.contains consistent with exists 0.006s + + HashMap[Int, Int] with Option: unorderedTraverse.contains consistent with forall 0.02s + + HashMap[Int, Int] with Option: unorderedTraverse.exists is lazy 0.005s + + HashMap[Int, Int] with Option: unorderedTraverse.forall consistent with exists 0.006s + + HashMap[Int, Int] with Option: unorderedTraverse.forall is lazy 0.008s + + HashMap[Int, Int] with Option: unorderedTraverse.forall true if empty 0.01s + + HashMap[Int, Int] with Option: unorderedTraverse.nonEmpty reference 0.016s + + HashMap[Int, Int] with Option: unorderedTraverse.unordered traverse consistent with sequence 0.016s + + HashMap[Int, Int] with Option: unorderedTraverse.unordered traverse parallel composition 0.012s + + HashMap[Int, Int] with Option: unorderedTraverse.unordered traverse sequential composition 0.02s + + HashMap[Int, Int] with Option: unorderedTraverse.unorderedFold consistent with unorderedFoldMap 0.009s + + HashMap[Int, Int] with Option: unorderedTraverse.unorderedFoldMapA identity 0.017s + + UnorderedTraverse[HashMap[Int, *]]: serializable.can serialize and deserialize 0.001s + + HashMap[Int, String]: commutativeMonoid.associative 0.023s + + HashMap[Int, String]: commutativeMonoid.collect0 0.001s + + HashMap[Int, String]: commutativeMonoid.combine all 0.012s + + HashMap[Int, String]: commutativeMonoid.combineAllOption 0.013s + + HashMap[Int, String]: commutativeMonoid.commutative 0.016s + + HashMap[Int, String]: commutativeMonoid.intercalateCombineAllOption 0.035s + + HashMap[Int, String]: commutativeMonoid.intercalateIntercalates 0.023s + + HashMap[Int, String]: commutativeMonoid.intercalateRepeat1 0.013s + + HashMap[Int, String]: commutativeMonoid.intercalateRepeat2 0.01s + + HashMap[Int, String]: commutativeMonoid.is id 0.008s + + HashMap[Int, String]: commutativeMonoid.left identity 0.008s + + HashMap[Int, String]: commutativeMonoid.repeat0 0.008s + + HashMap[Int, String]: commutativeMonoid.repeat1 0.007s + + HashMap[Int, String]: commutativeMonoid.repeat2 0.006s + + HashMap[Int, String]: commutativeMonoid.reverseCombineAllOption 0.014s + + HashMap[Int, String]: commutativeMonoid.reverseRepeat1 0.008s + + HashMap[Int, String]: commutativeMonoid.reverseRepeat2 0.006s + + HashMap[Int, String]: commutativeMonoid.reverseReverses 0.015s + + HashMap[Int, String]: commutativeMonoid.right identity 0.006s + + CommutativeMonoid[HashMap[Int, Int]]: serializable.can serialize and deserialize 0.002s + + show 0.003s + + isEmpty and nonEmpty 0.006s + + === 0.019s + + size 0.026s + + get 0.007s + + updated 0.014s + + removed 0.012s + + removed with collision 0.001s + + concat 0.016s + + fromSeq consistent with contains 0.005s + + fromIterableOnce consistent with contains 0.005s + + fromFoldable consistent with contains 0.004s + + iterator consistent with contains 0.009s + + foreach consistent with contains 0.015s + + foreach and iterator consistent 0.007s + + size consistent with iterator 0.015s + + size consistent with foreach 0.044s + + show consistent with === 0.015s + + toString consistent with equals 0.017s + + toMap consistent with fromIterableOnce 0.021s + + transform is equivalent to unorderedTransformA with Id 0.013s + + transform is same as the standard transform 0.008s +cats.collections.DequeueSuite: + + Dequeue[Int]: coflatMap.coflatMap associativity 0.051s + + Dequeue[Int]: coflatMap.coflatMap identity 0.005s + + Dequeue[Int]: coflatMap.coflatten coherence 0.009s + + Dequeue[Int]: coflatMap.coflatten throughMap 0.009s + + Dequeue[Int]: coflatMap.covariant composition 0.005s + + Dequeue[Int]: coflatMap.covariant identity 0.003s + + Dequeue[Int]: coflatMap.invariant composition 0.008s + + Dequeue[Int]: coflatMap.invariant identity 0.003s + + Dequeue[Int]: coflatMap.mapOrKeepToMapEquivalence 0.005s + + CoflatMap[Dequeue]: serializable.can serialize and deserialize 0.002s + + Dequeue[Int] with Option: traverse.collectFirst reference 0.007s + + Dequeue[Int] with Option: traverse.collectFirstSome reference 0.005s + + Dequeue[Int] with Option: traverse.contains all elements from itself 0.006s + + Dequeue[Int] with Option: traverse.contains consistent with exists 0.005s + + Dequeue[Int] with Option: traverse.contains consistent with forall 0.004s + + Dequeue[Int] with Option: traverse.covariant composition 0.009s + + Dequeue[Int] with Option: traverse.covariant identity 0.004s + + Dequeue[Int] with Option: traverse.dropWhile_ reference 0.004s + + Dequeue[Int] with Option: traverse.exists consistent with find 0.007s + + Dequeue[Int] with Option: traverse.exists is lazy 0.007s + + Dequeue[Int] with Option: traverse.filter_ reference 0.011s + + Dequeue[Int] with Option: traverse.fold reference 0.014s + + Dequeue[Int] with Option: traverse.foldLeft consistent with foldMap 0.033s + + Dequeue[Int] with Option: traverse.foldM identity 0.008s + + Dequeue[Int] with Option: traverse.foldRight consistent with foldMap 0.016s + + Dequeue[Int] with Option: traverse.foldRight is lazy 0.007s + + Dequeue[Int] with Option: traverse.foldRightDefer consistency 0.008s + + Dequeue[Int] with Option: traverse.forall consistent with exists 0.01s + + Dequeue[Int] with Option: traverse.forall is lazy 0.004s + + Dequeue[Int] with Option: traverse.forall true if empty 0.008s + + Dequeue[Int] with Option: traverse.get reference 0.004s + + Dequeue[Int] with Option: traverse.invariant composition 0.006s + + Dequeue[Int] with Option: traverse.invariant identity 0.004s + + Dequeue[Int] with Option: traverse.mapOrKeepToMapEquivalence 0.011s + + Dequeue[Int] with Option: traverse.nonEmpty reference 0.019s + + Dequeue[Int] with Option: traverse.ordered consistency 0.006s + + Dequeue[Int] with Option: traverse.reduceLeftOption consistent with reduceLeftToOption 0.006s + + Dequeue[Int] with Option: traverse.reduceRightOption consistent with reduceRightToOption 0.041s + + Dequeue[Int] with Option: traverse.takeWhile_ reference 0.017s + + Dequeue[Int] with Option: traverse.toList reference 0.005s + + Dequeue[Int] with Option: traverse.traverse derive foldMap 0.014s + + Dequeue[Int] with Option: traverse.traverse identity 0.007s + + Dequeue[Int] with Option: traverse.traverse order consistency 0.044s + + Dequeue[Int] with Option: traverse.traverse parallel composition 0.018s + + Dequeue[Int] with Option: traverse.traverse ref mapAccumulate 0.016s + + Dequeue[Int] with Option: traverse.traverse ref mapWithIndex 0.011s + + Dequeue[Int] with Option: traverse.traverse ref mapWithLongIndex 0.009s + + Dequeue[Int] with Option: traverse.traverse ref traverseWithIndexM 0.007s + + Dequeue[Int] with Option: traverse.traverse ref traverseWithLongIndexM 0.009s + + Dequeue[Int] with Option: traverse.traverse ref updated 0.008s + + Dequeue[Int] with Option: traverse.traverse ref zipWithIndex 0.009s + + Dequeue[Int] with Option: traverse.traverse ref zipWithLongIndex 0.007s + + Dequeue[Int] with Option: traverse.traverse sequential composition 0.006s + + Dequeue[Int] with Option: traverse.traverse traverseTap 0.004s + + Dequeue[Int] with Option: traverse.unordered traverse consistent with sequence 0.002s + + Dequeue[Int] with Option: traverse.unordered traverse parallel composition 0.01s + + Dequeue[Int] with Option: traverse.unordered traverse sequential composition 0.017s + + Dequeue[Int] with Option: traverse.unorderedFold consistent with unorderedFoldMap 0.006s + + Dequeue[Int] with Option: traverse.unorderedFoldMapA identity 0.018s + + Traverse[Dequeue]: serializable.can serialize and deserialize 0.001s + + enqueue onto an empty q can be fetched from either end 0.0s + + cons and then uncons 0.013s + + snoc and then unsnoc 0.014s + + cons and then unsnoc 0.01s + + snoc and then uncons 0.002s + + foldLeft 0.003s + + foldRight 0.002s + + toList 0.003s + + toList/reverse 0.002s + + toList/append 0.005s + + toList/Foldable consistency 0.004s + + toList/toStream consistency 0.005s + + equality 0.003s + + inequality 0.002s +[info] + PairingHeap.takeLargest is the same as sort.reverse.take: OK, passed 10000 tests. +cats.collections.RangeSuite: + + contains(x): returns true for x within [start, end] 0.06s + + contains(x): returns false for x < start 0.033s + + contains(x): returns false for x > end 0.012s + + contains(Range): returns true if the passed range is within this range 0.02s + + contains(Range): returns false if the passed range's start < this range's start 0.14s + + contains(Range): returns false if the passed range's end > this range's end 0.061s + + contains(Range): returns false if the passed range is a super-range of this one 0.083s + + overlaps(Range): returns true if the start of the first range is contained in the passed range 0.093s + + overlaps(Range): returns true if the end of the first range is contained in the passed range 0.052s + + overlaps(Range): returns true if the passed range is a super-range of the first range 0.142s + + overlaps(Range): returns false if the first range stops before the passed range starts 0.026s + + overlaps(Range): behavior should be consistent with & method 0.013s + + foreach: enumerates all values of a range 0.038s + + map: returns a mapped range 0.033s + + foldLeft: folds range values from start to end 0.485s + + foldRight: folds range values from end to start 0.131s + + diff(-): returns None if the passed range completely covers this one 0.009s + + diff(-): returns this range if it does not overlap the passed one 0.018s + + diff(-): returns a single range if the passed range partially overlaps this one on the left 0.005s + + diff(-): returns a single range if the passed range partially overlaps this one on the right 0.005s + + diff(-): returns two ranges if the passed range fully fits in the middle of this one 0.189s + + add(+): returns a single range if one of the ranges is a subrange of the other 0.033s + + add(+): returns a single range if two passed ranges are connected or patrially overlapping 0.012s + + add(+): returns both passed ranges if there is a gap between them 0.004s + + intersect(&): returns a smaller range if one of the ranges is subrange of the other 0.008s + + intersect(&): returns None for non-overlapping ranged 0.031s + + toInterator/toList: converts a range to Iterator/List 0.021s + + reverse: inverses a range 0.001s + + show: renders a math representation of a range 0.014s +[info] + PairingHeap.fromIterable is sorted: OK, passed 10000 tests. +[info] + PairingHeap.PairingHeap.empty is less than nonEmpty: OK, passed 10000 tests. +cats.collections.HashSetSuite: + + HashSet[Int]: hash.antisymmetry eq 0.039s + + HashSet[Int]: hash.hash compatibility 0.019s + + HashSet[Int]: hash.reflexivity eq 0.027s + + HashSet[Int]: hash.symmetry eq 0.057s + + HashSet[Int]: hash.transitivity eq 0.054s + + Hash[HashSet[Int]]: serializable.can serialize and deserialize 0.001s + + HashSet[Int]: unorderedFoldable.contains all elements from itself 0.006s + + HashSet[Int]: unorderedFoldable.contains consistent with exists 0.01s + + HashSet[Int]: unorderedFoldable.contains consistent with forall 0.019s + + HashSet[Int]: unorderedFoldable.exists is lazy 0.037s + + HashSet[Int]: unorderedFoldable.forall consistent with exists 0.056s + + HashSet[Int]: unorderedFoldable.forall is lazy 0.017s + + HashSet[Int]: unorderedFoldable.forall true if empty 0.019s + + HashSet[Int]: unorderedFoldable.nonEmpty reference 0.01s + + HashSet[Int]: unorderedFoldable.unorderedFold consistent with unorderedFoldMap 0.014s + + HashSet[Int]: unorderedFoldable.unorderedFoldMapA identity 0.009s + + UnorderedFoldable[HashSet]: serializable.can serialize and deserialize 0.003s + + HashSet[String]: commutativeMonoid.associative 0.255s + + HashSet[String]: commutativeMonoid.collect0 0.012s + + HashSet[String]: commutativeMonoid.combine all 0.029s + + HashSet[String]: commutativeMonoid.combineAllOption 0.03s + + HashSet[String]: commutativeMonoid.commutative 0.06s + + HashSet[String]: commutativeMonoid.intercalateCombineAllOption 0.081s + + HashSet[String]: commutativeMonoid.intercalateIntercalates 0.204s + + HashSet[String]: commutativeMonoid.intercalateRepeat1 0.027s + + HashSet[String]: commutativeMonoid.intercalateRepeat2 0.028s + + HashSet[String]: commutativeMonoid.is id 0.012s + + HashSet[String]: commutativeMonoid.left identity 0.012s + + HashSet[String]: commutativeMonoid.repeat0 0.008s + + HashSet[String]: commutativeMonoid.repeat1 0.005s + + HashSet[String]: commutativeMonoid.repeat2 0.004s + + HashSet[String]: commutativeMonoid.reverseCombineAllOption 0.045s + + HashSet[String]: commutativeMonoid.reverseRepeat1 0.043s + + HashSet[String]: commutativeMonoid.reverseRepeat2 0.006s + + HashSet[String]: commutativeMonoid.reverseReverses 0.059s + + HashSet[String]: commutativeMonoid.right identity 0.011s + + CommutativeMonoid[HashSet[String]]: serializable.can serialize and deserialize 0.007s + + HashSet[String]: distributiveLattice.join:semilattice.associativity 0.115s + + HashSet[String]: distributiveLattice.join:semilattice.can serialize and deserialize 0.052s + + HashSet[String]: distributiveLattice.join:semilattice.combineAllOption 0.007s + + HashSet[String]: distributiveLattice.join:semilattice.combineN(a, 1) == a 0.005s + + HashSet[String]: distributiveLattice.join:semilattice.combineN(a, 2) == a |+| a 0.006s + + HashSet[String]: distributiveLattice.join:semilattice.commutative 0.029s + + HashSet[String]: distributiveLattice.join:semilattice.idempotence 0.006s + + HashSet[String]: distributiveLattice.join:semilattice.isIdempotent 0.001s + + HashSet[String]: distributiveLattice.meet:semilattice.associativity 0.041s + + HashSet[String]: distributiveLattice.meet:semilattice.can serialize and deserialize 0.009s + + HashSet[String]: distributiveLattice.meet:semilattice.combineAllOption 0.019s + + HashSet[String]: distributiveLattice.meet:semilattice.combineN(a, 1) == a 0.019s + + HashSet[String]: distributiveLattice.meet:semilattice.combineN(a, 2) == a |+| a 0.025s + + HashSet[String]: distributiveLattice.meet:semilattice.commutative 0.036s + + HashSet[String]: distributiveLattice.meet:semilattice.idempotence 0.01s + + HashSet[String]: distributiveLattice.meet:semilattice.isIdempotent 0.006s + + HashSet[String]: distributiveLattice.absorption 0.03s + + HashSet[String]: distributiveLattice.can serialize and deserialize 0.001s + + HashSet[String]: distributiveLattice.distributive 0.046s + + DistributiveLattice[HashSet[String]]: serializable.can serialize and deserialize 0.006s + + show 0.01s + + isEmpty and nonEmpty 0.028s + + === 0.021s + + size 0.132s + + union 0.015s + + add 0.007s + + remove 0.015s + + fromSeq consistent with contains 0.002s + + fromIterableOnce consistent with contains 0.002s + + fromFoldable consistent with contains 0.001s + + iterator consistent with contains 0.004s + + foreach consistent with contains 0.005s + + foreach and iterator consistent 0.007s + + size consistent with iterator 0.006s + + size consistent with foreach 0.005s + + show consistent with === 0.019s + + toSet consistent with fromIterableOnce 0.04s + + union consistent with Scala Set union 0.004s + + diff consistent with Scala Set diff 0.004s + + intersect consistent with Scala Set intersect 0.002s + + filter consistent with Scala Set filter 0.023s + + filterNot consistent with Scala Set filterNot 0.026s +cats.collections.TreeListSuite: + + Traverse[TreeList]: traverse.collectFirst reference 0.009s + + Traverse[TreeList]: traverse.collectFirstSome reference 0.005s + + Traverse[TreeList]: traverse.contains all elements from itself 0.006s + + Traverse[TreeList]: traverse.contains consistent with exists 0.003s + + Traverse[TreeList]: traverse.contains consistent with forall 0.005s + + Traverse[TreeList]: traverse.covariant composition 0.037s + + Traverse[TreeList]: traverse.covariant identity 0.008s + + Traverse[TreeList]: traverse.dropWhile_ reference 0.004s + + Traverse[TreeList]: traverse.exists consistent with find 0.002s + + Traverse[TreeList]: traverse.exists is lazy 0.004s + + Traverse[TreeList]: traverse.filter_ reference 0.011s + + Traverse[TreeList]: traverse.fold reference 0.002s + + Traverse[TreeList]: traverse.foldLeft consistent with foldMap 0.014s + + Traverse[TreeList]: traverse.foldM identity 0.053s + + Traverse[TreeList]: traverse.foldRight consistent with foldMap 0.021s + + Traverse[TreeList]: traverse.foldRight is lazy 0.036s + + Traverse[TreeList]: traverse.foldRightDefer consistency 0.006s + + Traverse[TreeList]: traverse.forall consistent with exists 0.006s + + Traverse[TreeList]: traverse.forall is lazy 0.013s + + Traverse[TreeList]: traverse.forall true if empty 0.005s + + Traverse[TreeList]: traverse.get reference 0.009s + + Traverse[TreeList]: traverse.invariant composition 0.009s + + Traverse[TreeList]: traverse.invariant identity 0.006s + + Traverse[TreeList]: traverse.mapOrKeepToMapEquivalence 0.009s + + Traverse[TreeList]: traverse.nonEmpty reference 0.006s + + Traverse[TreeList]: traverse.ordered consistency 0.008s + + Traverse[TreeList]: traverse.reduceLeftOption consistent with reduceLeftToOption 0.021s + + Traverse[TreeList]: traverse.reduceRightOption consistent with reduceRightToOption 0.009s + + Traverse[TreeList]: traverse.takeWhile_ reference 0.064s + + Traverse[TreeList]: traverse.toList reference 0.008s + + Traverse[TreeList]: traverse.traverse derive foldMap 0.022s + + Traverse[TreeList]: traverse.traverse identity 0.004s + + Traverse[TreeList]: traverse.traverse order consistency 0.017s + + Traverse[TreeList]: traverse.traverse parallel composition 0.052s + + Traverse[TreeList]: traverse.traverse ref mapAccumulate 0.009s + + Traverse[TreeList]: traverse.traverse ref mapWithIndex 0.01s + + Traverse[TreeList]: traverse.traverse ref mapWithLongIndex 0.01s + + Traverse[TreeList]: traverse.traverse ref traverseWithIndexM 0.007s + + Traverse[TreeList]: traverse.traverse ref traverseWithLongIndexM 0.007s + + Traverse[TreeList]: traverse.traverse ref updated 0.007s + + Traverse[TreeList]: traverse.traverse ref zipWithIndex 0.011s + + Traverse[TreeList]: traverse.traverse ref zipWithLongIndex 0.006s + + Traverse[TreeList]: traverse.traverse sequential composition 0.007s + + Traverse[TreeList]: traverse.traverse traverseTap 0.003s + + Traverse[TreeList]: traverse.unordered traverse consistent with sequence 0.003s + + Traverse[TreeList]: traverse.unordered traverse parallel composition 0.004s + + Traverse[TreeList]: traverse.unordered traverse sequential composition 0.007s + + Traverse[TreeList]: traverse.unorderedFold consistent with unorderedFoldMap 0.007s + + Traverse[TreeList]: traverse.unorderedFoldMapA identity 0.012s + + Alternative[TreeList]: alternative.ap consistent with product + map 0.013s + + Alternative[TreeList]: alternative.appendK consistent with pure and combineK 0.032s + + Alternative[TreeList]: alternative.applicative homomorphism 0.004s + + Alternative[TreeList]: alternative.applicative identity 0.002s + + Alternative[TreeList]: alternative.applicative interchange 0.004s + + Alternative[TreeList]: alternative.applicative map 0.001s + + Alternative[TreeList]: alternative.applicative unit 0.002s + + Alternative[TreeList]: alternative.apply composition 0.011s + + Alternative[TreeList]: alternative.covariant composition 0.003s + + Alternative[TreeList]: alternative.covariant identity 0.001s + + Alternative[TreeList]: alternative.fromIterableOnce 0.004s + + Alternative[TreeList]: alternative.invariant composition 0.003s + + Alternative[TreeList]: alternative.invariant identity 0.001s + + Alternative[TreeList]: alternative.left distributivity 0.004s + + Alternative[TreeList]: alternative.map2/map2Eval consistency 0.005s + + Alternative[TreeList]: alternative.map2/product-map consistency 0.016s + + Alternative[TreeList]: alternative.mapOrKeepToMapEquivalence 0.018s + + Alternative[TreeList]: alternative.monoidK left identity 0.014s + + Alternative[TreeList]: alternative.monoidK right identity 0.014s + + Alternative[TreeList]: alternative.monoidal left identity 0.008s + + Alternative[TreeList]: alternative.monoidal right identity 0.007s + + Alternative[TreeList]: alternative.prependK consistent with pure and combineK 0.013s + + Alternative[TreeList]: alternative.productL consistent map2 0.011s + + Alternative[TreeList]: alternative.productR consistent map2 0.014s + + Alternative[TreeList]: alternative.replicateA_ consistent with replicateA.void 0.041s + + Alternative[TreeList]: alternative.right absorption 0.009s + + Alternative[TreeList]: alternative.right distributivity 0.015s + + Alternative[TreeList]: alternative.semigroupK associative 0.015s + + Alternative[TreeList]: alternative.semigroupal associativity 0.04s + + FunctorFilter[TreeList]: functorFilter.collect mapFilter consistency 0.043s + + FunctorFilter[TreeList]: functorFilter.filter mapFilter consistency 0.054s + + FunctorFilter[TreeList]: functorFilter.filterNot mapFilter consistency 0.001s + + FunctorFilter[TreeList]: functorFilter.flattenOption mapFilter consistency 0.002s + + FunctorFilter[TreeList]: functorFilter.mapFilter composition 0.002s + + FunctorFilter[TreeList]: functorFilter.mapFilter map consistency 0.002s + + Monad[TreeList]: monad.ap consistent with product + map 0.002s + + Monad[TreeList]: monad.applicative homomorphism 0.001s + + Monad[TreeList]: monad.applicative identity 0.002s + + Monad[TreeList]: monad.applicative interchange 0.002s + + Monad[TreeList]: monad.applicative map 0.002s + + Monad[TreeList]: monad.applicative unit 0.002s + + Monad[TreeList]: monad.apply composition 0.012s + + Monad[TreeList]: monad.covariant composition 0.002s + + Monad[TreeList]: monad.covariant identity 0.001s + + Monad[TreeList]: monad.flatMap associativity 0.01s + + Monad[TreeList]: monad.flatMap consistent apply 0.003s + + Monad[TreeList]: monad.flatMap from tailRecM consistency 0.004s + + Monad[TreeList]: monad.flatMapOrKeep flatMap coherence 0.003s + + Monad[TreeList]: monad.invariant composition 0.002s + + Monad[TreeList]: monad.invariant identity 0.002s + + Monad[TreeList]: monad.map flatMap coherence 0.002s + + Monad[TreeList]: monad.map2/map2Eval consistency 0.003s + + Monad[TreeList]: monad.map2/product-map consistency 0.004s + + Monad[TreeList]: monad.mapOrKeepToMapEquivalence 0.001s + + Monad[TreeList]: monad.monad left identity 0.001s + + Monad[TreeList]: monad.monad right identity 0.002s + + Monad[TreeList]: monad.monoidal left identity 0.001s + + Monad[TreeList]: monad.monoidal right identity 0.001s + + Monad[TreeList]: monad.mproduct consistent flatMap 0.002s + + Monad[TreeList]: monad.productL consistent map2 0.002s + + Monad[TreeList]: monad.productR consistent map2 0.004s + + Monad[TreeList]: monad.replicateA_ consistent with replicateA.void 0.012s + + Monad[TreeList]: monad.semigroupal associativity 0.013s + + Monad[TreeList]: monad.tailRecM consistent flatMap 0.019s + + Monad[TreeList]: monad.tailRecM stack safety 0.186s + + CoflatMap[TreeList]: coflatMap.coflatMap associativity 0.028s + + CoflatMap[TreeList]: coflatMap.coflatMap identity 0.002s + + CoflatMap[TreeList]: coflatMap.coflatten coherence 0.003s + + CoflatMap[TreeList]: coflatMap.coflatten throughMap 0.002s + + CoflatMap[TreeList]: coflatMap.covariant composition 0.002s + + CoflatMap[TreeList]: coflatMap.covariant identity 0.001s + + CoflatMap[TreeList]: coflatMap.invariant composition 0.001s + + CoflatMap[TreeList]: coflatMap.invariant identity 0.001s + + CoflatMap[TreeList]: coflatMap.mapOrKeepToMapEquivalence 0.001s + + Traverse[TreeList]: serializable.can serialize and deserialize 0.002s + + iterator works 0.0s + + ++ works 0.002s + + drop/take work 0.002s + + lastOption works 0.011s + + toReverseIterator works 0.002s + + reverse works 0.001s + + strictFoldRight works 0.001s + + fromList/toList works 0.001s + + size works 0.001s + + split combined is identity 0.0s + + split produces a full left tree 0.001s + + pattern matching works 0.001s + + maxDepth <= 2 log_2 N + 1 0.001s + + Eq[TreeList[A]] works 0.004s + + Order[TreeList[A]] works 0.002s + + PartialOrder[TreeList[A]] works 0.01s + + Monoid[TreeList[A]].combine works 0.01s + + Monoid[TreeList[A]].empty works 0.0s + + toString is as expected 0.021s + + TreeList.get works 0.009s + + toIterator throws the same type of exception as List on empty 0.002s + + toReverseIterator throws the same type of exception as List on empty 0.001s + + TreeList.NonEmpty.apply/unapply are inverses 0.001s + + TreeList.traverse_/traverse consistency 0.003s + + TreeList.sequence_/sequence consistency 0.002s + + Show matches toString 0.001s + + lastOption matches get(size - 1L) 0.001s + + toListReverse == toList.reverse 0.001s + + updated works 0.004s + + we don't stack overflow on large sequences 0.421s + + filter/filterNot consistency 0.009s +[info] + PairingHeap.PairingHeap.combineAll (remove) does < log_2 N + 8 work: OK, passed 10000 tests. +[info] + PairingHeap.pop returns the minimum element: OK, passed 10000 tests. +cats.collections.HeapSuite: + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.add increases size 0.125s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.add is consisten with foldMap 0.443s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.add to empty is singleton 0.012s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.addAll + toSortedList same as sorting 0.02s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.addAll matches default impl 0.082s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.addAllLargest matches default impl 0.148s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.addIfLarger matches default impl 0.131s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.build matches default impl 0.022s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.compare 0.059s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.contains all elements from itself 0.03s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.contains consistent with exists 0.054s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.contains consistent with forall 0.024s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.contains matches toSortedList 0.027s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.empty is Monoid.empty 0.006s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.exists is lazy 0.039s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.forall consistent with exists 0.063s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.forall is lazy 0.041s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.forall true if empty 0.082s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.max 0.104s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.min 0.028s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.minimumOption is the min 0.016s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.nonEmpty reference 0.015s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.pop matches default impl 0.024s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.remove decreases size 0.011s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.remove min never decreases min 0.024s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.size matches unorderedFoldMap 0.026s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.sortedFoldLeft matches default impl 0.063s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.takeLargest matches default impl 0.04s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.toSortedList matches default impl 0.046s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.totality 0.061s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.unadd matches default impl 0.025s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.unorderedFold consistent with unorderedFoldMap 0.021s + + PartiallyOrderedSet[Heap]: partiallyOrderedSet.unorderedFoldMapA identity 0.023s + + Order[Heap[Int]]: order.antisymmetry 0.018s + + Order[Heap[Int]]: order.antisymmetry eq 0.023s + + Order[Heap[Int]]: order.compare 0.015s + + Order[Heap[Int]]: order.gt 0.021s + + Order[Heap[Int]]: order.gteqv 0.021s + + Order[Heap[Int]]: order.lt 0.02s + + Order[Heap[Int]]: order.max 0.021s + + Order[Heap[Int]]: order.min 0.022s + + Order[Heap[Int]]: order.partialCompare 0.021s + + Order[Heap[Int]]: order.pmax 0.043s + + Order[Heap[Int]]: order.pmin 0.08s + + Order[Heap[Int]]: order.reflexivity eq 0.036s + + Order[Heap[Int]]: order.reflexivity gt 0.036s + + Order[Heap[Int]]: order.reflexivity lt 0.043s + + Order[Heap[Int]]: order.symmetry eq 0.066s + + Order[Heap[Int]]: order.totality 0.083s + + Order[Heap[Int]]: order.transitivity 0.038s + + Order[Heap[Int]]: order.transitivity eq 0.029s + + sorted 0.006s + + heapify is sorted 0.008s + + adding increases size 0.011s + + add is the same as + 0.015s + + addAll is the same as ++ 0.015s + + addAll is the same as folding with add 0.015s + + remove decreases size 0.013s + + pop and remove return the same heap 0.013s + + pop returns the minimum element 0.012s + + size is consistent with isEmpty/nonEmpty 0.009s + + height is <= log_2 N + 1 for all heaps 0.006s + + heapify is the same as adding 0.008s + + minimumOption after removing one is >= before 0.025s + + Heap.minimumOption is the real minimum 0.0s + + Heap.foldLeft is consistent with toList.foldLeft 0.02s + + Show[Heap[Int]] works like toList.mkString 0.013s + + Order[Heap[Int]] works like List[Int] 0.016s + + Heap.exists is correct 0.014s + + Heap.forall is correct 0.011s + + Heap.empty is less than nonEmpty 0.014s + + takeLargest is the same as sort.reverse.take 0.008s + + Heap.toPairingHeap.toList == Heap.toList 0.02s + + Heap property is always maintained 0.024s +[info] + PairingHeap.size is consistent with isEmpty/nonEmpty: OK, passed 10000 tests. +[info] + PairingHeap.pop and remove return the same heap: OK, passed 10000 tests. +[info] + PairingHeap.fromIterable is the same as adding: OK, passed 10000 tests. +[info] + PairingHeap.PairingHeap satisfies the heap property: OK, passed 10000 tests. +[info] + PairingHeap.PairingHeap.exists is correct: OK, passed 10000 tests. +[info] + BitSet.!x.isEmpty == x.nonEmpty: OK, passed 1000 tests. +[info] + PairingHeap.sorted: OK, passed 10000 tests. +[info] + BitSet.!(x - a)(a): OK, passed 1000 tests. +[info] + PairingHeap.minimumOption after removing one is >= before: OK, passed 10000 tests. +[info] + BitSet.x.isEmpty = (x.size = 0): OK, passed 1000 tests. +[info] + BitSet.limit/height consistency: OK, passed 1000 tests. +[info] + PairingHeap.Show[PairingHeap[Int]] works like toList.mkString: OK, passed 10000 tests. +[info] + BitSet.x | x = x: OK, passed 1000 tests. +[info] + BitSet.test order: OK, passed 1000 tests. +[info] + BitSet.x.compact = x: OK, passed 1000 tests. +[info] + BitSet.x + a + a = x + a: OK, passed 1000 tests. +[info] + BitSet.x.toSet - a == (x - a).toSet: OK, passed 1000 tests. +[info] + BitSet.x & Empty = Empty: OK, passed 1000 tests. +[info] + BitSet.x.isEmpty == (x.compact eq BitSet.Empty): OK, passed 1000 tests. +[info] + BitSet.(x & (y | z) = (x & y) | (x & z): OK, passed 1000 tests. +[info] + PairingHeap.PairingHeap.forall is correct: OK, passed 10000 tests. +[info] + BitSet.BitSet(set: _*).toSet = set: OK, passed 1000 tests. +[info] + BitSet.(x & y) & z = x & (y & z): OK, passed 1000 tests. +[info] + BitSet.BitSet.empty contains nothing: OK, passed 1000 tests. +[info] + BitSet.test ordering: OK, passed 1000 tests. +[info] + BitSet.(x + a)(a): OK, passed 1000 tests. +[info] + BitSet.x & y = y & x: OK, passed 1000 tests. +[info] + BitSet.+ is commutative: OK, passed 1000 tests. +[info] + BitSet.(x intersects y) = (y intersects x): OK, passed 1000 tests. +[info] + BitSet.(x ^ 0) = x: OK, passed 1000 tests. +[info] + BitSet.(x ^ y) = (y ^ x): OK, passed 1000 tests. +[info] + BitSet.(x ^ x) = 0: OK, passed 1000 tests. +[info] + BitSet.x & x = x: OK, passed 1000 tests. +[info] + BitSet.x + a - a == x - a: OK, passed 1000 tests. +[info] + BitSet.0 -- x = 0: OK, passed 1000 tests. +[info] + BitSet.(x ^ y) = ((x -- (x & y)) | (y -- (x & y))): OK, passed 1000 tests. +[info] + BitSet.x -- x = 0: OK, passed 1000 tests. +[info] + BitSet.(x & y)(z) == x(z) && y(z): OK, passed 1000 tests. +[info] + BitSet.x -- 0 = x: OK, passed 1000 tests. +[info] + BitSet.(x ^ y)(n) = x(n) ^ y(n): OK, passed 1000 tests. +[info] + BitSet.((x ^ y) ^ z) = (x ^ (y ^ z)): OK, passed 1000 tests. +[info] + BitSet.x.toSet == x.iterator.toSet: OK, passed 1000 tests. +[info] + BitSet.- is commutative: OK, passed 1000 tests. +[info] + BitSet.BitSet(x.toSet: _*) = x: OK, passed 1000 tests. +[info] + PairingHeap.PairingHeap.foldLeft is consistent with toList.foldLeft: OK, passed 10000 tests. +[info] + BitSet.(x = y) = (x.toSet = y.toSet): OK, passed 1000 tests. +[info] + BitSet.x.toSet + a == (x + a).toSet: OK, passed 1000 tests. +[info] + BitSet.x | Empty = x: OK, passed 1000 tests. +[info] + BitSet.(x -- y).toSet = (x.toSet -- y.toSet): OK, passed 1000 tests. +[info] + BitSet.(x intersects y) = (x & y).nonEmpty: OK, passed 1000 tests. +[info] + PairingHeap.Order[PairingHeap[Int]] works like List[Int]: OK, passed 10000 tests. +[info] + BitSet.x -- BitSet(n) = x - n: OK, passed 1000 tests. +[info] + BitSet.x.iterator.size = x.size: OK, passed 1000 tests. +[info] + BitSet.(x | y)(z) == x(z) || y(z): OK, passed 1000 tests. +[info] + BitSet.(x | y) | z = x | (y | z): OK, passed 1000 tests. +[info] + BitSet.x - a - a = x - a: OK, passed 1000 tests. +[info] + BitSet.x.iterator.forall(x(_)): OK, passed 1000 tests. +[info] + BitSet.(x -- y)(n) = x(n) && (!y(n)): OK, passed 1000 tests. +[info] + BitSet.x -- y -- y = x -- y: OK, passed 1000 tests. +[info] + PairingHeap.PairingHeap.minimumOption is the real minimum: OK, passed 10000 tests. +[info] + BitSet.x.iterator.toList.reverse = x.reverseIterator.toList: OK, passed 1000 tests. +[info] + BitSet.x | y = y | x: OK, passed 1000 tests. +[info] + BitSet.we never mutate the original item on |, &, ^, --: OK, passed 1000 tests. +[info] + BitSet.Bitset.fromScalaRange consistent with BitSet(...): OK, passed 1000 tests. +cats.collections.AnotherDietSuite: + + foldLeft 1.167s + + foldLeft/toList 0.887s + + foldRight 0.065s + + foldRight/toList 0.114s + + not be modified when inserting existing item 4.396s + + -- 0.048s + + toIterator/toList 0.008s +cats.collections.DietSuite: + + shown empty 0.009s + + shown all intervals 0.0s + + remove side ranges 0.002s + + return empty when removing from empty 0.001s + + diet eq 0.008s + + same ranges define the same diet 0.87s + + reshaping results on the same diet 0.306s + + different set of ranges ==> different diets 0.867s + + remove inner range 0.001s + + insert/remove 0.875s + + distinct 0.261s + + min 0.324s + + max 0.415s + + min/max empty 0.001s + + merge 1.042s + + intersection range 0.073s + + intersection diet 0.681s + + join disjoint range 0.0s + + contains 0.396s + + not contains 0.146s + + not be modified when removing non-existent item 0.033s + + invariant regression 0.002s + + invariant 0.065s + + one and fromRange are consistent 0.01s + + fromRange contains consistent with Range contains 0.038s + + one and contains are consistent 0.025s + + one toList 0.016s + + range toList 0.102s + + Diet[Int]: commutativeMonoid.associative 0.066s + + Diet[Int]: commutativeMonoid.collect0 0.001s + + Diet[Int]: commutativeMonoid.combine all 0.083s + + Diet[Int]: commutativeMonoid.combineAllOption 0.017s + + Diet[Int]: commutativeMonoid.commutative 0.024s + + Diet[Int]: commutativeMonoid.intercalateCombineAllOption 0.058s + + Diet[Int]: commutativeMonoid.intercalateIntercalates 0.038s + + Diet[Int]: commutativeMonoid.intercalateRepeat1 0.027s + + Diet[Int]: commutativeMonoid.intercalateRepeat2 0.018s + + Diet[Int]: commutativeMonoid.is id 0.008s + + Diet[Int]: commutativeMonoid.left identity 0.008s + + Diet[Int]: commutativeMonoid.repeat0 0.005s + + Diet[Int]: commutativeMonoid.repeat1 0.005s + + Diet[Int]: commutativeMonoid.repeat2 0.007s + + Diet[Int]: commutativeMonoid.reverseCombineAllOption 0.017s + + Diet[Int]: commutativeMonoid.reverseRepeat1 0.006s + + Diet[Int]: commutativeMonoid.reverseRepeat2 0.005s + + Diet[Int]: commutativeMonoid.reverseReverses 0.01s + + Diet[Int]: commutativeMonoid.right identity 0.006s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.associativity 0.018s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.can serialize and deserialize 0.004s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.combineAll 0.02s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.combineAll(Nil) == id 0.007s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.combineAllOption 0.017s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.combineN(a, 0) == id 0.008s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.combineN(a, 1) == a 0.007s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.combineN(a, 2) == a |+| a 0.008s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.commutative 0.011s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.isEmpty 0.004s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.leftIdentity 0.006s + + Diet[Int]: semiring.additive:additive commutative monoid.base:commutative monoid.rightIdentity 0.007s + + Diet[Int]: semiring.additive:additive commutative monoid.can serialize and deserialize 0.001s + + Diet[Int]: semiring.additive:additive commutative monoid.sum(Nil) == zero 0.007s + + Diet[Int]: semiring.additive:additive commutative monoid.sumN(a, 0) == zero 0.006s + + Diet[Int]: semiring.additive:additive commutative monoid.sumN(a, 1) == a 0.005s + + Diet[Int]: semiring.additive:additive commutative monoid.sumN(a, 2) == a + a 0.007s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.base:semigroup.associativity 0.018s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.base:semigroup.can serialize and deserialize 0.001s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.base:semigroup.combineAllOption 0.014s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.base:semigroup.combineN(a, 1) == a 0.007s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.base:semigroup.combineN(a, 2) == a |+| a 0.011s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.can serialize and deserialize 0.001s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.pow(a, 1) == a 0.006s + + Diet[Int]: semiring.multiplicative:multiplicative semigroup.pow(a, 2) == a * a 0.007s + + Diet[Int]: semiring.distributive 0.02s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.associativity 0.01s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.can serialize and deserialize 0.001s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.combineAll 0.012s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.combineAll(Nil) == id 0.006s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.combineAllOption 0.015s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.combineN(a, 0) == id 0.005s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.combineN(a, 1) == a 0.004s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.combineN(a, 2) == a |+| a 0.005s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.commutative 0.009s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.idempotence 0.003s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.isEmpty 0.004s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.isIdempotent 0.0s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.leftIdentity 0.006s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.join:boundedSemilattice.rightIdentity 0.005s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.associativity 0.01s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.can serialize and deserialize 0.001s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.combineAllOption 0.011s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.combineN(a, 1) == a 0.004s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.combineN(a, 2) == a |+| a 0.004s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.commutative 0.008s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.idempotence 0.005s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.meet:semilattice.isIdempotent 0.0s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.absorption 0.008s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.can serialize and deserialize 0.001s + + Diet[Int]: generalized bool.lattice:lowerBoundedDistributiveLattice.distributive 0.016s + + Diet[Int]: generalized bool.x\\y ∧ y = 0 0.01s + + Diet[Int]: generalized bool.x\\y ∨ y = x ∨ y 0.008s +[info] + BitSet.we never mutate the original item on +/-: OK, passed 1000 tests. +[info] + BitSet.(x = y) = (x.## = y.##): OK, passed 1000 tests. +[info] ScalaCheck +[info] Passed: Total 71, Failed 0, Errors 0, Passed 71 +[info] Passed: Total 786, Failed 0, Errors 0, Passed 786 +[success] Total time: 14 s, completed 27 Feb 2026, 1:40:07 am