anchor.diff:      [<Test>]
       let ``emtpy representedParty element`` () =
           TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<repr:representedParty />") |> ignore)
  -        |> should (throwWithMessage "Element `http://x-road.eu/xsd/representation.xsd:representedParty` cannot be empty.") typeof<XRoadException>
  +        |> should (throwWithMessage "Element `{http://x-road.eu/xsd/representation.xsd}representedParty` cannot be empty.") typeof<XRoadException>
   
       [<Test>]
       let ``element partyCode is required for representedParty element`` () =
           TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<repr:representedParty></repr:representedParty>") |> ignore)
  -        |> should (throwWithMessage "Element `http://x-road.eu/xsd/representation.xsd:representedParty` must have child element `http://x-road.eu/xsd/representation.xsd:partyCode`.") typeof<XRoadException>
  +        |> should (throwWithMessage "Element `{http://x-road.eu/xsd/representation.xsd}representedParty` must have child element `{http://x-road.eu/xsd/representation.xsd}partyCode`.") typeof<XRoadException>
   
       [<Test>]
       let ``wrong element order for representedParty element`` () =
           TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<repr:representedParty><repr:partyCode /><repr:partyClass /></repr:representedParty>") |> ignore)
  -        |> should (throwWithMessage "Unexpected element `http://x-road.eu/xsd/representation.xsd:partyClass` in element `http://x-road.eu/xsd/representation.xsd:representedParty`.") typeof<XRoadException>
  +        |> should (throwWithMessage "Unexpected element `{http://x-road.eu/xsd/representation.xsd}partyClass` in element `{http://x-road.eu/xsd/representation.xsd}representedParty`.") typeof<XRoadException>
   
       [<Test>]
       let ``can handle missing optional element for representedParty element`` () =
  
positive.code:     [<Test>]
      let ``empty centralService element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:centralService />") |> ignore)
          |> should (throwWithMessage "Element `http://x-road.eu/xsd/xroad.xsd:centralService` cannot be empty.") typeof<XRoadException>
  
      [<Test>]
      let ``missing objectType attribute for centralService element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:centralService></xrd:centralService>") |> ignore)
          |> should (throwWithMessage "Element `http://x-road.eu/xsd/xroad.xsd:centralService` must have attribute `http://x-road.eu/xsd/identifiers:objectType` value.") typeof<XRoadException>
  
      [<Test>]
      let ``missing xRoadInstance element for centralService element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:centralService id:objectType=""CENTRALSERVICE""></xrd:centralService>") |> ignore)
          |> should (throwWithMessage "Element `http://x-road.eu/xsd/xroad.xsd:centralService` must have child element `http://x-road.eu/xsd/identifiers:xRoadInstance`.") typeof<XRoadException>
  
      [<Test>]
      let ``missing serviceCode element for centralService element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:centralService id:objectType=""CENTRALSERVICE""><id:xRoadInstance /></xrd:centralService>") |> ignore)
          |> should (throwWithMessage "Element `http://x-road.eu/xsd/xroad.xsd:centralService` must have child element `http://x-road.eu/xsd/identifiers:serviceCode`.") typeof<XRoadException>
  
      [<Test>]
      let ``valid centralService element`` () =
  
negative.code:     [<Test>]
      let ``unrecognized X-Road header element`` () =
          TestDelegate(fun _ -> parseHeader @"<xrd:x />" |> ignore)
          |> should (throwWithMessage "Unexpected X-Road header element `{http://x-road.eu/xsd/xroad.xsd}x`.") typeof<XRoadException>
  
      [<Test>]
      let ``empty service element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:service />") |> ignore)
          |> should (throwWithMessage "Element `{http://x-road.eu/xsd/xroad.xsd}service` cannot be empty.") typeof<XRoadException>
  
      [<Test>]
      let ``missing objectType attribute for service element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:service></xrd:service>") |> ignore)
          |> should (throwWithMessage "Element `{http://x-road.eu/xsd/xroad.xsd}service` must have attribute `{http://x-road.eu/xsd/identifiers}objectType` value.") typeof<XRoadException>
  
      [<Test>]
      let ``missing xRoadInstance element for service element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:service id:objectType=""SERVICE""></xrd:service>") |> ignore)
          |> should (throwWithMessage "Element `{http://x-road.eu/xsd/xroad.xsd}service` must have child element `{http://x-road.eu/xsd/identifiers}xRoadInstance`.") typeof<XRoadException>
  
      [<Test>]
      let ``invalid element in service element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:service id:objectType=""SERVICE""><x /></xrd:service>") |> ignore)
          |> should (throwWithMessage "Element `{http://x-road.eu/xsd/xroad.xsd}service` must have child element `{http://x-road.eu/xsd/identifiers}xRoadInstance`.") typeof<XRoadException>
  
      [<Test>]
      let ``missing memberClass element for service element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:service id:objectType=""SERVICE""><id:xRoadInstance /></xrd:service>") |> ignore)
          |> should (throwWithMessage "Element `{http://x-road.eu/xsd/xroad.xsd}service` must have child element `{http://x-road.eu/xsd/identifiers}memberClass`.") typeof<XRoadException>
  
      [<Test>]
      let ``missing memberCode element for service element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:service id:objectType=""SERVICE""><id:xRoadInstance /><id:memberClass /></xrd:service>") |> ignore)
          |> should (throwWithMessage "Element `{http://x-road.eu/xsd/xroad.xsd}service` must have child element `{http://x-road.eu/xsd/identifiers}memberCode`.") typeof<XRoadException>
  
      [<Test>]
      let ``missing serviceCode element for service element`` () =
          TestDelegate(fun _ -> parseHeader (minimalValidHeader @"<xrd:service id:objectType=""SERVICE""><id:xRoadInstance /><id:memberClass /><id:memberCode /></xrd:service>") |> ignore)
          |> should (throwWithMessage "Element `{http://x-road.eu/xsd/xroad.xsd}service` must have child element `{http://x-road.eu/xsd/identifiers}serviceCode`.") typeof<XRoadException>
  
      [<Test>]
      let ``read minimal group of elements for service element`` () =
  