Doc

Details

Grants

References

Dependencies

Code




NAME VALUE
OWNER WTP
OBJECT_NAME WTPLSQL
SUBOBJECT_NAME null
OBJECT_ID 41930
DATA_OBJECT_ID null
OBJECT_TYPE PACKAGE BODY
CREATED 29-JUN-2018 15:09:15
LAST_DDL_TIME 29-JUN-2018 15:21:16
TIMESTAMP 2018-06-29:15:21:16
STATUS VALID
TEMPORARY N
GENERATED N
SECONDARY N
NAMESPACE 2
EDITION_NAME null
PRIVILEGE GRANTEE GRANTABLE GRANTOR OBJECT_NAME
EXECUTE PUBLIC NO WTP WTPLSQL
NAME OWNER TYPE OBJECT_ID STATUS TYPE_LINK
NAME OWNER TYPE OBJECT_ID STATUS TYPE_LINK
package body wtplsql
as

   C_KEEP_NUM_RECS  number := 20;

   g_test_runs_rec   wt_test_runs%ROWTYPE;

   $IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
   $THEN
      TYPE test_all_aa_type is table of varchar2(400) index by varchar2(400);
      test_all_aa       test_all_aa_type;
      wtplsql_skip_test boolean := FALSE;
   $END  ----------------%WTPLSQL_end_ignore_lines%----------------


----------------------
--  Private Procedures
----------------------


------------------------------------------------------------
-- This procedure is separated for internal WTPLSQL testing
procedure check_runner
is
   l_package_check        number;
begin
   -- These RAISEs can be captured because the Test Runs Record is set.
   --  Check for NULL Runner Name
   if g_test_runs_rec.runner_name is null
   then
      raise_application_error (-20001, 'RUNNER_NAME is null');
   end if;
   --  Check for Valid Runner Name
   select count(*) into l_package_check
    from  all_arguments
    where owner         = USER
     and  object_name   = 'WTPLSQL_RUN'
     and  package_name  = g_test_runs_rec.runner_name
     and  argument_name is null
     and  position      = 1
     and  sequence      = 0;
   if l_package_check != 1
   then
      raise_application_error (-20002, 'RUNNER_NAME "' ||
                           g_test_runs_rec.runner_name ||
                           '.WTPLSQL_RUN" is not valid');
   end if;
end check_runner;

$IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
$THEN
   procedure t_check_runner
   is
      l_save_test_runs_rec   wt_test_runs%ROWTYPE := g_test_runs_rec;
      l_msg_in   varchar2(4000);
      l_err_in   varchar2(4000);
      --------------------------------------  WTPLSQL Testing --
      procedure l_test_sqlerrm is begin
         -- Restore the G_TEST_RUNS_REC
         g_test_runs_rec := l_save_test_runs_rec;
         wt_assert.eq
                  (msg_in          => l_msg_in
                  ,check_this_in   => SQLERRM
                  ,against_this_in => l_err_in);
      end l_test_sqlerrm;
   begin
      --------------------------------------  WTPLSQL Testing --
      -- This Test Case runs in the EXECUTE IMMEDAITE in the TEST_RUN
      --   procedure in this package.
      wt_assert.g_testcase := 'CHECK_RUNNER Sad Path 1';
      begin
         g_test_runs_rec.runner_name := '';
         l_msg_in := 'Null RUNNER_NAME';
         l_err_in := 'ORA-20001: RUNNER_NAME is null';
         check_runner;
         l_test_sqlerrm;
      exception when others then
         l_test_sqlerrm;
      end;
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'CHECK_RUNNER Sad Path 2';
      begin
         g_test_runs_rec.runner_name := 'BOGUS';
         l_msg_in := 'Invalid RUNNER_NAME';
         l_err_in := 'ORA-20002: RUNNER_NAME "BOGUS.WTPLSQL_RUN" is not valid';
         check_runner;
         l_test_sqlerrm;
      exception when others then
         l_test_sqlerrm;
      end;
   end t_check_runner;
