You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
941 lines
34 KiB
941 lines
34 KiB
#!/usr/bin/python
|
|
|
|
"""
|
|
test_cli_options.py
|
|
|
|
Tests output generated by Uncrustifys commandline options
|
|
(excluding actual source code formatting)
|
|
|
|
:author: DanielChumak
|
|
:license: GPL v2+
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
import sys
|
|
from sys import stderr, argv, exit as sys_exit
|
|
from os import makedirs, remove, name as os_name
|
|
from os.path import dirname, relpath, abspath, isdir, isfile, join as path_join, split as path_split
|
|
from shutil import rmtree, copyfile
|
|
from subprocess import Popen, PIPE
|
|
from io import open
|
|
from datetime import date
|
|
import re
|
|
import difflib
|
|
import argparse
|
|
import pprint
|
|
#import traceback
|
|
|
|
if os_name == 'nt':
|
|
EX_OK = 0
|
|
EX_USAGE = 64
|
|
EX_SOFTWARE = 70
|
|
NULL_DEVICE = 'nul'
|
|
else:
|
|
from os import EX_OK, EX_USAGE, EX_SOFTWARE
|
|
NULL_DEVICE = '/dev/null'
|
|
|
|
RE_CALLSTACK = r'\[CallStack:( \w+:\w+(, \w+:\w+)*|-DEBUG NOT SET-)?\]'
|
|
RE_DO_SPACE = (r'\n\ndo_space : WARNING: unrecognized do_space:'
|
|
r'\n[^\n]+\n[^\n]+\n')
|
|
|
|
|
|
def eprint(*args, **kwargs):
|
|
"""
|
|
print() wrapper that sets file=stderr
|
|
"""
|
|
print(*args, file=stderr, **kwargs)
|
|
|
|
|
|
def decode_out(text):
|
|
text = text.decode('utf-8')
|
|
text = text.replace(u'\r\n', u'\n')
|
|
text = text.replace(u'\r', u'\n')
|
|
return text
|
|
|
|
|
|
def proc(bin_path, args_arr=()):
|
|
"""
|
|
simple Popen wrapper to return std out/err utf8 strings
|
|
|
|
|
|
Parameters
|
|
----------------------------------------------------------------------------
|
|
:param bin_path: string
|
|
path to the binary that is going to be called
|
|
|
|
:param args_arr : list/tuple
|
|
all needed arguments
|
|
|
|
|
|
:return: string, string
|
|
----------------------------------------------------------------------------
|
|
generated output of both stdout and stderr
|
|
|
|
>>> proc("echo", "test")
|
|
'test'
|
|
"""
|
|
if not isfile(bin_path):
|
|
eprint("bin 1 is not a file: %s" % bin_path)
|
|
return False
|
|
|
|
# call uncrustify, hold output in memory
|
|
call_arr = [bin_path]
|
|
call_arr.extend(args_arr)
|
|
proc = Popen(call_arr, stdout=PIPE, stderr=PIPE)
|
|
|
|
out_txt, err_txt = proc.communicate()
|
|
|
|
return decode_out(out_txt), decode_out(err_txt)
|
|
|
|
|
|
def write_to_output_path(output_path, result_str):
|
|
"""
|
|
writes the contents of result_str to the output path
|
|
"""
|
|
print("Auto appending differences to: " + output_path)
|
|
|
|
'''
|
|
newline = None: this outputs \r\n
|
|
newline = "\r": this outputs \r
|
|
newline = "\n": this outputs \n
|
|
newline = "" : this outputs \n
|
|
For the sake of consistency, all newlines are now being written out as \n
|
|
However, if the result_str itself contains \r\n, then \r\n will be output
|
|
as this code doesn't post process the data being written out
|
|
'''
|
|
with open(output_path, 'w', encoding="utf-8", newline="\n") as f:
|
|
f.write(result_str)
|
|
|
|
|
|
def get_file_content(fp):
|
|
"""
|
|
returns file content as an utf8 string or None if fp is not a file
|
|
|
|
|
|
Parameters
|
|
----------------------------------------------------------------------------
|
|
:param fp: string
|
|
path of the file that will be read
|
|
|
|
|
|
:return: string or None
|
|
----------------------------------------------------------------------------
|
|
the file content
|
|
|
|
"""
|
|
#print("3-1: fp is "+fp)
|
|
#print("3-1b: gen_result_path is "+gen_result_path)
|
|
out = None
|
|
|
|
if isfile(fp):
|
|
#print("A: "+abspath(fp))
|
|
#print("2a is a file: %s" % fp)
|
|
with open(fp, encoding="utf-8", newline="\n") as f:
|
|
out = f.read()
|
|
#else:
|
|
#print("B: "+abspath(fp))
|
|
#print("2bx is Not a file: %s" % fp)
|
|
#for line in traceback.format_stack():
|
|
# print(line.strip())
|
|
#print("2bx+ is Not a file: %s" % fp)
|
|
|
|
return out
|
|
|
|
|
|
def check_generated_output(gen_expected_path, gen_result_path,
|
|
result_manip=None, program_args=None):
|
|
"""
|
|
compares the content of two files,
|
|
|
|
is intended to compare a file that was generated during a call of Uncrustify
|
|
with a file that has the expected content
|
|
|
|
|
|
Parameters
|
|
----------------------------------------------------------------------------
|
|
:param gen_expected_path: string
|
|
path to a file that will be compared with the generated file
|
|
|
|
:param gen_result_path: string
|
|
path to the file that will be generated by Uncrustify
|
|
|
|
:param result_manip: lambda OR list or tuple of lambdas
|
|
optional lambda function(s) that will be applied (before the comparison)
|
|
on the content of the generated file,
|
|
the lambda function(s) should accept one string parameter
|
|
|
|
:param program_args: tuple of options
|
|
a collection of multiple options used to add extra functionality to the
|
|
script (i.e. auto apply changes or show diffs on command line)
|
|
|
|
:return: bool
|
|
----------------------------------------------------------------------------
|
|
True or False depending on whether both files have the same content
|
|
|
|
>>> check_generated_output("/dev/null", "/dev/null")
|
|
True
|
|
"""
|
|
|
|
#print("2-1: gen_expected_path is "+gen_expected_path)
|
|
#print("2-2: gen_result_path is "+gen_result_path)
|
|
gen_exp_txt = get_file_content(gen_expected_path)
|
|
#print("2-3: gen_exp_txt is ")
|
|
#+gen_exp_txt)
|
|
if gen_exp_txt is None:
|
|
return False
|
|
|
|
gen_res_txt = get_file_content(gen_result_path)
|
|
#print("2-4: gen_res_txt is "+gen_res_txt)
|
|
if gen_res_txt is None:
|
|
return False
|
|
|
|
#print("2: result_manip is "+result_manip)
|
|
#if result_manip is not None:
|
|
# print("2-5: result_manip is "+result_manip)
|
|
#else:
|
|
# print("2-6: result_manip is None")
|
|
if result_manip is not None:
|
|
if type(result_manip) is list or type(result_manip) is tuple:
|
|
for m in result_manip:
|
|
gen_res_txt = m(gen_res_txt)
|
|
else:
|
|
gen_res_txt = result_manip(gen_res_txt)
|
|
|
|
#print("2-7: gen_res_txt is ")
|
|
#print(gen_res_txt)
|
|
#print("2-8: gen_exp_txt is ")
|
|
#print(gen_exp_txt)
|
|
if gen_res_txt != gen_exp_txt:
|
|
with open(gen_result_path, 'w', encoding="utf-8", newline="") as f:
|
|
f.write(gen_res_txt)
|
|
|
|
if program_args.apply and program_args.auto_output_path:
|
|
write_to_output_path(program_args.auto_output_path, gen_res_txt)
|
|
return True
|
|
elif program_args.diff:
|
|
print("\n************************************")
|
|
print("Problem (1) with %s" % gen_result_path)
|
|
print("************************************")
|
|
|
|
file_diff = difflib.ndiff(gen_res_txt.splitlines(False),
|
|
gen_exp_txt.splitlines(False))
|
|
|
|
for line in file_diff:
|
|
pprint.PrettyPrinter(indent=4, width=280).pprint(line)
|
|
|
|
return False
|
|
else:
|
|
print("\nProblem (2) with %s" % gen_result_path)
|
|
print("use(gen): '--diff' to find out why %s %s are different"
|
|
% (gen_result_path, gen_expected_path))
|
|
return False
|
|
|
|
remove(gen_result_path)
|
|
#print(abspath(gen_result_path))
|
|
|
|
return True
|
|
|
|
|
|
def check_std_output(expected_path, result_path, result_str, result_manip=None,
|
|
program_args=None):
|
|
"""
|
|
compares output generated by Uncrustify (std out/err) with a the content of
|
|
a file
|
|
|
|
Parameters
|
|
----------------------------------------------------------------------------
|
|
:param expected_path: string
|
|
path of the file that will be compared with the output of Uncrustify
|
|
|
|
:param result_path: string
|
|
path to which the Uncrustifys output will be saved in case of a mismatch
|
|
|
|
:param result_str: string (utf8)
|
|
the output string generated by Uncrustify
|
|
|
|
:param result_manip: lambda OR list or tuple of lambdas
|
|
see result_manip for check_generated_output
|
|
|
|
:param program_args: tuple of options
|
|
a collection of multiple options used to add extra functionality to the
|
|
script (i.e. auto apply changes or show diffs on command line)
|
|
|
|
:return: bool
|
|
----------------------------------------------------------------------------
|
|
True or False depending on whether both files have the same content
|
|
|
|
"""
|
|
exp_txt = get_file_content(expected_path)
|
|
if exp_txt is None:
|
|
return False
|
|
|
|
if result_manip is not None:
|
|
if type(result_manip) is list or type(result_manip) is tuple:
|
|
for m in result_manip:
|
|
result_str = m(result_str)
|
|
else:
|
|
result_str = result_manip(result_str)
|
|
|
|
if result_str != exp_txt:
|
|
with open(result_path, 'w', encoding="utf-8", newline="\n") as f:
|
|
f.write(result_str)
|
|
|
|
if program_args.apply and program_args.auto_output_path:
|
|
write_to_output_path(program_args.auto_output_path, result_str)
|
|
return True
|
|
|
|
if program_args.diff:
|
|
print("\n************************************")
|
|
print("Problem (3) with result_path is %s" % result_path)
|
|
print(" expected_path is %s" % expected_path)
|
|
print("************************************")
|
|
|
|
file_diff = difflib.ndiff(result_str.splitlines(False),
|
|
exp_txt.splitlines(False))
|
|
|
|
"""
|
|
change the value of width
|
|
look at: If compact is false (the default)...
|
|
"""
|
|
for line in file_diff:
|
|
pprint.PrettyPrinter(indent=4, width=280).pprint(line)
|
|
else:
|
|
print("\nProblem (4) with %s" % result_path)
|
|
print("use: '--diff' to find out why %s %s are different"
|
|
% (result_path, expected_path))
|
|
return False
|
|
return True
|
|
|
|
|
|
def check_uncrustify_output(
|
|
uncr_bin,
|
|
program_args,
|
|
args_arr=(),
|
|
out_expected_path=None, out_result_manip=None, out_result_path=None,
|
|
err_expected_path=None, err_result_manip=None, err_result_path=None,
|
|
gen_expected_path=None, gen_result_manip=None, gen_result_path=None):
|
|
"""
|
|
compares outputs generated by Uncrustify with files
|
|
|
|
Parameters
|
|
----------------------------------------------------------------------------
|
|
:param uncr_bin: string
|
|
path to the Uncrustify binary
|
|
|
|
:param program_args: tuple of options
|
|
a collection of multiple options used to add extra functionality to the
|
|
script (i.e. auto apply changes or show diffs on command line)
|
|
|
|
:param args_arr: list/tuple
|
|
Uncrustify commandline arguments
|
|
|
|
:param out_expected_path: string
|
|
file that will be compared with Uncrustifys stdout output
|
|
|
|
:param out_result_manip: string
|
|
lambda function that will be applied to Uncrustifys stdout output
|
|
(before the comparison with out_expected_path),
|
|
the lambda function should accept one string parameter
|
|
|
|
:param out_result_path: string
|
|
path where Uncrustifys stdout output will be saved to in case of a
|
|
mismatch
|
|
|
|
:param err_expected_path: string
|
|
path to a file that will be compared with Uncrustifys stderr output
|
|
|
|
:param err_result_manip: string
|
|
see out_result_manip (is applied to Uncrustifys stderr instead)
|
|
|
|
:param err_result_path: string
|
|
see out_result_path (is applied to Uncrustifys stderr instead)
|
|
|
|
:param gen_expected_path: string
|
|
path to a file that will be compared with a file generated by Uncrustify
|
|
|
|
:param gen_result_path: string
|
|
path to a file that will be generated by Uncrustify
|
|
|
|
:param gen_result_manip:
|
|
see out_result_path (is applied, in memory, to the file content of the
|
|
file generated by Uncrustify instead)
|
|
|
|
|
|
:return: bool
|
|
----------------------------------------------------------------------------
|
|
True if all specified files match up, False otherwise
|
|
"""
|
|
# check param sanity
|
|
if not out_expected_path and not err_expected_path and not gen_expected_path:
|
|
eprint("No expected comparison file provided")
|
|
return False
|
|
|
|
if bool(gen_expected_path) != bool(gen_result_path):
|
|
eprint("'gen_expected_path' and 'gen_result_path' must be used in "
|
|
"combination")
|
|
return False
|
|
|
|
if gen_result_manip and not gen_result_path:
|
|
eprint("Set up 'gen_result_path' if 'gen_result_manip' is used")
|
|
|
|
out_res_txt, err_res_txt = proc(uncr_bin, args_arr)
|
|
|
|
ret_flag = True
|
|
|
|
if program_args.apply:
|
|
valid_path = [out_expected_path, err_expected_path, gen_expected_path]
|
|
program_args.auto_output_path = next(item for item in valid_path if item is not None)
|
|
|
|
if out_expected_path and not check_std_output(
|
|
out_expected_path, out_result_path, out_res_txt,
|
|
result_manip=out_result_manip,
|
|
program_args=program_args):
|
|
ret_flag = False
|
|
|
|
if program_args.apply:
|
|
valid_path = [err_expected_path, out_expected_path, gen_expected_path]
|
|
program_args.auto_output_path = next(item for item in valid_path if item is not None)
|
|
|
|
if err_expected_path and not check_std_output(
|
|
err_expected_path, err_result_path, err_res_txt,
|
|
result_manip=err_result_manip,
|
|
program_args=program_args):
|
|
ret_flag = False
|
|
|
|
#print("1: gen_expected_path is "+gen_expected_path)
|
|
#print("1: gen_result_path is "+gen_result_path)
|
|
#if gen_result_manip is not None:
|
|
# print("1: gen_result_manip is "+gen_result_manip)
|
|
#else:
|
|
# print("1: gen_result_manip is None")
|
|
#print("program_args is "+program_args)
|
|
if gen_expected_path and not check_generated_output(
|
|
gen_expected_path, gen_result_path,
|
|
result_manip=gen_result_manip,
|
|
program_args=program_args):
|
|
ret_flag = False
|
|
|
|
return ret_flag
|
|
|
|
|
|
def clear_dir(path):
|
|
"""
|
|
clears a directory by deleting and creating it again
|
|
|
|
|
|
Parameters
|
|
----------------------------------------------------------------------------
|
|
:param path:
|
|
path of the directory
|
|
|
|
|
|
:return: void
|
|
"""
|
|
if isdir(path):
|
|
rmtree(path)
|
|
makedirs(path)
|
|
|
|
|
|
def reg_replace(pattern, replacement):
|
|
"""
|
|
returns a generated lambda function that applies a regex string replacement
|
|
|
|
|
|
Parameters:
|
|
----------------------------------------------------------------------------
|
|
|
|
:param pattern: regex pattern
|
|
the pattern that will be used to find targets to replace
|
|
|
|
:param replacement: string
|
|
the replacement that will be applied
|
|
|
|
|
|
:return: lambda function
|
|
----------------------------------------------------------------------------
|
|
the generated lambda function, takes in a string on which the
|
|
replacement will be applied and returned
|
|
|
|
>>> l = reg_replace(r"a", "b")
|
|
>>> a = l("a")
|
|
'b'
|
|
"""
|
|
return lambda text: re.sub(pattern, replacement, text)
|
|
|
|
|
|
def string_replace(string_target, replacement):
|
|
"""
|
|
returns a generated lambda function that applies a string replacement
|
|
|
|
like reg_replace, uses string.replace() instead
|
|
"""
|
|
return lambda text: text.replace(string_target, replacement)
|
|
|
|
|
|
def s_path_join(path, *paths):
|
|
"""
|
|
Wrapper for the os.path.join function, splits every path component to
|
|
replace it with a system specific path separator. This is for consistent
|
|
path separators (and also systems that don't use either '\' or '/')
|
|
|
|
|
|
Parameter
|
|
----------------------------------------------------------------------------
|
|
:params path, paths: string
|
|
see os.path.join
|
|
|
|
:return: string
|
|
----------------------------------------------------------------------------
|
|
a joined path, see os.path.join
|
|
|
|
>>> s_path_join('./z/d/', '../a/b/c/f')
|
|
r'.\z\a\b\c\f'
|
|
"""
|
|
p_splits = list(path_split(path))
|
|
for r in map(path_split, paths):
|
|
p_splits.extend(r)
|
|
return path_join(*p_splits)
|
|
|
|
|
|
def main(args):
|
|
# set working dir to script dir
|
|
script_dir = dirname(relpath(__file__))
|
|
|
|
parser = argparse.ArgumentParser(description='Test CLI Options')
|
|
parser.add_argument('--diff', action='store_true',
|
|
help='show diffs when there is a test mismatch')
|
|
parser.add_argument('--apply', action='store_true',
|
|
help='auto apply the changes from the results folder to the output folder')
|
|
parser.add_argument('--build',
|
|
default=s_path_join(script_dir, '../../build'),
|
|
help='specify location of the build directory')
|
|
parser.add_argument('--config',
|
|
default='Release',
|
|
help='the build_type value (Release or Debug)')
|
|
parser.add_argument('--test',
|
|
default=s_path_join(script_dir, '../../build/tests/cli'),
|
|
help='specify the location of the test cli build folder')
|
|
|
|
parsed_args = parser.parse_args()
|
|
|
|
# find the uncrustify binary
|
|
bin_found = False
|
|
uncr_bin = ''
|
|
bd_dir = parsed_args.build
|
|
test_dir = parsed_args.test
|
|
|
|
bin_paths = [s_path_join(bd_dir, 'uncrustify'),
|
|
s_path_join(bd_dir, 'uncrustify.exe'),
|
|
s_path_join(bd_dir, 'Debug/uncrustify'),
|
|
s_path_join(bd_dir, 'Debug/uncrustify.exe'),
|
|
s_path_join(bd_dir, 'Release/uncrustify'),
|
|
s_path_join(bd_dir, 'Release/uncrustify.exe'),
|
|
s_path_join(bd_dir, 'RelWithDebInfo/uncrustify'),
|
|
s_path_join(bd_dir, 'RelWithDebInfo/uncrustify.exe'),
|
|
s_path_join(bd_dir, 'MinSizeRel/uncrustify'),
|
|
s_path_join(bd_dir, 'MinSizeRel/uncrustify.exe')]
|
|
for uncr_bin in bin_paths:
|
|
if not isfile(uncr_bin):
|
|
eprint("is 3 not a file: %s" % uncr_bin)
|
|
else:
|
|
print("Uncrustify binary found: %s" % uncr_bin)
|
|
bin_found = True
|
|
break
|
|
if not bin_found:
|
|
eprint("No Uncrustify binary found")
|
|
sys_exit(EX_USAGE)
|
|
print("Summary:")
|
|
print("Python version is: "+sys.version)
|
|
print("OS is: %s" % os_name)
|
|
|
|
clear_dir(s_path_join(test_dir, 'results'))
|
|
|
|
return_flag = True
|
|
|
|
print("Test help ...")
|
|
#
|
|
# Test help
|
|
# -h -? --help --usage
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
out_expected_path=s_path_join(script_dir, 'output/help.txt'),
|
|
out_result_path=s_path_join(test_dir, 'results/help.txt'),
|
|
out_result_manip=[
|
|
string_replace(' --mtime : Preserve mtime on replaced files.\n', ''),
|
|
string_replace('.exe', ''),
|
|
reg_replace(r'currently \d+ options', 'currently x options')
|
|
]):
|
|
return_flag = False
|
|
print("Test help is OK")
|
|
|
|
print("Test false parameter ...")
|
|
#
|
|
# Test false parameter
|
|
# --xyz
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['--xyz'],
|
|
err_expected_path=s_path_join(script_dir, 'output/xyz-err.txt'),
|
|
err_result_path=s_path_join(test_dir, 'results/xyz-err.txt')
|
|
):
|
|
return_flag = False
|
|
print("Test false parameter is OK")
|
|
|
|
print("Test Version ...")
|
|
#
|
|
# Test Version
|
|
# -v
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-v'],
|
|
out_expected_path=s_path_join(script_dir, 'output/v-out.txt'),
|
|
out_result_path=s_path_join(test_dir, 'results/v-out.txt'),
|
|
out_result_manip=reg_replace(r'Uncrustify.+', 'Uncrustify')
|
|
):
|
|
return_flag = False
|
|
print("Test Version is OK")
|
|
|
|
# temporary removed
|
|
#print("Test --show-config ...")
|
|
##
|
|
## Test --show-config
|
|
##
|
|
#if not check_uncrustify_output(
|
|
# uncr_bin,
|
|
# parsed_args,
|
|
# args_arr=['--show-config'],
|
|
# out_expected_path=s_path_join(script_dir, 'output/show_config.txt'),
|
|
# out_result_path=s_path_join(test_dir, 'results/show_config.txt'),
|
|
# out_result_manip=reg_replace(r'\# Uncrustify.+', '')
|
|
# ):
|
|
# return_flag = False
|
|
#print("Test --show-config is OK")
|
|
|
|
print("Test the truncate option ...")
|
|
#
|
|
# Test the truncate option
|
|
#
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', s_path_join(script_dir, 'config/truncate.cfg'),
|
|
'-f', s_path_join(script_dir, 'input/truncate.cpp'),
|
|
'-o', NULL_DEVICE,
|
|
'-L', '83'],
|
|
err_expected_path=s_path_join(script_dir, 'output/truncate.txt'),
|
|
err_result_path=s_path_join(test_dir, 'results/truncate.txt'),
|
|
err_result_manip=[reg_replace(r'\([0-9]+\)', ' '),
|
|
reg_replace(RE_DO_SPACE, '')]
|
|
):
|
|
return_flag = False
|
|
print("Test the truncate option is OK")
|
|
|
|
#print("Test --update-config ...")
|
|
# temporary removed
|
|
##
|
|
## Test --update-config
|
|
##
|
|
#if not check_uncrustify_output(
|
|
# uncr_bin,
|
|
# parsed_args,
|
|
# args_arr=['-c', s_path_join(script_dir, 'config/mini_d.cfg'),
|
|
# '--update-config'],
|
|
# out_expected_path=s_path_join(script_dir, 'output/mini_d_uc.txt'),
|
|
# out_result_path=s_path_join(test_dir, 'results/mini_d_uc.txt'),
|
|
# out_result_manip=reg_replace(r'\# Uncrustify.+', ''),
|
|
# err_expected_path=s_path_join(script_dir, 'output/mini_d_error.txt'),
|
|
# err_result_path=s_path_join(test_dir, 'results/mini_d_error0.txt'),
|
|
# err_result_manip=string_replace('\\', '/')
|
|
# ):
|
|
# return_flag = False
|
|
|
|
#if not check_uncrustify_output(
|
|
# uncr_bin,
|
|
# parsed_args,
|
|
# args_arr=['-c', s_path_join(script_dir, 'config/mini_nd.cfg'),
|
|
# '--update-config'],
|
|
# out_expected_path=s_path_join(script_dir, 'output/mini_nd_uc.txt'),
|
|
# out_result_path=s_path_join(test_dir, 'results/mini_nd_uc.txt'),
|
|
# out_result_manip=reg_replace(r'\# Uncrustify.+', ''),
|
|
# err_expected_path=s_path_join(script_dir, 'output/mini_d_error.txt'),
|
|
# err_result_path=s_path_join(test_dir, 'results/mini_d_error1.txt'),
|
|
# err_result_manip=string_replace('\\', '/')
|
|
# ):
|
|
# return_flag = False
|
|
#print("Test --update-config is OK")
|
|
|
|
#print("Test --update-config-with-doc ...")
|
|
##
|
|
## Test --update-config-with-doc
|
|
##
|
|
#if not check_uncrustify_output(
|
|
# uncr_bin,
|
|
# parsed_args,
|
|
# args_arr=['-c', s_path_join(script_dir, 'config/mini_d.cfg'),
|
|
# '--update-config-with-doc'],
|
|
# out_expected_path=s_path_join(script_dir, 'output/mini_d_ucwd.txt'),
|
|
# out_result_path=s_path_join(test_dir, 'results/mini_d_ucwd.txt'),
|
|
# out_result_manip=reg_replace(r'\# Uncrustify.+', ''),
|
|
# err_expected_path=s_path_join(script_dir, 'output/mini_d_error.txt'),
|
|
# err_result_path=s_path_join(test_dir, 'results/mini_d_error2.txt'),
|
|
# err_result_manip=string_replace('\\', '/')
|
|
# ):
|
|
# return_flag = False
|
|
#print("Test --update-config-with-doc is OK")
|
|
|
|
#if not check_uncrustify_output(
|
|
# uncr_bin,
|
|
# parsed_args,
|
|
# args_arr=['-c', s_path_join(script_dir, 'config/mini_nd.cfg'),
|
|
# '--update-config-with-doc'],
|
|
# out_expected_path=s_path_join(script_dir, 'output/mini_nd_ucwd.txt'),
|
|
# out_result_path=s_path_join(test_dir, 'results/mini_nd_ucwd.txt'),
|
|
# out_result_manip=reg_replace(r'\# Uncrustify.+', ''),
|
|
# err_expected_path=s_path_join(script_dir, 'output/mini_d_error.txt'),
|
|
# err_result_path=s_path_join(test_dir, 'results/mini_d_error3.txt'),
|
|
# err_result_manip=string_replace('\\', '/')
|
|
# ):
|
|
# return_flag = False
|
|
|
|
print("Test -p ...")
|
|
#
|
|
# Test -p
|
|
#
|
|
if os_name != 'nt':
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', s_path_join(script_dir, 'config/mini_nd.cfg'),
|
|
'-f', s_path_join(script_dir, 'input/testSrcP.cpp'),
|
|
'-p', s_path_join(test_dir, 'results/p.txt')],
|
|
gen_expected_path=s_path_join(script_dir, 'output/p.txt'),
|
|
gen_result_path=s_path_join(test_dir, 'results/p.txt'),
|
|
gen_result_manip=reg_replace(r'\# Uncrustify.+[^\n\r]', '')
|
|
):
|
|
return_flag = False
|
|
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-f', s_path_join(script_dir, 'input/class_enum_struct_union.cpp'),
|
|
'-p', s_path_join(test_dir, 'results/class_enum_struct_union.txt')],
|
|
gen_expected_path=s_path_join(script_dir, 'output/class_enum_struct_union.txt'),
|
|
gen_result_path=s_path_join(test_dir, 'results/class_enum_struct_union.txt'),
|
|
gen_result_manip=reg_replace(r'\# Uncrustify.+[^\n\r]', '')
|
|
):
|
|
return_flag = False
|
|
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-f', s_path_join(script_dir, 'input/in_fcn_def.cpp'),
|
|
'-p', s_path_join(test_dir, 'results/in_fcn_def.txt')],
|
|
gen_expected_path=s_path_join(script_dir, 'output/in_fcn_def.txt'),
|
|
gen_result_path=s_path_join(test_dir, 'results/in_fcn_def.txt'),
|
|
gen_result_manip=reg_replace(r'\# Uncrustify.+[^\n\r]', '')
|
|
):
|
|
return_flag = False
|
|
print("Test -p is OK")
|
|
|
|
#print("Test -p and -c with '-' input ...")
|
|
if os_name == 'nt' or check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', '-',
|
|
'-f', NULL_DEVICE,
|
|
'-p', '-'],
|
|
out_expected_path=s_path_join(script_dir, 'output/pc-.txt'),
|
|
out_result_manip=reg_replace(r'\# Uncrustify.+[^\n\r]', ''),
|
|
out_result_path=s_path_join(test_dir, 'results/pc-.txt')
|
|
):
|
|
pass
|
|
|
|
#print("Test -p and -c with '-' input ...")
|
|
#
|
|
# Test -p and -c with '-' input
|
|
#
|
|
else:
|
|
return_flag = False
|
|
#print("Test -p and -c with '-' input is OK")
|
|
|
|
print("Test -p and --debug-csv-format option ...")
|
|
#
|
|
# Test -p and --debug-csv-format option
|
|
#
|
|
if os_name != 'nt' and not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', '-',
|
|
'-f', s_path_join(script_dir, 'input/class_enum_struct_union.cpp'),
|
|
'-p', s_path_join(test_dir, 'results/class_enum_struct_union.csv'),
|
|
'--debug-csv-format'],
|
|
gen_expected_path=s_path_join(script_dir, 'output/class_enum_struct_union.csv'),
|
|
gen_result_path=s_path_join(test_dir, 'results/class_enum_struct_union.csv'),
|
|
):
|
|
return_flag = False
|
|
print("Test -p and --debug-csv-format option is OK")
|
|
|
|
if parsed_args.config == 'Debug':
|
|
print("Test --tracking space:FILE ...")
|
|
print(" config is Debug")
|
|
#
|
|
# Test --tracking space:FILE
|
|
#
|
|
if os_name != 'nt':
|
|
# doesn't work under windows
|
|
temp_result_path = s_path_join(script_dir, 'results/Debug_tracking_space.html')
|
|
abc = "space:" + temp_result_path # Issue #4066
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', s_path_join(script_dir, 'config/tracking_space.cfg'),
|
|
'-f', s_path_join(script_dir, 'input/tracking_space.cpp'),
|
|
'--tracking',
|
|
abc,
|
|
#s_path_join(script_dir, 'results/Debug_tracking_space.html')
|
|
#temp_result_path
|
|
# '-L'
|
|
#, 'A'
|
|
#, '2'
|
|
#, '>'
|
|
#, '/home/guy/A-T.txt'
|
|
],
|
|
gen_expected_path=s_path_join(script_dir, 'output/Debug_tracking_space.html'),
|
|
#gen_result_path=s_path_join(script_dir, 'results/Debug_tracking_space.html')
|
|
gen_result_path=temp_result_path
|
|
):
|
|
#print("/home/guy/A-T.txt")
|
|
#else:
|
|
#print("/home/guy/A-T.txt")
|
|
return_flag = False
|
|
print("Test --tracking space:FILE is OK")
|
|
|
|
#sys_exit()
|
|
|
|
print("Test --replace ...")
|
|
#
|
|
# Test --replace
|
|
#
|
|
copyfile("input/backup.h-save", "input/backup.h")
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', s_path_join(script_dir, 'config/replace.cfg'),
|
|
'-F', s_path_join(script_dir, 'input/replace.list'),
|
|
'--replace', '--no-backup'],
|
|
gen_expected_path=s_path_join(script_dir, 'output/backup.h'),
|
|
gen_result_path=s_path_join(script_dir, 'input/backup.h'),
|
|
err_expected_path=s_path_join(script_dir, 'output/replace.txt'),
|
|
err_result_path=s_path_join(test_dir, 'results/replace.txt'),
|
|
):
|
|
return_flag = False
|
|
print("Test --replace is OK")
|
|
|
|
print("Test --universalindent ...")
|
|
# The flag CMAKE_BUILD_TYPE must be set to "Release", or all lines with
|
|
# 'Description="<html>(<number>)text abc.</html>" must be changed to
|
|
# 'Description="<html>text abc.</html>"
|
|
#
|
|
# OR it is possible to introduce a new parameter: gen_expected_manip
|
|
#
|
|
# The last "reg_replace(r'\r', '')" is necessary under Windows, because
|
|
# fprintf puts a \r\n at the end of a line. To make the check, we use
|
|
# output/universalindent.cfg, generated under Linux, with only \n at the
|
|
# end of a line.
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-o', s_path_join(test_dir, 'results/universalindent.cfg'),
|
|
'--universalindent'],
|
|
gen_expected_path=s_path_join(script_dir, 'output/universalindent.cfg'),
|
|
gen_result_path=s_path_join(test_dir, 'results/universalindent.cfg'),
|
|
gen_result_manip=[reg_replace(r'version=U.+', ''),
|
|
reg_replace(r'\(\d+\)', ''),
|
|
reg_replace(r'\r', '')]
|
|
):
|
|
return_flag = False
|
|
print("Test --universalindent is OK")
|
|
|
|
print("Test -L ...")
|
|
# Debug Options:
|
|
# -L
|
|
# look at src/log_levels.h
|
|
Ls_A = ['9', '21', '25', '28', '31', '36', '66', '92']
|
|
for L in Ls_A:
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', NULL_DEVICE, '-L', L, '-o', NULL_DEVICE,
|
|
'-f', s_path_join(script_dir, 'input/testSrc.cpp')],
|
|
err_expected_path=s_path_join(script_dir, 'output/%s.txt' % L),
|
|
err_result_path=s_path_join(test_dir, 'results/%s.txt' % L),
|
|
err_result_manip=[reg_replace(r'\([0-9]+\)', ' '),
|
|
reg_replace(r'\:[0-9]+\)', ' '),
|
|
reg_replace(r'\[line [0-9]+', '[ '),
|
|
reg_replace(r' \[[_|,|1|A-Z]*\]', ' []'),
|
|
reg_replace(r', \[[_|,|1|A-Z]*\]', ', []'),
|
|
reg_replace(r', \[0[xX][0-9a-fA-F]+:[_|,|1|A-Z]*\]', ', []'),
|
|
reg_replace(r' \[0[xX][0-9a-fA-F]+:[_|,|1|A-Z]*\]', ' []'),
|
|
reg_replace(r'^[ \t]*[_A-Za-z][_A-Za-z0-9]*::', ''),
|
|
reg_replace(RE_CALLSTACK, '[CallStack]'),
|
|
reg_replace(RE_DO_SPACE, ''),
|
|
reg_replace(r'Chunk::', '')]
|
|
):
|
|
return_flag = False
|
|
print("Test -L is OK")
|
|
|
|
### Test logger buffer overflow
|
|
##if not check_uncrustify_output(
|
|
## uncr_bin,
|
|
## parsed_args,
|
|
## args_arr=['-c', NULL_DEVICE, '-L', '99', '-o', NULL_DEVICE,
|
|
## '-f', s_path_join(script_dir, 'input/logger.cs')],
|
|
## err_expected_path=s_path_join(script_dir, 'output/logger_cs_L_99.txt'),
|
|
## err_result_path=s_path_join(test_dir, 'results/logger_cs_L_99.txt'),
|
|
## err_result_manip=reg_replace(r'[0-9]', '')
|
|
## ):
|
|
## return_flag = False
|
|
|
|
# misc error_tests
|
|
error_tests = ["I-842", "unmatched_close_pp"]
|
|
for test in error_tests:
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', s_path_join(script_dir, 'config/%s.cfg' % test),
|
|
'-f', s_path_join(script_dir, 'input/%s.cpp' % test),
|
|
'-o', NULL_DEVICE, '-q'],
|
|
err_expected_path=s_path_join(script_dir, 'output/%s.txt' % test),
|
|
err_result_path=s_path_join(test_dir, 'results/%s.txt' % test)
|
|
):
|
|
return_flag = False
|
|
|
|
print("Test $(year) keyword ...")
|
|
# Test $(year) keyword (issue #3251)
|
|
if not check_uncrustify_output(
|
|
uncr_bin,
|
|
parsed_args,
|
|
args_arr=['-c', s_path_join(script_dir, 'config/copyright-header.cfg'),
|
|
'-f', s_path_join(script_dir, 'input/testSrc.cpp')],
|
|
out_expected_path=s_path_join(script_dir, 'output/copyright-header.cpp'),
|
|
out_result_path=s_path_join(test_dir, 'results/copyright-header.cpp'),
|
|
out_result_manip=string_replace(str(date.today().year), 'this year'),
|
|
):
|
|
return_flag = False
|
|
print("Test $(year) keyword is OK")
|
|
|
|
if return_flag:
|
|
print("all tests are OK")
|
|
sys_exit(EX_OK)
|
|
else:
|
|
print("some problem(s) are still present")
|
|
sys_exit(EX_SOFTWARE)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main(argv[1:])
|