#!/usr/bin/python

import unittest
from xmlcomp import XmlComp
import xml.dom
from Ft.Xml import InputSource
from Ft.Xml.Domlette import NonvalidatingReader
from StringIO import StringIO
"""
The contents of this file are subject to the Mozilla Public License  Version 1.1 (the "License"); you may not use this file except in  compliance with the License. 
You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
Software distributed under the License is distributed on an "AS IS"  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the  License for the specific language governing rights and limitations under  the License. 

The Original Code is available at http://downloads.xmlschemata.org/python/xvif/

The Initial Developer of the Original Code is Eric van der Vlist. Portions  created by Eric van der Vlist are Copyright (C) 2002. All Rights Reserved. 

Contributor(s): 
"""


class TestXmlComp(unittest.TestCase):
	
		
	def test01(self):
		comp = XmlComp()
		for c in (xml.dom.Node.ELEMENT_NODE,
			xml.dom.Node.ATTRIBUTE_NODE,
			xml.dom.Node.TEXT_NODE,
			XmlComp.NAMESPACE_PREFIX,
			XmlComp.NAMESPACE_DECLARATION,
			XmlComp.WHITESPACES):
			self.failUnless(c in comp.checks,
				'%s should be checked by default' % c)
		for c in (xml.dom.Node.ENTITY_NODE,
			xml.dom.Node.PROCESSING_INSTRUCTION_NODE,
			xml.dom.Node.COMMENT_NODE,
			xml.dom.Node.DOCUMENT_NODE,
			xml.dom.Node.DOCUMENT_TYPE_NODE,
			xml.dom.Node.NOTATION_NODE,
			XmlComp.EMPTY_TEXT):
			self.failUnless(not c in comp.checks,
				'%s should not be checked by default' % c)
		
	def test02(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo/>", "dummy")
		d2 = reader.parseString("<bar/>", "dummy")
		comp = XmlComp(checks=[])
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( not res,
				'd1 should be equal to d2 when elements are not tested (%s)' % res)
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2' )

	def test03(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo/>", "dummy")
		d2 = reader.parseString("<foo xmlns='bar'/>", "dummy")
		comp = XmlComp(checks=[])
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( not res,
				'd1 should be equal to d2 when elements are not tested (%s)' % res)
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2' )

	def test04(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<bar:foo xmlns:bar='bar'/>", "dummy")
		d2 = reader.parseString("<foo xmlns='bar'/>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 when namespace prefixes are not tested (%s)' % res)
		comp.addCheck(XmlComp.NAMESPACE_PREFIX)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when namespace prefixes are checked' )

	def test05(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo xmlns:bar='bar'/>", "dummy")
		d2 = reader.parseString("<foo/>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 when namespace declarations are not tested (%s)' % res)
		comp.addCheck(XmlComp.NAMESPACE_DECLARATION)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when namespace declarations are checked' )
		res = comp.compare(d2, d1)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when namespace declarations are checked' )

	def test06(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo xmlns:bar='bar'/>", "dummy")
		d2 = reader.parseString("<foo xmlns:bar='foo'/>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 when namespace declarations are not tested (%s)' % res)
		comp.addCheck(XmlComp.NAMESPACE_DECLARATION)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when namespace declarations are checked' )
		res = comp.compare(d2, d1)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when namespace declarations are checked' )

	def test07(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo bar='bar'/>", "dummy")
		d2 = reader.parseString("<foo/>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 when attributes are not tested (%s)' % res)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when attributes are checked' )
		res = comp.compare(d2, d1)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when attributes are checked' )

	def test08(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo bar:bar='bar' xmlns:bar='ns' xmlns:other='otherns'/>", "dummy")
		d2 = reader.parseString("<foo foo:bar='bar' xmlns:foo='ns'/>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 when prefixes are not tested (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 when prefixes are not tested (%s)' % res)
		comp.addCheck(XmlComp.NAMESPACE_PREFIX)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when prefixes are checked' )
		res = comp.compare(d2, d1)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when prefixes are checked' )
		comp.removeCheck(XmlComp.NAMESPACE_PREFIX)
		comp.addCheck(XmlComp.NAMESPACE_DECLARATION)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when ns declarations are checked' )
		res = comp.compare(d2, d1)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when ns declarations are checked' )


	def test09(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo>bar</foo>", "dummy")
		d2 = reader.parseString("<foo/>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 when text nodes are not tested (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 when text nodes are not tested (%s)' % res)
		comp.addCheck(xml.dom.Node.TEXT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when text nodes are checked' )
		res = comp.compare(d2, d1)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when text nodes are checked' )


	def test10(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo>bar</foo>", "dummy")
		d2 = reader.parseString("<foo>foo</foo>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 when text nodes are not tested (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 when text nodes are not tested (%s)' % res)
		comp.addCheck(xml.dom.Node.TEXT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d1, d2)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when text nodes are checked' )
		res = comp.compare(d2, d1)
		print res
		self.failUnless( res,
				'd1 should not be equal to d2 when text nodes are checked' )


	def test11(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo>bar</foo>", "dummy")
		d2 = reader.parseString("<foo><![CDATA[bar]]></foo>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		comp.addCheck(xml.dom.Node.TEXT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)

	def test12(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo>bar</foo>", "dummy")
		d2 = reader.parseString("<foo>b<![CDATA[a]]>r</foo>", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		comp.addCheck(xml.dom.Node.TEXT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)

	def test13(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo>b a r</foo>", "dummy")
		d2 = reader.parseString("""<foo>
		b
		a	r
		</foo>""", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		comp.addCheck(xml.dom.Node.TEXT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		comp.addCheck(XmlComp.WHITESPACES)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless(res,
				'd1 should not be equal to d2')
		res = comp.compare(d2, d1)
		self.failUnless(res,
				'd1 should not be equal to d2')

	def test14(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo/>", "dummy")
		d2 = reader.parseString("""<foo>
			
			</foo>""", "dummy")
		comp = XmlComp(checks=[])
		comp.addCheck(xml.dom.Node.ELEMENT_NODE)
		comp.addCheck(xml.dom.Node.ATTRIBUTE_NODE)
		comp.addCheck(xml.dom.Node.TEXT_NODE)
		comp.addCheck(XmlComp.WHITESPACES)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		comp.addCheck(XmlComp.EMPTY_TEXT)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless(res,
				'd1 should not be equal to d2')
		res = comp.compare(d2, d1)
		self.failUnless(res,
				'd1 should not be equal to d2')

	def test15(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("<foo><bar/></foo>", "dummy")
		d2 = reader.parseString("<foo><bar>bar</bar></foo>", "dummy")
		comp = XmlComp()
		comp.removeCheck(xml.dom.Node.TEXT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		res = comp.compare(d2, d1)
		self.failUnless( not res,
				'd1 should be equal to d2 (%s)' % res)
		comp.addCheck(xml.dom.Node.TEXT_NODE)
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless(res,
				'd1 should not be equal to d2')
		res = comp.compare(d2, d1)
		self.failUnless(res,
				'd1 should not be equal to d2')

	def test16(self):
		reader = NonvalidatingReader
		d1 = reader.parseString("""<test>
					<foo/>
				</test>""", "dummy")
		d2 = reader.parseString("""<test/>""", "dummy")
		comp = XmlComp()
		res = comp.compare(d1, d1)
		self.failUnless( not res,
				'd1 should be equal to d1 (%s)' % res)
		res = comp.compare(d2, d2)
		self.failUnless( not res,
				'd2 should be equal to d2 (%s)' % res)
		res = comp.compare(d1, d2)
		self.failUnless(res,
				'd1 should not be equal to d2')
		res = comp.compare(d2, d1)
		self.failUnless(res,
				'd1 should not be equal to d2')

if __name__ == "__main__":
	unittest.main()