$END  ----------------%WTPLSQL_end_ignore_lines%----------------


------------------------------------------------------------
procedure insert_test_run
is
   PRAGMA AUTONOMOUS_TRANSACTION;
   l_wt_test_runs_recNULL  wt_test_runs%ROWTYPE;
begin
   if g_test_runs_rec.id is null
   then
      return;
   end if;
   g_test_runs_rec.end_dtm := systimestamp;
   insert into wt_test_runs values g_test_runs_rec;
   g_test_runs_rec := l_wt_test_runs_recNULL;
   COMMIT;
exception
   when OTHERS
   then
      DBMS_OUTPUT.PUT_LINE(dbms_utility.format_error_stack ||
                           dbms_utility.format_error_backtrace);
end insert_test_run;

$IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
$THEN
   procedure t_insert_test_run
   is
      --------------------------------------  WTPLSQL Testing --
      TYPE l_dbmsout_buff_type is table of varchar2(32767);
      l_dbmsout_buff   l_dbmsout_buff_type := l_dbmsout_buff_type(1);
      l_test_runs_rec  wt_test_runs%ROWTYPE;
      l_dbmsout_line   varchar2(32767);
      l_dbmsout_stat   number;
      l_num_recs       number;
   begin
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'INSERT_TEST_RUN Happy Path 1';
      l_test_runs_rec := g_test_runs_rec;
      insert_test_run;
      g_test_runs_rec := l_test_runs_rec;
      wt_assert.eqqueryvalue (
         msg_in           => 'Number of Records',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where id = ' || l_test_runs_rec.id,
         against_value_in => 1);
      --------------------------------------  WTPLSQL Testing --
      delete from wt_test_runs
       where id = l_test_runs_rec.id;
      COMMIT;
      wt_assert.eqqueryvalue (
         msg_in           => 'Records After Delete',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where id = ' || l_test_runs_rec.id,
         against_value_in => 0);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'INSERT_TEST_RUN Sad Path 1';
      -- Save/Clear the DBMS_OUPTUT Buffer
      loop
         DBMS_OUTPUT.GET_LINE (
            line   => l_dbmsout_line,
            status => l_dbmsout_stat);
         exit when l_dbmsout_stat != 0;
         l_dbmsout_buff(l_dbmsout_buff.COUNT) := l_dbmsout_line;
         l_dbmsout_buff.extend;
      end loop;
      --------------------------------------  WTPLSQL Testing --
      wt_assert.isnotnull (
         msg_in        => 'l_dbmsout_buff.COUNT - 1',
         check_this_in => l_dbmsout_buff.COUNT - 1);
      --------------------------------------  WTPLSQL Testing --
      select count(*) into l_num_recs from wt_test_runs;
      l_test_runs_rec := g_test_runs_rec;
      g_test_runs_rec.start_dtm := null;
      insert_test_run;
      g_test_runs_rec := l_test_runs_rec;
      wt_assert.eqqueryvalue (
         msg_in           => 'Number of Records should stay the same',
         check_query_in   => 'select count(*) from wt_test_runs',
         against_value_in => l_num_recs);
      --------------------------------------  WTPLSQL Testing --
      DBMS_OUTPUT.GET_LINE (
         line   => l_dbmsout_line,
         status => l_dbmsout_stat);
      wt_assert.eq (
         msg_in          => 'DBMS_OUTPUT Status',
         check_this_in   => l_dbmsout_stat,
         against_this_in => 0);
      --------------------------------------  WTPLSQL Testing --
      if wt_assert.last_pass
      then
         wt_assert.isnotnull (
            msg_in        => 'DBMS_OUTPUT Line',
            check_this_in => l_dbmsout_line);
         wt_assert.this (
            msg_in        => 'Confirm DBMS_OUTPUT Line text',
            check_this_in => (l_dbmsout_line like 'ORA-01400: cannot insert NULL into ("WTP"."WT_TEST_RUNS"."START_DTM")%'));
      --------------------------------------  WTPLSQL Testing --
         if not wt_assert.last_pass
         then
            -- No match, put the line back into DBMS_OUTPUT buffer and end this.
            DBMS_OUTPUT.PUT_LINE(l_dbmsout_line);
         end if;
      end if;
      --------------------------------------  WTPLSQL Testing --
      -- Restore the DBMS_OUPTUT Buffer
      for i in 1 .. l_dbmsout_buff.COUNT - 1
      loop
         DBMS_OUTPUT.PUT_LINE(l_dbmsout_buff(i));
      end loop;
      wt_assert.isnotnull (
         msg_in        => 'l_dbmsout_buff.COUNT - 1',
         check_this_in =>  l_dbmsout_buff.COUNT - 1);
   end t_insert_test_run;
