anchor.diff:          
   [<TestCase>]  
   let map () : unit =
  -    MapTester Array.map Array.map
  +    MapTester Vector.map Vector.map
           
   [<TestCase>]
   let mapWithSideEffects  () : unit =
  
positive.code: 
  [<TestCase>]
  let empty () : unit =
      let emptyArray = Array.empty
      if Array.length emptyArray <> 0 then Assert.Fail()    
          
      let c : int[]   = Array.empty<int>
      Assert.IsTrue( (c = [| |]) )
          
      let d : string[] = Array.empty<string>
      Assert.IsTrue( (d = [| |]) )
      ()
  
  
  [<TestCase>]
  let append () : unit =
      // integer array
      let intArray = Array.append [| 1; 2 |] [| 3; 4 |]
      Assert.IsTrue( (intArray = [| 1; 2; 3; 4 |]) )
          
      // string array
      let strArray = Array.append [| "a"; "b" |] [| "C"; "D" |]
      Assert.IsTrue( (strArray = [| "a"; "b"; "C"; "D" |]) )
  
      // empty array
      let emptyArray : int[]  = [|   |]
      let singleArray : int[] = [| 1 |]
          
      let appEmptySingle = Array.append emptyArray singleArray
      let appSingleEmpty = Array.append singleArray emptyArray
          
      Assert.IsTrue( (appEmptySingle = [| 1 |]) )
      Assert.IsTrue( (appSingleEmpty = [| 1 |]) )
        
      // null array
      let nullArray = null:int[]
      let validArray = [| 1 |]
      checkThrowsArgumentNullException (fun () -> Array.append validArray nullArray |> ignore)    
      checkThrowsArgumentNullException (fun () -> Array.append nullArray validArray |> ignore)   
  
      ()
  
  [<TestCase>]
  let average () : unit =   
        
      // empty float32 array
      let emptyFloatArray = Array.empty<float32> 
      checkThrowsArgumentException(fun () -> Array.average emptyFloatArray |> ignore)
          
      // empty double array
      let emptyDoubleArray = Array.empty<System.Double> 
      checkThrowsArgumentException(fun () -> Array.average emptyDoubleArray |> ignore)
          
      // empty decimal array
      let emptyDecimalArray = Array.empty<System.Decimal> 
      checkThrowsArgumentException (fun () -> Array.average emptyDecimalArray |>ignore )
  
      // float32 array
      let floatArray: float32[] = [| 1.2f; 3.5f; 6.7f |]
      let averageOfFloat = Array.average floatArray
      if averageOfFloat <> 3.8000000000000003f then Assert.Fail()
          
      // double array
      let doubleArray: System.Double[] = [| 1.0;8.0 |]
      let averageOfDouble = Array.average doubleArray
      if averageOfDouble <> 4.5 then Assert.Fail()
          
      // decimal array
      let decimalArray: decimal[] = [| 0M; 19M; 19.03M |]
      let averageOfDecimal = Array.average decimalArray
      if averageOfDecimal <> 12.676666666666666666666666667M then Assert.Fail()      
          
      // null array
      let nullArr = null : double[]    
      checkThrowsArgumentNullException (fun () -> Array.average nullArr |> ignore) 
  
      ()
          
  [<TestCase>]
  let averageBy () : unit =  
      
      // empty double array   
      let emptyDouArray = Array.empty<System.Double>
      let funcd x = x + 6.7
      checkThrowsArgumentException(fun () -> Array.averageBy funcd emptyDouArray |> ignore)
                  
      // empty float32 array
      let emptyFloat32Array: float32[] = [||]
      let funcf x = x + 9.8f 
      checkThrowsArgumentException(fun () -> Array.averageBy funcf emptyFloat32Array |> ignore)
          
      // empty decimal array
      let emptyDecimalArray = Array.empty<System.Decimal>
      let funcDecimal x = x + 9.8M 
      checkThrowsArgumentException(fun () -> Array.averageBy funcDecimal emptyDecimalArray |> ignore)
          
      // float32 array
      let floatArray: float32[] = [| 1.2f;3.5f;6.7f |]      
      let averageOfFloat = Array.averageBy funcf floatArray
      if averageOfFloat <> 13.5999994f then Assert.Fail()
          
      // double array
      let doubleArray: System.Double[] = [| 1.0;8.0 |]
      let averageOfDouble = Array.averageBy funcd doubleArray
      if averageOfDouble <> 11.2 then Assert.Fail()
          
      // decimal array
      let decimalArray: decimal[] = [| 0M;19M;19.03M |]
      let averageOfDecimal = Array.averageBy funcDecimal decimalArray
      if averageOfDecimal <> 22.476666666666666666666666667M then Assert.Fail()     
          
      // null array
      let nullArr : double[] = null
      checkThrowsArgumentNullException (fun () -> Array.averageBy funcd nullArr |> ignore) 
          
      ()
          
  [<TestCase>]
  let blit () : unit = 
      // int array   
      let intSrc = [| 1..10 |]
      let intDes:int[] = Array.zeroCreate 10 
      Array.blit intSrc 0 intDes 0 5
      if intDes.[4] <> 5 then Assert.Fail()
      if intDes.[5] <> 0 then Assert.Fail()
          
      // string array
      let strSrc = [| "a";"b";"c";"d";"e";"j"|]
      let strDes = Array.create 10 "w"
      Array.blit strSrc 1 strDes 2 3
      if strDes.[3] <> "c" || Array.get strDes 4 = "w" then Assert.Fail()
       
      // null array
      let nullArr = null:string[]
      checkThrowsArgumentNullException (fun () -> Array.blit nullArr 1 strDes 2 3 |> ignore) 
  
      // bounds check
      checkThrowsArgumentException (fun () -> Array.blit intSrc -1 intDes 1 3 |> ignore)
      checkThrowsArgumentException (fun () -> Array.blit intSrc 1 intDes -1 3 |> ignore)
      checkThrowsArgumentException (fun () -> Array.blit intSrc 1 intDes 1 -3 |> ignore)
      checkThrowsArgumentException (fun () -> Array.blit intSrc 1 intDes 1 300 |> ignore)
      checkThrowsArgumentException (fun () -> Array.blit intSrc 1 intDes 5 8 |> ignore)
          
      ()
  
        
  let private ChooseTester chooseInt chooseString = 
      // int array
      let intSrc:int [] = [| 1..100 |]    
      let funcInt x = if (x%5=0) then Some x else None       
      let intChoosed : int[] = chooseInt funcInt intSrc
      if intChoosed.[1] <> 10 then Assert.Fail()
          
      // string array
      let stringSrc: string [] = "Lists are a commonly used data structure. They are not mutable, i.e., you can't delete an element of a list – instead you create a new list with the element deleted. List values often share storage under the hood, i.e., a list value only allocate more memory when you actually execute construction operations.".Split([|' '|], System.StringSplitOptions.RemoveEmptyEntries)
      let funcString x = match x with
                          | "list"-> Some x
  
negative.code:     Assert.AreEqual(100,!stamp)
  
  let private MapiTester mapiInt mapiString =
      // empty vector 
      let f i x = (i, x + 1)
      let result = mapiInt f Vector.empty
      if result <> Vector.empty then Assert.Fail ()
          
      // int vector
      let result : vector<int*int> = mapiInt f <| Vector.ofArray [| 1..2 |]
      if result <> Vector.ofArray [| (0,2); (1,3) |] then Assert.Fail ()
          
      // string vector
      let result : vector<int*int> = Vector.ofArray [| "a"; "aa"; "aaa" |] |> mapiString (fun i (s:string) -> i, s.Length) 
      if result <> Vector.ofArray [| (0,1); (1,2); (2,3) |] then Assert.Fail ()
          
      // null vector
      let nullArg : vector<int> = null
      checkThrowsArgumentNullException (fun () -> mapiInt f nullArg |> ignore)        
      ()
  
  [<TestCase>]
  let mapi () : unit = MapiTester Vector.mapi Vector.mapi
  
  [<TestCase>]
  let mapiWithSideEffects  () : unit =
  