Added the basic cases for container conversions.

The cases are made of conversions of lists of:
* C++ primitive type
* C++ class treated as Python primitive type
* Value type as C++ value
* Object type as C++ pointer
* Container of container of C++ primitive type

The container is converted when called from Python or from C++ (via
virtual methods), and passed as arguments to Python and to C++.

Reviewed by Luciano Wolf <luciano.wolf@openbossa.org>
Reviewed by Renato Araújo <renato.filho@openbossa.org>

8 files changed, 511 insertions, 0 deletions

diff --git a/tests/libminimal/CMakeLists.txt b/tests/libminimal/CMakeLists.txt
index 7fa87dc39..9b47bff5e 100644
--- a/tests/libminimal/CMakeLists.txt
+++ b/tests/libminimal/CMakeLists.txt
@@ -2,6 +2,7 @@ project(libminimal)
 
 set(libminimal_SRC
 obj.cpp
+listuser.cpp
 )
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/tests/libminimal/listuser.cpp b/tests/libminimal/listuser.cpp
new file mode 100644
index 000000000..2f5ad4504
--- /dev/null
+++ b/tests/libminimal/listuser.cpp
@@ -0,0 +1,118 @@
+/*
+ * This file is part of the Shiboken Python Binding Generator project.
+ *
+ * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <numeric>
+#include <cstdlib>
+#include "listuser.h"
+
+std::list<int>
+ListUser::createIntList(int num)
+{
+    std::list<int> retval;
+    for (int i = 0; i < num; ++i)
+        retval.push_back(i);
+    return retval;
+}
+
+int
+ListUser::sumIntList(std::list<int> intList)
+{
+    int total = 0;
+    for (std::list<int>::iterator iter = intList.begin(); iter != intList.end(); iter++)
+        total += *iter;
+    return total;
+}
+
+std::list<MinBool>
+ListUser::createMinBoolList(MinBool mb1, MinBool mb2)
+{
+    std::list<MinBool> retval;
+    retval.push_back(mb1);
+    retval.push_back(mb2);
+    return retval;
+}
+
+MinBool
+ListUser::oredMinBoolList(std::list<MinBool> minBoolList)
+{
+    MinBool result(false);
+    for (std::list<MinBool>::iterator iter = minBoolList.begin(); iter != minBoolList.end(); iter++)
+        result |= *iter;
+    return result;
+}
+
+std::list<Val>
+ListUser::createValList(int num)
+{
+    std::list<Val> retval;
+    for (int i = 0; i < num; ++i)
+        retval.push_back(Val(i));
+    return retval;
+}
+
+int
+ListUser::sumValList(std::list<Val> valList)
+{
+    int total = 0;
+    for (std::list<Val>::iterator iter = valList.begin(); iter != valList.end(); iter++)
+        total += iter->valId();
+    return total;
+}
+
+std::list<Obj*>
+ListUser::createObjList(Obj* o1, Obj* o2)
+{
+    std::list<Obj*> retval;
+    retval.push_back(o1);
+    retval.push_back(o2);
+    return retval;
+}
+
+int
+ListUser::sumObjList(std::list<Obj*> objList)
+{
+    int total = 0;
+    for (std::list<Obj*>::iterator iter = objList.begin(); iter != objList.end(); iter++)
+        total += (*iter)->objId();
+    return total;
+}
+
+std::list<std::list<int> >
+ListUser::createListOfIntLists(int num)
+{
+    std::list<std::list<int> > retval;
+    for (int i = 0; i < num; ++i)
+        retval.push_back(createIntList(num));
+    return retval;
+}
+
+int
+ListUser::sumListOfIntLists(std::list<std::list<int> > intListList)
+{
+    int total = 0;
+    for (std::list<std::list<int> >::iterator it0 = intListList.begin(); it0 != intListList.end(); it0++) {
+        for (std::list<int>::iterator it1 = (*it0).begin(); it1 != (*it0).end(); it1++)
+            total += *it1;
+    }
+    return total;
+}
+
diff --git a/tests/libminimal/listuser.h b/tests/libminimal/listuser.h
new file mode 100644
index 000000000..8f65fff64
--- /dev/null
+++ b/tests/libminimal/listuser.h
@@ -0,0 +1,67 @@
+/*
+ * This file is part of the Shiboken Python Binding Generator project.
+ *
+ * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+ *
+ * Contact: PySide team <contact@pyside.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef LISTUSER_H
+#define LISTUSER_H
+
+#include <list>
+#include "obj.h"
+#include "val.h"
+#include "minbool.h"
+
+#include "libminimalmacros.h"
+
+struct LIBMINIMAL_API ListUser
+{
+    // List of C++ primitive type items
+    virtual std::list<int> createIntList(int num);
+    std::list<int> callCreateIntList(int num) { return createIntList(num); }
+    virtual int sumIntList(std::list<int> intList);
+    int callSumIntList(std::list<int> intList) { return sumIntList(intList); }
+
+    // List of C++ MinBool objects used as primitives in Python
+    virtual std::list<MinBool> createMinBoolList(MinBool mb1, MinBool mb2);
+    std::list<MinBool> callCreateMinBoolList(MinBool mb1, MinBool mb2) { return createMinBoolList(mb1, mb2); }
+    virtual MinBool oredMinBoolList(std::list<MinBool> minBoolList);
+    MinBool callOredMinBoolList(std::list<MinBool> minBoolList) { return oredMinBoolList(minBoolList); }
+
+    // List of C++ value types
+    virtual std::list<Val> createValList(int num);
+    std::list<Val> callCreateValList(int num) { return createValList(num); }
+    virtual int sumValList(std::list<Val> valList);
+    int callSumValList(std::list<Val> valList) { return sumValList(valList); }
+
+    // List of C++ object types
+    virtual std::list<Obj*> createObjList(Obj* o1, Obj* o2);
+    std::list<Obj*> callCreateObjList(Obj* o1, Obj* o2) { return createObjList(o1, o2); }
+    virtual int sumObjList(std::list<Obj*> objList);
+    int callSumObjList(std::list<Obj*> objList) { return sumObjList(objList); }
+
+    // List of lists of C++ primitive type items
+    virtual std::list<std::list<int> > createListOfIntLists(int num);
+    std::list<std::list<int> > callCreateListOfIntLists(int num) { return createListOfIntLists(num); }
+    virtual int sumListOfIntLists(std::list<std::list<int> > intListList);
+    int callSumListOfIntLists(std::list<std::list<int> > intListList) { return sumListOfIntLists(intListList); }
+};
+
+#endif // LISTUSER_H
+
diff --git a/tests/minimalbinding/CMakeLists.txt b/tests/minimalbinding/CMakeLists.txt
index af93dd365..6229dd7cb 100644
--- a/tests/minimalbinding/CMakeLists.txt
+++ b/tests/minimalbinding/CMakeLists.txt
@@ -8,6 +8,7 @@ set(minimal_SRC
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/minimal_module_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/obj_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/val_wrapper.cpp
+${CMAKE_CURRENT_BINARY_DIR}/minimal/listuser_wrapper.cpp
 ${CMAKE_CURRENT_BINARY_DIR}/minimal/minbooluser_wrapper.cpp
 )
 
diff --git a/tests/minimalbinding/global.h b/tests/minimalbinding/global.h
index c27c686b7..da283d11e 100644
--- a/tests/minimalbinding/global.h
+++ b/tests/minimalbinding/global.h
@@ -1,3 +1,4 @@
 #include "obj.h"
 #include "val.h"
 #include "minbool.h"
+#include "listuser.h"
diff --git a/tests/minimalbinding/list_conversions.h b/tests/minimalbinding/list_conversions.h
new file mode 100644
index 000000000..6ed8d9647
--- /dev/null
+++ b/tests/minimalbinding/list_conversions.h
@@ -0,0 +1,4 @@
+namespace Shiboken {
+template<typename T>
+struct Converter<std::list<T> > : StdListConverter<std::list<T> > {};
+}
diff --git a/tests/minimalbinding/listuser_test.py b/tests/minimalbinding/listuser_test.py
new file mode 100644
index 000000000..8874ac842
--- /dev/null
+++ b/tests/minimalbinding/listuser_test.py
@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# This file is part of the Shiboken Python Bindings Generator project.
+#
+# Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+#
+# Contact: PySide team <contact@pyside.org>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public License
+# version 2.1 as published by the Free Software Foundation. Please
+# review the following information to ensure the GNU Lesser General
+# Public License version 2.1 requirements will be met:
+# http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+# #
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA
+
+import unittest
+from minimal import ListUser, Val, Obj
+
+
+class ExtListUser(ListUser):
+    def __init__(self):
+        ListUser.__init__(self)
+
+    def createIntList(self, num):
+        return range(0, num * 2, 2)
+
+    def sumIntList(self, intList):
+        return sum(intList) * 2
+
+    def createMinBoolList(self, mb1, mb2):
+        return [not mb1, not mb2]
+
+    def oredMinBoolList(self, minBoolList):
+        return not reduce(lambda a, b: a|b, minBoolList)
+
+    def createValList(self, num):
+        return [Val(i) for i in range(0, num * 2, 2)]
+
+    def sumValList(self, valList):
+        return sum([val.valId() for val in valList]) * 2
+
+    def createObjList(self, o1, o2):
+        o1.setObjId(o1.objId() * 2)
+        o2.setObjId(o2.objId() * 2)
+        return [o1, o2]
+
+    def sumObjList(self, objList):
+        return sum([obj.objId() for obj in objList]) * 2
+
+    def createListOfIntLists(self, num):
+        return [self.createIntList(num)] * 4
+
+    def sumListOfIntLists(self, intListList):
+        return sum([sum(line) for line in intListList]) * 2
+
+
+class IntListConversionTest(unittest.TestCase):
+
+    def testCreateIntList(self):
+        num = 4
+        lu = ListUser()
+        lst = lu.createIntList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), int)
+        self.assertEqual(lst, range(num))
+        lst = lu.callCreateIntList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), int)
+        self.assertEqual(lst, range(num))
+
+    def testCreateIntListFromExtendedClass(self):
+        lu = ExtListUser()
+        num = 4
+        lst = lu.createIntList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), int)
+        self.assertEqual(lst, range(0, num * 2, 2))
+        lst = lu.callCreateIntList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), int)
+        self.assertEqual(lst, range(0, num * 2, 2))
+
+    def testSumIntList(self):
+        lu = ListUser()
+        lst = range(4)
+        self.assertEqual(lu.sumIntList(lst), sum(lst))
+        self.assertEqual(lu.callSumIntList(lst), sum(lst))
+
+    def testSumIntListFromExtendedClass(self):
+        lu = ExtListUser()
+        lst = range(4)
+        self.assertEqual(lu.sumIntList(lst), sum(lst) * 2)
+        self.assertEqual(lu.callSumIntList(lst), sum(lst) * 2)
+
+
+class MinBoolListConversionTest(unittest.TestCase):
+
+    def testCreateMinBoolList(self):
+        lu = ListUser()
+        lst = lu.createMinBoolList(True, False)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), bool)
+        self.assertEqual(lst, [True, False])
+
+        lst = lu.callCreateMinBoolList(False, True)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), bool)
+        self.assertEqual(lst, [False, True])
+
+    def testCreateMinBoolListFromExtendedClass(self):
+        lu = ExtListUser()
+        lst = lu.createMinBoolList(True, False)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), bool)
+        self.assertEqual(lst, [False, True])
+
+        lst = lu.callCreateMinBoolList(False, True)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), bool)
+        self.assertEqual(lst, [True, False])
+
+    def testOredMinBoolList(self):
+        lu = ListUser()
+        lst = [False, False, True]
+        self.assertTrue(lu.oredMinBoolList(lst))
+        self.assertTrue(lu.callOredMinBoolList(lst))
+        lst = [False, False, False]
+        self.assertFalse(lu.oredMinBoolList(lst))
+        self.assertFalse(lu.callOredMinBoolList(lst))
+
+    def testOredMinBoolListFromExtendedClass(self):
+        lu = ExtListUser()
+        lst = [False, False, True]
+        self.assertFalse(lu.oredMinBoolList(lst))
+        self.assertFalse(lu.callOredMinBoolList(lst))
+        lst = [False, False, False]
+        self.assertTrue(lu.oredMinBoolList(lst))
+        self.assertTrue(lu.callOredMinBoolList(lst))
+
+
+class ValListConversionTest(unittest.TestCase):
+
+    def testCreateValList(self):
+        num = 4
+        lu = ListUser()
+        lst = lu.createValList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), Val)
+        self.assertEqual([val.valId() for val in lst], range(num))
+        lst = lu.callCreateValList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), Val)
+        self.assertEqual([val.valId() for val in lst], range(num))
+
+    def testCreateValListFromExtendedClass(self):
+        lu = ExtListUser()
+        num = 4
+        lst = lu.createValList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), Val)
+        self.assertEqual([val.valId() for val in lst], range(0, num * 2, 2))
+        lst = lu.callCreateValList(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), Val)
+        self.assertEqual([val.valId() for val in lst], range(0, num * 2, 2))
+
+    def testSumValList(self):
+        lu = ListUser()
+        lst = [Val(i) for i in range(4)]
+        self.assertEqual(lu.sumValList(lst), sum([val.valId() for val in lst]))
+        self.assertEqual(lu.callSumValList(lst), sum([val.valId() for val in lst]))
+
+    def testSumValListFromExtendedClass(self):
+        lu = ExtListUser()
+        lst = [Val(i) for i in range(4)]
+        self.assertEqual(lu.sumValList(lst), sum([val.valId() for val in lst]) * 2)
+        self.assertEqual(lu.callSumValList(lst), sum([val.valId() for val in lst]) * 2)
+
+
+class ObjListConversionTest(unittest.TestCase):
+
+    def testCreateObjList(self):
+        o1 = Obj(1)
+        o2 = Obj(2)
+        lu = ListUser()
+        lst = lu.createObjList(o1, o2)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), Obj)
+        self.assertEqual(lst, [o1, o2])
+        self.assertEqual([obj.objId() for obj in lst], [1, 2])
+
+        lst = lu.callCreateObjList(o1, o2)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), Obj)
+        self.assertEqual(lst, [o1, o2])
+        self.assertEqual([obj.objId() for obj in lst], [1, 2])
+
+    def testCreateObjListFromExtendedClass(self):
+        o1 = Obj(1)
+        o2 = Obj(2)
+        lu = ExtListUser()
+        lst = lu.createObjList(o1, o2)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), Obj)
+        self.assertEqual(lst, [o1, o2])
+        self.assertEqual([obj.objId() for obj in lst], [2, 4])
+
+        lst = lu.callCreateObjList(o1, o2)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), 2)
+        for i in lst:
+            self.assertEqual(type(i), Obj)
+        self.assertEqual(lst, [o1, o2])
+        self.assertEqual([obj.objId() for obj in lst], [4, 8])
+
+    def testSumObjList(self):
+        lu = ListUser()
+        lst = [Obj(i) for i in range(4)]
+        self.assertEqual(lu.sumObjList(lst), sum([obj.objId() for obj in lst]))
+        self.assertEqual(lu.callSumObjList(lst), sum([obj.objId() for obj in lst]))
+
+    def testSumObjListFromExtendedClass(self):
+        lu = ExtListUser()
+        lst = [Obj(i) for i in range(4)]
+        self.assertEqual(lu.sumObjList(lst), sum([obj.objId() for obj in lst]) * 2)
+        self.assertEqual(lu.callSumObjList(lst), sum([obj.objId() for obj in lst]) * 2)
+
+
+class ListOfIntListConversionTest(unittest.TestCase):
+
+    def testCreateListOfIntLists(self):
+        num = 4
+        lu = ListUser()
+        lst = lu.createListOfIntLists(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), list)
+            self.assertEqual(i, range(num))
+            for j in i:
+                self.assertEqual(type(j), int)
+        self.assertEqual(lst, [range(num)] * 4)
+
+    def testCreateListOfIntListsFromExtendedClass(self):
+        num = 4
+        lu = ExtListUser()
+        lst = lu.createListOfIntLists(num)
+        self.assertEqual(type(lst), list)
+        self.assertEqual(len(lst), num)
+        for i in lst:
+            self.assertEqual(type(i), list)
+            self.assertEqual(i, range(0, num * 2, 2))
+            for j in i:
+                self.assertEqual(type(j), int)
+        self.assertEqual(lst, [range(0, num * 2, 2)] * 4)
+
+    def testSumListIntLists(self):
+        lu = ListUser()
+        lst = [range(4)] * 4
+        self.assertEqual(lu.sumListOfIntLists(lst), sum([sum(line) for line in [range(4)] * 4]))
+        self.assertEqual(lu.callSumListOfIntLists(lst), sum([sum(line) for line in [range(4)] * 4]))
+
+    def testSumListOfIntListsFromExtendedClass(self):
+        lu = ExtListUser()
+        lst = [range(4)] * 4
+        self.assertEqual(lu.sumListOfIntLists(lst), sum([sum(line) for line in [range(4)] * 4]) * 2)
+        self.assertEqual(lu.callSumListOfIntLists(lst), sum([sum(line) for line in [range(4)] * 4]) * 2)
+
+
+if __name__ == '__main__':
+    unittest.main()
+
diff --git a/tests/minimalbinding/typesystem_minimal.xml b/tests/minimalbinding/typesystem_minimal.xml
index c3e681177..7f160ddaf 100644
--- a/tests/minimalbinding/typesystem_minimal.xml
+++ b/tests/minimalbinding/typesystem_minimal.xml
@@ -8,8 +8,14 @@
         <include file-name="minbool.h" location="global"/>
     </primitive-type>
 
+    <container-type name="std::list" type="list">
+        <conversion-rule file="list_conversions.h"/>
+        <include file-name="list" location="global"/>
+    </container-type>
+
     <object-type name="Obj"/>
     <value-type name="Val"/>
+    <value-type name="ListUser"/>
     <value-type name="MinBoolUser"/>
 </typesystem>