$END  ----------------%WTPLSQL_end_ignore_lines%----------------


---------------------
--  Public Procedures
---------------------


------------------------------------------------------------
function show_version
   return varchar2
is
   ret_str  wt_version.text%TYPE;
begin
   select max(t1.text) into ret_str
    from  wt_version  t1
    where t1.install_dtm = (select max(t2.install_dtm)
                             from  wt_version  t2);
   return ret_str;
exception when NO_DATA_FOUND
then
   return '';
end show_version;

$IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
$THEN
   procedure t_show_version
   is
      existing_version   wt_version.text%TYPE;
   begin
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'Show Version Happy Path';
      existing_version := show_version;
      wt_assert.isnotnull (
         msg_in        => 'Test Existing Version',
         check_this_in => existing_version);
      --------------------------------------  WTPLSQL Testing --
      insert into wt_version (install_dtm, action, text)
         values (to_date('31-DEC-4000','DD-MON-YYYY'), 'TESTING', 'TESTING');
      wt_assert.eq (
         msg_in          => 'Test New Version',
         check_this_in   => show_version,
         against_this_in => 'TESTING');
      --------------------------------------  WTPLSQL Testing --
      rollback;
      wt_assert.eq (
         msg_in          => 'Return to Existing Version',
         check_this_in   => show_version,
         against_this_in => existing_version);
   end t_show_version;
$END  ----------------%WTPLSQL_end_ignore_lines%----------------


------------------------------------------------------------
procedure test_run
      (in_package_name  in  varchar2)
is
   l_test_runs_rec_NULL   wt_test_runs%ROWTYPE;
   l_error_stack          varchar2(32000);
   procedure concat_err_message is begin
      if g_test_runs_rec.error_message is not null
      then
         g_test_runs_rec.error_message := substr(l_error_stack || CHR(10)||
                                                 g_test_runs_rec.error_message
                                                ,1,4000);
      else
         g_test_runs_rec.error_message := l_error_stack;
      end if;
   end concat_err_message;
begin
   $IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
   $THEN
      -- This will avoid running the TEST_RUN procedure for some self-tests
      if wtplsql_skip_test
      then
         test_all_aa(in_package_name) := 'X';
         return;
      end if;
      --DBMS_OUTPUT.PUT_LINE('DEBUG WTPLSQL selftest Enabled for Test Runner "' || in_package_name || '"');
   $END  ----------------%WTPLSQL_end_ignore_lines%----------------
   -- Reset the Test Runs Record before checking anything
   g_test_runs_rec               := l_test_runs_rec_NULL;
   g_test_runs_rec.id            := wt_test_runs_seq.nextval;
   g_test_runs_rec.start_dtm     := systimestamp;
   g_test_runs_rec.runner_owner  := USER;
   g_test_runs_rec.runner_name   := in_package_name;
   g_test_runs_rec.error_message := '';
   check_runner;
   -- Initialize
   delete_runs(in_runner_owner => g_test_runs_rec.runner_owner  -- Autonomous Transaction COMMIT
              ,in_runner_name  => g_test_runs_rec.runner_name);
   wt_assert.reset_globals;
   wt_test_run_stat.initialize;
   wt_result.initialize(g_test_runs_rec.id);
   wt_profiler.initialize(in_test_run_id      => g_test_runs_rec.id,
                          in_runner_name      => g_test_runs_rec.runner_name,
                          out_dbout_owner     => g_test_runs_rec.dbout_owner,
                          out_dbout_name      => g_test_runs_rec.dbout_name,
                          out_dbout_type      => g_test_runs_rec.dbout_type,
                          out_trigger_offset  => g_test_runs_rec.trigger_offset,
                          out_profiler_runid  => g_test_runs_rec.profiler_runid,
                          out_error_message   => l_error_stack);
   concat_err_message;
   -- Call the Test Runner
   begin
      execute immediate 'BEGIN ' || in_package_name || '.WTPLSQL_RUN; END;';
   exception
      when OTHERS
      then
         l_error_stack := dbms_utility.format_error_stack     ||
                          dbms_utility.format_error_backtrace ;
         concat_err_message;
   end;

   -- Finalize
   insert_test_run;            -- Autonomous Transaction COMMIT
   wt_profiler.finalize;       -- Autonomous Transaction COMMIT
   wt_result.finalize;         -- Autonomous Transaction COMMIT
   wt_test_run_stat.finalize;  -- Autonomous Transaction COMMIT

