Merge branch 'cheeseng-pass-2.13-tests' into 3.1.x

Author: bvenners

project/GenColCompatHelper.scala

@@ -55,9 +55,18 @@ object GenColCompatHelper {
           |
           |  object Factory {}
           |
-          |  def className(col: scala.collection.Iterable[_]): String = org.scalactic.NameUtil.getSimpleNameOfAnObjectsClass(col)
+          |  def className(col: scala.collection.Iterable[_]): String = {
+          |    val colToString = col.toString
+          |    val bracketIdx = colToString.indexOf("(")
+          |    if (bracketIdx >= 0)
+          |      colToString.take(bracketIdx)
+          |    else
+          |      org.scalactic.NameUtil.getSimpleNameOfAnObjectsClass(col)
+          |  }
           |
           |  def newBuilder[A, C](f: Factory[A, C]): scala.collection.mutable.Builder[A, C] = f.newBuilder
+          |
+          |  type StringOps = scala.collection.StringOps
           |}
           |
         """.stripMargin
@@ -118,6 +127,8 @@ object GenColCompatHelper {
           |  def className(col: scala.collection.GenTraversable[_]): String = col.stringPrefix
           |
           |  def newBuilder[A, C](f: Factory[A, C]): scala.collection.mutable.Builder[A, C] = f.apply()
+          |
+          |  type StringOps = scala.collection.immutable.StringOps
           |}
           |
         """.stripMargin

project/templates/Every.template

@@ -537,9 +537,9 @@ sealed abstract class Every[+T] protected (underlying: Vector[T]) extends Partia
    * That is, every key <code>k</code> is bound to an <code>Every</code> of those elements <code>x</code> for which <code>f(x)</code> equals <code>k</code>.
    * </p>
    */
