Fix lengthCompare for indexed types

NthPortal · NthPortal · commit b0bd4615cf9e · 2018-07-12T17:59:22.000-04:00
diff --git a/src/library/scala/collection/ArrayOps.scala b/src/library/scala/collection/ArrayOps.scala
@@ -221,7 +221,7 @@ final class ArrayOps[A](val xs: Array[A]) extends AnyVal {
     *        x >  0       if this.length >  len
     *   }}}
     */
-  def lengthCompare(len: Int): Int = xs.length - len
+  def lengthCompare(len: Int): Int = Integer.compare(xs.length, len)
 
   /** Selects an interval of elements. The returned array is made up
     * of all elements `x` which satisfy the invariant:
diff --git a/src/library/scala/collection/IndexedSeq.scala b/src/library/scala/collection/IndexedSeq.scala
@@ -52,7 +52,7 @@ trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] { self =>
 
   override def last: A = apply(length - 1)
 
-  override def lengthCompare(len: Int): Int = length - len
+  override def lengthCompare(len: Int): Int = Integer.compare(length, len)
 
   final override def knownSize: Int = length
 
diff --git a/src/library/scala/collection/StringOps.scala b/src/library/scala/collection/StringOps.scala
@@ -155,6 +155,8 @@ final class StringOps(private val s: String) extends AnyVal {
   /** Get the char at the specified index. */
   @`inline` def apply(i: Int): Char = s.charAt(i)
 
+  def lengthCompare(len: Int): Int = Integer.compare(s.length, len)
+
   /** Builds a new collection by applying a function to all chars of this String.
     *
     *  @param f      the function to apply to each char.
diff --git a/src/library/scala/collection/immutable/Vector.scala b/src/library/scala/collection/immutable/Vector.scala
@@ -80,8 +80,6 @@ final class Vector[+A] private[immutable] (private[collection] val startIndex: I
 
   def length: Int = endIndex - startIndex
 
-  override def lengthCompare(len: Int): Int = length - len
-
   private[collection] def initIterator[B >: A](s: VectorIterator[B]): Unit = {
     s.initFrom(this)
     if (dirty) s.stabilize(focus)
diff --git a/test/junit/scala/collection/IndexedSeqTest.scala b/test/junit/scala/collection/IndexedSeqTest.scala
@@ -39,6 +39,12 @@ abstract class IndexedTest[T, E] {
     }
   }
 
+  /** check that lengthCompare compares values correctly */
+  @Test def checkLengthCompare(): Unit = {
+    val test = underTest(size)
+    assert(lengthCompare(test, Integer.MIN_VALUE) > 0)
+  }
+
   /**
     * check simple equallity of the initial data.
     * More a test of the infra that we use in this est than a full test of equallity
@@ -231,6 +237,8 @@ abstract class IndexedTest[T, E] {
   //the length of underTest
   def length(underTest: T): Int
 
+  def lengthCompare(underTest: T, len: Int): Int
+
   //the value at index i of underTest
   def get(underTest: T, i: Int): E
 
@@ -316,6 +324,8 @@ package IndexedTestImpl {
                                val TYPE: Class[_]) extends IndexedTest[Array[E], E]{
     override final def length(underTest: Array[E]) = underTest.length
 
+    override final def lengthCompare(underTest: Array[E], len: Int): Int = underTest.lengthCompare(len)
+
     override def get(underTest: Array[E], i: Int) = underTest(i)
 
     override def slice(underTest: Array[E], from: Int, to: Int) = underTest.slice(from, to)
@@ -347,6 +357,8 @@ package IndexedTestImpl {
     import mutable.ArraySeq
     override final def length(underTest: ArraySeq[E]) = underTest.length
 
+    override final def lengthCompare(underTest: ArraySeq[E], len: Int): Int = underTest.lengthCompare(len)
+
     override def get(underTest: ArraySeq[E], i: Int) = underTest(i)
 
     override def slice(underTest: ArraySeq[E], from: Int, to: Int) = underTest.slice(from, to)
@@ -377,6 +389,8 @@ package IndexedTestImpl {
   abstract class MutableIndexedSeqTest[T <: mutable.Seq[E], E] extends IndexedTest[T, E]   with DataProvider[E]{
     override final def length(underTest: T) = underTest.length
 
+    override final def lengthCompare(underTest: T, len: Int): Int = underTest.lengthCompare(len)
+
     override def get(underTest: T, i: Int) = underTest(i)
 
     override def slice(underTest: T, from: Int, to: Int) = underTest.slice(from, to).asInstanceOf[T]
@@ -407,6 +421,8 @@ package IndexedTestImpl {
   abstract class ImmutableIndexedSeqTest[T <: SeqOps[E, Seq, T], E] extends IndexedTest[T, E]   with DataProvider[E] {
     override final def length(underTest: T) = underTest.length
 
+    override final def lengthCompare(underTest: T, len: Int): Int = underTest.lengthCompare(len)
+
     override def get(underTest: T, i: Int) = underTest(i)
 
     override def slice(underTest: T, from: Int, to: Int) = underTest.slice(from, to)
@@ -428,6 +444,8 @@ package IndexedTestImpl {
   abstract class StringOpsBaseTest extends IndexedTest[StringOps, Char] with DataProvider[Char]  {
     override final def length(underTest: StringOps) = underTest.size
 
+    override final def lengthCompare(underTest: StringOps, len: Int): Int = underTest.lengthCompare(len)
+
     override def get(underTest: StringOps, i: Int) = underTest(i)
 
     override def slice(underTest: StringOps, from: Int, to: Int) = underTest.slice(from, to)

Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,8 @@ final class StringOps(private val s: String) extends AnyVal {`
`155`	`155`	`/** Get the char at the specified index. */`
`156`	`156`	@`inline` def apply(i: Int): Char = s.charAt(i)
`157`	`157`
	`158`	`+ def lengthCompare(len: Int): Int = Integer.compare(s.length, len)`
	`159`	`+`
`158`	`160`	`/** Builds a new collection by applying a function to all chars of this String.`
`159`	`161`	`*`
`160`	`162`	`* @param f the function to apply to each char.`