# -*- coding: iso-8859-15 -*-
"""Unittests for xmi2py"""

__revision__ = '$Id: test_xmi2py.py,v 1.3 2005/04/15 11:00:47 syt Exp $'

import unittest
from cStringIO import StringIO
from pyreverse.xmi2py import *

class ToIdentifierTC(unittest.TestCase):
    def testToId(self):
        strings = [(u'été', 'ete'),
               (u'être', 'etre'),
               (u'éé à ï\tô,.;', 'eeaio')]
        for input, output in strings:
            self.failUnlessEqual(output, toIdentifier(input))
    

class Attrs2dictTC(unittest.TestCase):
    def setUp(self):
        from xml.sax.xmlreader import AttributesImpl
        self.attrs = AttributesImpl({'a':'1',
                                     'b':u'toto',
                                     'c':u'été'})

    def testConversion(self):
        d = attrs2dict(self.attrs)
        self.failUnlessEqual(d,{'a': 1,
                                'b':'toto',
                                'c': 'été'})


class MethodTC(unittest.TestCase):
    def setUp(self):
        self.meth1 = Method()
        self.meth1.setName(u'meth1')
        self.meth1.addParameter(u'aName')
        self.meth1.addParameter(u'return')


    def testMethod(self):
        self.failUnlessEqual(self.meth1.name, 'meth1')
        self.failUnlessEqual(self.meth1.parameters, ['self', 'aName'])

    def testSerialize(self):
        out = StringIO()
        self.meth1.serialize(out)
        expected_repr=('    def meth1(self, aName):\n'
                       '        pass\n'
                       '\n'
                       )
        self.failUnlessEqual(out.getvalue(), expected_repr)
        

class ClassTC(unittest.TestCase):
    def setUp(self):
        self.Class = Class()
        self.Class.setName('Liaison Radiale')
        self.Class.addAttribute(u'position')

        self.Class2 = Class(u'Liaison Radiale Etendue')
        self.Class2.extends(self.Class)
        self.Class2.addAttribute('jeu')

        self.Class3 = Class('Empty')


    def testConstruction(self):
        self.failUnlessEqual(self.Class.name, 'LiaisonRadiale')
        self.failUnlessEqual(self.Class.attributes, ['position'])

    def testExtension(self):
        self.failUnlessEqual(self.Class2.parent, self.Class)
        self.failUnlessEqual(self.Class.parent, None)
        

    def testSerialize(self):
        out = StringIO()
        self.Class.serialize(out)
        expected_repr=('class LiaisonRadiale:\n'
                       '    def __init__(self, position=None):\n'
                       '        position = position\n'
                       '\n'
                       )
        self.failUnlessEqual(out.getvalue(), expected_repr)

    def testSerializeExtension(self):
        out = StringIO()
        self.Class2.serialize(out)
        expected_repr=('class LiaisonRadialeEtendue(LiaisonRadiale):\n'
                       '    def __init__(self, position=None, jeu=None):\n'
                       '        LiaisonRadiale.__init__(self, position)\n'
                       '        jeu = jeu\n'
                       '\n'
                       )
        self.failUnlessEqual(out.getvalue(), expected_repr)

    def testSerializeEmpty(self):
        out = StringIO()
        self.Class3.serialize(out)
        expected_repr=('class Empty:\n'
                       '    def __init__(self):\n'
                       '        pass\n'
                       '\n'
                       )
        self.failUnlessEqual(out.getvalue(), expected_repr)



class HandlerTC(unittest.TestCase):
    def setUp(self):
        self.handler = XmiHandler()
        self.handler.startDocument()
        
        self.createClass(u'Liaison Radiale Etendue',
                           u'xmi.4',
                           [u'jeu'],
                           u'xmi.2',
                           [(u'addExtension', ('extension',))])

        self.createClass(u'Liaison Radiale',
                           u'xmi.2',
                           [u'position'])

        self.handler.endDocument()

    def createClass(self, name, id, attributes,
                    extendsId = None,
                    methods=None):
        """methods is a list of (name, (parameters))"""
        classTag = u"Foundation.Core.Class"
        nameTag = u'Foundation.Core.ModelElement.name'
        attrTag = u'Foundation.Core.Attribute'
        genTag = u'Foundation.Core.Generalization'
        genChildTag = u'Foundation.Core.Generalization.child'
        genParentTag = u'Foundation.Core.Generalization.parent'
        genElementTag = u'Foundation.Core.GeneralizableElement'
        methTag = u'Foundation.Core.Operation'
        paramTag = u'Foundation.Core.Parameter'
        
        methods = methods or []

        startElement = self.handler.startElement
        endElement = self.handler.endElement
        characters = self.handler.characters
        
        startElement(classTag, {u"xmi.id": id})
        startElement(nameTag, {})
        characters(name)
        endElement(nameTag)
        for attr in attributes:
            startElement(attrTag, {})
            startElement(nameTag, {})
            characters(attr)
            endElement(nameTag)
            endElement(attrTag)
        if extendsId:
            startElement(genTag, {})
            startElement(genChildTag, {})
            startElement(genElementTag, {u"xmi.idref": id})
            endElement(genElementTag)
            endElement(genChildTag)
            startElement(genParentTag, {})
            startElement(genElementTag, {u"xmi.idref": extendsId})
            endElement(genElementTag)
            endElement(genParentTag)
            endElement(genTag)

        for methName, params in methods:
            startElement(methTag, {})
            startElement(nameTag, {})
            characters(methName)
            endElement(nameTag)
            for param in params:
                startElement(paramTag,{})
                startElement(nameTag, {})
                characters(methName)
                endElement(nameTag)
                endElement(paramTag)
            endElement(methTag)
            
        endElement(classTag)

    def testStartClass(self):
        c1 = self.handler.classes[u"xmi.2"]
        c2 = self.handler.classes[u"xmi.4"]
        self.failUnlessEqual(c1.name, "LiaisonRadiale")
        self.failUnlessEqual(c1.attributes, ['position'])
        self.failUnlessEqual(len(self.handler.classes), 2)
        self.failUnlessEqual(c2.parent, c1)
        self.failUnlessEqual(len(c2.methods), 2)
        self.failUnlessEqual(c2.methods[1].name, "addExtension")
        self.failUnlessEqual(len(c2.methods[1].parameters), 2)

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