Doc
Details
Grants
References
Dependencies
Code
Doc
Details
Grants
References
Dependencies
Code
| NAME | VALUE |
|---|---|
| OWNER | WTP |
| OBJECT_NAME | WT_TEST_RUN_STAT |
| SUBOBJECT_NAME | null |
| OBJECT_ID | 41961 |
| DATA_OBJECT_ID | null |
| OBJECT_TYPE | PACKAGE BODY |
| CREATED | 29-JUN-2018 15:21:18 |
| LAST_DDL_TIME | 29-JUN-2018 15:21:18 |
| TIMESTAMP | 2018-06-29:15:21:18 |
| STATUS | VALID |
| TEMPORARY | N |
| GENERATED | N |
| SECONDARY | N |
| NAMESPACE | 2 |
| EDITION_NAME | null |
| PRIVILEGE | GRANTEE | GRANTABLE | GRANTOR | OBJECT_NAME |
|---|
| NAME | OWNER | TYPE | OBJECT_ID | STATUS | TYPE_LINK |
|---|
| NAME | OWNER | TYPE | OBJECT_ID | STATUS | TYPE_LINK |
|---|
package body wt_test_run_stat
as
TYPE tc_aa_type is
table of wt_testcase_stats%ROWTYPE
index by varchar2(50);
g_tc_aa tc_aa_type;
g_rec wt_test_run_stats%ROWTYPE;
----------------------
-- Private Procedures
----------------------
---------------------
-- Public Procedures
---------------------
------------------------------------------------------------
procedure initialize
is
l_recNULL wt_test_run_stats%ROWTYPE;
begin
g_rec := l_recNULL;
g_tc_aa.delete;
end initialize;
$IF $$WTPLSQL_SELFTEST ------%WTPLSQL_begin_ignore_lines%------
$THEN
procedure t_initialize
is
l_tc_aaSAVE tc_aa_type;
l_recSAVE wt_test_run_stats%ROWTYPE;
l_tc_aaTEST tc_aa_type;
l_recTEST wt_test_run_stats%ROWTYPE;
begin
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'Initialize Happy Path 1 Setup';
l_tc_aaTEST('TESTCASE1').test_run_id := -2;
l_recTEST.test_run_id := -1;
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').test_run_id',
check_this_in => l_tc_aaTEST('TESTCASE1').test_run_id,
against_this_in => -2 );
wt_assert.eq (
msg_in => 'l_recTEST.test_run_id',
check_this_in => l_recTEST.test_run_id,
against_this_in => -1 );
-------------------------------------- WTPLSQL Testing --
l_tc_aaSAVE := g_tc_aa;
l_recSAVE := g_rec;
g_tc_aa := l_tc_aaTEST;
g_rec := l_recTEST;
initialize;
l_tc_aaTEST := g_tc_aa;
l_recTEST := g_rec;
g_tc_aa := l_tc_aaSAVE;
g_rec := l_recSAVE;
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'Initialize Happy Path 1';
wt_assert.eq (
msg_in => 'l_tc_aaTEST.COUNT',
check_this_in => l_tc_aaTEST.COUNT,
against_this_in => 0 );
wt_assert.isnull (
msg_in => 'l_recTEST.test_run_id',
check_this_in => l_recTEST.test_run_id );
end t_initialize;
$END ----------------%WTPLSQL_end_ignore_lines%----------------
------------------------------------------------------------
procedure add_result
(in_results_rec in wt_results%ROWTYPE)
is
tc varchar2(50);
begin
-- If this raises an exception, it must be done before any other values
-- are set because they will not be rolled-back after the "raise".
case in_results_rec.status
when 'PASS' then
g_rec.passes := nvl(g_rec.passes,0) + 1;
when 'FAIL' then
g_rec.failures := nvl(g_rec.failures,0) + 1;
when 'ERR' then
g_rec.errors := nvl(g_rec.errors,0) + 1;
else
raise_application_error(-20010, 'Unknown Result status "' ||
in_results_rec.status || '"');
end case;
g_rec.test_run_id := in_results_rec.test_run_id;
g_rec.asserts := nvl(g_rec.asserts,0) + 1;
g_rec.min_interval_msecs := least(nvl(g_rec.min_interval_msecs,999999999)
,in_results_rec.interval_msecs);
g_rec.max_interval_msecs := greatest(nvl(g_rec.max_interval_msecs,0)
,in_results_rec.interval_msecs);
g_rec.tot_interval_msecs := nvl(g_rec.tot_interval_msecs,0) +
in_results_rec.interval_msecs;
if in_results_rec.testcase is not null
then
tc := in_results_rec.testcase;
g_tc_aa(tc).testcase := tc;
g_tc_aa(tc).test_run_id := in_results_rec.test_run_id;
g_tc_aa(tc).asserts := nvl(g_tc_aa(tc).asserts,0) + 1;
case in_results_rec.status
when 'PASS' then
g_tc_aa(tc).passes := nvl(g_tc_aa(tc).passes,0) + 1;
when 'FAIL' then
g_tc_aa(tc).failures := nvl(g_tc_aa(tc).failures,0) + 1;
when 'ERR' then
g_tc_aa(tc).errors := nvl(g_tc_aa(tc).errors,0) + 1;
-- No need to check "ELSE" because it would have been caught above
end case;
g_tc_aa(tc).min_interval_msecs := least(nvl(g_tc_aa(tc).min_interval_msecs,999999999)
,in_results_rec.interval_msecs);
g_tc_aa(tc).max_interval_msecs := greatest(nvl(g_tc_aa(tc).max_interval_msecs,0)
,in_results_rec.interval_msecs);
g_tc_aa(tc).tot_interval_msecs := nvl(g_tc_aa(tc).tot_interval_msecs,0) +
in_results_rec.interval_msecs;
end if;
end add_result;
$IF $$WTPLSQL_SELFTEST ------%WTPLSQL_begin_ignore_lines%------
$THEN
procedure t_add_result
is
l_tc_aaSAVE tc_aa_type;
l_recSAVE wt_test_run_stats%ROWTYPE;
l_tc_aaTEST tc_aa_type;
l_recTEST wt_test_run_stats%ROWTYPE;
l_resultTEST wt_results%ROWTYPE;
l_sqlerrm varchar2(4000);
begin
-------------------------------------- WTPLSQL Testing --
-- Overview:
-- 1) Save results in temporary variables
-- 2) Clear ADD_RESULT variables
-- 3) Call ADD_RESULT several times with test data.
-- 4) Capture test results
-- 5) Restore saved results
-- 6) Confirm the test results using WT_ASSERT.
-------------------------------------- WTPLSQL Testing --
l_tc_aaSAVE := g_tc_aa;
l_recSAVE := g_rec;
g_tc_aa := l_tc_aaTEST;
g_rec := l_recTEST;
l_resultTEST.test_run_id := -10;
l_resultTEST.interval_msecs := 10;
l_resultTEST.status := 'PASS';
l_resultTEST.testcase := 'TESTCASE1';
add_result(l_resultTEST);
-------------------------------------- WTPLSQL Testing --
l_resultTEST.interval_msecs := 20;
l_resultTEST.status := 'FAIL';
l_resultTEST.testcase := 'TESTCASE1';
add_result(l_resultTEST);
l_resultTEST.interval_msecs := 30;
l_resultTEST.status := 'ERR';
l_resultTEST.testcase := 'TESTCASE1';
add_result(l_resultTEST);
-------------------------------------- WTPLSQL Testing --
l_resultTEST.interval_msecs := 40;
l_resultTEST.status := 'ABC';
l_resultTEST.testcase := 'TESTCASE1';
begin
add_result(l_resultTEST);
l_sqlerrm := SQLERRM;
exception when others then
l_sqlerrm := SQLERRM;
end;
-------------------------------------- WTPLSQL Testing --
l_tc_aaTEST := g_tc_aa;
l_recTEST := g_rec;
g_tc_aa := l_tc_aaSAVE;
g_rec := l_recSAVE;
wt_assert.g_testcase := 'Add Result Testing';
wt_assert.eq (
msg_in => 'Add Result Sad Path 1',
check_this_in => 'ORA-20010: Unknown Result status "ABC"',
against_this_in => l_sqlerrm);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.test_run_id',
check_this_in => l_recTEST.test_run_id,
against_this_in => -10);
wt_assert.eq (
msg_in => 'l_recTEST.asserts',
check_this_in => l_recTEST.asserts,
against_this_in => 3);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.passes',
check_this_in => l_recTEST.passes,
against_this_in => 1);
wt_assert.eq (
msg_in => 'l_recTEST.failures',
check_this_in => l_recTEST.failures,
against_this_in => 1);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.errors',
check_this_in => l_recTEST.errors,
against_this_in => 1);
wt_assert.eq (
msg_in => 'l_recTEST.min_interval_msecs',
check_this_in => l_recTEST.min_interval_msecs,
against_this_in => 10);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.max_interval_msecs',
check_this_in => l_recTEST.max_interval_msecs,
against_this_in => 30);
wt_assert.eq (
msg_in => 'l_recTEST.tot_interval_msecs',
check_this_in => l_recTEST.tot_interval_msecs,
against_this_in => 60);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').test_run_id',
check_this_in => l_tc_aaTEST('TESTCASE1').test_run_id,
against_this_in => -10);
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').asserts',
check_this_in => l_tc_aaTEST('TESTCASE1').asserts,
against_this_in => 3);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').passes',
check_this_in => l_tc_aaTEST('TESTCASE1').passes,
against_this_in => 1);
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').failures',
check_this_in => l_tc_aaTEST('TESTCASE1').failures,
against_this_in => 1);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').errors',
check_this_in => l_tc_aaTEST('TESTCASE1').errors,
against_this_in => 1);
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').min_interval_msecs',
check_this_in => l_tc_aaTEST('TESTCASE1').min_interval_msecs,
against_this_in => 10);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').max_interval_msecs',
check_this_in => l_tc_aaTEST('TESTCASE1').max_interval_msecs,
against_this_in => 30);
wt_assert.eq (
msg_in => 'l_tc_aaTEST(''TESTCASE1'').tot_interval_msecs',
check_this_in => l_tc_aaTEST('TESTCASE1').tot_interval_msecs,
against_this_in => 60);
end t_add_result;
$END ----------------%WTPLSQL_end_ignore_lines%----------------
------------------------------------------------------------
procedure add_profile
(in_dbout_profiles_rec in wt_dbout_profiles%ROWTYPE)
is
begin
-- If this raises an exception, it must be done before any other values
-- are set because they will not be rolled-back after the "raise".
case in_dbout_profiles_rec.status
when 'EXEC' then
g_rec.executed_lines := nvl(g_rec.executed_lines,0) + 1;
-- Only count the executed time.
g_rec.min_executed_usecs := least(nvl(g_rec.min_executed_usecs,999999999)
,in_dbout_profiles_rec.min_usecs);
g_rec.max_executed_usecs := greatest(nvl(g_rec.max_executed_usecs,0)
,in_dbout_profiles_rec.max_usecs);
g_rec.tot_executed_usecs := nvl(g_rec.tot_executed_usecs,0) +
( in_dbout_profiles_rec.total_usecs /
in_dbout_profiles_rec.total_occur );
when 'IGNR' then
g_rec.ignored_lines := nvl(g_rec.ignored_lines,0) + 1;
when 'EXCL' then
g_rec.excluded_lines := nvl(g_rec.excluded_lines,0) + 1;
when 'NOTX' then
g_rec.notexec_lines := nvl(g_rec.notexec_lines,0) + 1;
when 'UNKN' then
g_rec.unknown_lines := nvl(g_rec.unknown_lines,0) + 1;
else
raise_application_error(-20011, 'Unknown Profile status "' ||
in_dbout_profiles_rec.status || '"');
end case;
g_rec.test_run_id := in_dbout_profiles_rec.test_run_id;
g_rec.profiled_lines := nvl(g_rec.profiled_lines,0) + 1;
end add_profile;
$IF $$WTPLSQL_SELFTEST ------%WTPLSQL_begin_ignore_lines%------
$THEN
procedure t_add_profile
is
l_recSAVE wt_test_run_stats%ROWTYPE;
l_recTEST wt_test_run_stats%ROWTYPE;
l_profileTEST wt_dbout_profiles%ROWTYPE;
l_sqlerrm varchar2(4000);
begin
-------------------------------------- WTPLSQL Testing --
-- Overview:
-- 1) Save results in temporary variables
-- 2) Clear ADD_PROFILE variables
-- 3) Call ADD_PROFILE several times with test data.
-- 4) Capture test results
-- 5) Restore saved results
-- 6) Confirm the test results using WT_ASSERT.
-------------------------------------- WTPLSQL Testing --
l_recSAVE := g_rec;
g_rec := l_recTEST;
l_profileTEST.test_run_id := -20;
l_profileTEST.min_usecs := 10;
l_profileTEST.max_usecs := 20;
l_profileTEST.total_usecs := 30;
l_profileTEST.total_occur := 1;
l_profileTEST.status := 'EXEC';
add_profile(l_profileTEST);
l_profileTEST.status := 'EXEC';
add_profile(l_profileTEST);
-------------------------------------- WTPLSQL Testing --
l_profileTEST.status := 'EXEC';
add_profile(l_profileTEST);
l_profileTEST.status := 'EXEC';
add_profile(l_profileTEST);
l_profileTEST.status := 'EXEC';
add_profile(l_profileTEST);
l_profileTEST.status := 'IGNR';
add_profile(l_profileTEST);
l_profileTEST.status := 'IGNR';
add_profile(l_profileTEST);
-------------------------------------- WTPLSQL Testing --
l_profileTEST.status := 'IGNR';
add_profile(l_profileTEST);
l_profileTEST.status := 'IGNR';
add_profile(l_profileTEST);
l_profileTEST.status := 'NOTX';
add_profile(l_profileTEST);
l_profileTEST.status := 'NOTX';
add_profile(l_profileTEST);
l_profileTEST.status := 'NOTX';
add_profile(l_profileTEST);
-------------------------------------- WTPLSQL Testing --
l_profileTEST.status := 'EXCL';
add_profile(l_profileTEST);
l_profileTEST.status := 'EXCL';
add_profile(l_profileTEST);
l_profileTEST.status := 'UNKN';
add_profile(l_profileTEST);
-------------------------------------- WTPLSQL Testing --
l_profileTEST.status := 'ABC';
begin
add_profile(l_profileTEST);
l_sqlerrm := SQLERRM;
exception when others then
l_sqlerrm := SQLERRM;
end;
l_recTEST := g_rec;
g_rec := l_recSAVE;
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'Add Profile Testing';
wt_assert.eq (
msg_in => 'l_recTEST.test_run_id',
check_this_in => l_recTEST.test_run_id,
against_this_in => -20);
wt_assert.eq (
msg_in => 'l_recTEST.profiled_lines',
check_this_in => l_recTEST.profiled_lines,
against_this_in => 15);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.min_executed_usecs',
check_this_in => l_recTEST.min_executed_usecs,
against_this_in => 10);
wt_assert.eq (
msg_in => 'l_recTEST.max_executed_usecs',
check_this_in => l_recTEST.max_executed_usecs,
against_this_in => 20);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.tot_executed_usecs',
check_this_in => l_recTEST.tot_executed_usecs,
against_this_in => 150);
wt_assert.eq (
msg_in => 'l_recTEST.executed_lines',
check_this_in => l_recTEST.executed_lines,
against_this_in => 5);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.ignored_lines',
check_this_in => l_recTEST.ignored_lines,
against_this_in => 4);
wt_assert.eq (
msg_in => 'l_recTEST.notexec_lines',
check_this_in => l_recTEST.notexec_lines,
against_this_in => 3);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.excluded_lines',
check_this_in => l_recTEST.excluded_lines,
against_this_in => 2);
wt_assert.eq (
msg_in => 'l_recTEST.unknown_lines',
check_this_in => l_recTEST.unknown_lines,
against_this_in => 1);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'Add Result Sad Path 1',
check_this_in => 'ORA-20011: Unknown Profile status "ABC"',
against_this_in => l_sqlerrm);
end t_add_profile;
$END ----------------%WTPLSQL_end_ignore_lines%----------------
------------------------------------------------------------
procedure finalize
is
PRAGMA AUTONOMOUS_TRANSACTION;
l_executable_lines number;
tc varchar2(50);
begin
if g_rec.test_run_id is null
then
initialize;
return;
end if;
g_rec.testcases := g_tc_aa.COUNT;
g_rec.asserts := nvl(g_rec.asserts ,0);
g_rec.passes := nvl(g_rec.passes ,0);
g_rec.failures := nvl(g_rec.failures,0);
g_rec.errors := nvl(g_rec.errors ,0);
if g_rec.asserts != 0
then
g_rec.test_yield := round(g_rec.passes/g_rec.asserts, 3);
g_rec.avg_interval_msecs := round(g_rec.tot_interval_msecs/g_rec.asserts, 3);
end if;
if g_rec.profiled_lines is not null
then
g_rec.executed_lines := nvl(g_rec.executed_lines ,0);
g_rec.ignored_lines := nvl(g_rec.ignored_lines,0);
g_rec.excluded_lines := nvl(g_rec.excluded_lines ,0);
g_rec.notexec_lines := nvl(g_rec.notexec_lines ,0);
g_rec.unknown_lines := nvl(g_rec.unknown_lines ,0);
l_executable_lines := g_rec.executed_lines + g_rec.notexec_lines;
if l_executable_lines != 0
then
g_rec.code_coverage := round(g_rec.executed_lines/l_executable_lines, 3);
g_rec.avg_executed_usecs := round(g_rec.tot_executed_usecs/l_executable_lines, 3);
end if;
end if;
insert into wt_test_run_stats values g_rec;
if g_rec.testcases > 0
then
tc := g_tc_aa.FIRST;
loop
g_tc_aa(tc).asserts := nvl(g_tc_aa(tc).asserts ,0);
g_tc_aa(tc).passes := nvl(g_tc_aa(tc).passes ,0);
g_tc_aa(tc).failures := nvl(g_tc_aa(tc).failures,0);
g_tc_aa(tc).errors := nvl(g_tc_aa(tc).errors ,0);
if g_rec.asserts != 0
then
g_tc_aa(tc).test_yield := round(g_tc_aa(tc).passes /
g_tc_aa(tc).asserts, 3);
g_tc_aa(tc).avg_interval_msecs := round(g_tc_aa(tc).tot_interval_msecs /
g_tc_aa(tc).asserts, 3);
end if;
insert into wt_testcase_stats values g_tc_aa(tc);
exit when tc = g_tc_aa.LAST;
tc := g_tc_aa.NEXT(tc);
end loop;
end if;
COMMIT;
initialize;
end finalize;
$IF $$WTPLSQL_SELFTEST ------%WTPLSQL_begin_ignore_lines%------
$THEN
procedure t_finalize
is
l_tc_aaSAVE tc_aa_type;
l_recSAVE wt_test_run_stats%ROWTYPE;
l_tc_aaTEST tc_aa_type;
l_recTEST wt_test_run_stats%ROWTYPE;
l_recNULL wt_test_run_stats%ROWTYPE;
l_tstat_rec wt_testcase_stats%ROWTYPE;
l_test_run_id number := -102;
l_tc varchar2(50) := 'TC2';
l_sql_txt varchar2(4000);
l_sqlerrm varchar2(4000);
-------------------------------------- WTPLSQL Testing --
procedure run_finalize (in_msg_txt in varchar2) is begin
l_tc_aaSAVE := g_tc_aa;
l_recSAVE := g_rec;
g_tc_aa := l_tc_aaTEST;
g_rec := l_recTEST;
begin
finalize;
l_sqlerrm := SQLERRM;
exception when others then
l_sqlerrm := SQLERRM;
end;
-------------------------------------- WTPLSQL Testing --
l_tc_aaTEST := g_tc_aa;
l_recTEST := g_rec;
g_tc_aa := l_tc_aaSAVE;
g_rec := l_recSAVE;
wt_assert.eq (
msg_in => in_msg_txt,
check_this_in => l_sqlerrm,
against_this_in => 'ORA-0000: normal, successful completion');
end run_finalize;
begin
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'FINALIZE Happy Path Setup';
l_sql_txt := 'insert into WT_TEST_RUNS' ||
' (id, start_dtm, runner_owner, runner_name)' ||
' values (' || l_test_run_id || ', sysdate, USER, ''TESTRUNNER3'')';
wt_assert.raises (
msg_in => 'Insert WT_TEST_RUNS Record',
check_call_in => l_sql_txt,
against_exc_in => '');
commit;
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'FINALIZE Happy Path 1';
l_tc_aaTEST.delete;
l_recTEST := l_recNULL;
l_recTEST.test_run_id := l_test_run_id;
run_finalize('Run Finalize for Happy Path 1'); -- AUTONOMOUS COMMIT
-------------------------------------- WTPLSQL Testing --
begin
select * into l_recTEST
from WT_TEST_RUN_STATS
where test_run_id = l_test_run_id;
l_sqlerrm := SQLERRM;
exception when others then
l_sqlerrm := SQLERRM;
end;
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'Retieve WT_TEST_RUN_STATS record',
check_this_in => l_sqlerrm,
against_this_in => 'ORA-0000: normal, successful completion');
wt_assert.eq (
msg_in => 'l_recTEST.test_run_id',
check_this_in => l_recTEST.test_run_id,
against_this_in => l_test_run_id);
-------------------------------------- WTPLSQL Testing --
wt_assert.isnull (
msg_in => 'l_recTEST.test_yield',
check_this_in => l_recTEST.test_yield);
wt_assert.eq (
msg_in => 'l_recTEST.asserts',
check_this_in => l_recTEST.asserts,
against_this_in => 0);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.passes',
check_this_in => l_recTEST.passes,
against_this_in => 0);
wt_assert.eq (
msg_in => 'l_recTEST.failures',
check_this_in => l_recTEST.failures,
against_this_in => 0);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.errors',
check_this_in => l_recTEST.errors,
against_this_in => 0);
wt_assert.eq (
msg_in => 'l_recTEST.testcases',
check_this_in => l_recTEST.testcases,
against_this_in => 0);
-------------------------------------- WTPLSQL Testing --
wt_assert.isnull (
msg_in => 'l_recTEST.min_interval_msecs',
check_this_in => l_recTEST.min_interval_msecs);
wt_assert.isnull (
msg_in => 'l_recTEST.avg_interval_msecs',
check_this_in => l_recTEST.avg_interval_msecs);
wt_assert.isnull (
msg_in => 'l_recTEST.max_interval_msecs',
check_this_in => l_recTEST.max_interval_msecs);
-------------------------------------- WTPLSQL Testing --
wt_assert.isnull (
msg_in => 'l_recTEST.tot_interval_msecs',
check_this_in => l_recTEST.tot_interval_msecs);
wt_assert.isnull (
msg_in => 'l_recTEST.code_coverage',
check_this_in => l_recTEST.code_coverage);
wt_assert.isnull (
msg_in => 'l_recTEST.profiled_lines',
check_this_in => l_recTEST.profiled_lines);
-------------------------------------- WTPLSQL Testing --
wt_assert.isnull (
msg_in => 'l_recTEST.executed_lines',
check_this_in => l_recTEST.executed_lines);
wt_assert.isnull (
msg_in => 'l_recTEST.ignored_lines',
check_this_in => l_recTEST.ignored_lines);
wt_assert.isnull (
msg_in => 'l_recTEST.excluded_lines',
check_this_in => l_recTEST.excluded_lines);
-------------------------------------- WTPLSQL Testing --
wt_assert.isnull (
msg_in => 'l_recTEST.notexec_lines',
check_this_in => l_recTEST.notexec_lines);
wt_assert.isnull (
msg_in => 'l_recTEST.unknown_lines',
check_this_in => l_recTEST.unknown_lines);
wt_assert.isnull (
msg_in => 'l_recTEST.avg_executed_usecs',
check_this_in => l_recTEST.avg_executed_usecs);
-------------------------------------- WTPLSQL Testing --
wt_assert.eqqueryvalue (
msg_in => 'There should be no WT_TESTCASE_STATS records',
check_query_in => 'select count(*) from WT_TESTCASE_STATS' ||
' where test_run_id = ' || l_test_run_id,
against_value_in => 0);
-------------------------------------- WTPLSQL Testing --
wt_assert.raises (
msg_in => 'Delete WT_TEST_RUN_STATS Record',
check_call_in => 'delete from WT_TEST_RUN_STATS where test_run_id = ' ||
l_test_run_id,
against_exc_in => '');
commit;
wt_assert.eqqueryvalue (
msg_in => 'There should be no WT_TEST_RUN_STATS records',
check_query_in => 'select count(*) from WT_TEST_RUN_STATS' ||
' where test_run_id = ' || l_test_run_id,
against_value_in => 0);
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'FINALIZE Happy Path 2';
l_tc_aaTEST.delete;
l_tc_aaTEST(l_tc||'a').test_run_id := l_test_run_id;
l_tc_aaTEST(l_tc||'a').testcase := l_tc||'a';
l_tc_aaTEST(l_tc||'a').asserts := 3;
l_tc_aaTEST(l_tc||'a').passes := 2;
l_tc_aaTEST(l_tc||'a').failures := 1;
--l_tc_aaTEST(l_tc||'a').errors := null;
l_tc_aaTEST(l_tc||'a').tot_interval_msecs := 300;
-------------------------------------- WTPLSQL Testing --
l_tc_aaTEST(l_tc||'b').test_run_id := l_test_run_id;
l_tc_aaTEST(l_tc||'b').testcase := l_tc||'b';
l_tc_aaTEST(l_tc||'b').asserts := 3;
l_tc_aaTEST(l_tc||'b').passes := 2;
l_tc_aaTEST(l_tc||'b').failures := 1;
--l_tc_aaTEST(l_tc||'b').errors := null;
l_tc_aaTEST(l_tc||'b').tot_interval_msecs := 300;
-------------------------------------- WTPLSQL Testing --
l_recTEST := l_recNULL;
l_recTEST.test_run_id := l_test_run_id;
l_recTEST.asserts := 6;
l_recTEST.passes := 4;
l_recTEST.failures := 2;
--l_recTEST.errors := null;
l_recTEST.tot_interval_msecs := 600;
-------------------------------------- WTPLSQL Testing --
l_recTEST.profiled_lines := 20;
l_recTEST.executed_lines := 8;
l_recTEST.ignored_lines := 6;
l_recTEST.excluded_lines := 4;
l_recTEST.notexec_lines := 2;
--l_recTEST.unknown_lines := null;
l_recTEST.tot_executed_usecs := 2000;
run_finalize('Run Finalize for Happy Path 2'); -- AUTONOMOUS COMMIT
-------------------------------------- WTPLSQL Testing --
begin
select * into l_tstat_rec
from WT_TESTCASE_STATS
where test_run_id = l_test_run_id
and testcase = l_tc||'a';
l_sqlerrm := SQLERRM;
exception when others then
l_sqlerrm := SQLERRM;
end;
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'Retieve WT_TESTCASE_STATS record',
check_this_in => l_sqlerrm,
against_this_in => 'ORA-0000: normal, successful completion');
wt_assert.eq (
msg_in => 'l_tstat_rec.test_run_id',
check_this_in => l_tstat_rec.test_run_id,
against_this_in => l_test_run_id);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tstat_rec.testcase',
check_this_in => l_tstat_rec.testcase,
against_this_in => l_tc||'a');
wt_assert.eq (
msg_in => 'l_tstat_rec.asserts',
check_this_in => l_tstat_rec.asserts,
against_this_in => 3);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tstat_rec.passes',
check_this_in => l_tstat_rec.passes,
against_this_in => 2);
wt_assert.eq (
msg_in => 'l_tstat_rec.failures',
check_this_in => l_tstat_rec.failures,
against_this_in => 1);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tstat_rec.errors',
check_this_in => l_tstat_rec.errors,
against_this_in => 0);
wt_assert.eq (
msg_in => 'l_tstat_rec.test_yield',
check_this_in => l_tstat_rec.test_yield,
against_this_in => 0.667);
wt_assert.eq (
msg_in => 'l_tstat_rec.avg_interval_msecs',
check_this_in => l_tstat_rec.avg_interval_msecs,
against_this_in => 100);
-------------------------------------- WTPLSQL Testing --
begin
select * into l_tstat_rec
from WT_TESTCASE_STATS
where test_run_id = l_test_run_id
and testcase = l_tc||'b';
l_sqlerrm := SQLERRM;
exception when others then
l_sqlerrm := SQLERRM;
end;
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'Retieve WT_TESTCASE_STATS record',
check_this_in => l_sqlerrm,
against_this_in => 'ORA-0000: normal, successful completion');
wt_assert.eq (
msg_in => 'l_tstat_rec.test_run_id',
check_this_in => l_tstat_rec.test_run_id,
against_this_in => l_test_run_id);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tstat_rec.testcase',
check_this_in => l_tstat_rec.testcase,
against_this_in => l_tc||'b');
wt_assert.eq (
msg_in => 'l_tstat_rec.asserts',
check_this_in => l_tstat_rec.asserts,
against_this_in => 3);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tstat_rec.passes',
check_this_in => l_tstat_rec.passes,
against_this_in => 2);
wt_assert.eq (
msg_in => 'l_tstat_rec.failures',
check_this_in => l_tstat_rec.failures,
against_this_in => 1);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_tstat_rec.errors',
check_this_in => l_tstat_rec.errors,
against_this_in => 0);
wt_assert.eq (
msg_in => 'l_tstat_rec.test_yield',
check_this_in => l_tstat_rec.test_yield,
against_this_in => 0.667);
wt_assert.eq (
msg_in => 'l_tstat_rec.avg_interval_msecs',
check_this_in => l_tstat_rec.avg_interval_msecs,
against_this_in => 100);
-------------------------------------- WTPLSQL Testing --
begin
select * into l_recTEST
from WT_TEST_RUN_STATS
where test_run_id = l_test_run_id;
l_sqlerrm := SQLERRM;
exception when others then
l_sqlerrm := SQLERRM;
end;
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'Retieve WT_TEST_RUN_STATS record',
check_this_in => l_sqlerrm,
against_this_in => 'ORA-0000: normal, successful completion');
wt_assert.eq (
msg_in => 'l_recTEST.test_run_id',
check_this_in => l_recTEST.test_run_id,
against_this_in => l_test_run_id);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.test_yield',
check_this_in => l_recTEST.test_yield,
against_this_in => 0.667);
wt_assert.eq (
msg_in => 'l_recTEST.asserts',
check_this_in => l_recTEST.asserts,
against_this_in => 6);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.passes',
check_this_in => l_recTEST.passes,
against_this_in => 4);
wt_assert.eq (
msg_in => 'l_recTEST.failures',
check_this_in => l_recTEST.failures,
against_this_in => 2);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.errors',
check_this_in => l_recTEST.errors,
against_this_in => 0);
wt_assert.eq (
msg_in => 'l_recTEST.testcases',
check_this_in => l_recTEST.testcases,
against_this_in => 2);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.avg_interval_msecs',
check_this_in => l_recTEST.avg_interval_msecs,
against_this_in => 100);
wt_assert.eq (
msg_in => 'l_recTEST.code_coverage',
check_this_in => l_recTEST.code_coverage,
against_this_in => 0.8);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.profiled_lines',
check_this_in => l_recTEST.profiled_lines,
against_this_in => 20);
wt_assert.eq (
msg_in => 'l_recTEST.executed_lines',
check_this_in => l_recTEST.executed_lines,
against_this_in => 8);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.ignored_lines',
check_this_in => l_recTEST.ignored_lines,
against_this_in => 6);
wt_assert.eq (
msg_in => 'l_recTEST.excluded_lines',
check_this_in => l_recTEST.excluded_lines,
against_this_in => 4);
-------------------------------------- WTPLSQL Testing --
wt_assert.eq (
msg_in => 'l_recTEST.notexec_lines',
check_this_in => l_recTEST.notexec_lines,
against_this_in => 2);
wt_assert.eq (
msg_in => 'l_recTEST.unknown_lines',
check_this_in => l_recTEST.unknown_lines,
against_this_in => 0);
wt_assert.eq (
msg_in => 'l_recTEST.avg_executed_usecs',
check_this_in => l_recTEST.avg_executed_usecs,
against_this_in => 200);
-------------------------------------- WTPLSQL Testing --
wt_assert.raises (
msg_in => 'Delete WT_TESTCASE_STATS Record',
check_call_in => 'delete from WT_TESTCASE_STATS where test_run_id = ' ||
l_test_run_id,
against_exc_in => '');
commit;
wt_assert.eqqueryvalue (
msg_in => 'There should be no WT_TESTCASE_STATS records',
check_query_in => 'select count(*) from WT_TESTCASE_STATS' ||
' where test_run_id = ' || l_test_run_id,
against_value_in => 0);
-------------------------------------- WTPLSQL Testing --
wt_assert.raises (
msg_in => 'Delete WT_TEST_RUN_STATS Record',
check_call_in => 'delete from WT_TEST_RUN_STATS where test_run_id = ' ||
l_test_run_id,
against_exc_in => '');
commit;
wt_assert.eqqueryvalue (
msg_in => 'There should be no WT_TEST_RUN_STATS records',
check_query_in => 'select count(*) from WT_TEST_RUN_STATS' ||
' where test_run_id = ' || l_test_run_id,
against_value_in => 0);
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'FINALIZE Sad Path 1';
l_tc_aaTEST.delete;
l_recTEST := l_recNULL;
l_recTEST.asserts := 2;
run_finalize('Run Finalize for Sad Path 1'); -- AUTONOMOUS COMMIT
wt_assert.isnull (
msg_in => 'l_recTEST.test_run_id',
check_this_in => l_recTEST.test_run_id);
wt_assert.isnull (
msg_in => 'l_recTEST.asserts',
check_this_in => l_recTEST.asserts);
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'FINALIZE Happy Path Teardown';
wt_assert.raises (
msg_in => 'Delete WT_TEST_RUNS Record',
check_call_in => 'delete from WT_TEST_RUNS where id = ' ||
l_test_run_id,
against_exc_in => '');
commit;
end t_finalize;
$END ----------------%WTPLSQL_end_ignore_lines%----------------
------------------------------------------------------------
procedure delete_records
(in_test_run_id in number)
is
begin
delete from wt_testcase_stats
where test_run_id = in_test_run_id;
delete from wt_test_run_stats
where test_run_id = in_test_run_id;
end delete_records;
$IF $$WTPLSQL_SELFTEST ------%WTPLSQL_begin_ignore_lines%------
$THEN
procedure t_delete_records
is
l_test_run_id number := -100;
l_sql_txt varchar2(4000);
begin
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'Delete Records Happy Path Setup';
l_sql_txt := 'insert into WT_TEST_RUNS' ||
' (id, start_dtm, runner_owner, runner_name)' ||
' values (' || l_test_run_id || ', sysdate, USER, ''TESTRUNNER2'')';
wt_assert.raises (
msg_in => 'Insert WT_TEST_RUNS Record',
check_call_in => l_sql_txt,
against_exc_in => '');
-------------------------------------- WTPLSQL Testing --
l_sql_txt := 'insert into WT_TEST_RUN_STATS (test_run_id) values (' ||
l_test_run_id || ')';
wt_assert.raises (
msg_in => 'Insert WT_TEST_RUN_STATS Record',
check_call_in => l_sql_txt,
against_exc_in => '');
l_sql_txt := 'insert into WT_TESTCASE_STATS (test_run_id, testcase)' ||
' values (' || l_test_run_id || ', ''TESTCASE2'')';
wt_assert.raises (
msg_in => 'Insert WT_TESTCASE_STATS Record',
check_call_in => l_sql_txt,
against_exc_in => '');
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'Delete Records Happy Path and Teardown';
wt_assert.raises (
msg_in => 'Delete Records with NULL ID',
check_call_in => 'begin wt_test_run_stat.delete_records(' ||
l_test_run_id || '); end;',
against_exc_in => '');
wt_assert.raises (
msg_in => 'Delete WT_TEST_RUNS Record',
check_call_in => 'delete from WT_TEST_RUNS where id = ' || l_test_run_id,
against_exc_in => '');
-------------------------------------- WTPLSQL Testing --
wt_assert.g_testcase := 'Delete Records Test Sad Paths';
wt_assert.raises (
msg_in => 'Delete Records with NULL ID',
check_call_in => 'begin wt_test_run_stat.delete_records(null); end;',
against_exc_in => '');
wt_assert.raises (
msg_in => 'Delete Records with Invalid ID',
check_call_in => 'begin wt_test_run_stat.delete_records(-0.01); end;',
against_exc_in => '');
end t_delete_records;
$END ----------------%WTPLSQL_end_ignore_lines%----------------
--==============================================================--
$IF $$WTPLSQL_SELFTEST ------%WTPLSQL_begin_ignore_lines%------
$THEN
procedure WTPLSQL_RUN --% WTPLSQL SET DBOUT "WT_TEST_RUN_STAT:PACKAGE BODY" %--
is
begin
t_initialize;
t_add_result;
t_add_profile;
t_finalize;
t_delete_records;
end WTPLSQL_RUN;
$END ----------------%WTPLSQL_end_ignore_lines%----------------
--==============================================================--
end wt_test_run_stat;