def test_ProgramGenerator__create_program():
    msg = ''' Test ProgramGenerator.create_program: 
    Just see if function does not crash.
    '''
    #py.test.skip(msg)
    print msg
    
    from freeode.pygenerator import ProgramGenerator
    from freeode.interpreter import Interpreter
    
    prog_text = \
'''
class A:
    data a: Float
    data b: Float param
    
    func initialize(this):
        b = 1
    
    func dynamic(this):
        $a = b
    
compile A
'''
    
    #interpret the compile time code
    intp = Interpreter()
    intp.interpret_module_string(prog_text, 'foo.siml', '__main__')
    #create the output text
    pg = ProgramGenerator()
    pg.create_program('foo.siml', intp.get_compiled_objects())
    print pg.get_buffer()
예제 #2
0
def test_ProgramGenerator__create_program_2():
    msg = \
    ''' 
    Test ProgramGenerator.create_program: 
    Test program with additional initialization function.
    Load program as module and test init_*** function.
    '''
    #skip_test(msg)
    print msg
    
    import os
    from freeode.pygenerator import ProgramGenerator
    from freeode.interpreter import Interpreter
    
    prog_text = \
'''
class A:
    data x: Float 
    data b: Float param
    
    #This is the additional initialization function.
    func init_b(this, in_b):
        b = in_b #set parameter
        x = 0    #set initial value
                                                       #10     
    func initialize(this):
        b = 0.1 #set parameter
        x = 0   #set initial value
        
    func dynamic(this):
        $x = b
        
compile A
'''
    
    #interpret the compile time code
    intp = Interpreter()
    intp.interpret_module_string(prog_text, 'foo.siml', '__main__')
    #create the output text
    pg = ProgramGenerator()
    pg.create_program('foo.siml', intp.get_compiled_objects())
    #print pg.get_buffer()
    
    #write the buffer into a file, import the file as a module
    progname = 'testprog_ProgramGenerator__create_program_2'
    prog_text_file = open(progname + '.py','w')
    prog_text_file.write(pg.get_buffer())
    prog_text_file.close()
    module = __import__(progname)
    
    #test the generated module
    A = module.A
    a = A()
    #call generated init_b(...) function
    a.init_b(42)
    assert a.param.b == 42
    
    #clean up
    os.remove(progname + '.py')
    os.remove(progname + '.pyc')
예제 #3
0
def test_ProgramGenerator__create_program_1():
    msg = \
    ''' 
    Test ProgramGenerator.create_program: 
    Test basic functions of the compiler. Loads generated program as module.
    '''
    #skip_test(msg)
    print msg
    
    import os
    from freeode.pygenerator import ProgramGenerator
    from freeode.interpreter import Interpreter
    
    prog_text = \
'''
class A:
    data x: Float
    data b: Float param
    
    func initialize(this):
        x = 0
        b = 1
        solution_parameters(duration = 30, reporting_interval = 0.1)
    
    func dynamic(this):
        $x = b
    
compile A
'''
    
    #interpret the compile time code
    intp = Interpreter()
    intp.interpret_module_string(prog_text, 'foo.siml', '__main__')
    #create the output text
    pg = ProgramGenerator()
    pg.create_program('foo.siml', intp.get_compiled_objects())
    #print pg.get_buffer()
    
    #write the buffer into a file, import the file as a module
    progname = 'testprog_ProgramGenerator__create_program_1'
    prog_text_file = open(progname + '.py','w')
    prog_text_file.write(pg.get_buffer())
    prog_text_file.close()
    module = __import__(progname)
    
    #test the generated module
    A = module.A
    a = A()
    #call generated initialize(...) function
    a.initialize()
    assert a.param.b == 1
    #solve (trivial) ODE and test solution
    a.simulateDynamic()
    x_vals = a.getResults()['x']
    assert abs(x_vals[-1] - 30) < 1e-6
    
    #clean up
    os.remove(progname + '.py')
    os.remove(progname + '.pyc')
def test_ProgramGenerator__write_program_start():
    msg = ''' Test ProgramGenerator.write_program_start: 
    Just see if function does not crash.
    '''
    #py.test.skip(msg)
    print msg
    from freeode.pygenerator import ProgramGenerator
    
    pg = ProgramGenerator()
    pg.write_program_start()
    print pg.get_buffer()
def test_ProgramGenerator__write_program_end():
    msg = ''' Test ProgramGenerator.write_program_end: 
    Just see if function does not crash.
    '''
    #py.test.skip(msg)
    print msg
    from freeode.pygenerator import ProgramGenerator
    
    pg = ProgramGenerator()
    pg.simulation_class_names = ['Foo', 'Bar']
    pg.write_program_end()
    print pg.get_buffer()
