test-itcc

#!/usr/bin/python

# itcc - a read-eval-print loop for C/C++ programmers
#
# Copyright (C) 2009 Andy Balaam
# with python3 and tcc support by Henry Kroll III
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.

import re

import libigcc.runtcc
from libigcc.runtcc import UserInput
import libigcc.source_code
import libigcc.version

class FakeWriteableFile:
	def __init__( self ):
		self.lines = []

	def write( self, line ):
		self.lines.append( line )

class FakeReadableFile:
	def __init__( self, lines ):
		self.lines = lines

	def readline( self ):
		if len( self.lines ) == 0:
			return None
		line = self.lines[0]
		self.lines = self.lines[1:]
		return line

def assert_strings_equal( str1, str2 ):
	if str1 == str2:
		return

	raise AssertionError( "\n" + str1 + "\n!=\n" + str2 )

def assert_strings_match( string, re_string ):
	cmp_re = re.compile( re_string, re.DOTALL )

	if cmp_re.match( string ):
		return

	raise AssertionError( "\n" + string
		+ "\ndoes not match regular expression\n" + re_string )

def strip_codes(text):
	# Define the regular expression pattern to match ANSI escape codes
	ansi_escape = re.compile(r'\x1b\[[0-9;]*m')
	# Use the pattern to remove the color codes from the text
	stripped_text = ansi_escape.sub('', text)
	return stripped_text

def run_program( commands, expected_output, print_welcome = False,
		argv = None ):

	outputfile = FakeWriteableFile()
	stdinfile = FakeReadableFile( commands )
	ret = libigcc.runtcc.run( outputfile, stdinfile, print_welcome, argv )
	txt = "".join( outputfile.lines )
	assert_strings_equal( strip_codes(txt), expected_output )

	return ret

def run_program_regex_output( commands, expected_output_re ):
	outputfile = FakeWriteableFile()
	stdinfile = FakeReadableFile( commands )
	libigcc.runtcc.run( outputfile, stdinfile, False )

	assert_strings_match( "".join( outputfile.lines ), expected_output_re )

def test_print_argv():
	commands = [ "puts(argv[1]);" ]
	expected_output = 'tcc> puts(argv[1]);\nfoo\ntcc> \n'
	run_program( commands, expected_output, False, ['--', 'foo'] )

def test_declare_var():
	commands = [ "int a;" ]
	expected_output = 'tcc> int a;\ntcc> \n'
	run_program( commands, expected_output )

def test_declare_var_assign():
	commands = [ "int a;", "a = 10;" ]
	expected_output = 'tcc> int a;\ntcc> a = 10;\ntcc> \n'
	run_program( commands, expected_output )

def test_declare_and_assign_var_then_print():
	commands = [ "int a = 10;",
		r'printf( "%d\n", a );' ]

	expected_output = (
'''tcc> int a = 10;
tcc> printf( "%d\\n", a );
10
tcc> 
''' )

	run_program( commands, expected_output )


def test_print_twice():
	commands = [ "int a = 10;",
		r'printf( "%d\n", a );',
		"++a;",
		r'printf( "%d\n", a );' ]

	expected_output = (
'''tcc> int a = 10;
tcc> printf( "%d\\n", a );
10
tcc> ++a;
tcc> printf( "%d\\n", a );
11
tcc> 
''' )

	run_program( commands, expected_output )

def test_compile_error():
	commands = [ "int a" ] # no semicolon

	expected_output = (
'''tcc> int a
[Compile error - type .e to see it.]
tcc> 
''' )

	run_program( commands, expected_output )

def test_compile_error_display():
	commands = [
		"int a", # no semicolon
		".e" ]

	# Just look for a string "xpected" in the compiler output.
	expected_output_re = (
r'''.*expected.*''' )

	run_program_regex_output( commands, expected_output_re )


def test_include():
	commands = [
		'#include <glob.h>',
		'glob_t pglob;',
		'int g = glob("*.txt", 0, NULL, &pglob);',
		'for (int i=pglob.gl_pathc;i--;){ puts(pglob.gl_pathv[i]);}' ]

	expected_output = (
r'''tcc> #include <glob.h>
tcc> glob_t pglob;
tcc> int g = glob("*.txt", 0, NULL, &pglob);
tcc> for (int i=pglob.gl_pathc;i--;){ puts(pglob.gl_pathv[i]);}
README.txt
COPYING.txt
tcc> 
''' )

	run_program( commands, expected_output )

