1 #

     2 # Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 # All rights reserved.

     4 # This component and the accompanying materials are made available

     5 # under the terms of "Eclipse Public License v1.0"

     6 # which accompanies this distribution, and is available

     7 # at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 #

     9 # Initial Contributors:

    10 # Nokia Corporation - initial contribution.

    11 #

    12 # Contributors:

    13 #

    14 # Description: 

    15 #

    16 

    17 

    18 """

    19 Test the CPF root file parsing routines

    20 """

    21 

    22 import zipfile

    23 import unittest

    24 import string

    25 import sys,os,re

    26 import __init__

    27 

    28 from cone.public import utils, container, exceptions

    29 

    30 ROOT_PATH = os.path.dirname(os.path.abspath(__file__))

    31 importpk   = os.path.join(ROOT_PATH,"Import.pk")

    32 

    33 

    34 class TestC(object):

    35     def __init__(self, path=""):

    36         self.path = path

    37     def test(self):

    38         return "test string"

    39 class TestB(object):

    40     def __init__(self, path=""):

    41         self.path = path

    42     def test(self):

    43         return "test string"

    44     

    45     

    46 class TestDataContainer(unittest.TestCase):

    47     def setUp(self):

    48         pass

    49     

    50     def test_add_values_and_get_values(self):

    51         cont = container.DataContainer()

    52         cont.add_value('test/ff',123)

    53         cont.add_value('test/ff','test')

    54         self.assertEquals(cont.get_value('test/ff'),'test')

    55         self.assertEquals(cont.get_values('test/ff')[0],123)

    56         self.assertEquals(cont.get_values('test/ff')[1],'test')

    57         

    58     def test_add_values_and_list_values(self):

    59         cont = container.DataContainer()

    60         cont.add_value('test/ff',123)

    61         cont.add_value('test/ff','test')

    62         cont.add_value('test/foo','test')

    63         keys = cont.list_keys()

    64         self.assertEquals(len(keys),2)

    65 

    66     def test_add_values_and_remove_one_value(self):

    67         cont = container.DataContainer()

    68         cont.add_value('test/ff',123)

    69         cont.add_value('test/ff','test')

    70         cont.add_value('test/foo','test')

    71         cont.add_value('test/foo','123')

    72         cont.add_value('sss',123)

    73         cont.remove_value('test/foo','test')        

    74         self.assertEquals(cont.get_values('test/foo'),['123'])

    75 

    76     def test_add_values_and_remove_all_values_of_a_key(self):

    77         cont = container.DataContainer()

    78         cont.add_value('test/ff',123)

    79         cont.add_value('test/ff','test')

    80         cont.add_value('test/foo','test')

    81         cont.add_value('test/foo','123')

    82         cont.add_value('test/foo','foobar')

    83         cont.add_value('sss',123)

    84         for val in cont.get_values('test/foo'):

    85             cont.remove_value('test/foo',val)

    86         self.assertEquals(cont.get_values('test/foo'),[])

    87 

    88     def test_add_values_and_remove_key(self):

    89         cont = container.DataContainer()

    90         cont.add_value('test/ff',123)

    91         cont.add_value('test/ff','test')

    92         cont.add_value('test/foo','test')

    93         cont.add_value('test/foo','123')

    94         cont.add_value('test/foo','foobar')

    95         cont.add_value('sss',123)

    96         cont.remove_key('test/foo')

    97         self.assertEquals(cont.list_keys(),['test/ff','sss'])

    98 

    99     def test_add_values_clear_all_data(self):

   100         cont = container.DataContainer()

   101         cont.add_value('test/ff',123)

   102         cont.add_value('test/ff','test')

   103         cont.add_value('test/foo','test')

   104         cont.add_value('test/foo','123')

   105         cont.clear()

   106         self.assertEquals(len(cont.list_keys()),0)

   107         

   108     def test_conatainer_flatten(self):

   109         data = container.DataContainer()

   110         data.add_value('test', 1)

   111         data.add_value('test', 2)

   112         data.add_value('test', 3)

   113         data.add_value('foo', 1)

   114         data.add_value('foo', 2)

   115         data.add_value('bar', 3)

   116         self.assertEquals(data.flatten(),{'test': 3, 'foo' : 2,'bar': 3})

   117 

   118 

   119 

   120 class TestObjectProxy(unittest.TestCase):    

   121     def test_create_object_proxy_for_test(self):

   122         cont = container.ObjectProxy(TestC("foo"))

   123         self.assertTrue(cont)

   124         self.assertEquals(cont.test(),"test string")

   125 

   126     def test_create_none_proxy(self):

   127         cont = container.ObjectProxy("")

   128         self.assertTrue(cont)

   129         try: 

   130             cont.test()

   131             self.fail("calling None succeeds?")

   132         except AttributeError:

   133             pass

   134 

   135     def test_create_object_proxy_for_string(self):

   136         cont = container.ObjectProxy("test string")

   137         self.assertTrue(cont)

   138         self.assertEquals(cont.startswith("test"),True)

   139         

   140 

   141 def graph(obj):

   142     if obj._parent:

   143         return ["%s -> %s" % (obj._parent._name, obj._name)]

   144     return []

   145 

   146 class TestObjectContainer(unittest.TestCase):    

   147     def test_create_object_container(self):

   148         cont = container.ObjectContainer("test")

   149         self.assertTrue(cont)

   150 

   151     def test_add_incorrect_type(self):

   152         cont = container.ObjectContainer()

   153         try: 

   154             cont._add(container.ObjectProxy())

   155             self.fail("Adding incorrect class type to container succeeds?")

   156         except exceptions.IncorrectClassError,e:

   157             pass

   158             

   159 

   160     def test_add_child(self):

   161         cont = container.ObjectContainer("root")

   162         obj = container.ObjectContainer("test")

   163         cont._add(obj)

   164         cont._add(container.ObjectContainer("foo"))

   165         self.assertEquals(cont._list(),['test','foo'])

   166         self.assertEquals(cont.test,obj)

   167 

   168     def test_add_internal_child(self):

   169         cont = container.ObjectContainer("root")

   170         obj = container.ObjectContainer("?test")

   171         cont._add(obj)

   172         cont._add(container.ObjectContainer("foo"))

   173         self.assertEquals(cont._list(),['foo'])

   174         self.assertEquals(cont._get('?test'),obj)

   175         

   176 

   177     def test_add_child_to_path(self):

   178         cont = container.ObjectContainer("test")

   179         obj = container.ObjectContainer("test")

   180         cont._add_to_path("com.nokia", obj)

   181         self.assertEquals(cont._list(),['com'])

   182         self.assertEquals(cont.com.nokia._list(),['test'])

   183         self.assertEquals(cont.com.nokia.test,obj)

   184 

   185     def test_add_child_to_path_and_replace_parent(self):

   186         cont = container.ObjectContainer("test")

   187         obj = container.ObjectContainer("test")

   188         cont._add_to_path("com.nokia", obj)

   189         cont._add_to_path("com", container.ObjectContainer("bar"))

   190         com = container.ObjectContainer("com")

   191         cont._add(com)

   192         self.assertEquals(cont._list(),['com'])

   193         self.assertEquals(cont.com._list(),['nokia','bar'])

   194         self.assertEquals(cont.com.bar._parent,com)

   195         self.assertEquals(cont.com.nokia._list(),['test'])

   196         self.assertEquals(cont.com.nokia.test,obj)

   197 

   198     def test_append(self):

   199         cont = container.ObjectContainer("test")

   200         cont._append(container.ObjectContainer('test'))

   201         self.assertEquals(len(utils.get_list(cont.test)), 1)

   202         cont._append(container.ObjectContainer('test'))

   203         self.assertEquals(len(cont.test), 2)

   204 

   205     def test_prepend(self):

   206         cont = container.ObjectContainer("test")

   207         cont._prepend(container.ObjectContainer('test'))

   208         self.assertEquals(len(utils.get_list(cont.test)), 1)

   209         cont._prepend(container.ObjectContainer('test'))

   210         self.assertEquals(len(cont.test), 2)

   211 

   212     def test_replace(self):

   213         cont = container.ObjectContainer("test")

   214         t1 = container.ObjectContainer('test')

   215         cont._replace(t1)

   216         self.assertEquals(cont.test, t1)

   217         t2 = container.ObjectContainer('test')

   218         cont._replace(t2)

   219         self.assertEquals(cont.test, t2)

   220 

   221     def test_error(self):

   222         cont = container.ObjectContainer("test")

   223         t1 = container.ObjectContainer('test')

   224         cont._error(t1)

   225         self.assertEquals(cont.test, t1)

   226         t2 = container.ObjectContainer('test')

   227         try:

   228             cont._error(t2)

   229             self.fail("adding same with error succeeds")

   230         except exceptions.AlreadyExists, e:

   231             pass

   232 

   233     def test_add_child_to_existing_path_with_error(self):

   234         cont = container.ObjectContainer("test")

   235         obj = container.ObjectContainer("test")

   236         cont._add_to_path("com.nokia", obj)

   237         com = container.ObjectContainer("com")

   238         try:

   239             cont._add(com, policy=container.ERROR)

   240             self.fail("Adding an existing object succeeds with ERROR policy")

   241         except exceptions.AlreadyExists, e:

   242             pass

   243 

   244     def test_add_child_to_existing_path_append(self):

   245         cont = container.ObjectContainer("test")

   246         obj = container.ObjectContainer("test")

   247         cont._add_to_path("com.nokia", obj)

   248         cont._add_to_path("com.nokia", container.ObjectContainer("test"), container.APPEND)

   249         com = container.ObjectContainer("com")

   250         cont._add(com, policy=container.APPEND)

   251         self.assertEquals(len(cont._get('com')),2)

   252         self.assertEquals(cont._get('com')[1],com)

   253         self.assertEquals(len(cont._objects()),2)

   254         self.assertEquals(len(cont.com[0].nokia.test),2)

   255         self.assertEquals(len(cont._get('com[0].nokia.test')),2)

   256         self.assertEquals([e._name for e in cont._traverse()],['com', 'nokia', 'test', 'test', 'com'])

   257         

   258     def test_add_child_to_existing_path_append_and_objects(self):

   259         cont = container.ObjectContainer("test")

   260         cont._add(container.ObjectContainer("dummy"),container.APPEND)

   261         cont._add(container.ObjectContainer("child"),container.APPEND)

   262         cont._add(container.ObjectContainer("child"),container.APPEND)

   263         cont._add(container.ObjectContainer("child"),container.APPEND)

   264         self.assertEquals(len(cont._objects()),4)

   265         cont._remove('child[1]')

   266         self.assertEquals(len(cont._objects()),3)

   267         cont._remove('child[0]')

   268         cont._remove('child[0]')

   269         self.assertEquals(len(cont._objects()),1)

   270 

   271     def test_add_child_and_access_via_index(self):

   272         cont = container.ObjectContainer("test")

   273         cont._add(container.ObjectContainer("dummy"),container.APPEND)

   274         d1 = cont._get('dummy')

   275         d2 = cont._get('dummy[0]')

   276         self.assertEquals(d1,d2)

   277         try:

   278             cont._get('dummy[1]')

   279             self.fail("getting dummy")

   280         except exceptions.NotFound:

   281             pass

   282 

   283     def test_add_child_to_existing_path_append_and_remove(self):

   284         cont = container.ObjectContainer("test")

   285         obj = container.ObjectContainer("test")

   286         cont._add_to_path("com.nokia", obj)

   287         com = container.ObjectContainer("com")

   288         cont._add(com, policy=container.APPEND)

   289         self.assertEquals(len(cont._get('com')),2)

   290         self.assertEquals(cont._get('com')[1],com)

   291         self.assertEquals(cont._list(),['com'])

   292         cont._remove('com')

   293         self.assertEquals(cont._list(), [])

   294         

   295     def test_add_child_to_existing_path_prepend(self):

   296         cont = container.ObjectContainer("test")

   297         obj = container.ObjectContainer("test")

   298         cont._add_to_path("com.nokia", obj)

   299         com = container.ObjectContainer("com")

   300         cont._add(com, policy=container.PREPEND)

   301         self.assertEquals(len(cont._get('com')),2)

   302         self.assertEquals(cont._get('com')[0],com)

   303 

   304     def test_add_child_and_get(self):

   305         cont = container.ObjectContainer("test")

   306         obj = container.ObjectContainer("test")

   307         cont._add_to_path("com.nokia", obj)

   308         self.assertEquals(cont._get('com.nokia.test'),obj)

   309         self.assertEquals(cont.com._get('nokia.test'),obj)

   310         self.assertEquals(cont.com.nokia._get('test'),obj)

   311 

   312     def test_add_child_and_remove_one(self):

   313         cont = container.ObjectContainer("test")

   314         obj = container.ObjectContainer("test")

   315         cont._add_to_path("com.nokia", obj)

   316         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   317         cont._add_to_path("com", container.ObjectContainer("bar"))

   318         self.assertEquals(len(cont._traverse()),5)

   319         cont._remove("com.nokia.foo")

   320         self.assertEquals(len(cont._traverse()),4)

   321         

   322     def test_add_child_and_remove_all(self):

   323         cont = container.ObjectContainer("test")

   324         obj = container.ObjectContainer("test")

   325         cont._add_to_path("com.nokia", obj)

   326         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   327         cont._add_to_path("com", container.ObjectContainer("bar"))

   328         self.assertEquals(len(cont._traverse()),5)

   329         for item in cont._list():

   330             cont._remove(item)

   331         self.assertEquals(len(cont._list()),0)

   332 

   333     def test_add_children_and_list_all(self):

   334         cont = container.ObjectContainer("test")

   335         obj = TestC()

   336         cont._add_to_path("com.nokia", container.ObjectContainer("test"))

   337         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   338         cont._add_to_path("com", container.ObjectContainer("bar"))

   339         self.assertEquals(len(cont._traverse()),5)

   340 

   341     def test_create_hieararchy_and_remove_child(self):

   342         root = container.ObjectContainer("test")

   343         root._add(container.ObjectContainer("child1"))

   344         root._add(container.ObjectContainer("child2"))

   345         root.child1._add(container.ObjectContainer("child11"))

   346         root.child1._add(container.ObjectContainer("child12"))

   347         root.child2._add(container.ObjectContainer("child21"))

   348         self.assertEquals(root._list_traverse(),

   349                           ['child1', 

   350                           'child1.child11', 

   351                           'child1.child12',

   352                           'child2',

   353                           'child2.child21'])

   354         root.child2._remove('child21')

   355         self.assertEquals(root._list_traverse()

   356                           ,['child1',  

   357                                            'child1.child11', 

   358                                            'child1.child12',

   359                                            'child2'])

   360 

   361     def test_add_children_and_traverse_and_get_path(self):

   362         cont = container.ObjectContainer("default")

   363         cont._add_to_path("com.nokia", container.ObjectContainer("test"))

   364         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   365         cont._add_to_path("com", container.ObjectContainer("bar"))

   366         cont.com._list()

   367         self.assertEquals(cont._traverse()[0]._path(),"default.com")

   368         self.assertEquals(cont._traverse()[0]._path(cont),"com")

   369         self.assertEquals(cont._traverse()[0]._path(cont.com),"")

   370 

   371     def test_add_children_and_traverse_filter_name_and_get_path(self):

   372         cont = container.ObjectContainer("default")

   373         cont._add_to_path("com.nokia", container.ObjectContainer("test"))

   374         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   375         cont._add_to_path("com", container.ObjectContainer("bar"))

   376         cont.com._list()

   377         ret = cont._traverse(name="^t.*$")

   378         self.assertEquals(len(ret),1)

   379         self.assertEquals(ret[0]._path(),"default.com.nokia.test")

   380 

   381     def test_add_children_and_traverse_filter_name_many(self):

   382         cont = container.ObjectContainer("default")

   383         cont._add_to_path("com.nokia", container.ObjectContainer("test"))

   384         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   385         cont._add_to_path("com", container.ObjectContainer("bar"))

   386         cont.com._list()

   387         ret = cont._traverse(path=".*nokia.*")

   388         self.assertEquals(len(ret),3)

   389         self.assertEquals(ret[0]._path(),"default.com.nokia")

   390 

   391     def test_add_children_tail_recurse_with_function(self):

   392         cont = container.ObjectContainer("default")

   393         cont._add_to_path("com.nokia", container.ObjectContainer("test"))

   394         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   395         cont._add_to_path("com", container.ObjectContainer("bar"))

   396         ret = cont._tail_recurse(graph)

   397         self.assertEquals(ret,['default -> com', 'com -> nokia', 'nokia -> test', 'nokia -> foo', 'com -> bar'])

   398 

   399     def test_add_children_head_recurse_with_function(self):

   400         cont = container.ObjectContainer("default")

   401         cont._add_to_path("com.nokia", container.ObjectContainer("test"))

   402         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   403         cont._add_to_path("com", container.ObjectContainer("bar"))

   404         ret = cont._head_recurse(graph)

   405         self.assertEquals(ret,['nokia -> test', 'nokia -> foo', 'com -> nokia', 'com -> bar', 'default -> com'])

   406 

   407     def test_add_children_and_find_parent(self):

   408         cont = container.ObjectContainer("default", container=True)

   409         cont._add(container.ObjectContainer("com",housut="test"))

   410         cont._add_to_path("com.nokia", container.ObjectContainer("test"))

   411         cont._add_to_path("com.nokia", container.ObjectContainer("foo"))

   412         cont._add_to_path("com", container.ObjectContainer("bar"))

   413         child = cont._get('com.nokia.test')

   414         self.assertEquals(child._find_parent()._name, 'nokia')

   415         self.assertEquals(child._find_parent(container=True)._name, 'default')

   416         self.assertEquals(child._find_parent(housut="test")._name, 'com')

   417         self.assertEquals(child._find_parent(__class__=container.ObjectContainer)._name, 'nokia')

   418         self.assertEquals(child._find_parent(type=container.ObjectContainer)._name, 'nokia')

   419 

   420 class TestObjectProxyContainer(unittest.TestCase):    

   421     def test_create_object_container_for_test(self):

   422         cont = container.ObjectProxyContainer(TestC("foo"))

   423         self.assertTrue(cont)

   424         self.assertEquals(cont.test(),"test string")

   425 

   426     def test_create_none_container(self):

   427         cont = container.ObjectProxyContainer(None)

   428         self.assertTrue(cont)

   429         try: 

   430             cont.test()

   431             self.fail("calling None succeeds?")

   432         except AttributeError:

   433             pass

   434 

   435     def test_create_object_container_for_string(self):

   436         cont = container.ObjectProxyContainer("Test")

   437         self.assertTrue(cont)

   438         self.assertEquals(cont.startswith("Test"),True)

   439         

   440     def test_create_object_container(self):

   441         cont = container.ObjectProxyContainer(TestC())

   442         self.assertTrue(cont)

   443 

   444     def test_add_child(self):

   445         cont = container.ObjectProxyContainer(None)

   446         obj = TestC()

   447         cont._add(container.ObjectProxyContainer(obj,"test"))

   448         self.assertEquals(cont._list(),['test'])

   449         self.assertEquals(cont.test._obj,obj)

   450     

   451     def test_add_child_to_path(self):

   452         cont = container.ObjectProxyContainer(None)

   453         obj = TestC()

   454         cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))

   455         self.assertEquals(cont._list(),['com'])

   456         self.assertEquals(cont.com.nokia._list(),['test'])

   457         self.assertEquals(cont.com.nokia.test._obj,obj)

   458         self.assertEquals(cont.com.nokia.test.test(),"test string")

   459 

   460     def test_add_child_and_get(self):

   461         cont = container.ObjectProxyContainer(None)

   462         obj = TestC()

   463         cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))

   464         self.assertEquals(cont._get('com.nokia.test')._obj,obj)

   465         self.assertEquals(cont.com._get('nokia.test')._obj,obj)

   466         self.assertEquals(cont.com.nokia._get('test')._obj,obj)

   467 

   468     def test_add_child_and_remove_one(self):

   469         cont = container.ObjectProxyContainer(None)

   470         obj = TestC()

   471         cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))

   472         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   473         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   474         

   475         self.assertEquals(len(cont._traverse()),5)

   476         cont._remove("com.nokia.foo")

   477         self.assertEquals(len(cont._traverse()),4)

   478         

   479     def test_add_child_and_remove_all(self):

   480         cont = container.ObjectProxyContainer(None)

   481         obj = TestC()

   482         cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))

   483         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   484         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   485         self.assertEquals(len(cont._traverse()),5)

   486         for item in cont._list():

   487             cont._remove(item)

   488         self.assertEquals(len(cont._list()),0)

   489 

   490     def test_add_children_and_list_all(self):

   491         cont = container.ObjectProxyContainer(None)

   492         obj = TestC()

   493         cont._add_to_path("com.nokia", container.ObjectProxyContainer(obj,"test"))

   494         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   495         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   496         self.assertEquals(len(cont._traverse()),5)

   497 

   498     def test_add_children_and_traverse_and_get_path(self):

   499         cont = container.ObjectProxyContainer(None,"default")

   500         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))

   501         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   502         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   503         cont.com._list()

   504         self.assertEquals(cont._traverse()[0]._path(),"default.com")

   505 

   506     def test_add_children_and_traverse_filter_name_and_get_path(self):

   507         cont = container.ObjectProxyContainer(None,"default")

   508         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))

   509         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   510         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   511         cont.com._list()

   512         ret = cont._traverse(name="^t.*$")

   513         self.assertEquals(len(ret),1)

   514         self.assertEquals(ret[0]._path(),"default.com.nokia.test")

   515 

   516     def test_add_children_and_traverse_filter_name_many(self):

   517         cont = container.ObjectProxyContainer(None,"default")

   518         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))

   519         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   520         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   521         cont.com._list()

   522         ret = cont._traverse(path=".*nokia.*")

   523         self.assertEquals(len(ret),3)

   524         self.assertEquals(ret[0]._path(),"default.com.nokia")

   525 

   526     def test_add_children_and_traverse_filter_class(self):

   527         cont = container.ObjectProxyContainer(None,"default")

   528         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))

   529         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   530         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   531         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestB(),"bee"))

   532         cont.com.nokia._add(container.ObjectProxyContainer(TestB(),"vee"))

   533         ret = cont._traverse(filters=[lambda x: hasattr(x,'_obj') and isinstance(x._obj, TestB)])

   534         self.assertEquals(len(ret),2)

   535         self.assertEquals(ret[0]._path(cont),"com.nokia.bee")

   536         self.assertEquals(ret[1]._path(cont),"com.nokia.vee")

   537 

   538     def test_add_children_and_traverse_filter_class_proxies(self):

   539         cont = container.ObjectProxyContainer(None,"default")

   540         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"test"))

   541         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestC(),"foo"))

   542         cont._add_to_path("com", container.ObjectProxyContainer(TestC(),"bar"))

   543         cont._add_to_path("com.nokia", container.ObjectProxyContainer(TestB(),"bee"))

   544         cont.com.nokia._add(container.ObjectProxyContainer(TestB(),"vee"))

   545         ret = cont._traverse(filters=[lambda x: isinstance(x, container.ObjectProxyContainer)])

   546         self.assertEquals(len(ret),5)

   547         self.assertEquals(ret[0]._path(cont),"com.nokia.test")

   548         self.assertEquals(ret[1]._path(cont),"com.nokia.foo")

   549 

   550 class TestLoadProxy(unittest.TestCase):

   551     def test_create_load_proxy(self):

   552         proxy = container.LoadProxy(importpk, container.LoadInterface())

   553         proxy._load()

   554         self.assertTrue(proxy._obj != None)

   555 

   556     def test_create_load_proxy_and_get(self):

   557         proxy = container.LoadProxy(importpk, container.LoadInterface())

   558         self.assertEquals(proxy.list_resources(''),['test1.txt', 'test2.txt', 'test3.txt'])

   559         self.assertTrue(proxy._obj != None)

   560 

   561     def test_create_load_proxy_and_unload(self):

   562         proxy = container.LoadProxy(importpk, container.LoadInterface())

   563         self.assertEquals(proxy.list_resources(''),['test1.txt', 'test2.txt', 'test3.txt'])

   564         proxy.set('path',"unload.pk")

   565         proxy._unload()

   566         self.assertTrue(proxy._obj == None)

   567         proxy =None

   568         proxy2 = container.LoadProxy("unload.pk", container.LoadInterface())

   569         self.assertEquals(proxy2.list_resources(''),['test1.txt', 'test2.txt', 'test3.txt'])

   570         os.unlink("unload.pk")

   571 

   572 if __name__ == '__main__':

   573     unittest.main()

   574