anchor.diff:          Assert.AreEqual ([max0 .. three .. min0], [])
   
           exceptions zero one two
  +
  +        // tests for singleStepRangeEnumerator, as it only is used if start and/or end are not the
  +        // minimum or maximum of the number range and it is counting by 1s
  +        Assert.AreEqual ([min1 .. min3], [min1; min2; min3])
  +        Assert.AreEqual ([max3 .. max1], [max3; max2; max1])
   
       let inline signed min0 max0 =
           let zero  = LanguagePrimitives.GenericZero
  
positive.code:     [<Test>] member this.Int64  () = RangeTestsHelpers.signed   System.Int64.MinValue  System.Int64.MaxValue
      [<Test>] member this.UInt64 () = RangeTestsHelpers.unsigned System.UInt64.MinValue System.UInt64.MaxValue
  
  
negative.code: module internal RangeTestsHelpers =
      // strictly speaking, this is just undefined behaviour, but at some point the F# library decided that
      // it was an exception, so we are ensuring that such behaviour is retained
      let inline regressionExceptionBeforeStartSingleStepRangeEnumerator zero one = 
          let sequence = seq { zero .. one .. one }
          let enumerator = sequence.GetEnumerator()
          enumerator.Current |> ignore
  
      let inline regressionExceptionBeforeStartVariableStepIntegralRange zero two = 
          let sequence = seq { zero .. two .. two }
          let enumerator = sequence.GetEnumerator()
          enumerator.Current |> ignore
  
      // strictly speaking, this is just undefined behaviour, but at some point the F# library decided that
      // it was an exception, so we are ensuring that such behaviour is retained
      let inline regressionExceptionAfterEndSingleStepRangeEnumerator zero one = 
          let sequence = seq { zero .. one .. one }
          let enumerator = sequence.GetEnumerator()
          while enumerator.MoveNext () do ignore ()
          enumerator.Current |> ignore
  
      let inline regressionExceptionAfterEndVariableStepIntegralRange zero two = 
          let sequence = seq { zero .. two .. two }
          let enumerator = sequence.GetEnumerator()
          while enumerator.MoveNext () do ignore ()
          enumerator.Current |> ignore
  
      let inline exceptions zero one two =
          Assert.Throws (typeof<System.ArgumentException>, (fun () -> [one .. zero .. two] |> List.length |> ignore)) |> ignore
  
          Assert.Throws (typeof<System.InvalidOperationException>, (fun () -> regressionExceptionBeforeStartSingleStepRangeEnumerator zero one)) |> ignore
          Assert.Throws (typeof<System.InvalidOperationException>, (fun () -> regressionExceptionBeforeStartVariableStepIntegralRange zero two)) |> ignore
          Assert.Throws (typeof<System.InvalidOperationException>, (fun () -> regressionExceptionAfterEndSingleStepRangeEnumerator zero one))    |> ignore
          Assert.Throws (typeof<System.InvalidOperationException>, (fun () -> regressionExceptionAfterEndVariableStepIntegralRange zero two))    |> ignore
  
      let inline common (min0, min1, min2, min3) (max0, max1, max2, max3) (zero, one, two, three) =
          Assert.AreEqual ([min0 ..          min3], [min0; min1; min2; min3])
  