def test_multiple_repeated_includes():
	commands = [
		'#include <glob.h>',
		'glob_t pglob;',
		'int g = glob("*.txt", 0, NULL, &pglob);',
		'# include <libgen.h>',
		'puts(dirname(pglob.gl_pathv[1]));' ]

	expected_output = (
r"""tcc> #include <glob.h>
tcc> glob_t pglob;
tcc> int g = glob("*.txt", 0, NULL, &pglob);
tcc> # include <libgen.h>
tcc> puts(dirname(pglob.gl_pathv[1]));
.
tcc> 
""" )

	run_program( commands, expected_output )

def test_list_program():
	commands = [
		'int a;',
		'a += 2;',
		'#include <wctype.h>',
		'.l' ]

	expected_output = (
r'''tcc> int a;
tcc> a += 2;
tcc> #include <wctype.h>
tcc> .l
#include <wctype.h>

    int a;
    a += 2;
tcc> 
''' )

	run_program( commands, expected_output )

class FakeRunner:
	def __init__( self, user_commands_string, user_includes_string ):
		self.user_commands_string = user_commands_string
		self.user_includes_string = user_includes_string

	def get_user_commands_string( self ):
		return self.user_commands_string

	def get_user_includes_string( self ):
		return self.user_includes_string

def test_list_full_program():
	commands = [
		'int a;',
		'a += 2;',
		'#include <iconv.h>',
		'.L' ]

	fakerunner = FakeRunner( 'int a;\n	a += 2;\n',
		"#include <iconv.h>\n" )

	expected_output = (
'''tcc> int a;
tcc> a += 2;
tcc> #include <iconv.h>
tcc> .L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iconv.h>

int main(int argc, char **argv, char **env){
    int a;
    a += 2;
    return 0;
}
tcc> 
''')

	run_program( commands, expected_output )

def test_help_message():
	commands = [
		'.h' ]

	expected_output_re = ".*Show this help message"

	run_program_regex_output( commands, expected_output_re )

def test_quit():
	commands = [
		'.q' ]

	expected_output = "tcc> .q\n\n"

	ret = run_program( commands, expected_output )

	assert_strings_equal( ret, "quit" )

def test_welcome_message():
	commands = []
	expected_output = (
'''itcc $version
Released under GNU GPL version 2 or later, with NO WARRANTY.
Get tcc from https://repo.or.cz/tinycc.git
Type ".h" for help.

tcc> 
''' ).replace( "$version", libigcc.version.VERSION )

	run_program( commands, expected_output, True )

def test_include_dir_on_cmd_line():
	commands = [ '#include "hello.h"',
		'hello();' ]

	expected_output = (
'''tcc> #include "hello.h"
tcc> hello();
Hello, 
tcc> 
''' )

	argv = [ "-I", "test/cpp" ]

	run_program( commands, expected_output, argv = argv )


def test_2_include_dirs_on_cmd_line():
	commands = [ '#include "hello.h"',
		'hello();',
		'#include "world.h"',
		'world();', ]

	expected_output = (
'''tcc> #include "hello.h"
tcc> hello();
Hello, 
tcc> #include "world.h"
tcc> world();
world!
tcc> 
''' )

	argv = [ "-I", "test/cpp", "-I", "test/cpp2" ]

	run_program( commands, expected_output, argv = argv )


def test_lib():
	commands = [ '#include "math.h"',
		r'printf("2^4=%f", pow(2,4));', ]

	expected_output = (
r'''tcc> #include "math.h"
tcc> printf("2^4=%f", pow(2,4));
2^4=16.000000
tcc> 
''' )

	argv = [ "-lm" ]

	run_program( commands, expected_output, argv = argv )


def test_print_license():
	commands = [ '.c' ]

	expected_output_re = (
r'''tcc> \.c
.*GNU GENERAL PUBLIC LICENSE.*
tcc> 
''' )

	run_program_regex_output( commands, expected_output_re )



def test_print_warranty():
	commands = [ '.w' ]

	expected_output_re = (
r'''tcc> \.w
.*Disclaimer of Warranty.*
tcc> 
''' )

	run_program_regex_output( commands, expected_output_re )


def test_runner_get_user_input():
	runner = libigcc.runtcc.Runner( None, None, None, None )
	runner.user_input = [
		UserInput("0", UserInput.COMMAND),
		UserInput("1", UserInput.COMMAND),
		UserInput("2", UserInput.COMMAND) ]
	runner.input_num = 3
	assert( tuple( runner.get_user_input() ) == (
		UserInput("0", UserInput.COMMAND),
		UserInput("1", UserInput.COMMAND),
		UserInput("2", UserInput.COMMAND) ) )

	runner.input_num = 2
	assert( tuple( runner.get_user_input() ) == (
		UserInput("0", UserInput.COMMAND),
		UserInput("1", UserInput.COMMAND) ) )

	runner.input_num = 1
	assert( tuple( runner.get_user_input() ) == (
		UserInput("0", UserInput.COMMAND), ) )


