def test_read_output(self):
"""Test case for GetIO.read_output"""
# Define test text list
test_texts = [
"Test Text 1", "Numbers 1234",
"Special characters !@#$%^&*(){}+=-[]", "Function characters "
]
# Initiate class
iostream = GetIO()
# Iterate over test texts
for text in test_texts:
# Randomly select stderr or stdout
if random() < 0.5:
# Print test text
print(text)
else:
# Print test text to stderr
print(text, file=sys.stderr)
# Run method
res = [text for text in iostream.read_output() if text][0]
# Check function output
self.assertEqual(res, text + "\n")
# Reset stdout and stderr
sys.stdout, sys.stderr = self.default_stdout, self.default_stderr
def test_read_stderr(self):
"""Test case for GetIO.read_stderr"""
# Define test text list
test_texts = [
"Test Text 1", "Numbers 1234",
"Special characters !@#$%^&*(){}+=-[]", "Function characters "
]
# Initiate class
iostream = GetIO()
# Iterate over test texts
for text in test_texts:
# Print test text
print(text, file=sys.stderr)
# Run method
res = iostream.read_stderr()
# Check function output
self.assertEqual(res, text + "\n")
# Reset stdout and stderr
sys.stdout, sys.stderr = self.default_stdout, self.default_stderr
def test_reset_stdout_line_count(self):
"""Test case for GetIO.reset_stdout_line_count"""
# Create StringIO instance
iostream = GetIO()
# Run method
iostream.reset_stdout_line_count()
# Test function with inputs and expected outputs
self.assertEqual(iostream.stdout_line_count, 0)
# Reset stdout and stderr
sys.stdout, sys.stderr = self.default_stdout, self.default_stderr
def test_reset_output(self):
"""Test case for GetIO.reset_output"""
# Define expected result list
res_tup = (self.default_stdout, self.default_stderr, True)
# Initiate class
iostream = GetIO()
# Run method
iostream.reset_output()
# Check function output
self.assertEqual((sys.stdout, sys.stderr, iostream.reset), res_tup)
# Reset stdout and stderr
sys.stdout, sys.stderr = self.default_stdout, self.default_stderr
def test_stub_output(self):
"""Test case for GetIO.stub_output"""
# Define expected result list
res_tup = (True, True, False)
# Initiate class
iostream = GetIO()
# Run method
iostream.stub_output()
# Check function output
self.assertEqual(
(isinstance(sys.stdout, StringIO), isinstance(
sys.stderr, StringIO), iostream.reset), res_tup)
# Reset stdout and stderr
sys.stdout, sys.stderr = self.default_stdout, self.default_stderr
def test_print(self):
"""Test case for GetIO.print"""
# Define test text list
test_texts = [
"Test Text 1", "Numbers 1234",
"Special characters !@#$%^&*(){}+=-[]", "Function characters "
]
# Initiate class
iostream = GetIO()
# Iterate over test texts
for text in test_texts:
# Initiate StringIO object and stub default stdout
buffer = StringIO()
iostream.default_stdout = buffer
# Print to console
iostream.print(text)
iostream.default_stdout = self.default_stdout
# Read stdout
res = buffer.getvalue()
# Check function output
self.assertEqual((res, isinstance(sys.stdout, StringIO)),
(text + "\n", True))
# Reset stdout and stderr
sys.stdout, sys.stderr = self.default_stdout, self.default_stderr
def get_output(file_content, lang_to, outfile_name):
"""Returns PLC output for given input parameters"""
# Make new temporary file
with TemporaryFile(suffix=".py", dir=".", mode="x+") as file:
# Write test program to file
file.write("\n".join(file_content))
# Save file name
file_name = file.name
# Seek start of file
file.seek(0)
# Set file overwrite to true
overwrite = "Y"
# Make list of all inputs
input_list = [file_name, lang_to, outfile_name, overwrite]
# Make GetIO object (to stub input)
io_stream = GetIO()
# Stub input
with patch("builtins.input", side_effect=input_list):
# Stub output to StringIO
io_stream.stub_output()
try:
# Run PLC with parameters
PLC()
finally:
# Reset output to standard output
io_stream.reset_output()
# Close the file
file.close()
# Delete file after using it
# remove(file_name)
# Open output file
with open(outfile_name) as file:
# Read and return lines from output file
return [
line.strip() for line in file.readlines()
if line.strip() != ""
]
def test___init__(self):
"""Test case for GetIO.__init__"""
# Define expected result list
res_tup = (self.default_stdout, self.default_stderr, True, True, False,
0, 0)
# Initiate class
iostream = GetIO()
# Check function output
self.assertEqual(
(iostream.default_stdout, iostream.default_stderr,
isinstance(sys.stdout, StringIO), isinstance(
sys.stderr, StringIO), iostream.reset,
iostream.stdout_line_count, iostream.stderr_line_count), res_tup)
# Reset stdout and stderr
sys.stdout, sys.stderr = self.default_stdout, self.default_stderr
def test_PLC(self):
"""Tests PLC function of file PLC.py"""
# Initialize io_stream
io_stream = GetIO()
# Create valid file name set
valid_file_path = [
("test_examples/python_1.py", "python"),
("test_examples/java_1.java", "java"),
("test_examples/cpp_1.cpp", "cpp"),
("test_examples/c_1.c", "c"),
]
# Create valid languages set
valid_language = [
"JaVa",
"CpP",
"C",
"PytHOn",
]
# Create file names set (valid if language and file name match)
file_name = ["java.jaVa", "cpp.Cpp", "c.C", "python.pY"]
# Create test set with valid data
valid_test_set = []
for i in range(len(valid_file_path)):
valid_test_set.append((
valid_file_path[i][0],
valid_language[i],
file_name[i],
"{} -> {}\nFile Write SUCCESSFUL\nOutput: {}\n".format(
valid_file_path[i][1], valid_language[i].lower(),
file_name[i]),
))
# Create test set with invalid
# Create test set for file not found error
file_not_found_error = "File - {} Does not exist"
file_path_not_found_test_set = (
"test_examples/python_file_1",
"python_file_1.py",
"random_file.py",
)
# Store expected error response
file_not_found_expected_error = []
for path in file_path_not_found_test_set:
error_string = file_not_found_error.format(path)
file_not_found_expected_error.append(error_string)
# Create test set for unsupported file types
unsupported_type_error = "Unsupported file type"
unsupported_type_test_set = ("test_examples/unsupported_file.format", )
# Store expected error response
test_size = len(unsupported_type_test_set)
unsupported_type_expected_error = [unsupported_type_error] * test_size
# Create test set for unknown language
unsupported_language_error = "Unsupported language {}"
unsupported_language_test_set = (
"J.A.V.A",
"My own language",
"Ruby",
"Perl",
"Python Console",
)
# Store expected error response
unsupported_language_expected_error = []
for i, language in enumerate(unsupported_language_test_set):
error_string = unsupported_language_error.format(language)
unsupported_language_expected_error.append(error_string)
# Create test set for same from and to language file types
same_lang_error = "Language of file is same as to conversion language"
same_lang_test_set = ("python", )
# Create test set for mismatched file name
unsupported_extension_error = "Extension and language don't match"
unsupported_extension_test_set = (
"some file.random extension",
"this name is completely.insane",
file_name[3],
file_name[2],
)
# Store expected error response
test_size = len(unsupported_extension_test_set)
unsupported_extension_expected_error = ([unsupported_extension_error] *
test_size)
# Create test set for invalid file names
invalid_file_name_error = "File name must not contain '\\/:*?\"<>|'"
invalid_file_name_test_set = ("java_file/\\\"Epic:<*|*>?\".java",
"file\\my\\path:*.py")
# Store expected error response
invalid_file_name_expected_error = ([invalid_file_name_error] *
len(invalid_file_name_test_set))
# Store expected error response
test_size = len(same_lang_test_set)
same_lang_expected_error = [same_lang_error] * test_size
# Check user abort
user_abort = ("q", "User Abort")
# Add one valid test set value to let the program proceed
# Merge all invalid file path test sets
invalid_file_path_test_set = (file_path_not_found_test_set +
unsupported_type_test_set +
tuple([valid_file_path[0][0]]))
# Merge all file path related expected errors
file_path_expected_error = (file_not_found_expected_error +
unsupported_type_expected_error + [""])
# Merge all invalid language test sets
invalid_language_test_set = (unsupported_language_test_set +
same_lang_test_set +
tuple([valid_language[0]]))
# Merge all language related expected errors
language_expected_error = (unsupported_language_expected_error +
same_lang_expected_error + [""])
# Merge all invalid file name test sets
invalid_file_name_test_set = (unsupported_extension_test_set +
invalid_file_name_test_set +
tuple([file_name[0]]))
# Merge all file name related expected errors
valid_input_result = "{} -> {}\nFile Write SUCCESSFUL\nOutput: {}\n".format(
valid_file_path[0][1], valid_language[0].lower(), file_name[0])
file_name_expected_error = (unsupported_extension_expected_error +
invalid_file_name_expected_error +
[valid_input_result])
# Merge all invalid test sets
invalid_test_set = (invalid_file_path_test_set +
invalid_language_test_set +
invalid_file_name_test_set)
# Merge all expected error lists
expected_error = ("\n\n".join(file_path_expected_error) +
"\n\n".join(language_expected_error) +
"\n\n".join(file_name_expected_error))
# Run test for all tests in valid_test_set
for test in valid_test_set:
with patch('builtins.input', side_effect=test[:3]):
PLC.PLC()
self.assertEqual(io_stream.read_stdout(), test[3])
remove(test[2])
# Run test for all tests in invalid_test_set
io_stream.reset_stdout_line_count()
with patch('builtins.input', side_effect=invalid_test_set):
PLC.PLC()
self.assertEqual(io_stream.read_stdout(), expected_error)
remove(file_name[0])
# Run test for user abort function
with patch('builtins.input', return_value=user_abort[0]):
with self.assertRaises(SystemExit):
PLC.PLC()
self.assertEqual(io_stream.read_stdout(), user_abort[1])
# Reset output streams to default
io_stream.reset_output()