2 @message |
assert
- Generator GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
+ Generator PUBLIC.GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
- Generator GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
+ Generator PUBLIC.GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
- Generator GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
+ Generator PUBLIC.GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
- Generator GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
+ Generator PUBLIC.GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
- Generator GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
+ Generator PUBLIC.GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
- Generator GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
+ Generator PUBLIC.GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
- Generator GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
+ Generator PUBLIC.GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
LOG DETAILS:
2025-06-25 05:19:40.553
2025-06-25 05:19:40.564 act_src = <firebird.qa.plugin.Action object at [hex]>
2025-06-25 05:19:40.577 act_res = <firebird.qa.plugin.Action object at [hex]>
2025-06-25 05:19:40.586 tmp_fbk = PosixPath('/var/tmp/qa_2024/test_1878/tmp_core_4524.encrypted.fbk')
2025-06-25 05:19:40.596 capsys = <_pytest.capture.CaptureFixture object at [hex]>
2025-06-25 05:19:40.602
2025-06-25 05:19:40.608 @pytest.mark.encryption
2025-06-25 05:19:40.617 @pytest.mark.version('>=4.0')
2025-06-25 05:19:40.628 def test_1(act_src: Action, act_res: Action, tmp_fbk:Path, capsys):
2025-06-25 05:19:40.637
2025-06-25 05:19:40.646 init_sql = """
2025-06-25 05:19:40.658 set bail on;
2025-06-25 05:19:40.670 create sequence gen_ba0bab start with 12192683;
2025-06-25 05:19:40.682 create sequence gen_badf00d start with 195948557;
2025-06-25 05:19:40.694 create sequence gen_caca0 start with 830624;
2025-06-25 05:19:40.704 create sequence gen_c0ffee start with 12648430;
2025-06-25 05:19:40.712 create sequence gen_dec0de start with 14598366;
2025-06-25 05:19:40.720 create sequence gen_decade start with 14600926;
2025-06-25 05:19:40.727 create sequence gen_7FFFFFFF start with 2147483647;
2025-06-25 05:19:40.734 commit;
2025-06-25 05:19:40.745 """
2025-06-25 05:19:40.753
2025-06-25 05:19:40.760 act_src.expected_stdout = ''
2025-06-25 05:19:40.766 act_src.isql(switches = ['-q'], input = init_sql, combine_output = True, io_enc = locale.getpreferredencoding())
2025-06-25 05:19:40.771 assert act_src.clean_stdout == act_src.clean_expected_stdout
2025-06-25 05:19:40.776 act_src.reset()
2025-06-25 05:19:40.787
2025-06-25 05:19:40.794 check_sequence_values=[]
2025-06-25 05:19:40.800 with act_src.db.connect() as con:
2025-06-25 05:19:40.809 with con.cursor() as cur:
2025-06-25 05:19:40.822 get_current_seq_values='''
2025-06-25 05:19:40.833 execute block returns( gen_curr bigint) as
2025-06-25 05:19:40.841 declare gen_name rdb$generator_name;
2025-06-25 05:19:40.847 begin
2025-06-25 05:19:40.852 for
2025-06-25 05:19:40.858 select rdb$generator_name from rdb$generators where rdb$system_flag is distinct from 1 order by rdb$generator_id
2025-06-25 05:19:40.866 into gen_name
2025-06-25 05:19:40.872 do begin
2025-06-25 05:19:40.878 execute statement 'execute block returns(g bigint) as begin g = gen_id('|| gen_name ||', 0); suspend; end' into gen_curr;
2025-06-25 05:19:40.885 suspend;
2025-06-25 05:19:40.890 end
2025-06-25 05:19:40.894 end
2025-06-25 05:19:40.899 '''
2025-06-25 05:19:40.904
2025-06-25 05:19:40.910 # Obtain current values of user generators:
2025-06-25 05:19:40.916 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2025-06-25 05:19:40.922 cur.execute(get_current_seq_values)
2025-06-25 05:19:40.934 for r in cur:
2025-06-25 05:19:40.944 check_sequence_values += r[0],
2025-06-25 05:19:40.951
2025-06-25 05:19:40.957
2025-06-25 05:19:40.962 # Obtain page size and ID of generators page:
2025-06-25 05:19:40.967 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2025-06-25 05:19:40.972 cur.execute('select m.mon$page_size,min(rdb$page_number) from mon$database m cross join rdb$pages p where p.rdb$page_type = 9 group by 1')
2025-06-25 05:19:40.977 pg_size, gen_page_number = -1,-1
2025-06-25 05:19:40.985 for r in cur:
2025-06-25 05:19:40.993 pg_size=r[0]
2025-06-25 05:19:41.000 gen_page_number=r[1]
2025-06-25 05:19:41.011 # print(r[0],r[1])
2025-06-25 05:19:41.023
2025-06-25 05:19:41.031
2025-06-25 05:19:41.038 # Read gen page, convert it to hex and check whether generator values can be found there or no:
2025-06-25 05:19:41.045 # Expected result: YES for all values because DB not encrypted now.
2025-06-25 05:19:41.050 # ~~~~~~~~~~~~~~~
2025-06-25 05:19:41.057 check_page_for_readable_values(act_src.db.db_path, gen_page_number, pg_size, check_sequence_values, False, 'INIT. ')
2025-06-25 05:19:41.068
2025-06-25 05:19:41.078 act_src.expected_stdout = 'INIT. ' + SUCCESS_MSG
2025-06-25 05:19:41.089 act_src.stdout = capsys.readouterr().out
2025-06-25 05:19:41.103 assert act_src.clean_stdout == act_src.clean_expected_stdout
2025-06-25 05:19:41.116 act_src.reset()
2025-06-25 05:19:41.129
2025-06-25 05:19:41.142 ######################################################
2025-06-25 05:19:41.152
2025-06-25 05:19:41.161 t1=py_dt.datetime.now()
2025-06-25 05:19:41.168 d1 = t1-t1
2025-06-25 05:19:41.175 sttm = f'alter database encrypt with "{ENCRYPTION_PLUGIN}" key "{ENCRYPTION_KEY}"'
2025-06-25 05:19:41.181 try:
2025-06-25 05:19:41.188 con.execute_immediate(sttm)
2025-06-25 05:19:41.194 con.commit()
2025-06-25 05:19:41.199 except DatabaseError as e:
2025-06-25 05:19:41.207 print( e.__str__() )
2025-06-25 05:19:41.215
2025-06-25 05:19:41.222 act_src.expected_stdout = ''
2025-06-25 05:19:41.228 act_src.stdout = capsys.readouterr().out
2025-06-25 05:19:41.238 assert act_src.clean_stdout == act_src.clean_expected_stdout
2025-06-25 05:19:41.244 act_src.reset()
2025-06-25 05:19:41.250
2025-06-25 05:19:41.256 while True:
2025-06-25 05:19:41.262 t2=py_dt.datetime.now()
2025-06-25 05:19:41.268 d1=t2-t1
2025-06-25 05:19:41.275 if d1.seconds*1000 + d1.microseconds//1000 > MAX_WAITING_ENCR_FINISH:
2025-06-25 05:19:41.285 con.execute_immediate(f"select 'TIMEOUT EXPIRATION: encryption took {d1.seconds*1000 + d1.microseconds//1000} ms which exceeds limit = {MAX_WAITING_ENCR_FINISH} ms.' as msg from rdb$database")
2025-06-25 05:19:41.292 break
2025-06-25 05:19:41.298
2025-06-25 05:19:41.303 # Possible output:
2025-06-25 05:19:41.316 # Database not encrypted
2025-06-25 05:19:41.328 # Database encrypted, crypt thread not complete
2025-06-25 05:19:41.338 act_src.isql(switches=['-q'], input = 'show database;', combine_output = True)
2025-06-25 05:19:41.350 if 'Database encrypted' in act_src.stdout:
2025-06-25 05:19:41.359 if 'not complete' in act_src.stdout:
2025-06-25 05:19:41.367 pass
2025-06-25 05:19:41.374 else:
2025-06-25 05:19:41.386 break
2025-06-25 05:19:41.397 act_src.reset()
2025-06-25 05:19:41.408
2025-06-25 05:19:41.420 if d1.seconds*1000 + d1.microseconds//1000 <= MAX_WAITING_ENCR_FINISH:
2025-06-25 05:19:41.431 act_src.reset()
2025-06-25 05:19:41.440 act_src.gstat(switches=['-e'])
2025-06-25 05:19:41.447
2025-06-25 05:19:41.452 # Data pages: total 884803, encrypted 884803, non-crypted 0
2025-06-25 05:19:41.458 # ...
2025-06-25 05:19:41.466 pattern = re.compile('(data|index|blob|generator)\\s+pages[:]{0,1}\\s+total[:]{0,1}\\s+\\d+[,]{0,1}\\s+encrypted[:]{0,1}\\s+\\d+.*[,]{0,1}non-crypted[:]{0,1}\\s+\\d+.*', re.IGNORECASE)
2025-06-25 05:19:41.476 for line in act_src.stdout.splitlines():
2025-06-25 05:19:41.485 if pattern.match(line.strip()):
2025-06-25 05:19:41.493 # We assume that every line finishes with number of NON-crypted pages, and this number must be 0:
2025-06-25 05:19:41.504 words = line.split()
2025-06-25 05:19:41.513 if words[-1] == '0':
2025-06-25 05:19:41.521 print(words[0] + ': expected, ' + words[-1])
2025-06-25 05:19:41.527 else:
2025-06-25 05:19:41.534 print(words[0] + ': UNEXPECTED, ' + words[-1])
2025-06-25 05:19:41.540
2025-06-25 05:19:41.546 expected_gstat_tail = """
2025-06-25 05:19:41.551 Data: expected, 0
2025-06-25 05:19:41.558 Index: expected, 0
2025-06-25 05:19:41.563 Blob: expected, 0
2025-06-25 05:19:41.572 Generator: expected, 0
2025-06-25 05:19:41.582 """
2025-06-25 05:19:41.590 act_src.expected_stdout = expected_gstat_tail
2025-06-25 05:19:41.601 act_src.stdout = capsys.readouterr().out
2025-06-25 05:19:41.611 assert act_src.clean_stdout == act_src.clean_expected_stdout
2025-06-25 05:19:41.621 act_src.reset()
2025-06-25 05:19:41.629
2025-06-25 05:19:41.635 else:
2025-06-25 05:19:41.642 print(f'TIMEOUT EXPIRATION: encryption took {d1.seconds*1000 + d1.microseconds//1000} ms which exceeds limit = {MAX_WAITING_ENCR_FINISH} ms.')
2025-06-25 05:19:41.647
2025-06-25 05:19:41.653 ######################################################
2025-06-25 05:19:41.659
2025-06-25 05:19:41.667 # see also core_6071_test.py:
2025-06-25 05:19:41.678 act_src.gbak(switches=['-b', '-KEYHOLDER', ENCRYPTION_HOLDER, '-crypt', ENCRYPTION_PLUGIN, act_src.db.dsn, str(tmp_fbk)])
2025-06-25 05:19:41.686 act_src.reset()
2025-06-25 05:19:41.692
2025-06-25 05:19:41.700 act_src.gbak(switches=['-rep', '-KEYHOLDER', ENCRYPTION_HOLDER, str(tmp_fbk), act_res.db.dsn ])
2025-06-25 05:19:41.707 act_src.reset()
2025-06-25 05:19:41.712
2025-06-25 05:19:41.717 act_src.gfix(switches=['-v', '-full', str(act_res.db.db_path)])
2025-06-25 05:19:41.722 act_src.reset()
2025-06-25 05:19:41.727
2025-06-25 05:19:41.732 # Read gen page in RESTORED database, convert it to hex and check whether generator values can be found there or no.
2025-06-25 05:19:41.738 # Expected result: NOT for all values because DB was encrypted.
2025-06-25 05:19:41.744 # ~~~~~~~~~~~~~~~~
2025-06-25 05:19:41.751 check_page_for_readable_values(act_res.db.db_path, gen_page_number, pg_size, check_sequence_values, True, 'FINAL. ')
2025-06-25 05:19:41.755
2025-06-25 05:19:41.761 act_src.expected_stdout = 'FINAL. ' + SUCCESS_MSG
2025-06-25 05:19:41.767 act_src.stdout = capsys.readouterr().out
2025-06-25 05:19:41.773 assert act_src.clean_stdout == act_src.clean_expected_stdout
2025-06-25 05:19:41.778 act_src.reset()
2025-06-25 05:19:41.789
2025-06-25 05:19:41.798 #< with act_src.db.connect()
2025-06-25 05:19:41.806
2025-06-25 05:19:41.814 # Final check: ensure that sequences have proper values:
2025-06-25 05:19:41.819 ##############
2025-06-25 05:19:41.826 act_res.expected_stdout = """
2025-06-25 05:19:41.832 Generator GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
2025-06-25 05:19:41.839 Generator GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
2025-06-25 05:19:41.846 Generator GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
2025-06-25 05:19:41.851 Generator GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
2025-06-25 05:19:41.856 Generator GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
2025-06-25 05:19:41.860 Generator GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
2025-06-25 05:19:41.866 Generator GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
2025-06-25 05:19:41.871 """
2025-06-25 05:19:41.885 act_res.isql(switches = ['-q'], input = 'show sequ;', combine_output = True, io_enc = locale.getpreferredencoding())
2025-06-25 05:19:41.898 > assert act_res.clean_stdout == act_res.clean_expected_stdout
2025-06-25 05:19:41.910 E assert
2025-06-25 05:19:41.921 E - Generator GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
2025-06-25 05:19:41.934 E + Generator PUBLIC.GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
2025-06-25 05:19:41.951 E - Generator GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
2025-06-25 05:19:41.958 E + Generator PUBLIC.GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
2025-06-25 05:19:41.967 E - Generator GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
2025-06-25 05:19:41.972 E + Generator PUBLIC.GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
2025-06-25 05:19:41.980 E - Generator GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
2025-06-25 05:19:41.985 E + Generator PUBLIC.GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
2025-06-25 05:19:41.994 E - Generator GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
2025-06-25 05:19:41.999 E + Generator PUBLIC.GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
2025-06-25 05:19:42.010 E - Generator GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
2025-06-25 05:19:42.015 E + Generator PUBLIC.GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
2025-06-25 05:19:42.024 E - Generator GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
2025-06-25 05:19:42.029 E + Generator PUBLIC.GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
2025-06-25 05:19:42.037
2025-06-25 05:19:42.042 tests/bugs/core_4524_test.py:281: AssertionError
2025-06-25 05:19:42.050 ---------------------------- Captured stdout setup -----------------------------
2025-06-25 05:19:42.057 Creating db: localhost:/var/tmp/qa_2024/test_1878/test.fdb [page_size=None, sql_dialect=None, charset='NONE', user=SYSDBA, password=masterkey]
2025-06-25 05:19:42.070 Creating db: localhost:/var/tmp/qa_2024/test_1878/tmp_core_4524.restored.fdb [page_size=None, sql_dialect=None, charset='NONE', user=SYSDBA, password=masterkey]
|
3 #text |
act_src = <firebird.qa.plugin.Action pytest object at [hex]>
act_res = <firebird.qa.plugin.Action pytest object at [hex]>
tmp_fbk = PosixPath('/var/tmp/qa_2024/test_1878/tmp_core_4524.encrypted.fbk')
capsys = <_pytest.capture.CaptureFixture pytest object at [hex]>
@pytest.mark.encryption
@pytest.mark.version('>=4.0')
def test_1(act_src: Action, act_res: Action, tmp_fbk:Path, capsys):
init_sql = """
set bail on;
create sequence gen_ba0bab start with 12192683;
create sequence gen_badf00d start with 195948557;
create sequence gen_caca0 start with 830624;
create sequence gen_c0ffee start with 12648430;
create sequence gen_dec0de start with 14598366;
create sequence gen_decade start with 14600926;
create sequence gen_7FFFFFFF start with 2147483647;
commit;
"""
act_src.expected_stdout = ''
act_src.isql(switches = ['-q'], input = init_sql, combine_output = True, io_enc = locale.getpreferredencoding())
assert act_src.clean_stdout == act_src.clean_expected_stdout
act_src.reset()
check_sequence_values=[]
with act_src.db.connect() as con:
with con.cursor() as cur:
get_current_seq_values='''
execute block returns( gen_curr bigint) as
declare gen_name rdb$generator_name;
begin
for
select rdb$generator_name from rdb$generators where rdb$system_flag is distinct from 1 order by rdb$generator_id
into gen_name
do begin
execute statement 'execute block returns(g bigint) as begin g = gen_id('|| gen_name ||', 0); suspend; end' into gen_curr;
suspend;
end
end
'''
# Obtain current values of user generators:
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cur.execute(get_current_seq_values)
for r in cur:
check_sequence_values += r[0],
# Obtain page size and ID of generators page:
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cur.execute('select m.mon$page_size,min(rdb$page_number) from mon$database m cross join rdb$pages p where p.rdb$page_type = 9 group by 1')
pg_size, gen_page_number = -1,-1
for r in cur:
pg_size=r[0]
gen_page_number=r[1]
# print(r[0],r[1])
# Read gen page, convert it to hex and check whether generator values can be found there or no:
# Expected result: YES for all values because DB not encrypted now.
# ~~~~~~~~~~~~~~~
check_page_for_readable_values(act_src.db.db_path, gen_page_number, pg_size, check_sequence_values, False, 'INIT. ')
act_src.expected_stdout = 'INIT. ' + SUCCESS_MSG
act_src.stdout = capsys.readouterr().out
assert act_src.clean_stdout == act_src.clean_expected_stdout
act_src.reset()
######################################################
t1=py_dt.datetime.now()
d1 = t1-t1
sttm = f'alter database encrypt with "{ENCRYPTION_PLUGIN}" key "{ENCRYPTION_KEY}"'
try:
con.execute_immediate(sttm)
con.commit()
except DatabaseError as e:
print( e.__str__() )
act_src.expected_stdout = ''
act_src.stdout = capsys.readouterr().out
assert act_src.clean_stdout == act_src.clean_expected_stdout
act_src.reset()
while True:
t2=py_dt.datetime.now()
d1=t2-t1
if d1.seconds*1000 + d1.microseconds//1000 > MAX_WAITING_ENCR_FINISH:
con.execute_immediate(f"select 'TIMEOUT EXPIRATION: encryption took {d1.seconds*1000 + d1.microseconds//1000} ms which exceeds limit = {MAX_WAITING_ENCR_FINISH} ms.' as msg from rdb$database")
break
# Possible output:
# Database not encrypted
# Database encrypted, crypt thread not complete
act_src.isql(switches=['-q'], input = 'show database;', combine_output = True)
if 'Database encrypted' in act_src.stdout:
if 'not complete' in act_src.stdout:
pass
else:
break
act_src.reset()
if d1.seconds*1000 + d1.microseconds//1000 <= MAX_WAITING_ENCR_FINISH:
act_src.reset()
act_src.gstat(switches=['-e'])
# Data pages: total 884803, encrypted 884803, non-crypted 0
# ...
pattern = re.compile('(data|index|blob|generator)\\s+pages[:]{0,1}\\s+total[:]{0,1}\\s+\\d+[,]{0,1}\\s+encrypted[:]{0,1}\\s+\\d+.*[,]{0,1}non-crypted[:]{0,1}\\s+\\d+.*', re.IGNORECASE)
for line in act_src.stdout.splitlines():
if pattern.match(line.strip()):
# We assume that every line finishes with number of NON-crypted pages, and this number must be 0:
words = line.split()
if words[-1] == '0':
print(words[0] + ': expected, ' + words[-1])
else:
print(words[0] + ': UNEXPECTED, ' + words[-1])
expected_gstat_tail = """
Data: expected, 0
Index: expected, 0
Blob: expected, 0
Generator: expected, 0
"""
act_src.expected_stdout = expected_gstat_tail
act_src.stdout = capsys.readouterr().out
assert act_src.clean_stdout == act_src.clean_expected_stdout
act_src.reset()
else:
print(f'TIMEOUT EXPIRATION: encryption took {d1.seconds*1000 + d1.microseconds//1000} ms which exceeds limit = {MAX_WAITING_ENCR_FINISH} ms.')
######################################################
# see also core_6071_test.py:
act_src.gbak(switches=['-b', '-KEYHOLDER', ENCRYPTION_HOLDER, '-crypt', ENCRYPTION_PLUGIN, act_src.db.dsn, str(tmp_fbk)])
act_src.reset()
act_src.gbak(switches=['-rep', '-KEYHOLDER', ENCRYPTION_HOLDER, str(tmp_fbk), act_res.db.dsn ])
act_src.reset()
act_src.gfix(switches=['-v', '-full', str(act_res.db.db_path)])
act_src.reset()
# Read gen page in RESTORED database, convert it to hex and check whether generator values can be found there or no.
# Expected result: NOT for all values because DB was encrypted.
# ~~~~~~~~~~~~~~~~
check_page_for_readable_values(act_res.db.db_path, gen_page_number, pg_size, check_sequence_values, True, 'FINAL. ')
act_src.expected_stdout = 'FINAL. ' + SUCCESS_MSG
act_src.stdout = capsys.readouterr().out
assert act_src.clean_stdout == act_src.clean_expected_stdout
act_src.reset()
#< with act_src.db.connect()
# Final check: ensure that sequences have proper values:
##############
act_res.expected_stdout = """
Generator GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
Generator GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
Generator GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
Generator GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
Generator GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
Generator GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
Generator GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
"""
act_res.isql(switches = ['-q'], input = 'show sequ;', combine_output = True, io_enc = locale.getpreferredencoding())
> assert act_res.clean_stdout == act_res.clean_expected_stdout
E assert
E - Generator GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
E + Generator PUBLIC.GEN_7FFFFFFF, current value: 2147483646, initial value: 2147483647, increment: 1
E - Generator GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
E + Generator PUBLIC.GEN_BA0BAB, current value: 12192682, initial value: 12192683, increment: 1
E - Generator GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
E + Generator PUBLIC.GEN_BADF00D, current value: 195948556, initial value: 195948557, increment: 1
E - Generator GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
E + Generator PUBLIC.GEN_C0FFEE, current value: 12648429, initial value: 12648430, increment: 1
E - Generator GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
E + Generator PUBLIC.GEN_CACA0, current value: 830623, initial value: 830624, increment: 1
E - Generator GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
E + Generator PUBLIC.GEN_DEC0DE, current value: 14598365, initial value: 14598366, increment: 1
E - Generator GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
E + Generator PUBLIC.GEN_DECADE, current value: 14600925, initial value: 14600926, increment: 1
tests/bugs/core_4524_test.py:281: AssertionError
|