-  final def groupBy[K](f: T => K): Map[K, Every[T]] = {
+  final def groupBy[K](f: T => K) = {
     val mapKToVec = underlying.groupBy(f)
-    mapKToVec.mapValues { vec => Every(vec.head, vec.tail: _*) }
+    (mapKToVec.mapValues { vec => Every(vec.head, vec.tail: _*) }).toMap
   }
 
   /**

scalactic-macro/src/main/resources/org/scalactic/ScalacticBundle.properties

@@ -107,4 +107,5 @@ notLiteralFiniteFloat=PosFiniteFloat.apply can only be invoked on a floating poi
 notValidFiniteDouble=PosFiniteDouble.apply can only be invoked on a finite (n != Double.PositiveInfinity && n != Double.NegativeInfinity) floating point literal, like FiniteDouble(42.0).
 notLiteralFiniteDouble=PosFiniteDouble.apply can only be invoked on a floating point literal, like FiniteDouble(42.0). Please use FiniteDouble.from instead.
 notValidNumericChar=NumericChar.apply can only be invoked on Char literals that are numbers, like '8'.
-notLiteralNumericChar=NumericChar.apply can only be invoked on Char literals that are numbers, like '8'. Please use NumericChar.from instead.
+notLiteralNumericChar=NumericChar.apply can only be invoked on Char literals that are numbers, like '8'. Please use NumericChar.from instead.
+invalidSize=Invalid size: {0}

scalactic-macro/src/main/scala/org/scalactic/anyvals/NumericString.scala

@@ -950,8 +950,8 @@ final class NumericString private (val value: String) extends AnyVal {
    *          defined and collecting the results.  The
    *          order of the elements is preserved.
    */
-  def collect[B](pf: PartialFunction[Char, B]): String =
-    value.collect(pf).mkString
+  def collect(pf: PartialFunction[Char, Char]) =
+    value.collect(pf)
 
   /**
    * Finds the first character of the `NumericString` for
@@ -1908,32 +1908,30 @@ final class NumericString private (val value: String) extends AnyVal {
    *  @return a new string containing the prefix scan of the
    *          elements in this `NumericString`
    */
-  def scan[B >: Char](z: B)(op: (B, B) ⇒ B): IndexedSeq[B] =
+  def scan(z: Char)(op: (Char, Char) ⇒ Char) =
     value.scan(z)(op)
 
   /** Produces a collection containing cumulative results of applying the
    *  operator going left to right.
    *
-   *  @tparam B      the type of the elements in the resulting collection
    *  @param z       the initial value
    *  @param op      the binary operator applied to the intermediate
    *                 result and the element
    *  @return        collection with intermediate results
    */
-  def scanLeft[B](z: B)(op: (B, Char) ⇒ B): IndexedSeq[B] =
+  def scanLeft(z: String)(op: (String, Char) ⇒ String) =
     value.scanLeft(z)(op)
 
   /** Produces a collection containing cumulative results of
    *  applying the operator going right to left.  The head of
    *  the collection is the last cumulative result.
    *
-   *  @tparam B      the type of the elements in the resulting collection
    *  @param z       the initial value
    *  @param         op the binary operator applied to the intermediate
    *                 result and the element
    *  @return        collection with intermediate results
    */
-  def scanRight[B](z: B)(op: (Char, B) ⇒ B): IndexedSeq[B] =
+  def scanRight(z: String)(op: (Char, String) ⇒ String) =
     value.scanRight(z)(op)
 
 
@@ -2393,7 +2391,7 @@ final class NumericString private (val value: String) extends AnyVal {
    *                  `NumericString` followed by all elements
    *                  of `that`.
    */
-  def union[B >: Char](that: Seq[B]): IndexedSeq[B] =
+  def union(that: Seq[Char]) =
     value.union(that)
 
   /** A copy of this `NumericString` with one single replaced element.

scalactic-test/src/test/scala/org/scalactic/ChainSpec.scala

@@ -555,65 +555,71 @@ class ChainSpec extends UnitSpec {
     }
   }
   it should "have 2 indexOfSlice methods that take a GenSeq" in {
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3)) shouldBe 1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3), 3) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5), 3) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5)) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(5)) shouldBe 4
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5)) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 0) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 1) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), -1) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List.empty) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List.empty, 6) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(List.empty, 4) shouldBe 4
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3), 3)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5), 3)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 0) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 0)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 1)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), -1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), -1)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List.empty) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List.empty)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List.empty, 6) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List.empty, 6)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(List.empty, 4) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List.empty, 4)
 
     val es = Chain("one", "two", "three", "four", "five")
-    es.indexOfSlice(List("one", "two")) shouldBe 0;
-    es.indexOfSlice(List("one", "two"), 1) shouldBe -1
-    es.indexOfSlice(List("ONE", "TWO")) shouldBe -1;
+    val el = List("one", "two", "three", "four", "five")
+    es.indexOfSlice(List("one", "two")) shouldBe el.indexOfSlice(List("one", "two"))
+    es.indexOfSlice(List("one", "two"), 1) shouldBe el.indexOfSlice(List("one", "two"), 1)
+    es.indexOfSlice(List("ONE", "TWO")) shouldBe el.indexOfSlice(List("ONE", "TWO"))
+
     {
       implicit val strEq = StringNormalizations.lowerCased.toEquality
-      es.indexOfSlice(List("one", "two")) shouldBe 0;
+      es.indexOfSlice(List("one", "two")) shouldBe 0
       es.indexOfSlice(List("ONE", "TWO")) shouldBe -1
     }
   }
   it should "have 2 indexOfSlice methods that take an Every" in {
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3)) shouldBe 1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3), 3) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3, 5), 3) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3, 5)) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(5)) shouldBe 4
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5)) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), 0) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), 1) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), -1) shouldBe 0
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3), 3)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3, 5), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3, 5), 3)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3, 5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), 0) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), 0)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), 1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), 1)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), -1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(Every(1, 2, 3, 4, 5), -1)
 
     val es = Chain("one", "two", "three", "four", "five")
-    es.indexOfSlice(Every("one", "two")) shouldBe 0;
-    es.indexOfSlice(Every("one", "two"), 1) shouldBe -1
-    es.indexOfSlice(Every("ONE", "TWO")) shouldBe -1;
+    val el = List("one", "two", "three", "four", "five")
+    es.indexOfSlice(Every("one", "two")) shouldBe el.indexOfSlice(Every("one", "two"))
+    es.indexOfSlice(Every("one", "two"), 1) shouldBe el.indexOfSlice(Every("one", "two"), 1)
+    es.indexOfSlice(Every("ONE", "TWO")) shouldBe el.indexOfSlice(Every("ONE", "TWO"))
+
     {
       implicit val strEq = StringNormalizations.lowerCased.toEquality
       es.indexOfSlice(Every("one", "two")) shouldBe 0;
       es.indexOfSlice(Every("ONE", "TWO")) shouldBe -1
     }
   }
   it should "have 2 indexOfSlice methods that take a Chain" in {
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3)) shouldBe 1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3), 3) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3, 5), 3) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3, 5)) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(5)) shouldBe 4
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5)) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5), 0) shouldBe 0
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5), 1) shouldBe -1
-    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5), -1) shouldBe 0
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3), 3)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3, 5), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5), 3)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(2, 3, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5))
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5), 0) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 0)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5), 1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 1)
+    Chain(1, 2, 3, 4, 5).indexOfSlice(Chain(1, 2, 3, 4, 5), -1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), -1)
 
     val es = Chain("one", "two", "three", "four", "five")
-    es.indexOfSlice(Chain("one", "two")) shouldBe 0;
-    es.indexOfSlice(Chain("one", "two"), 1) shouldBe -1
-    es.indexOfSlice(Chain("ONE", "TWO")) shouldBe -1;
+    val el = Chain("one", "two", "three", "four", "five")
+    es.indexOfSlice(Chain("one", "two")) shouldBe el.indexOfSlice(List("one", "two"))
+    es.indexOfSlice(Chain("one", "two"), 1) shouldBe el.indexOfSlice(List("one", "two"), 1)
+    es.indexOfSlice(Chain("ONE", "TWO")) shouldBe el.indexOfSlice(List("ONE", "TWO"))
+
     {
       implicit val strEq = StringNormalizations.lowerCased.toEquality
       es.indexOfSlice(Chain("one", "two")) shouldBe 0;

scalactic-test/src/test/scala/org/scalactic/EverySpec.scala

@@ -480,18 +480,18 @@ class EverySpec extends UnitSpec {
     Every(1, 2, 3, 4, 5).indexOf(5, 3) shouldBe 4
   }
   it should "have 2 indexOfSlice methods that take a GenSeq" in {
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3)) shouldBe 1
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3), 3) shouldBe -1
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5), 3) shouldBe -1
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5)) shouldBe -1
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(5)) shouldBe 4
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5)) shouldBe 0
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 0) shouldBe 0
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 1) shouldBe -1
-    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), -1) shouldBe 0
-    Every(1, 2, 3, 4, 5).indexOfSlice(List.empty) shouldBe 0
-    Every(1, 2, 3, 4, 5).indexOfSlice(List.empty, 6) shouldBe -1
-    Every(1, 2, 3, 4, 5).indexOfSlice(List.empty, 4) shouldBe 4
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3))
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3), 3)
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5), 3) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5), 3)
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(2, 3, 5))
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(5))
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5)) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5))
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 0) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 0)
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), 1)
+    Every(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), -1) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List(1, 2, 3, 4, 5), -1)
+    Every(1, 2, 3, 4, 5).indexOfSlice(List.empty) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List.empty)
+    Every(1, 2, 3, 4, 5).indexOfSlice(List.empty, 6) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List.empty, 6)
+    Every(1, 2, 3, 4, 5).indexOfSlice(List.empty, 4) shouldBe List(1, 2, 3, 4, 5).indexOfSlice(List.empty, 4)
   }
   it should "have 2 indexOfSlice methods that take an Every" in {
     Every(1, 2, 3, 4, 5).indexOfSlice(Every(2, 3)) shouldBe 1