anchor.diff:  
   
   let [<Test>] ``struct records are comparable`` () =
  -    Check.QuickThrowOnFailure <|
  -    fun (i1:int) (i2:int) ->
  -        i1 <> i2 ==>
  -        let sr1 = { C = i1; D = i2 }
  -        let sr2 = { C = i1; D = i2 }
  -        (sr1 = sr2)                    |@ "sr1 = sr2" .&.
  -        ({ sr1 with C = sr1.D} <> sr2) |@ "{sr1 with C = sr1.D} <> sr2" .&.
  -        (sr1.Equals sr2)               |@ "sr1.Equals sr2"
  +    let i1, i2 = 0, 4
  +    let sr1 = { C = i1; D = i2 }
  +    let sr2 = { C = i1; D = i2 }
  +    Assert.IsTrue ((sr1 = sr2))
  +    Assert.IsTrue ({ sr1 with C = sr1.D} <> sr2) 
  +    Assert.IsTrue (sr1.Equals sr2)               
   
   
   let [<Test>] ``struct records support pattern matching`` () =
  -    Check.QuickThrowOnFailure <|
  -    fun (i1:int) (i2:int) ->
  -        let sr1 = { C = i1; D = i2 }
  +    let i1, i2 = 0, 4
  +    let sr1 = { C = i1; D = i2 }
  +    Assert.IsTrue
           (match sr1 with
           | { C = c; D = d } when c = i1 && d = i2 -> true
           | _ -> false) 
  -        |@ "with pattern match on struct record" .&.
  +    Assert.IsTrue
           (sr1 |> function 
           | { C = c; D = d } when c = i1 && d = i2 -> true
           | _ -> false)
  -        |@ "function pattern match on struct record"
   
   
   let [<Test>] ``struct records support let binds using `` () =
  -    Check.QuickThrowOnFailure <|
  -    fun (i1:int) (i2:int) ->
  -        let sr1 = { C = i1; D = i2 }
  -        let { C = c1; D = d2 } as sr2 = sr1
  -        (sr1 = sr2)          |@ "sr1 = sr2" .&.
  -        (c1 = i1 && d2 = i2) |@ "c1 = i1 && d2 = i2"
  +    let i1, i2 = 0, 4
  +    let sr1 = { C = i1; D = i2 }
  +    let { C = c1; D = d2 } as sr2 = sr1
  +    Assert.IsTrue((sr1 = sr2))
  +    Assert.IsTrue(c1 = i1 && d2 = i2) 
   
   
   let [<Test>] ``struct records support function argument bindings`` () =
  -    Check.QuickThrowOnFailure <|
  -    fun (i1:int) (i2:int) ->
  -        let sr1 = { C = i1; D = i2 }
  -        let test sr1 ({ C = c1; D = d2 } as sr2) =
  -            sr1 = sr2 && c1 = i1 && d2 = i2
  -        test sr1 sr1      
  +    let i1, i2 = 0, 4
  +    let sr1 = { C = i1; D = i2 }
  +    let test sr1 ({ C = c1; D = d2 } as sr2) =
  +        sr1 = sr2 && c1 = i1 && d2 = i2
  +    Assert.IsTrue (test sr1 sr1)
           
           
   [<Struct>]
  
positive.code: 
  
  let [<Test>] ``struct records have correct behaviour with a [<DefaultValue>] on a value type field`` () =
      Check.QuickThrowOnFailure <|
      fun (i1:int) (i2:int) ->
          let r = { A = i1; B = i2 }
          let r1 = { R1 = r }
          (r1.R1 = { A = i1; B = i2 }) |@ "r1.R1 = { A = i1; B = i2 }" .&.
          (r1.R2 = { C = 0; D = 0 })   |@ "r1.R2 = { C = 0; D = 0 }"
  
  
  let [<Test>] ``struct records exhibit correct behaviour for Unchecked.defaultof`` () =
  
negative.code: 
  
  let [<Test>] ``can compare records`` () = 
      let i1, i2 = 0, 4
      let r1 = { A = i1; B = i2 }
      let r2 = { A = i1; B = i2 }
      Assert.IsTrue ((r1 = r2))
      Assert.IsTrue ({ r1 with A = r1.B} <> r2) 
      Assert.IsTrue (r1.Equals r2)  
  
  
  [<Struct>]
  