def test_passthrough(self):
     src = """
     def test():
         x = __pydron_new_cell__('x')
         x.cell_contents = 42
         class X(object):
             def foo__U0(x, self):
                   print x.cell_contents
             foo = __pydron_wrap_closure__(foo__U0, (x__P1,))
             __pydron_members__ = 123
                 
     """
     expected = """
     def test():
         x = __pydron_new_cell__('x')
         x.cell_contents = 42
         def class_X__U0(x__P1):
             def foo__U0(x, self):
                   print x.cell_contents
             foo = __pydron_wrap_closure__(foo__U0, (x__P1,))
             __pydron_members__ = 123
             return __pydron_members__
         X = __pydron_read_global__('type')('X', (object,), class_X__U0(x))
     """
     utils.compare(src, expected, declass.DeClass)

 def testModImport(self):
     src = """
     import x
     """
     expected = """
     x = __import__('x', globals(), None, None)
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportAlias(self):
     src = """
     import x as y
     """
     expected = """
     y = __import__('x', globals(), None, None)
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportNested(self):
     src = """
     import x.y
     """
     expected = """
     x = __import__('x.y', globals(), None, None)
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportFromPureRelative(self):
     src = """
     from . import y
     """
     expected = """
     module__U0 = __import__(None, globals(), None, ('y',), 1)
     y = module__U0.y
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportFromRelative2(self):
     src = """
     from ..x import y
     """
     expected = """
     module__U0 = __import__('x', globals(), None, ('y',), 2)
     y = module__U0.y
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportFromAs(self):
     src = """
     from x import y as z
     """
     expected = """
     module__U0 = __import__('x', globals(), None, ('y',))
     z = module__U0.y
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportFromNested(self):
     src = """
     from a.b.c import y
     """
     expected = """
     module__U0 = __import__('a.b.c', globals(), None, ('y',))
     y = module__U0.y
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportMultiple(self):
     src = """
     import x, y
     """
     expected = """
     x = __import__('x', globals(), None, None)
     y = __import__('y', globals(), None, None)
     """
     utils.compare(src, expected, deimport.DeImport)

 def testImportFromStar(self):
     src = """
     from x import *
     """
     expected = """
     module__U0 = __import__('x', globals(), None, ('*',))
     for module_element__U0 in getattr(module__U0, '__all__', dir(module__U0)):
         globals()[module_element__U0] = getattr(module__U0, module_element__U0)
     """
     utils.compare(src, expected, deimport.DeImport)

 def test_parameter(self):
     src = """
     def test(x):
         pass
     """
     expected = """
     def test(x):
         pass
     """
     utils.compare(src, expected, deunbound.DeUnbound)

 def testImportFromMultiple(self):
     src = """
     from x import y, z
     """
     expected = """
     module__U0 = __import__('x', globals(), None, ('y', 'z'))
     y = module__U0.y
     z = module__U0.z
     """
     utils.compare(src, expected, deimport.DeImport)

    def test_compare(self):
        """ Tests the compare funciton """

        a, b = "test123", "test123"
        compare_result_true = compare(a, b)
        self.assertTrue(compare_result_true)

        a, b = "test123", "test456"
        compare_result_false = compare(a, b)
        self.assertFalse(compare_result_false)

 def test_builtin(self):
     src = """
     def test():
         globals()
     """
     expected = """
     def test():
         __pydron_read_global__('globals')()
     """
     utils.compare(src, expected, deglobal.DeGlobal)

 def test_read_implicit(self):
     src = """
     def test():
         print x
     """
     expected = """
     def test():
         print __pydron_read_global__('x')
     """
     utils.compare(src, expected, deglobal.DeGlobal)

 def test_False(self):
     src = """
     def test():
         return None
     """
     expected = """
     def test():
         return None
     """
     utils.compare(src, expected, deglobal.DeGlobal)

    def step_statictics(simu, network, plot, inputs, outputs):
        entire_FoN = inputs + network["FoN"].stateHiddenNeurons + network["FoN"].stateOutputNeurons
        entire_FoN2 = inputs + network["FoN2"].stateHiddenNeurons + network["FoN2"].stateOutputNeurons

        lin = simu.examples.ninputs
        lhi = lin + lin // 4
        lout = lhi + simu.examples.noutputs

        # rms
        simu.rms("FoN", inputs, outputs)
        simu.rms("SoN", network["FoN"].stateHiddenNeurons, entire_FoN)

        plot["SoN_rms_input"] += (
            network["SoN"].calc_RMS_range(network["FoN"].stateHiddenNeurons, entire_FoN, 0, lin) / lout * (lin - 0)
        )
        plot["SoN_rms_hidden"] += (
            network["SoN"].calc_RMS_range(network["FoN"].stateHiddenNeurons, entire_FoN, lin, lhi) / lout * (lhi - lin)
        )
        plot["SoN_rms_output"] += (
            network["SoN"].calc_RMS_range(network["FoN"].stateHiddenNeurons, entire_FoN, lhi, lout)
            / lout
            * (lout - lhi)
        )

        simu.rms("FoN2", inputs, outputs)
        simu.rms("SoN2", network["FoN2"].stateHiddenNeurons, entire_FoN2)

        plot["SoN2_rms_input"] += (
            network["SoN2"].calc_RMS_range(network["FoN2"].stateHiddenNeurons, entire_FoN2, 0, lin) / lout * (lin - 0)
        )
        plot["SoN2_rms_hidden"] += (
            network["SoN2"].calc_RMS_range(network["FoN2"].stateHiddenNeurons, entire_FoN2, lin, lhi)
            / lout
            * (lhi - lin)
        )
        plot["SoN2_rms_output"] += (
            network["SoN2"].calc_RMS_range(network["FoN2"].stateHiddenNeurons, entire_FoN2, lhi, lout)
            / lout
            * (lout - lhi)
        )

        # err
        simu.err("FoN", outputs)
        plot["SoN_err_input"] += 1 - compare(inputs, network["SoN"].stateOutputNeurons[0:lin])
        if not compare_f(network["FoN"].stateHiddenNeurons, network["SoN"].stateOutputNeurons[lin:lhi], 0.3):
            plot["SoN_err_hidden"] += 1
        if index_max(network["SoN"].stateOutputNeurons[lhi:lout]) != index_max(network["FoN"].stateOutputNeurons):
            plot["SoN_err_output"] += 1

        simu.err("FoN2", outputs)
        plot["SoN2_err_input"] += 1 - compare(inputs, network["SoN2"].stateOutputNeurons[0:lin])
        if not compare_f(network["FoN2"].stateHiddenNeurons, network["SoN2"].stateOutputNeurons[lin:lhi], 0.3):
            plot["SoN2_err_hidden"] += 1
        if index_max(network["SoN"].stateOutputNeurons[lhi:lout]) != index_max(network["FoN2"].stateOutputNeurons):
            plot["SoN2_err_output"] += 1

 def test_None(self):
     src = """
     def test():
         x = None
     """
     expected = """
     def test():
         x = __pydron_unbound__
         x = None
     """
     utils.compare(src, expected, deunbound.DeUnbound)

 def test_assignment(self):
     src = """
     def test():
         x = 1
     """
     expected = """
     def test():
         x = __pydron_unbound__
         x = 1
     """
     utils.compare(src, expected, deunbound.DeUnbound)

 def test_delete(self):
     src = """
     def test():
         global x
         del x
     """
     expected = """
     def test():
         __pydron_delete_global__('x')
     """
     utils.compare(src, expected, deglobal.DeGlobal)