def test7_white_space_import():
filename = '7_white_space.data'
filepath = test_file_path + filename
# Test File Import
assert sfcparse.importfile(filepath)
file_import = sfcparse.importfile(filepath)
# Test Attributes and Types
assert (file_import.data_list == [1, 2, 3]) and (type(
file_import.data_list) == type(list()))
assert (file_import.data_str == "data") and (type(file_import.data_str)
== type(str()))
assert (file_import.data_tuple == (1, 2, 3)) and (type(
file_import.data_tuple) == type(tuple()))
assert (file_import.data_none == None) and (type(file_import.data_none)
== type(None))
assert (file_import.data_bytes == b'data') and (type(
file_import.data_bytes) == type(bytes()))
assert (file_import.data_float == 1.0) and (type(file_import.data_float)
== type(float()))
assert (file_import.data_set == {1, 2, 3}) and (type(file_import.data_set)
== type(set()))
assert (file_import.data_bool == True) and (type(file_import.data_bool)
== type(bool()))
def test2_single_line_import():
filename = '2_single_line.data'
filepath = test_file_path + filename
# Test File Import
assert sfcparse.importfile(filepath)
file_import = sfcparse.importfile(filepath)
# Test Attributes and Types
assert (file_import.data_str == "data") and (type(file_import.data_str)
== type(str()))
assert (file_import.data_int == 1) and (type(file_import.data_int) == type(
int()))
assert (file_import.data_float == 1.0) and (type(file_import.data_float)
== type(float()))
assert (file_import.data_bool == True) and (type(file_import.data_bool)
== type(bool()))
assert (file_import.data_list == [1, 2, 3]) and (type(
file_import.data_list) == type(list()))
assert (file_import.data_dict == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_dict) == type(dict()))
assert (file_import.data_tuple == (1, 2, 3)) and (type(
file_import.data_tuple) == type(tuple()))
assert (file_import.data_set == {1, 2, 3}) and (type(file_import.data_set)
== type(set()))
assert (file_import.data_none == None) and (type(file_import.data_none)
== type(None))
assert (file_import.data_bytes == b'data') and (type(
file_import.data_bytes) == type(bytes()))
def test6_nested_data_import():
filename = '6_nested.data'
filepath = test_file_path + filename
# Test File Import
assert sfcparse.importfile(filepath)
file_import = sfcparse.importfile(filepath)
# Test Attributes and Types
assert type(file_import.data_list) == type(list())
assert (file_import.data_list[0] == [1, 2, 3]) and (type(
file_import.data_list[0]) == type(list()))
assert (file_import.data_list[1] == [1, 2, 3, 4, 5]) and (type(
file_import.data_list[1]) == type(list()))
assert (file_import.data_list[2] == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_list[2]) == type(dict()))
assert (file_import.data_list[3] == (1, 2, 3)) and (type(
file_import.data_list[3]) == type(tuple()))
assert (file_import.data_list[4] == {1, 2, 3}) and (type(
file_import.data_list[4]) == type(set()))
assert (file_import.data_list[5] == [1, 2, 3]) and (type(
file_import.data_list[5]) == type(list()))
def test3_multi_data_file_export():
filename = '3_multi_data_file.data'
filepath = test_file_path + filename
data = {'k1':1, 'k2':2, 'k3':3}
big_data = f"""\n\n# Comment
data_b1 = {data}
data_b2 = {data}
data_b3 = {data}
"""
# Remove Any Existing Test File
try: remove(filepath)
except: pass
time.sleep(file_delay_timer)
# Test Not Exist, Create, Exist, Data and it's Type
assert not path.exists(filepath)
sfcparse.exportfile(filepath, f"data1 = {data}", f"\ndata2 = {data}", f"\ndata3 = {data}", big_data)
assert path.exists(filepath)
file_import = sfcparse.importfile(filepath)
assert (file_import.data1 == {'k1':1, 'k2':2, 'k3':3}) and (type(file_import.data1) == type(dict()))
assert (file_import.data2 == {'k1':1, 'k2':2, 'k3':3}) and (type(file_import.data2) == type(dict()))
assert (file_import.data3 == {'k1':1, 'k2':2, 'k3':3}) and (type(file_import.data3) == type(dict()))
assert (file_import.data_b1 == {'k1':1, 'k2':2, 'k3':3}) and (type(file_import.data_b1) == type(dict()))
assert (file_import.data_b2 == {'k1':1, 'k2':2, 'k3':3}) and (type(file_import.data_b2) == type(dict()))
assert (file_import.data_b3 == {'k1':1, 'k2':2, 'k3':3}) and (type(file_import.data_b3) == type(dict()))
# Remove Test File
time.sleep(file_delay_timer)
try: remove(filepath)
except: pass
def test1_basic_file_append():
filename = '1_basic_file_append.data'
filepath = test_file_path + filename
data = {'k1': 1, 'k2': 2, 'k3': 3}
# Remove Any Existing Test File, then Create New One
try:
remove(filepath)
except:
pass
time.sleep(file_delay_timer)
assert not path.exists(filepath)
sfcparse.exportfile(filepath)
assert path.exists(filepath)
# Test Single Line Append and Verify
sfcparse.appendfile(filepath, f"data = {data}")
file_import = sfcparse.importfile(filepath)
assert (file_import.data == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data) == type(dict()))
# Remove Test File
time.sleep(file_delay_timer)
try:
remove(filepath)
except:
pass
def test2_multi_data_file_append():
filename = '2_multi_data_file.data'
filepath = test_file_path + filename
data = {'k1': 1, 'k2': 2, 'k3': 3}
big_data = f"""\n\n# Comment
data_b1 = {data}
data_b2 = {data}
data_b3 = {data}
"""
# Remove Any Existing Test File
try:
remove(filepath)
except:
pass
time.sleep(file_delay_timer)
assert not path.exists(filepath)
sfcparse.exportfile(filepath)
assert path.exists(filepath)
# Test Multi Line Append and Verify
sfcparse.appendfile(filepath, f"data1 = {data}", f"\ndata2 = {data}",
f"\ndata3 = {data}", big_data)
file_import = sfcparse.importfile(filepath)
assert (file_import.data1 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data1) == type(dict()))
assert (file_import.data2 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data2) == type(dict()))
assert (file_import.data3 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data3) == type(dict()))
assert (file_import.data_b1 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_b1) == type(dict()))
assert (file_import.data_b2 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_b2) == type(dict()))
assert (file_import.data_b3 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_b3) == type(dict()))
# Remove Test File
time.sleep(file_delay_timer)
try:
remove(filepath)
except:
pass
def test3_data_tamper_file_append():
filename = '3_data_tamper_file.data'
filepath = test_file_path + filename
data = {'k1': 1, 'k2': 2, 'k3': 3}
big_data = f"""# Comment
data_b1 = {data}
data_b2 = {data}
data_b3 = {data}"""
# Remove Any Existing Test File
try:
remove(filepath)
except:
pass
time.sleep(file_delay_timer)
assert not path.exists(filepath)
# Export File with "Present Data"
sfcparse.exportfile(filepath, big_data)
assert path.exists(filepath)
# Test Append Without Tampering Present Data and Verify. Appending 3x Lines
sfcparse.appendfile(filepath, f"data1 = {data}", f"data2 = {data}",
f"data3 = {data}")
file_import = sfcparse.importfile(filepath)
assert (file_import.data1 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data1) == type(dict()))
assert (file_import.data2 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data2) == type(dict()))
assert (file_import.data3 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data3) == type(dict()))
assert (file_import.data_b1 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_b1) == type(dict()))
assert (file_import.data_b2 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_b2) == type(dict()))
assert (file_import.data_b3 == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_b3) == type(dict()))
# Remove Test File
time.sleep(file_delay_timer)
try:
remove(filepath)
except:
pass
def test3_multi_line_import():
filename = '3_multi_line.data'
filepath = test_file_path + filename
# Test File Import
assert sfcparse.importfile(filepath)
file_import = sfcparse.importfile(filepath)
# Test Attributes and Types
assert (file_import.data_list == [1, 2, 3]) and (type(
file_import.data_list) == type(list()))
assert (file_import.data_dict == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_dict) == type(dict()))
assert (file_import.data_tuple == (1, 2, 3)) and (type(
file_import.data_tuple) == type(tuple()))
assert (file_import.data_set == {1, 2, 3}) and (type(file_import.data_set)
== type(set()))
def test10_misc_data_import():
filename = '10_misc.data'
filepath = test_file_path + filename
# Test File Import
assert sfcparse.importfile(filepath)
file_import = sfcparse.importfile(filepath)
# Test Attributes and Types
assert (file_import.data_single_tuple_1 == (1, )) and (type(
file_import.data_single_tuple_1) == type(tuple()))
assert (file_import.data_single_tuple_2 == (1, )) and (type(
file_import.data_single_tuple_2) == type(tuple()))
assert (file_import.data_tuple_int_1 == 1) and (type(
file_import.data_tuple_int_1) == type(int()))
assert (file_import.data_tuple_int_2 == 1) and (type(
file_import.data_tuple_int_2) == type(int()))
assert (file_import.data_str_1 == "data with internal spaces") and (type(
file_import.data_str_1) == type(str()))
assert (file_import.data_str_2
== " data with internal and end spaces ") and (type(
file_import.data_str_2) == type(str()))
assert (file_import.data_list == [1, 2, 3]) and (type(
file_import.data_list) == type(list()))
assert (file_import.data_dict == {
'k1': 1,
'k2': 2,
'k3': 3
}) and (type(file_import.data_dict) == type(dict()))
assert (file_import.data_tuple == (1, 2, 3)) and (type(
file_import.data_tuple) == type(tuple()))
assert (file_import.data_set == {1, 2, 3}) and (type(file_import.data_set)
== type(set()))
assert (file_import.data_token1 == [
'normal value', "var = 'value'", 'normal value'
]) and (type(file_import.data_token1) == type(list()))
assert (file_import.data_end_token1 == [
'normal value', "var = 'value'", 'normal value'
]) and (type(file_import.data_end_token1) == type(list()))
def test9_big_data_import():
filename = '9_big_data_with_singles.data'
filepath = test_file_path + filename
big_data_len = 100_000
# Test File Import
assert sfcparse.importfile(filepath)
file_import = sfcparse.importfile(filepath)
# Test Attributes and Types
assert (len(file_import.data_single) == big_data_len) and (type(
file_import.data_single) == type(list()))
assert (file_import.data_float == 1.0) and (type(file_import.data_float)
== type(float()))
assert (file_import.data_bool == True) and (type(file_import.data_bool)
== type(bool()))
assert (len(file_import.data_multi) == big_data_len) and (type(
file_import.data_multi) == type(dict()))
assert (file_import.data_none == None) and (type(file_import.data_none)
== type(None))
assert (file_import.data_bytes == b'data') and (type(
file_import.data_bytes) == type(bytes()))
def test5_multi_single_comments_import():
filename = '5_multi-single_comments.data'
filepath = test_file_path + filename
# Test File Import
assert sfcparse.importfile(filepath)
file_import = sfcparse.importfile(filepath)
# Test Attributes and Types
assert (file_import.data_bool == True) and (type(file_import.data_bool)
== type(bool()))
assert (file_import.data_list == [1, 2, 3]) and (type(
file_import.data_list) == type(list()))
assert (file_import.data_str == "data") and (type(file_import.data_str)
== type(str()))
assert (file_import.data_tuple == (1, 2, 3)) and (type(
file_import.data_tuple) == type(tuple()))
assert (file_import.data_none == None) and (type(file_import.data_none)
== type(None))
assert (file_import.data_bytes == b'data') and (type(
file_import.data_bytes) == type(bytes()))
assert (file_import.data_set == {1, 2, 3}) and (type(file_import.data_set)
== type(set()))
def test2_data_file_export():
filename = '2_data_file.data'
filepath = test_file_path + filename
data = {'k1':1, 'k2':2, 'k3':3}
# Remove Any Existing Test File
try: remove(filepath)
except: pass
time.sleep(file_delay_timer)
# Test Not Exist, Create, Exist, Data and it's Type
assert not path.exists(filepath)
sfcparse.exportfile(filepath, f"data = {data}")
assert path.exists(filepath)
file_import = sfcparse.importfile(filepath)
assert (file_import.data == {'k1':1, 'k2':2, 'k3':3}) and (type(file_import.data) == type(dict()))
# Remove Test File
time.sleep(file_delay_timer)
try: remove(filepath)
except: pass
def test1_default_format_export():
filename = '1_data_format.data'
filepath = test_file_path + filename
data = {'k1':1, 'k2':2, 'k3':3, 'k4':4, 'k5':5}
# Remove Any Existing Test File
try: remove(filepath)
except: pass
time.sleep(file_delay_timer)
# Test Formatted Data then Export it and Read it
data_formatted = sfcparse.cleanformat(data)
assert not path.exists(filepath)
sfcparse.exportfile(filepath, f"data = {data_formatted}")
assert path.exists(filepath)
file_import = sfcparse.importfile(filepath)
assert (file_import.data == {'k1':1, 'k2':2, 'k3':3, 'k4':4, 'k5':5}) and (type(file_import.data) == type(dict()))
# Remove Test File
time.sleep(file_delay_timer)
try: remove(filepath)
except: pass
def test2_indent_format_export():
filename = '2_indent_format.data'
filepath = test_file_path + filename
data = {'k1':1, 'k2':2, 'k3':3, 'k4':4, 'k5':5}
# Remove Any Existing Test File
try: remove(filepath)
except: pass
time.sleep(file_delay_timer)
# Test Formatted Data with Indent Change then Export it and Read it
data_formatted1 = sfcparse.cleanformat(data, 0)
data_formatted2 = sfcparse.cleanformat(data, 7)
assert not path.exists(filepath)
sfcparse.exportfile(filepath, f"data1 = {data_formatted1}")
assert path.exists(filepath)
sfcparse.appendfile(filepath, f"data2 = {data_formatted2}")
file_import = sfcparse.importfile(filepath)
assert (file_import.data1 == {'k1':1, 'k2':2, 'k3':3, 'k4':4, 'k5':5}) and (type(file_import.data1) == type(dict()))
assert (file_import.data2 == {'k1':1, 'k2':2, 'k3':3, 'k4':4, 'k5':5}) and (type(file_import.data2) == type(dict()))
# Remove Test File
time.sleep(file_delay_timer)
try: remove(filepath)
except: pass
def test1_basic_file_import():
filename = '1_empty.data'
filepath = test_file_path + filename
assert path.getsize(filepath) == 0, f"File Not Empty: {filename}"
assert sfcparse.importfile(filepath), f"Cannot Import File {filename}"
def test2_code_notexec_import(self):
filename = '2_code_notexec.data'
filepath = test_file_path + filename
with self.assertRaises(SyntaxError):
sfcparse.importfile(filepath)
