Replicate sorted test to NEV and NES

tests/src/test/scala/cats/tests/NonEmptyVectorTests.scala

@@ -314,9 +314,20 @@ class NonEmptyVectorTests extends CatsSuite {
     }
   }
 
+
   test("NonEmptyVector#zipWith is consistent with Vector#zip and then Vector#map") {
     forAll { (a: NonEmptyVector[Int], b: NonEmptyVector[Int], f: (Int, Int) => Int) =>
-      a.zipWith(b)(f).toVector should === (a.toVector.zip(b.toVector).map { case (x, y) => f(x, y)})
+      a.zipWith(b)(f).toVector should ===(a.toVector.zip(b.toVector).map { case (x, y) => f(x, y) })
+    }
+  }
+  test("NonEmptyVector#nonEmptyPartition remains sorted") {
+    forAll { (nev: NonEmptyVector[Int], f: Int => Either[String, String]) =>
+
+      val sorted = NonEmptyVector.fromVectorUnsafe(nev.map(f).toVector.sorted)
+      val ior = Reducible[NonEmptyVector].nonEmptyPartition(sorted)(identity)
+
+      ior.left.map(xs => xs.sorted should === (xs))
+      ior.right.map(xs => xs.sorted should === (xs))
     }
   }
 }

tests/src/test/scala/cats/tests/OneAndTests.scala

@@ -128,6 +128,19 @@ class OneAndTests extends CatsSuite {
     }
   }
 
+  test("NonEmptyStream#nonEmptyPartition remains sorted") {
+    forAll { (nes: NonEmptyStream[Int], f: Int => Either[String, String]) =>
+
+      val nesf = nes.map(f)
+      val sortedStream = (nesf.head #:: nesf.tail).sorted
+      val sortedNes = OneAnd(sortedStream.head, sortedStream.tail)
+      val ior = Reducible[NonEmptyStream].nonEmptyPartition(sortedNes)(identity)
+
+      ior.left.map(xs => xs.sorted should === (xs))
+      ior.right.map(xs => xs.sorted should === (xs))
+    }
+  }
+
   test("reduceLeft consistent with foldLeft") {
     forAll { (nel: NonEmptyStream[Int], f: (Int, Int) => Int) =>
       nel.reduceLeft(f) should === (nel.tail.foldLeft(nel.head)(f))