anchor.diff:  
   
   let [<Test>] ``struct records have correct behaviour with a [<DefaultValue>] on a value type field`` () =
  -    let i1, i2 = 0, 4
  -    let r = { A = i1; B = i2 }
  -    let r1 = { R1 = r }
  -    Assert.IsTrue (r1.R1 = { A = i1; B = i2 }) 
  -    Assert.IsTrue (r1.R2 = { C = 0; D = 0 })   
  +    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`` () =
  
positive.code: 
  
  let [<Test>] ``struct records are comparable`` () =
      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`` () =
      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) 
      Assert.IsTrue
          (sr1 |> function 
          | { C = c; D = d } when c = i1 && d = i2 -> true
          | _ -> false)
  
  
  let [<Test>] ``struct records support let binds using `` () =
      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`` () =
      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>]
  
negative.code:     
  
  let [<Test>] ``struct recrods fields can be mutated`` () =
      Check.QuickThrowOnFailure <|
      fun (i1:int) (i2:int) (m1:int) (m2:int) ->
          (i1 <> m1 && i2 <> m2) ==>
              let mutable sr1 = { M1 = i1; M2 = i2}
              sr1.M1 <- m1
              sr1.M2 <- m2
              sr1.M1 = m1 && sr1.M2 = m2
  
  
  [<Struct>]
  