anchor.diff:  // Test assertions
   // ----------------------------------------------------------------------------
   let responseStatusEquals (status : HttpStatusCode) (result : Example) = 
  -    let test = 
  -        testCase (sprintf "%s: should return %s" result.Title (status.ToString())) 
  -        <| fun _ -> result.Response.StatusCode |> should equal status
  -    result.TestCases.Add(test)
  +    Assert.Equal<HttpStatusCode>(status, result.Response.StatusCode) // "Status code does not match"
       result
   
   let responseContainsHeader (header : string) (value : string) (result : Example) = 
  -    let test = testCase "Should contain header" <| fun _ -> result.Response.Headers.Get(header) |> should equal value
  -    result.TestCases.Add(test)
  +    Assert.Equal<string>(value, result.Response.Headers.Get(header)) // "Header value does not match"
       result
   
   let responseMatches (select : string) (expected : string) (result : Example) = 
  -    let test = 
  -        testCase (sprintf "%s: response should match %s" result.Title expected) <| fun _ -> 
  -            let value = JObject.Parse(result.ResponseBody)
  -            value.SelectToken(select).ToString() |> should equal expected
  -    result.TestCases.Add(test)
  +    let value = JObject.Parse(result.ResponseBody)
  +    Assert.Equal<string>(expected, value.SelectToken(select).ToString()) // "Response does not match"
       result
   
   let responseShouldContain (value : string) (result : Example) = 
  -    let test = 
  -        testCase (sprintf "%s: response should contain %s" result.Title value) 
  -        <| fun _ -> result.ResponseBody.Contains(value) |> should equal true
  -    result.TestCases.Add(test)
  +    Assert.True(result.ResponseBody.Contains(value), "Response does contain the required value")
       result
   
   let responseContainsProperty (group : string) (key : string) (property : string) (expected : string) (result : Example) = 
  -    let test = 
  -        testCase (sprintf "%s: should contain property %s" result.Title property) <| fun _ -> 
  -            let value = JObject.Parse(result.ResponseBody)
  -            value.SelectToken(group).[key].[property].ToString() |> should equal expected
  -    result.TestCases.Add(test)
  +    let value = JObject.Parse(result.ResponseBody)
  +    Assert.Equal<string>(expected, value.SelectToken(group).[key].[property].ToString()) //"Response does contain the required property"
       result
   
   let responseBodyIsNull (result : Example) = 
  -    let test = 
  -        testCase (sprintf "%s: response should not contain body" result.Title) 
  -        <| fun _ -> String.IsNullOrWhiteSpace(result.ResponseBody) |> should equal true
  -    result.TestCases.Add(test)
  +    Assert.True(String.IsNullOrWhiteSpace(result.ResponseBody), "Response should not contain body")
       result
  -
  -let runAssertions  (result : Example) = 
  -    testList result.Title result.TestCases
   
   // ----------------------------------------------------------------------------
   // Test logic
  
positive.code:     with :? WebException as e -> 
          result.Response <- e.Response :?> HttpWebResponse
          print result.Response
      result
  
  // ----------------------------------------------------------------------------
  
negative.code:       Uri : string
        Querystring : string
        Requestbody : string option
        Output : ResizeArray<string>
        OutputResponse : ResizeArray<string> }
  
  