diff --git a/ChangeLog b/ChangeLog
index 4188ae2..5740b22 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+Sat Jul 23 23:23:51 CEST 2005 Kasimier Buchcik <libxml2-cvs@cazic.net>
+
+	* test/schemas/any6* test/schemas/any7*: Added regression tests
+	  (they fail currently), but did not added results yet.
+
 Sat Jul 23 23:07:05 CEST 2005 Kasimier Buchcik <libxml2-cvs@cazic.net>
 
 	* xmlschemas.c: Removed the workaround code in
diff --git a/test/schemas/any6_0.xml b/test/schemas/any6_0.xml
new file mode 100755
index 0000000..068a1a9
--- /dev/null
+++ b/test/schemas/any6_0.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<!-- Dummy instance for any-1_1.xsd -->
+<foo:foo xmlns:foo="urn:test:foo" xmlns:moo="urn:test:moo"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="urn:test:foo any-1_1.xsd">
+	<foo:bar/>
+	<moo:moo/>
+</foo:foo>
\ No newline at end of file
diff --git a/test/schemas/any6_1.xsd b/test/schemas/any6_1.xsd
new file mode 100644
index 0000000..23b2f5d
--- /dev/null
+++ b/test/schemas/any6_1.xsd
@@ -0,0 +1,36 @@
+<?xml version="1.0"?>
+<!--
+Content model error:
+
+any-err-not-determinist-1.xsd:29: element complexType: Schemas parser error : 
+local complex type: The content model is not determinist.
+
+As per Xerces and XSV this schema is OK.
+
+The problem appears when the maxOccurs of <bar> is greater than
+the one of the <any> wildcard. Additionally if both are "unbounded".
+If the latter is a different issue we should add an explicit test
+for it.
+
+Examples:
+<bar>        <any>        result
+ 2            1           error
+ 2            2           OK
+ 1            2           OK
+ unbounded    2           error
+ unbounded    unbounded   error
+ 2            unbounded   OK
+-->
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+	targetNamespace="urn:test:foo"
+	elementFormDefault="qualified">
+	<xs:element name="foo">
+		<xs:complexType>
+			<xs:sequence>
+				<xs:element name="bar" maxOccurs="2"/>
+				<xs:any namespace="##other" maxOccurs="1" processContents="lax"/>
+		  	</xs:sequence>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>
\ No newline at end of file
diff --git a/test/schemas/any7_0.xml b/test/schemas/any7_0.xml
new file mode 100755
index 0000000..d8f23d2
--- /dev/null
+++ b/test/schemas/any7_0.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<!-- 
+No error reported.
+
+Seems like <moo> is accepted, but should not, since "##other" rules out
+elements in no namespace.
+
+Xerces reports:
+any-err-2.xml:18,8: (Error) cvc-complex-type.2.4.a: Invalid content starting 
+with element 'moo'. 
+One of '{"urn:test:foo":bar, WC[##other:"urn:test:foo"]}' is expected.
+
+-->
+<foo:foo xmlns:foo="urn:test:foo" xmlns:moo="urn:test:moo"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="urn:test:foo any-2_1.xsd">
+	<foo:bar/>
+	<moo/>
+</foo:foo>
\ No newline at end of file
diff --git a/test/schemas/any7_1.xml b/test/schemas/any7_1.xml
new file mode 100755
index 0000000..624c712
--- /dev/null
+++ b/test/schemas/any7_1.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<!-- 
+Error reported:
+
+any-2_1.xml:17: element bar: Schemas validity error : 
+Element '{urn:test:foo}bar': This element is not expected. 
+Expected is one of ( {##other:urn:test:foo}* ).
+
+Tiny glitch: the error report mechanism fails to recognize
+that there is only one element of choice. It should report:
+"Excepted is ( {##other:urn:test:foo}* ).".
+-->
+<foo:foo xmlns:foo="urn:test:foo" xmlns:moo="urn:test:moo"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="urn:test:foo any-2_1.xsd">
+	<foo:bar/>
+	<foo:bar/>
+</foo:foo>
\ No newline at end of file
diff --git a/test/schemas/any7_1.xsd b/test/schemas/any7_1.xsd
new file mode 100755
index 0000000..546904f
--- /dev/null
+++ b/test/schemas/any7_1.xsd
@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+	targetNamespace="urn:test:foo"
+	elementFormDefault="qualified">
+	<xs:element name="foo">
+		<xs:complexType>
+			<xs:sequence>
+				<xs:element name="bar"/>
+				<xs:any namespace="##other" processContents="lax"/>
+			</xs:sequence>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>
\ No newline at end of file
