def test3(self):
     """
     An exception must be thrown when a stored routine with designation type singleton1 returns more than 1 values.
     @expectedException Exception
     """
     with self.assertRaises(ResultException):
         TestDataLayer.tst_test_singleton1a(2)

 def test13(self):
     """
     An exception must be thrown when a query returns more than 1 rows.
     """
     with self.assertRaises(ResultException):
         sql = 'select * from [dbo].[TST_FOO2] where tst_c00 <= 2'
         TestDataLayer.execute_row0(sql)

 def test3(self):
     """
     An exception must be thrown when a stored routine with designation type row1 returns more than 1 rows.
     @expectedException Exception
     """
     with self.assertRaises(Exception):
         TestDataLayer.tst_test_row1a(2)

 def test1(self):
     """
     Stored routine with designation type row1 must return 1 row and 1 row only.
     """
     # ???
     ret = TestDataLayer.tst_test_row1a(1)
     ret = TestDataLayer.tst_test_row1a(1)
     self.assertIsInstance(ret, dict)

    def test_argument_bit(self):
        result = TestDataLayer.tst_test_argument_bit(1)
        self.assertEqual(result, "0001")

        result = TestDataLayer.tst_test_argument_bit("110")
        self.assertEqual(result, "1100")

        result = TestDataLayer.tst_test_argument_bit("1010")
        self.assertEqual(result, "1010")

    def setUp(self):
        TestDataLayer.config['host'] = 'localhost'
        TestDataLayer.config['user'] = 'test'
        TestDataLayer.config['password'] = 'test'
        TestDataLayer.config['database'] = 'test'

        TestDataLayer.connect()

        self.held, sys.stdout = sys.stdout, StringIO()

 def test1(self):
     """
     Stored routine with designation type rows must return an empty array when no rows are selected.
     """
     ret = TestDataLayer.tst_test_rows1(0)
     self.assertIsInstance(ret, list)
     self.assertEqual(0, len(ret))

 def test3(self):
     """
     Stored routine with designation type rows must return an array with 3 rows when 3 rows are selected.
     """
     ret = TestDataLayer.tst_test_rows1(3)
     self.assertIsInstance(ret, list)
     self.assertEqual(3, len(ret))

 def test2(self):
     """
     Stored routine with designation type rows must return an array with 1 row when only 1 row is selected.
     """
     ret = TestDataLayer.tst_test_rows1(1)
     self.assertIsInstance(ret, list)
     self.assertEqual(1, len(ret))

 def test_none1(self):
     """
     SQL without selecting rows.
     """
     sql = 'insert into [TST_LABEL]([tst_test], [tst_label]) values(%s, %s)'
     ret = TestDataLayer.execute_none(sql, ('test_none1', None))
     self.assertIsNone(ret)

 def test1(self):
     """
     Stored routine with designation type singleton0 must return null.
     """
     from pystratum_test.TestDataLayer import TestDataLayer
     ret = TestDataLayer.tst_test_singleton0a(0)
     self.assertIsNone(ret)

 def test11b(self):
     """
     A query selecting 0 rows without arguments must return None.
     """
     sql = 'select * from [dbo].[TST_FOO2] where tst_c00 <= 0'
     ret = TestDataLayer.execute_row0(sql)
     self.assertIsNone(ret)

 def test11a(self):
     """
     Test with query selecting 1 row with arguments.
     """
     sql = 'select %s as "hello" from [dbo].[TST_FOO2] where tst_c00 <= %d'
     ret = TestDataLayer.execute_row1(sql, ('hello', 1))
     self.assertIsInstance(ret, dict)

 def test1(self):
     """
     Stored routine with designation type singleton1 must return 1 value and 1 value only.
     """
     from pystratum_test.TestDataLayer import TestDataLayer
     ret = TestDataLayer.tst_test_singleton1a(1)
     self.assertEqual(1, ret)

 def test2(self):
     """
     Stored routine with designation type rows_with_key must return empty array when no rows are selected.
     """
     rows = TestDataLayer.tst_test_rows_with_key1(0)
     self.assertIsInstance(rows, dict)
     self.assertEqual(0, len(rows))

 def test11a(self):
     """
     A query selecting 0 rows with arguments must return None.
     """
     sql = 'select %s as "hello" from [dbo].[TST_FOO2] where tst_c00 <= %d'
     ret = TestDataLayer.execute_row0(sql, ('hello', 0))
     self.assertIsNone(ret)

 def test11c(self):
     """
     Test with query selecting 1 row without arguments.
     """
     sql = 'select * from [dbo].[TST_FOO2] where tst_c00 <= 1'
     ret = TestDataLayer.execute_row1(sql)
     self.assertIsInstance(ret, dict)

 def test4(self):
     """
     Test constant __DIR__. Must return name of the folder where the source file of routine the is located.
     """
     dir_cur_file = os.path.dirname(os.path.abspath(__file__))
     dir_name = os.path.realpath(dir_cur_file + '/psql')
     ret = TestDataLayer.tst_magic_constant04()
     self.assertEqual(dir_name, ret)

 def test13c(self):
     """
     Test with query selecting 3 rows without arguments.
     """
     sql = 'select * from [dbo].[TST_FOO2] where [tst_c00] <= 3'
     ret = TestDataLayer.execute_rows(sql)
     self.assertIsInstance(ret, list)
     self.assertEqual(3, len(ret))

    def _test1(self):
        """
        Stored routine with designation type table must show table.
        @todo implement designation type table
        """
        template_table = """
+---------+---------+---------+---------+---------------------+------+------+
| tst_c00 | tst_c01 | tst_c02 | tst_c03 |       tst_c04       |  t   |  s   |
+---------+---------+---------+---------+---------------------+------+------+
| Hello   |       1 |   0.543 | 1.23450 | 2014-03-27 00:00:00 | 4444 |    1 |
| World   |       3 | 0.00003 | 0.00000 | 2014-03-28 00:00:00 |      |    1 |
+---------+---------+---------+---------+---------------------+------+------+
"""

        TestDataLayer.tst_test_table()
        table = sys.stdout
        self.assertEqual(table, template_table)