exception
   when OTHERS
   then
      l_error_stack := dbms_utility.format_error_stack     ||
                       dbms_utility.format_error_backtrace ;
      if g_test_runs_rec.id is null
      then
         DBMS_OUTPUT.PUT_LINE(l_error_stack);
         DBMS_OUTPUT.PUT_LINE('---------------------------');
         DBMS_OUTPUT.PUT_LINE(g_test_runs_rec.error_message);
      else
         concat_err_message;
         insert_test_run;    -- Autonomous Transaction COMMIT
      end if;
      wt_profiler.finalize;       -- Autonomous Transaction COMMIT
      wt_result.finalize;         -- Autonomous Transaction COMMIT
      wt_test_run_stat.finalize;  -- Autonomous Transaction COMMIT

end test_run;

--==============================================================--
-- No Unit Test for TEST_RUN.
--   Too complicated because testing occurs while the TEST_RUN
--   procedure is executing.  This also prevents 100% profiling.
--==============================================================--


------------------------------------------------------------
procedure test_all
is
   TYPE runners_nt_type is table of varchar2(128);
   l_runners_nt      runners_nt_type;
begin
   select package_name
     bulk collect into l_runners_nt
    from  user_arguments  t1
    where object_name = 'WTPLSQL_RUN'
     and  position    = 1
     and  sequence    = 0
     and  data_type   is null
     and  not exists (
          select 'x' from user_arguments  t2
           where t2.object_name = t1.object_name
            and  t2.position    > t1.position
            and  t2.sequence    > t1.sequence
            and  (   t2.overload is null
                  OR t2.overload = t1.overload)
          );
   for i in 1 .. l_runners_nt.COUNT
   loop
      test_run(l_runners_nt(i));
   end loop;
end test_all;

$IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
$THEN
   procedure t_test_all
   is
   begin
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'TEST_ALL Happy Path';
      test_all_aa.DELETE;
      wtplsql_skip_test := TRUE;
      -- TEST_ALL will populate the test_all_aa array
      wtplsql.test_all;
      wtplsql_skip_test := FALSE;
      -- This package should be in the test_all_aa array
      --------------------------------------  WTPLSQL Testing --
      wt_assert.this (
         msg_in        => 'test_all_aa.EXISTS(''WTPLSQL'')',
         check_this_in => test_all_aa.EXISTS('WTPLSQL'));
   end t_test_all;
$END  ----------------%WTPLSQL_end_ignore_lines%----------------


------------------------------------------------------------
procedure delete_runs
      (in_test_run_id  in number)
is
   PRAGMA AUTONOMOUS_TRANSACTION;
