Daily Test Coverage Improver: Add comprehensive XML runtime tests

tests/FSharp.Data.Core.Tests/FSharp.Data.Core.Tests.fsproj

@@ -41,6 +41,8 @@
     <Compile Include="StructuralTypes.fs" />
     <Compile Include="BaseTypesHtmlDocument.fs" />
     <Compile Include="XmlExtensions.fs" />
+    <Compile Include="XmlRuntime.fs" />
+    <Compile Include="XmlSchema.fs" />
     <Compile Include="WorldBankRuntime.fs" />
     <Compile Include="Program.fs" />
   </ItemGroup>

tests/FSharp.Data.Core.Tests/XmlRuntime.fs

@@ -0,0 +1,67 @@
+module FSharp.Data.Tests.XmlRuntime
+
+open FsUnit
+open NUnit.Framework
+open System
+open System.IO
+open System.Xml.Linq
+open System.Reflection
+open FSharp.Data.Runtime.BaseTypes
+
+// These tests use reflection to test the XmlElement methods that are marked as "generated code only"
+// This approach allows us to test the functionality while respecting the compiler constraints
+
+[<Test>]
+let ``XmlElement.Create via reflection creates proper element from XElement`` () =
+    let xelem = XElement(XName.Get("test"), "content")
+    let createMethod = typeof<XmlElement>.GetMethod("Create", [| typeof<XElement> |])
+    let xmlElement = createMethod.Invoke(null, [| xelem |]) :?> XmlElement
+    xmlElement.XElement.Name.LocalName |> should equal "test"
+    xmlElement.XElement.Value |> should equal "content"
+
+[<Test>]
+let ``XmlElement.Create via reflection from TextReader parses XML correctly`` () =
+    let xml = "<root><child>value</child></root>"
+    use reader = new StringReader(xml)
+    let createMethod = typeof<XmlElement>.GetMethod("Create", [| typeof<TextReader> |])
+    let xmlElement = createMethod.Invoke(null, [| reader |]) :?> XmlElement
+    xmlElement.XElement.Name.LocalName |> should equal "root"
+    xmlElement.XElement.Element(XName.Get("child")).Value |> should equal "value"
+
+[<Test>]
+let ``XmlElement.CreateList via reflection parses multiple elements correctly`` () =
+    let xml = "<item>1</item><item>2</item>"
+    use reader = new StringReader(xml)
+    let createListMethod = typeof<XmlElement>.GetMethod("CreateList", [| typeof<TextReader> |])
+    let elements = createListMethod.Invoke(null, [| reader |]) :?> XmlElement[]
+    elements.Length |> should equal 2
+    elements.[0].XElement.Value |> should equal "1"
+    elements.[1].XElement.Value |> should equal "2"
+
+[<Test>]
+let ``XmlElement ToString returns XElement string representation`` () =
+    let xelem = XElement(XName.Get("test"), "content")
+    let createMethod = typeof<XmlElement>.GetMethod("Create", [| typeof<XElement> |])
+    let xmlElement = createMethod.Invoke(null, [| xelem |]) :?> XmlElement
+    xmlElement.ToString() |> should contain "<test>content</test>"
+
+[<Test>]
+let ``XmlElement _Print property truncates long strings`` () =
+    let longContent = String.replicate 600 "a"
+    let xelem = XElement(XName.Get("test"), longContent)
+    let createMethod = typeof<XmlElement>.GetMethod("Create", [| typeof<XElement> |])
+    let xmlElement = createMethod.Invoke(null, [| xelem |]) :?> XmlElement
+    let printProperty = typeof<XmlElement>.GetProperty("_Print")
+    let printed = printProperty.GetValue(xmlElement) :?> string
+    printed.Length |> should equal 512
+    printed |> should endWith "..."
+
+[<Test>]
+let ``XmlElement _Print property handles short strings`` () =
+    let xelem = XElement(XName.Get("test"), "short")
+    let createMethod = typeof<XmlElement>.GetMethod("Create", [| typeof<XElement> |])
+    let xmlElement = createMethod.Invoke(null, [| xelem |]) :?> XmlElement
+    let printProperty = typeof<XmlElement>.GetProperty("_Print")
+    let printed = printProperty.GetValue(xmlElement) :?> string
+    printed |> should not' (endWith "...")
+    printed |> should contain "short"

