anchor.diff:  				    <xs:element name="bar" type="xs:string"/>
   			    </xs:sequence>
   		    </xs:complexType>
  -            <xs:element name="foo" type="barType">
  -	        </xs:element>"""
  -        let foo = (xsdSchema xsd).Elements |> List.head
  -        genElementCustom cust foo
  +            <xs:element name="foo" type="barType" />
  +	        """
  +        (xsdSchema xsd).Elements.Head
  +        |> genElementCustom cust
           |> Gen.sample 5 5
  -        |> Seq.map (fun xml -> printfn "%A" xml; xml.Element(XName.Get("bar")))
  -        |> Seq.forall(fun xml -> xml.Value = xml.Value.ToUpper())
  +        |> Seq.map (fun xml -> printfn "%A" xml; xml.Element(XName.Get("bar")).Value)
  +        |> Seq.forall(fun x -> x = x.ToUpper())
           |> Assert.IsTrue
  -
  -
   
       [<Test>]
       let ``the generator for a global element can be customized``() = 
  
positive.code:                 </xs:complexType>
              </xs:element>
          """
          let foo = (xsdSchema xsd).Elements |> List.head
          genElementCustom cust foo
          |> Gen.sample 5 5
          |> Seq.map (fun xml -> printfn "%A" xml; xml)
          |> Seq.forall(fun xml -> xml.Element(XName.Get("bar")).Value = "hello")
          |> Assert.IsTrue
  
      [<Test>]
      let ``the generator for an element can be customized with a function``() = 
          let foo = {Namespace = ""; Name = "foo"}
          let fooCustomization (xml: XElement) = 
              xml.Value <- xml.Value.ToUpper()
              xml
          let cust = { CustomGenerators.empty with ElementGeneratorMaps = dict [foo, fooCustomization] }
          let xsd = XmlGeneratorTest.makeSchema """<xs:element name="foo" type="xs:string" />"""
          let foo = (xsdSchema xsd).Elements |> List.head
          genElementCustom cust foo
          |> Gen.sample 5 5
          |> Seq.map (fun xml -> printfn "%A" xml; xml)
          |> Seq.forall(fun x -> x.Value = x.Value.ToUpper())
          |> Assert.IsTrue
  
      [<Test>]
      let ``custom generators don't work with derived types``() =
  
negative.code: 	    </xs:complexType>
          """
          let ct = { Namespace= ""; Name="ct" }
          let a1Name = XName.Get("a1")
          let ctGen = XElement(XName.Get("ct"), XAttribute(a1Name, "42")) |> Gen.constant
          let cust = { CustomGenerators.empty with ComplexGenerators = dict [ct, ctGen] }
          (fromText xsd).Elements.Head
          |> genElementCustom cust
          |> Gen.sample 10 10
          |> List.map(fun xml -> printfn "%A" xml; xml)
          |> List.exists(fun xml -> xml.Attribute(a1Name).Value <> "42")
          |> Assert.IsTrue
  
  module CombinedConstraintsTest = 
      
  