def test_ProgramGenerator__create_program_3():
    msg = \
    ''' 
    Test ProgramGenerator.create_program: 
    Test most common language features.
    '''
    #py.test.skip(msg)
    print msg
    
    import os
    from freeode.pygenerator import ProgramGenerator
    from freeode.interpreter import Interpreter
    
    prog_text = \
'''
class A:
    data x: Float 
    data a, b, c, d, e: Float param

    func initialize(this):
        a = 2 * (3 + 4)               # = 14, test brackets
        b = a**0 / 0.1 % 9 - -a/a  # = 2, arithmetic operators
        
        #if statement should reduce to single assignment
        if -2**-3 == -(2 ** (-3)):    # tricky operator precedence
            c = 1                     # c = 1
        else:
            c = 0
        
        #if statement, comparison and logical operators
        if (a != 1 and not a == 1 or a == 1) and (a < 1 or a > 1):
            d = 1                     # d = 1
            e = sin(d * 3.1415)       # close to 0 #test function call
        else:
            d = 0
            e = sin(d * 3.1415)       # = 0  #test function call
            
        x = 0   #set initial value
        
    func dynamic(this):
        $x = b
        
compile A
'''
    
    #interpret the compile time code
    intp = Interpreter()
    intp.interpret_module_string(prog_text, 'foo.siml', '__main__')
    #create the output text
    pg = ProgramGenerator()
    pg.create_program('foo.siml', intp.get_compiled_objects())
    print pg.get_buffer()
    
    #write the buffer into a file, import the file as a module
    #progname must be unique! otherwise race condition!
    progname = 'testprog_ProgramGenerator__create_program_3'
    prog_text_file = open(progname + '.py','w')
    prog_text_file.write(pg.get_buffer())
    prog_text_file.close()
    module = __import__(progname)
    
    #test the generated module
    A = module.A
    a = A()
    #call generated init_b(...) function
    a.initialize()
    assert a.param.a == 14
    assert a.param.b == 2
    assert a.param.c == 1
    assert a.param.d == 1
    assert abs(a.param.e) < 0.001 #close to 0 
    
    #clean up
    os.remove(progname + '.py')
예제 #7
0
def test_ProgramGenerator__all_variables_visible():
    msg = \
    ''' 
    Tests if all variables are visible in all main functions.
    Especially tests for existence an correct treatment of the variable 'time'.
    Runs the generated program as an external program.
    
    References:
    Fixed bug #598632
        https://bugs.launchpad.net/freeode/+bug/598632
    Blueprint:
        https://blueprints.launchpad.net/freeode/+spec/final-main-function-specification
    '''
    #skip_test(msg)
    print msg
    
    import os
    from subprocess import Popen, PIPE
    from freeode.pygenerator import ProgramGenerator
    from freeode.interpreter import Interpreter
    
    prog_text = \
'''
class A:
    data x: Float
    data b: Float param
    
    func initialize(this):
        x = 0
        b = 1
        solution_parameters(duration = 30, reporting_interval = 0.1)
        print("initial-values: ", b, x, $x, time)
    
    func dynamic(this):
        $x = b
        if abs(x - time) > 1e-6:
            print('dynamic-error: x = ', x, ', time = ', time)
        else:
            pass
    
    func final(this):
        print("final-values: ", b, x, $x, time)
compile A
'''
    
    #interpret the compile time code
    intp = Interpreter()
    intp.interpret_module_string(prog_text, '--no-file-name--', '__main__')
    #create the output text
    pg = ProgramGenerator()
    pg.create_program('foo.siml', intp.get_compiled_objects())
    #print pg.get_buffer()
    
    #write the buffer into a file
    progname = 'prog_test_ProgramGenerator__all_variables_visible'
    prog_text_file = open(progname + '.py','w')
    prog_text_file.write(pg.get_buffer())
    prog_text_file.close()
    
    #run the generated program
    sim = Popen('python ' + progname + '.py', shell=True, stdout=PIPE)
    res_txt, _ = sim.communicate()
#    print 'Program output: \n', res_txt     
#    print  'Return code: ', sim.returncode
    #the program must say that it terminated successfully
    assert sim.returncode == 0

    #TODO: do the following with search_result_lines
    #Scan the program's output to check if it's working.
    init_vals, final_vals = [], []
    dyn_error = False
    for line in res_txt.split('\n'):
        if line.startswith('initial-values:'):
            vals = line.split()[1:]
            init_vals = map(float, vals)
        elif line.startswith('final-values:'):
            vals = line.split()[1:]
            final_vals = map(float, vals)
        elif line.startswith('dynamic-error:'):
            dyn_error = True
        
    #Test if the values that the program returns are correct
    b, x, d_x, time = init_vals
    assert b == 1 and x == 0 and d_x == 0 and time == 0
    b, x, d_x, time = final_vals
    assert b == 1 and x == 30 and d_x == 0 and time == 30
    assert dyn_error == False, 'Error in dynamic function detected'
    
    #clean up
    os.remove(progname + '.py')