tests/FSharp.Data.Core.Tests/XmlSchema.fs

@@ -0,0 +1,91 @@
+module FSharp.Data.Tests.XmlSchema
+
+open FsUnit
+open NUnit.Framework
+open System
+open System.IO
+open FSharp.Data.Runtime.XmlSchema
+
+[<Test>]
+let ``ResolutionFolderResolver.ResolveUri handles absolute web URIs`` () =
+    let resolver = ResolutionFolderResolver("")
+    let baseUri = Uri("http://example.com/")
+    let relativeUri = "schema.xsd"
+    let result = resolver.ResolveUri(baseUri, relativeUri)
+    result.ToString() |> should equal "http://example.com/schema.xsd"
+
+[<Test>]
+let ``ResolutionFolderResolver.ResolveUri uses resolution folder when base is null`` () =
+    let resolver = ResolutionFolderResolver("http://example.com/schemas/")
+    let result = resolver.ResolveUri(null, "schema.xsd")
+    result.ToString() |> should equal "http://example.com/schemas/schema.xsd"
+
+[<Test>]
+let ``ResolutionFolderResolver.ResolveUri handles empty resolution folder`` () =
+    let resolver = ResolutionFolderResolver("")
+    let baseUri = Uri("http://example.com/")
+    let result = resolver.ResolveUri(baseUri, "schema.xsd")
+    result.ToString() |> should equal "http://example.com/schema.xsd"
+
+[<Test>]
+let ``ResolutionFolderResolver.ResolveUri adds trailing slash when needed`` () =
+    let resolver = ResolutionFolderResolver("http://example.com/schemas")
+    let result = resolver.ResolveUri(null, "schema.xsd")
+    result.ToString() |> should equal "http://example.com/schemas/schema.xsd"
+
+[<Test>]
+let ``parseSchema creates XmlSchemaSet from XSD text`` () =
+    let xsdText = """<?xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="root" type="xs:string"/>
+</xs:schema>"""
+    let schemaSet = parseSchema "" xsdText
+    schemaSet.Count |> should equal 1
+
+[<Test>]
+let ``parseSchema handles resolution folder parameter`` () =
+    let xsdText = """<?xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="test" type="xs:int"/>
+</xs:schema>"""
+    let schemaSet = parseSchema "http://example.com/schemas/" xsdText
+    schemaSet.Count |> should equal 1
+
+[<Test>]
+let ``parseSchemaFromTextReader creates XmlSchemaSet from TextReader`` () =
+    let xsdText = """<?xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="sample" type="xs:boolean"/>
+</xs:schema>"""
+    use reader = new StringReader(xsdText)
+    let schemaSet = parseSchemaFromTextReader "" reader
+    schemaSet.Count |> should equal 1
+
+[<Test>]
+let ``parseSchemaFromTextReader handles complex schema`` () =
+    let xsdText = """<?xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="person">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element name="name" type="xs:string"/>
+        <xs:element name="age" type="xs:int"/>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>"""
+    use reader = new StringReader(xsdText)
+    let schemaSet = parseSchemaFromTextReader "" reader
+    schemaSet.Count |> should equal 1
+
+[<Test>]
+let ``parseSchema throws for invalid XSD`` () =
+    let invalidXsd = "<invalid>not a schema</invalid>"
+    (fun () -> parseSchema "" invalidXsd |> ignore) |> should throw typeof<System.Xml.Schema.XmlSchemaException>
+
+[<Test>]
+let ``ResolutionFolderResolver handles relative URIs correctly`` () =
+    let resolver = ResolutionFolderResolver("./schemas/")
+    let baseUri = Uri("http://example.com/base/")
+    let result = resolver.ResolveUri(baseUri, "test.xsd")
+    result.ToString() |> should equal "http://example.com/base/test.xsd"