def test_runner_get_user_commands():
	runner = libigcc.runtcc.Runner( None, None, None, None )
	runner.user_input = [
		UserInput("0", UserInput.COMMAND),
		UserInput("1", UserInput.COMMAND),
		UserInput("X", UserInput.INCLUDE),
		UserInput("2", UserInput.COMMAND) ]
	runner.input_num = 4
	assert( tuple( runner.get_user_commands() ) == ( "0", "1", "2" ) )

	runner.input_num = 2
	assert( tuple( runner.get_user_commands() ) == ( "0", "1" ) )

	runner.input_num = 1
	assert( tuple( runner.get_user_commands() ) == ( "0", ) )


def test_undo_1():
	commands = [
		'int a;',
		'a = 5;',
		'foobar',
		'.u',
		r'printf("%i\n",a);',
		]

	expected_output = (
r'''tcc> int a;
tcc> a = 5;
tcc> foobar
[Compile error - type .e to see it.]
tcc> .u
[Undone '    foobar'.]
tcc> printf("%i\n",a);
5
tcc> 
''' )

	run_program( commands, expected_output )


def test_undo_2():
	commands = [
		'int a = 5;',
		'++a;',
		'++a;',
		'++a;',
		'.u',
		'.u',
		r'printf("%i\n",a);',
		]

	expected_output = (
r'''tcc> int a = 5;
tcc> ++a;
tcc> ++a;
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> .u
[Undone '    ++a;'.]
tcc> printf("%i\n",a);
6
tcc> 
''' )

	run_program( commands, expected_output )


def test_undo_before_beginning():
	commands = [
		'int a = 5;',
		'.u',
		'.u',
		'.u',
		r'printf("%i\n",a);',
		'.u',
		'int b = 7;',
		r'printf("%i\n",b);',
		]

	expected_output = (
r'''tcc> int a = 5;
tcc> .u
[Undone '    int a = 5;'.]
tcc> .u
[Nothing to undo.]
tcc> .u
[Nothing to undo.]
tcc> printf("%i\n",a);
[Compile error - type .e to see it.]
tcc> .u
[Undone '    printf("%i\n",a);'.]
tcc> int b = 7;
tcc> printf("%i\n",b);
7
tcc> 
''' )

	run_program( commands, expected_output )


def test_undo_includes_and_commands():
	commands = [
		'int a = 5;',
		'#include <unistd.h>',
		'++a;',
		'.u',
		'.u',
		'.u',
		]

	expected_output = (
r'''tcc> int a = 5;
tcc> #include <unistd.h>
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> .u
[Undone '#include <unistd.h>'.]
tcc> .u
[Undone '    int a = 5;'.]
tcc> 
''' )

	run_program( commands, expected_output )


def test_redo_1():
	commands = [
		'int a = 1;',
		'++a;',
		'.u',
		'.r',
		r'printf("%i\n",a);',
		]

	expected_output = (
r'''tcc> int a = 1;
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> .r
[Redone '    ++a;'.]
tcc> printf("%i\n",a);
2
tcc> 
''' )

	run_program( commands, expected_output )




def test_redo_2():
	commands = [
		'int a = 1;',
		'++a;',
		'.u',
		'.u',
		'.r',
		'.r',
		r'printf("%i\n",a);',
		]

	expected_output = (
r'''tcc> int a = 1;
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> .u
[Undone '    int a = 1;'.]
tcc> .r
[Redone '    int a = 1;'.]
tcc> .r
[Redone '    ++a;'.]
tcc> printf("%i\n",a);
2
tcc> 
''' )

	run_program( commands, expected_output )




def test_redo_before_beginning():
	commands = [
		'int a = 1;',
		'++a;',
		'.u',
		'.u',
		'.u',
		'.r',
		'.r',
		r'printf("%i\n",a);',
		]

	expected_output = (
r'''tcc> int a = 1;
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> .u
[Undone '    int a = 1;'.]
tcc> .u
[Nothing to undo.]
tcc> .r
[Redone '    int a = 1;'.]
tcc> .r
[Redone '    ++a;'.]
tcc> printf("%i\n",a);
2
tcc> 
''' )

	run_program( commands, expected_output )



def test_redo_after_end():
	commands = [
		'int a = 1;',
		'++a;',
		'.u',
		'.r',
		'.r',
		r'printf("%i\n",a);',
		]

	expected_output = (
r'''tcc> int a = 1;
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> .r
[Redone '    ++a;'.]
tcc> .r
[Nothing to redo.]
tcc> printf("%i\n",a);
2
tcc> 
''' )

	run_program( commands, expected_output )


