diff --git a/trytond/tests/test_importdata.py b/trytond/tests/test_importdata.py
index fb6761ec27..71b8e96237 100644
--- a/trytond/tests/test_importdata.py
+++ b/trytond/tests/test_importdata.py
@@ -36,26 +36,26 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.boolean.import_data(['boolean'],
-                [['True']]) == (1, 0, 0, 0))
+            self.assertEqual(self.boolean.import_data(['boolean'],
+                [['True']]), (1, 0, 0, 0))
 
-            self.assert_(self.boolean.import_data(['boolean'],
-                [['1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.boolean.import_data(['boolean'],
+                [['1']]), (1, 0, 0, 0))
 
-            self.assert_(self.boolean.import_data(['boolean'],
-                [['False']]) == (1, 0, 0, 0))
+            self.assertEqual(self.boolean.import_data(['boolean'],
+                [['False']]), (1, 0, 0, 0))
 
-            self.assert_(self.boolean.import_data(['boolean'],
-                [['0']]) == (1, 0, 0, 0))
+            self.assertEqual(self.boolean.import_data(['boolean'],
+                [['0']]), (1, 0, 0, 0))
 
-            self.assert_(self.boolean.import_data(['boolean'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.boolean.import_data(['boolean'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.boolean.import_data(['boolean'],
-                [['True'], ['False']]) == (2, 0, 0, 0))
+            self.assertEqual(self.boolean.import_data(['boolean'],
+                [['True'], ['False']]), (2, 0, 0, 0))
 
-            self.assert_(self.boolean.import_data(['boolean'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.boolean.import_data(['boolean'],
+                [['foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -65,26 +65,26 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.integer.import_data(['integer'],
-                [['1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['1']]), (1, 0, 0, 0))
 
-            self.assert_(self.integer.import_data(['integer'],
-                [['-1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['-1']]), (1, 0, 0, 0))
 
-            self.assert_(self.integer.import_data(['integer'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.integer.import_data(['integer'],
-                [['1'], ['2']]) == (2, 0, 0, 0))
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['1'], ['2']]), (2, 0, 0, 0))
 
-            self.assert_(self.integer.import_data(['integer'],
-                [['1.1']])[0] == -1)
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['1.1']])[0], -1)
 
-            self.assert_(self.integer.import_data(['integer'],
-                [['-1.1']])[0] == -1)
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['-1.1']])[0], -1)
 
-            self.assert_(self.integer.import_data(['integer'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.integer.import_data(['integer'],
+                [['foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -94,23 +94,23 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.float.import_data(['float'],
-                [['1.1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.float.import_data(['float'],
+                [['1.1']]), (1, 0, 0, 0))
 
-            self.assert_(self.float.import_data(['float'],
-                [['-1.1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.float.import_data(['float'],
+                [['-1.1']]), (1, 0, 0, 0))
 
-            self.assert_(self.float.import_data(['float'],
-                [['1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.float.import_data(['float'],
+                [['1']]), (1, 0, 0, 0))
 
-            self.assert_(self.float.import_data(['float'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.float.import_data(['float'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.float.import_data(['float'],
-                [['1.1'], ['2.2']]) == (2, 0, 0, 0))
+            self.assertEqual(self.float.import_data(['float'],
+                [['1.1'], ['2.2']]), (2, 0, 0, 0))
 
-            self.assert_(self.float.import_data(['float'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.float.import_data(['float'],
+                [['foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -120,23 +120,23 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.numeric.import_data(['numeric'],
-                [['1.1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['1.1']]), (1, 0, 0, 0))
 
-            self.assert_(self.numeric.import_data(['numeric'],
-                [['-1.1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['-1.1']]), (1, 0, 0, 0))
 
-            self.assert_(self.numeric.import_data(['numeric'],
-                [['1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['1']]), (1, 0, 0, 0))
 
-            self.assert_(self.numeric.import_data(['numeric'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.numeric.import_data(['numeric'],
-                [['1.1'], ['2.2']]) == (2, 0, 0, 0))
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['1.1'], ['2.2']]), (2, 0, 0, 0))
 
-            self.assert_(self.numeric.import_data(['numeric'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.numeric.import_data(['numeric'],
+                [['foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -146,14 +146,14 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.char.import_data(['char'],
-                [['test']]) == (1, 0, 0, 0))
+            self.assertEqual(self.char.import_data(['char'],
+                [['test']]), (1, 0, 0, 0))
 
-            self.assert_(self.char.import_data(['char'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.char.import_data(['char'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.char.import_data(['char'],
-                [['test'], ['foo'], ['bar']]) == (3, 0, 0, 0))
+            self.assertEqual(self.char.import_data(['char'],
+                [['test'], ['foo'], ['bar']]), (3, 0, 0, 0))
 
             transaction.cursor.rollback()
 
@@ -163,14 +163,14 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.text.import_data(['text'],
-                [['test']]) == (1, 0, 0, 0))
+            self.assertEqual(self.text.import_data(['text'],
+                [['test']]), (1, 0, 0, 0))
 
-            self.assert_(self.text.import_data(['text'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.text.import_data(['text'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.text.import_data(['text'],
-                [['test'], ['foo'], ['bar']]) == (3, 0, 0, 0))
+            self.assertEqual(self.text.import_data(['text'],
+                [['test'], ['foo'], ['bar']]), (3, 0, 0, 0))
 
             transaction.cursor.rollback()
 
@@ -180,14 +180,14 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.sha.import_data(['sha'],
-                [['test']]) == (1, 0, 0, 0))
+            self.assertEqual(self.sha.import_data(['sha'],
+                [['test']]), (1, 0, 0, 0))
 
-            self.assert_(self.sha.import_data(['sha'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.sha.import_data(['sha'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.sha.import_data(['sha'],
-                [['test'], ['foo']]) == (2, 0, 0, 0))
+            self.assertEqual(self.sha.import_data(['sha'],
+                [['test'], ['foo']]), (2, 0, 0, 0))
 
             transaction.cursor.rollback()
 
@@ -197,17 +197,17 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.date.import_data(['date'],
-                [['2010-01-01']]) == (1, 0, 0, 0))
+            self.assertEqual(self.date.import_data(['date'],
+                [['2010-01-01']]), (1, 0, 0, 0))
 
-            self.assert_(self.date.import_data(['date'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.date.import_data(['date'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.date.import_data(['date'],
-                [['2010-01-01'], ['2010-02-01']]) == (2, 0, 0, 0))
+            self.assertEqual(self.date.import_data(['date'],
+                [['2010-01-01'], ['2010-02-01']]), (2, 0, 0, 0))
 
-            self.assert_(self.date.import_data(['date'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.date.import_data(['date'],
+                [['foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -217,18 +217,18 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.datetime.import_data(['datetime'],
-                [['2010-01-01 12:00:00']]) == (1, 0, 0, 0))
+            self.assertEqual(self.datetime.import_data(['datetime'],
+                [['2010-01-01 12:00:00']]), (1, 0, 0, 0))
 
-            self.assert_(self.datetime.import_data(['datetime'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.datetime.import_data(['datetime'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.datetime.import_data(['datetime'],
-                [['2010-01-01 12:00:00'], ['2010-01-01 13:30:00']]) ==
+            self.assertEqual(self.datetime.import_data(['datetime'],
+                [['2010-01-01 12:00:00'], ['2010-01-01 13:30:00']]),
                 (2, 0, 0, 0))
 
-            self.assert_(self.datetime.import_data(['datetime'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.datetime.import_data(['datetime'],
+                [['foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -238,17 +238,17 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.selection.import_data(['selection'],
-                [['select1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.selection.import_data(['selection'],
+                [['select1']]), (1, 0, 0, 0))
 
-            self.assert_(self.selection.import_data(['selection'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.selection.import_data(['selection'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.selection.import_data(['selection'],
-                [['select1'], ['select2']]) == (2, 0, 0, 0))
+            self.assertEqual(self.selection.import_data(['selection'],
+                [['select1'], ['select2']]), (2, 0, 0, 0))
 
-            self.assert_(self.selection.import_data(['selection'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.selection.import_data(['selection'],
+                [['foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -258,29 +258,29 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.many2one.import_data(['many2one'],
-                [['Test']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2one.import_data(['many2one'],
+                [['Test']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2one.import_data(['many2one:id'],
-                [['test.import_data_many2one_target_test']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2one.import_data(['many2one:id'],
+                [['test.import_data_many2one_target_test']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2one.import_data(['many2one'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2one.import_data(['many2one'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2one.import_data(['many2one'],
-                [['Test'], ['Test']]) == (2, 0, 0, 0))
+            self.assertEqual(self.many2one.import_data(['many2one'],
+                [['Test'], ['Test']]), (2, 0, 0, 0))
 
-            self.assert_(self.many2one.import_data(['many2one'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.many2one.import_data(['many2one'],
+                [['foo']])[0], -1)
 
-            self.assert_(self.many2one.import_data(['many2one'],
-                [['Duplicate']])[0] == -1)
+            self.assertEqual(self.many2one.import_data(['many2one'],
+                [['Duplicate']])[0], -1)
 
-            self.assert_(self.many2one.import_data(['many2one:id'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.many2one.import_data(['many2one:id'],
+                [['foo']])[0], -1)
 
-            self.assert_(self.many2one.import_data(['many2one:id'],
-                [['test.foo']])[0] == -1)
+            self.assertEqual(self.many2one.import_data(['many2one:id'],
+                [['test.foo']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -290,43 +290,43 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Test 1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Test 1']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many:id'],
-                [['test.import_data_many2many_target_test1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2many.import_data(['many2many:id'],
+                [['test.import_data_many2many_target_test1']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Test 1,Test 2']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Test 1,Test 2']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many:id'],
+            self.assertEqual(self.many2many.import_data(['many2many:id'],
                 [['test.import_data_many2many_target_test1,'
-                    'test.import_data_many2many_target_test2']]) ==
+                    'test.import_data_many2many_target_test2']]),
                 (1, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Test\, comma']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Test\, comma']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Test\, comma,Test 1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Test\, comma,Test 1']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['']]) == (1, 0, 0, 0))
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['']]), (1, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Test 1'], ['Test 2']]) == (2, 0, 0, 0))
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Test 1'], ['Test 2']]), (2, 0, 0, 0))
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['foo']])[0] == -1)
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['foo']])[0], -1)
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Test 1,foo']])[0] == -1)
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Test 1,foo']])[0], -1)
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Duplicate']])[0] == -1)
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Duplicate']])[0], -1)
 
-            self.assert_(self.many2many.import_data(['many2many'],
-                [['Test 1,Duplicate']])[0] == -1)
+            self.assertEqual(self.many2many.import_data(['many2many'],
+                [['Test 1,Duplicate']])[0], -1)
 
             transaction.cursor.rollback()
 
@@ -336,15 +336,22 @@ class ImportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            self.assert_(self.one2many.import_data(['name', 'one2many/name'],
-                [['Test', 'Test 1']]) == (1, 0, 0, 0))
+            self.assertEqual(self.one2many.import_data(
+                    ['name', 'one2many/name'], [['Test', 'Test 1']]),
+                (1, 0, 0, 0))
 
-            self.assert_(self.one2many.import_data(['name', 'one2many/name'],
-                [['Test', 'Test 1'], ['', 'Test 2']]) == (1, 0, 0, 0))
+            self.assertEqual(self.one2many.import_data(
+                    ['name', 'one2many/name'], [
+                        ['Test', 'Test 1'], ['', 'Test 2']]),
+                (1, 0, 0, 0))
 
-            self.assert_(self.one2many.import_data(['name', 'one2many/name'],
-                [['Test 1', 'Test 1'], ['', 'Test 2'], ['Test 2', 'Test 1']])
-                == (2, 0, 0, 0))
+            self.assertEqual(self.one2many.import_data(
+                    ['name', 'one2many/name'],
+                    [
+                        ['Test 1', 'Test 1'],
+                        ['', 'Test 2'],
+                        ['Test 2', 'Test 1']]),
+                (2, 0, 0, 0))
 
             transaction.cursor.rollback()
 
@@ -385,10 +392,10 @@ class ImportDataTestCase(unittest.TestCase):
 
             transaction.cursor.rollback()
 
+
 def suite():
     return unittest.TestLoader().loadTestsFromTestCase(ImportDataTestCase)
 
 if __name__ == '__main__':
     suite = suite()
     unittest.TextTestRunner(verbosity=2).run(suite)
-