"Final" version of Array.filter, including test

- Small and large array edge case optimizations included
- Broke functionality into multiple functions

Author: manofstick

src/fsharp/FSharp.Core.Unittests/FSharp.Core/Microsoft.FSharp.Collections/ArrayModule.fs

@@ -724,7 +724,64 @@ type ArrayModule() =
         let nullArr = null:string[] 
         CheckThrowsArgumentNullException (fun () ->  Array.filter funcStr nullArr |> ignore) 
 
-        ()   
+        ()
+        
+    [<Test>]
+    member this.Filter2 () =
+        // The Array.filter algorith uses a bitmask as a temporary storage mechanism
+        // for which elements to filter. This introduces some possible error conditions
+        // around how the filter is filled and subsequently used, so filter test
+        // does a pretty exhaustive test suite.
+        // It works by first generating arrays which consist of sequences of unique
+        // positive and negative numbers, as per arguments, it then filters for the
+        // positive values, and then compares the results agains the original array.
+
+        let makeTestArray size posLength negLength startWithPos startFromEnd =
+            let array = Array.zeroCreate size
+
+            let mutable sign  = if startWithPos then 1         else -1
+            let mutable count = if startWithPos then posLength else negLength
+            for i = 1 to size do
+                let idx = if startFromEnd then size-i else i-1
+                array.[idx] <- (idx+1) * sign
+                count <- count - 1
+                if count <= 0 then
+                    sign <- sign * -1
+                    count <- if sign > 0 then posLength else negLength
+
+            array
+
+        let checkFilter filter (array:array<_>) =
+            let filtered = array |> filter (fun n -> n > 0)
+
+            let mutable idx = 0
+            for item in filtered do
+                while array.[idx] < item do
+                    idx <- idx + 1
+                if item <> array.[idx] then
+                    Assert.Fail ()
+            idx <- idx + 1
+            while idx < array.Length do
+                if array.[idx] > 0 then
+                    Assert.Fail ()
+                idx <- idx + 1
+
+        let checkCombinations filter maxSize =
+            for size = 0 to maxSize do
+                for posLength = 1 to size do
+                    for negLength = 1 to size do
+                        for startWithPos in [true; false] do
+                            for startFromEnd in [true; false] do
+                                let testArray = makeTestArray size posLength negLength startWithPos startFromEnd
+                                checkFilter filter testArray
+
+        // this could probably be a bit smaller, but needs to at least be > 64 to test chunk copying
+        // of data, and > 96 gives a safer feel, so settle on a nice decimal rounding of one hundred
+        // to appease those with digits.
+        let suitableTestMaxLength = 100 
+
+        checkCombinations Array.filter suitableTestMaxLength
+
 
 
     [<Test>]