def test_redo_includes_and_commands():
	commands = [
		'int a = 5;',
		'#include <unistd.h>',
		'++a;',
		'.u',
		'.u',
		'.u',
		'.r',
		'.r',
		'.r',
		]

	expected_output = (
r'''tcc> int a = 5;
tcc> #include <unistd.h>
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> .u
[Undone '#include <unistd.h>'.]
tcc> .u
[Undone '    int a = 5;'.]
tcc> .r
[Redone '    int a = 5;'.]
tcc> .r
[Redone '#include <unistd.h>'.]
tcc> .r
[Redone '    ++a;'.]
tcc> 
''' )

	run_program( commands, expected_output )


def test_undo_then_new_commands():
	commands = [
		'int a = 5;',
		'++a;',
		'.u',
		'--a;',
		'--a;',
		'.u',
		r'printf("%i\n",a);',
		]

	expected_output = (
r'''tcc> int a = 5;
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> --a;
tcc> --a;
tcc> .u
[Undone '    --a;'.]
tcc> printf("%i\n",a);
4
tcc> 
''' )

	run_program( commands, expected_output )


def test_undo_redo_with_output():
	commands = [
		'int a = 56;',
		r'printf("%i\n",a);',
		'.u',
		'.r',
		'.u',
		r'printf("%i\n",12);',
		]

	expected_output = (
r'''tcc> int a = 56;
tcc> printf("%i\n",a);
56
tcc> .u
[Undone '    printf("%i\n",a);'.]
tcc> .r
[Redone '    printf("%i\n",a);'.]
56
tcc> .u
[Undone '    printf("%i\n",a);'.]
tcc> printf("%i\n",12);
12
tcc> 
''' )

	run_program( commands, expected_output )



def test_print_stderr_twice():
	commands = [ "int a = 10;",
		r'fprintf(stderr, "%i\n", a);',
		"++a;",
		r'fprintf(stderr, "%i\n", a);' ]

	expected_output = (
'''tcc> int a = 10;
tcc> fprintf(stderr, "%i\\n", a);
10
tcc> ++a;
tcc> fprintf(stderr, "%i\\n", a);
11
tcc> 
''' )

	run_program( commands, expected_output )


def test_print_stderr_stdout():
	commands = [ "int a = 10;",
		r'fprintf(stderr, "%i\n", a);',
		"++a;",
		r'printf("%i\n",a);' ]

	expected_output = (
'''tcc> int a = 10;
tcc> fprintf(stderr, "%i\\n", a);
10
tcc> ++a;
tcc> printf("%i\\n",a);
11
tcc> 
''' )

	run_program( commands, expected_output )


def test_undo_stderr_then_new_commands():
	commands = [
		'int a = 5;',
		'++a;',
		'.u',
		'--a;',
		'--a;',
		'.u',
		r'fprintf(stderr, "%i\n", a);',
		]

	expected_output = (
r'''tcc> int a = 5;
tcc> ++a;
tcc> .u
[Undone '    ++a;'.]
tcc> --a;
tcc> --a;
tcc> .u
[Undone '    --a;'.]
tcc> fprintf(stderr, "%i\n", a);
4
tcc> 
''' )

	run_program( commands, expected_output )


def main():
	test_print_argv()
	test_declare_var()
	test_declare_var_assign()
	test_declare_and_assign_var_then_print()
	test_print_twice()
	test_compile_error()
	test_compile_error_display()
	test_include()
	test_multiple_repeated_includes()
	test_list_program()
	test_list_full_program()
	test_help_message();
	test_quit()
	test_welcome_message()
	test_include_dir_on_cmd_line()
	test_2_include_dirs_on_cmd_line()
	test_lib()
	test_print_license()
	test_print_warranty()
	test_runner_get_user_input()
	test_runner_get_user_commands()
	test_undo_1()
	test_undo_2()
	test_undo_before_beginning()
	test_undo_includes_and_commands()
	test_redo_1()
	test_redo_2()
	test_redo_before_beginning()
	test_redo_after_end()
	test_redo_includes_and_commands()
	test_undo_then_new_commands()
	test_undo_redo_with_output()
	test_print_stderr_twice()
	test_print_stderr_stdout()
	test_undo_stderr_then_new_commands()

	#test_readline_history();
	#test_print_command();
	#test_edit_in_vim();
	#test_compile_warning()
	#test_remove_compile_error_message()

	print("All tests passed.")


if __name__ == "__main__":
	main()