begin
   -- Profiler delete must be first because it contains a
   --    PRAGMA AUTONOMOUS_TRANSACTION
   wt_test_run_stat.delete_records(in_test_run_id);
   wt_profiler.delete_records(in_test_run_id);
   wt_result.delete_records(in_test_run_id);
   delete from wt_test_runs where id = in_test_run_id;
   COMMIT;
end delete_runs;

procedure delete_runs
      (in_runner_owner  in varchar2
      ,in_runner_name   in varchar2)
is
   num_recs    number;
begin
   num_recs := 1;
   for buf2 in (select id from wt_test_runs
                 where runner_owner = in_runner_owner
                  and  runner_name  = in_runner_name
                 order by start_dtm desc, id desc)
   loop
      -- Keep the last 20 rest runs for this USER
      if num_recs > C_KEEP_NUM_RECS
      then
       -- Autonomous Transaction COMMIT
       delete_runs(buf2.id);
      end if;
      num_recs := num_recs + 1;
   end loop;
end delete_runs;

$IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
$THEN
   procedure t_delete_run_id
   is
      l_num_recs   number;
      l_err_stack  varchar2(32000);
   begin
      --------------------------------------  WTPLSQL Testing --
      --  DELETE_RECORDS has already run when we arrive here.
      -- Cleanup from previous test
      delete from wt_test_runs
        where id between 0-C_KEEP_NUM_RECS and 0-1;
      commit;
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'DELETE_RUNS Happy Path 1';
      select count(*)
       into  l_num_recs
       from  wt_test_runs
       where runner_owner = USER
        and  runner_name  = g_test_runs_rec.runner_name;
      --------------------------------------  WTPLSQL Testing --
      wt_assert.isnotnull (
         msg_in        => 'Number of Records Before Insert',
         check_this_in => l_num_recs);
      wt_assert.this (
         msg_in        => 'Number of Records Before Insert <= ' || C_KEEP_NUM_RECS,
         check_this_in => l_num_recs <= C_KEEP_NUM_RECS);
      --------------------------------------  WTPLSQL Testing --
      insert into wt_test_runs values g_test_runs_rec;
      COMMIT;
      wt_assert.eqqueryvalue (
         msg_in           => 'Number of Records After Insert',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where id = ' || g_test_runs_rec.id,
         against_value_in => 1);
      delete_runs(g_test_runs_rec.id);  -- Autonomous Transaction
      --------------------------------------  WTPLSQL Testing --
      wt_assert.eqqueryvalue (
         msg_in           => 'Number of Records After Delete',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where id = ' || g_test_runs_rec.id,
         against_value_in => 0);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'DELETE_RUNS Happy Path 2';
      wt_assert.eqqueryvalue (
         msg_in           => 'Confirm number of records',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where runner_owner = ''' || USER ||
                           ''' and runner_name = ''' || g_test_runs_rec.runner_name ||
                           '''',
         against_value_in => l_num_recs);
      --------------------------------------  WTPLSQL Testing --
      for i in 1 .. C_KEEP_NUM_RECS
      loop
         insert into wt_test_runs
               (id, start_dtm, runner_owner, runner_name)
            values
               (0-i, sysdate-7000-i, USER, g_test_runs_rec.runner_name);
      end loop;
      commit;
      --------------------------------------  WTPLSQL Testing --
      wt_assert.eqqueryvalue (
         msg_in           => 'Check Added ' || C_KEEP_NUM_RECS || ' records',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where runner_owner = ''' || USER ||
                           ''' and runner_name = ''' || g_test_runs_rec.runner_name ||
                           '''',
         against_value_in => l_num_recs + C_KEEP_NUM_RECS);
      delete_runs(USER, g_test_runs_rec.runner_name);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.eqqueryvalue (
         msg_in           => 'Check number of records reduced',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where runner_owner = ''' || USER ||
                           ''' and runner_name = ''' || g_test_runs_rec.runner_name ||
                           '''',
         against_value_in => C_KEEP_NUM_RECS);
      delete from wt_test_runs
        where id between 0-C_KEEP_NUM_RECS and 0-1;
      commit;
      --------------------------------------  WTPLSQL Testing --
      wt_assert.eqqueryvalue (
         msg_in           => 'Confirm original number of records',
         check_query_in   => 'select count(*) from wt_test_runs' ||
                             ' where runner_owner = ''' || USER ||
                           ''' and runner_name = ''' || g_test_runs_rec.runner_name ||
                           '''',
         against_value_in => l_num_recs);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'DELETE_RUNS Sad Path 1';
      begin
         delete_runs(-9995);  -- Should run without error
         l_err_stack := dbms_utility.format_error_stack     ||
                        dbms_utility.format_error_backtrace ;
      exception when others then
         l_err_stack := dbms_utility.format_error_stack     ||
                        dbms_utility.format_error_backtrace ;
      end;
      --------------------------------------  WTPLSQL Testing --
      wt_assert.isnull (
         msg_in          => 'Delete Runs(-9995)',
         check_this_in   => l_err_stack);
   end t_delete_run_id;
$END  ----------------%WTPLSQL_end_ignore_lines%----------------


--==============================================================--
$IF $$WTPLSQL_SELFTEST  ------%WTPLSQL_begin_ignore_lines%------
$THEN
   procedure t_test_runs_rec_and_table
   is
   begin
      --------------------------------------  WTPLSQL Testing --
      wt_assert.g_testcase := 'TEST_RUNS_REC_AND_TABLE Happy Path';
      -- This Test Case runs in the EXECUTE IMMEDAITE in the TEST_RUN
      --   procedure in this package.
      wt_assert.isnotnull
               (msg_in        => 'g_test_runs_rec.id'
               ,check_this_in => g_test_runs_rec.id);
      wt_assert.isnotnull
               (msg_in        => 'g_test_runs_rec.start_dtm'
               ,check_this_in => g_test_runs_rec.start_dtm);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.isnotnull
               (msg_in        => 'g_test_runs_rec.runner_owner'
               ,check_this_in => g_test_runs_rec.runner_owner);
      wt_assert.eq
               (msg_in          => 'g_test_runs_rec.runner_name'
               ,check_this_in   => g_test_runs_rec.runner_name
               ,against_this_in => 'WTPLSQL');
      --------------------------------------  WTPLSQL Testing --
      wt_assert.isnull
               (msg_in        => 'g_test_runs_rec.dbout_owner'
               ,check_this_in => g_test_runs_rec.dbout_owner);
      wt_assert.isnull
               (msg_in          => 'g_test_runs_rec.dbout_name'
               ,check_this_in   => g_test_runs_rec.dbout_name);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.isnull
               (msg_in          => 'g_test_runs_rec.dbout_type'
               ,check_this_in   => g_test_runs_rec.dbout_type);
      wt_assert.isnull
               (msg_in        => 'g_test_runs_rec.profiler_runid'
               ,check_this_in => g_test_runs_rec.profiler_runid);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.isnull
               (msg_in        => 'g_test_runs_rec.end_dtm'
               ,check_this_in => g_test_runs_rec.end_dtm);
      wt_assert.isnull
               (msg_in        => 'g_test_runs_rec.error_message'
               ,check_this_in => g_test_runs_rec.error_message);
      --------------------------------------  WTPLSQL Testing --
      wt_assert.eqqueryvalue
               (msg_in             => 'TEST_RUNS Record for this TEST_RUN'
               ,check_query_in     => 'select count(*) from WT_TEST_RUNS' ||
                                      ' where id = ''' || g_test_runs_rec.id || ''''
               ,against_value_in   => 0);
   end t_test_runs_rec_and_table;
   ----------------------------------------
   procedure WTPLSQL_RUN
   is
   begin
      --------------------------------------  WTPLSQL Testing --
      t_show_version;
      t_check_runner;
      t_insert_test_run;
      t_test_all;
      t_delete_run_id;
      t_test_runs_rec_and_table;
   end;
$END  ----------------%WTPLSQL_end_ignore_lines%----------------
--==============================================================--


end wtplsql;