12.2 Stable :

Add block coverage
utPLSQL · lwasylow · Apr 16, 2018 · Mar 11, 2018 · Mar 13, 2018 · Mar 13, 2018
commit 68768f8391c263f3fc2fcb3220a1db1e292e2c1c
diff --git a/source/core/coverage/dbms_plssqlcode.sql b/source/core/coverage/dbms_plssqlcode.sql
@@ -0,0 +1,5 @@
+begin
+   DBMS_PLSQL_CODE_COVERAGE.create_coverage_tables(
+    force_it => TRUE);
+end;
+/
diff --git a/source/core/coverage/ut_coverage.pkb b/source/core/coverage/ut_coverage.pkb
@@ -156,13 +156,17 @@ create or replace package body ut_coverage is
   /**
   * Public functions
   */
-  procedure coverage_start is
+  procedure coverage_start(a_coverage_options ut_coverage_options default null) is
+    l_coverage_type varchar2(10) := coalesce(a_coverage_options.coverage_type, 'proftab');
   begin
+    set_coverage_type(a_coverage_type => l_coverage_type);
     ut_coverage_helper.coverage_start('utPLSQL Code coverage run '||ut_utils.to_string(systimestamp));
   end;
 
-  procedure coverage_start_develop is
+  procedure coverage_start_develop(a_coverage_options ut_coverage_options default null) is
+    l_coverage_type varchar2(10) := coalesce(a_coverage_options.coverage_type, 'proftab');
   begin
+    set_coverage_type(a_coverage_type => l_coverage_type);
     ut_coverage_helper.coverage_start_develop();
   end;
 
@@ -238,18 +242,18 @@ create or replace package body ut_coverage is
           loop
             exit when line_no is null;
 
-            if l_line_calls(line_no) > 0 then
+            if l_line_calls(line_no).calls > 0 then
               --total stats
               l_result.covered_lines := l_result.covered_lines + 1;
-              l_result.executions := l_result.executions + l_line_calls(line_no);
+              l_result.executions := l_result.executions + l_line_calls(line_no).calls;
               --object level stats
               l_result.objects(l_source_object.full_name).covered_lines := l_result.objects(l_source_object.full_name).covered_lines + 1;
-              l_result.objects(l_source_object.full_name).executions := l_result.objects(l_source_object.full_name).executions + l_line_calls(line_no);
-            elsif l_line_calls(line_no) = 0 then
+              l_result.objects(l_source_object.full_name).executions := l_result.objects(l_source_object.full_name).executions + l_line_calls(line_no).calls;
+            elsif l_line_calls(line_no).calls = 0 then
               l_result.uncovered_lines := l_result.uncovered_lines + 1;
               l_result.objects(l_source_object.full_name).uncovered_lines := l_result.objects(l_source_object.full_name).uncovered_lines + 1;
             end if;
-            l_result.objects(l_source_object.full_name).lines(line_no).executions := l_line_calls(line_no);
+            l_result.objects(l_source_object.full_name).lines(line_no).executions := l_line_calls(line_no).calls;
 
             line_no := l_line_calls.next(line_no);
           end loop;
@@ -263,12 +267,145 @@ create or replace package body ut_coverage is
     return l_result;
   end get_coverage_data_profiler;
 
+  function get_coverage_data_block(a_coverage_options ut_coverage_options) return ut_coverage.t_coverage is
+    l_line_calls          ut_coverage_helper.t_unit_line_calls;
+    l_result              ut_coverage.t_coverage;
+    l_new_unit            ut_coverage.t_unit_coverage;
+    line_no               binary_integer;
+    l_source_objects_crsr ut_coverage_helper.t_tmp_table_objects_crsr;
+    l_source_object       ut_coverage_helper.t_tmp_table_object;
+  begin
+    --prepare global temp table with sources
+    populate_tmp_table(a_coverage_options);
+
+    l_source_objects_crsr := ut_coverage_helper.get_tmp_table_objects_cursor();
+    loop
+      fetch l_source_objects_crsr
+        into l_source_object;
+      exit when l_source_objects_crsr%notfound;
+
+      --get coverage data
+      l_line_calls := ut_coverage_helper.get_raw_coverage_data_block(l_source_object.owner, l_source_object.name);
+
+      --if there is coverage, we need to filter out the garbage (badly indicated data)
+      if l_line_calls.count > 0 then
+        --remove lines that should not be indicted as meaningful
+        for i in 1 .. l_source_object.to_be_skipped_list.count loop
+          if l_source_object.to_be_skipped_list(i) is not null then
+            l_line_calls.delete(l_source_object.to_be_skipped_list(i));
+          end if;
+        end loop;
+      end if;
+
+      --if there are no file mappings or object was actually captured by profiler
+      if a_coverage_options.file_mappings is null or l_line_calls.count > 0 then
+
+        --populate total stats
+        l_result.total_lines := l_result.total_lines + l_source_object.lines_count;
+
+        --populate object level coverage stats
+        if not l_result.objects.exists(l_source_object.full_name) then
+          l_result.objects(l_source_object.full_name) := l_new_unit;
+          l_result.objects(l_source_object.full_name).owner := l_source_object.owner;
+          l_result.objects(l_source_object.full_name).name := l_source_object.name;
+          l_result.objects(l_source_object.full_name).total_lines := l_source_object.lines_count;
+        end if;
+        --map to results
+        line_no := l_line_calls.first;
+        if line_no is null then
+          l_result.uncovered_lines := l_result.uncovered_lines + l_source_object.lines_count;
+          l_result.objects(l_source_object.full_name).uncovered_lines := l_source_object.lines_count;
+        else
+          loop
+            exit when line_no is null;
+
+            --turn the block coverage into a line coverage format to allow for reading.
+            --whenever the linst is a part covered treat that line as a hit and execution but only part covered
+
+            --total stats        
+            --Get total blocks ,blocks covered, blocks not covered this will be used for PCT calc
+            l_result.total_blocks     := nvl(l_result.total_blocks, 0) + l_line_calls(line_no).blocks;
+            l_result.covered_blocks   := nvl(l_result.covered_blocks, 0) + l_line_calls(line_no).covered_blocks;
+            l_result.uncovered_blocks := nvl(l_result.uncovered_blocks, 0) +
+                                         (l_line_calls(line_no).blocks - l_line_calls(line_no).covered_blocks);
+
+            --If line is partially covered add as part line cover and covered for line reporter
+            if l_line_calls(line_no).partcovered = 1 then
+              l_result.partcovered_lines := l_result.partcovered_lines + 1;
+            end if;
+
+            if l_line_calls(line_no).covered_blocks > 0 then
+              l_result.covered_lines := l_result.covered_lines + 1;
+            end if;
+
+            -- Use nvl as be default is null and screw the calcs
+            --Increase total blocks
+            l_result.objects(l_source_object.full_name).lines(line_no).no_blocks := l_line_calls(line_no).blocks;
+            l_result.objects(l_source_object.full_name).lines(line_no).covered_blocks := l_line_calls(line_no).covered_blocks;
+            l_result.objects(l_source_object.full_name).total_blocks := nvl(l_result.objects(l_source_object.full_name)
+                                                                            .total_blocks
+                                                                           ,0) + l_line_calls(line_no).blocks;
+
+            --Total uncovered blocks is a line blocks minus covered blocsk
+            l_result.objects(l_source_object.full_name).uncovered_blocks := nvl(l_result.objects(l_source_object.full_name)
+                                                                                .uncovered_blocks
+                                                                               ,0) +
+                                                                            (l_line_calls(line_no).blocks - l_line_calls(line_no)
+                                                                             .covered_blocks);
+
+            --If we have any covered blocks in line
+            if l_line_calls(line_no).covered_blocks > 0 then            
+              --If any block is covered then we have a hit on that line
+              l_result.executions := l_result.executions + 1;
+              --object level stats
+              --If its part covered then mark it else treat as full cov
+              if l_line_calls(line_no).partcovered = 1 then
+                l_result.objects(l_source_object.full_name).partcovered_lines := l_result.objects(l_source_object.full_name)
+                                                                                 .partcovered_lines + 1;
+              end if;
+              l_result.objects(l_source_object.full_name).covered_lines := l_result.objects(l_source_object.full_name)
+                                                                             .covered_lines + 1;
+
+              --How many blocks we covered
+              l_result.objects(l_source_object.full_name).covered_blocks := nvl(l_result.objects(l_source_object.full_name)
+                                                                                .covered_blocks
+                                                                               ,0) + l_line_calls(line_no)
+                                                                           .covered_blocks;
+
+              --Object line executions
+              l_result.objects(l_source_object.full_name).executions := nvl(l_result.objects(l_source_object.full_name)
+                                                                            .executions
+                                                                           ,0) + 1;
+
+              l_result.objects(l_source_object.full_name).lines(line_no).executions := 1;
+
+              --Whenever there is no covered block treat as uncovered (query returns only lines where the blocks are in code so we
+              --dont have a false results here when there is no blocks
+            elsif l_line_calls(line_no).covered_blocks = 0 then
+              l_result.uncovered_lines := l_result.uncovered_lines + 1;
+              l_result.objects(l_source_object.full_name).uncovered_lines := l_result.objects(l_source_object.full_name)
+                                                                             .uncovered_lines + 1;
+              l_result.objects(l_source_object.full_name).lines(line_no).executions := 0;
+            end if;
+            --increase part covered counter (+ 1/0)
+            l_result.objects(l_source_object.full_name).lines(line_no).partcove := l_line_calls(line_no).partcovered;
+            line_no := l_line_calls.next(line_no);
+          end loop;
+        end if;
+      end if;
+
+    end loop;
+
+    close l_source_objects_crsr;
+
+    return l_result;
+  end get_coverage_data_block;
+
   function get_coverage_data(a_coverage_options ut_coverage_options) return t_coverage is
   begin
 
     if get_coverage_type = 'block' then
-      null;
-      --return get_coverage_data_block(a_coverage_options => a_coverage_options);
+      return get_coverage_data_block(a_coverage_options => a_coverage_options);
     else
       return get_coverage_data_profiler(a_coverage_options => a_coverage_options);
     end if;

diff --git a/source/core/coverage/ut_coverage.pks b/source/core/coverage/ut_coverage.pks
@@ -63,12 +63,12 @@ create or replace package ut_coverage authid current_user is
 
   function get_coverage_type return varchar2;
 
-  procedure coverage_start;
+  procedure coverage_start(a_coverage_options ut_coverage_options default null);
 
   /*
   * Start coverage in develop mode, where all internal calls to utPLSQL itself are also included
   */
-  procedure coverage_start_develop;
+  procedure coverage_start_develop(a_coverage_options ut_coverage_options default null);
 
   procedure coverage_stop;
 

diff --git a/source/core/coverage/ut_coverage_helper.pkb b/source/core/coverage/ut_coverage_helper.pkb
@@ -29,7 +29,7 @@ create or replace package body ut_coverage_helper is
   begin
     -- Make it dynamic to allow for block coverage.
     if ut_coverage.get_coverage_type = 'block' then
-       null;
+       g_coverage_id := dbms_plsql_code_coverage.start_coverage(run_comment => a_run_comment);
     else
        dbms_profiler.start_profiler(run_comment => a_run_comment, run_number => g_coverage_id);
        coverage_pause();
@@ -80,7 +80,7 @@ create or replace package body ut_coverage_helper is
     if not g_develop_mode then
       g_is_started := false;
       if ut_coverage.get_coverage_type = 'block' then
-         null;
+         dbms_plsql_code_coverage.stop_coverage;
       else
          dbms_profiler.stop_profiler();
       end if;
@@ -126,7 +126,45 @@ create or replace package body ut_coverage_helper is
          and u.unit_type not in ('PACKAGE SPEC', 'TYPE SPEC', 'ANONYMOUS BLOCK')
        group by d.line#;
     for i in 1 .. l_tmp_data.count loop
-      l_results(l_tmp_data(i).line) := l_tmp_data(i).calls;
+      l_results(l_tmp_data(i).line).calls := l_tmp_data(i).calls;
+    end loop;
+    return l_results;
+  end;
+
+  function get_raw_coverage_data_block(a_object_owner varchar2, a_object_name varchar2) return t_unit_line_calls is
+    type coverage_row is record(
+       line           binary_integer
+      ,blocks         binary_integer
+      ,covered_blocks binary_integer);
+    type coverage_rows is table of coverage_row;
+    l_tmp_data coverage_rows;
+    l_results  t_unit_line_calls;
+
+  begin
+    select ccb.line
+          ,count(ccb.block) totalblocks
+          ,sum(ccb.covered) as coveredblocks bulk collect
+      into l_tmp_data
+      from dbmspcc_units ccu
+      left outer join dbmspcc_blocks ccb
+        on ccu.run_id = ccb.run_id
+       and ccu.object_id = ccb.object_id
+     where ccu.owner = a_object_owner
+       and ccu.name = a_object_name
+       and ccu.run_id = g_coverage_id
+     group by ccb.line
+     order by 1;
+
+    for i in 1 .. l_tmp_data.count loop
+      l_results(l_tmp_data(i).line).blocks := l_tmp_data(i).blocks;
+      l_results(l_tmp_data(i).line).covered_blocks := l_tmp_data(i).covered_blocks;
+      l_results(l_tmp_data(i).line).partcovered := case
+                                                     when (l_tmp_data(i).covered_blocks > 0) and
+                                                          (l_tmp_data(i).blocks > l_tmp_data(i).covered_blocks) then
+                                                      1
+                                                     else
+                                                      0
+                                                   end;
     end loop;
     return l_results;
   end;

diff --git a/source/core/coverage/ut_coverage_helper.pks b/source/core/coverage/ut_coverage_helper.pks
@@ -18,7 +18,15 @@ create or replace package ut_coverage_helper authid definer is
 
   --table of line calls indexed by line number
   --!!! this table is sparse!!!
-  type t_unit_line_calls is table of number(38,0) index by binary_integer;
+  --type t_unit_line_calls is table of number(38,0) index by binary_integer;
+
+  type t_unit_line_call is record(
+     blocks         binary_integer default 0
+    ,covered_blocks binary_integer default 0
+    ,partcovered    binary_integer default 0
+    ,calls          binary_integer default 0);
+
+  type t_unit_line_calls is table of t_unit_line_call index by binary_integer;
 
   type t_coverage_sources_tmp_row is record (
     full_name      ut_coverage_sources_tmp.full_name%type,
@@ -60,6 +68,8 @@ create or replace package ut_coverage_helper authid definer is
 
   function get_raw_coverage_data_profiler(a_object_owner varchar2, a_object_name varchar2) return t_unit_line_calls;
 
+  function get_raw_coverage_data_block(a_object_owner varchar2, a_object_name varchar2) return t_unit_line_calls;
+
   /***
   * Allows overwriting of private global variable g_coverage_id
   * Used internally, only for unit testing of the framework only

diff --git a/source/core/coverage/ut_coverage_reporter_base.tpb b/source/core/coverage/ut_coverage_reporter_base.tpb
@@ -19,7 +19,7 @@ create or replace type body ut_coverage_reporter_base is
   overriding final member procedure before_calling_run(self in out nocopy ut_coverage_reporter_base, a_run ut_run) as
   begin
     (self as ut_output_reporter_base).before_calling_run(a_run);
-    ut_coverage.coverage_start();
+    ut_coverage.coverage_start(a_coverage_options => a_run.coverage_options);
   end;
 
   overriding final member procedure before_calling_before_all(self in out nocopy ut_coverage_reporter_base, a_suite in ut_logical_suite) is

diff --git a/source/install.sql b/source/install.sql
@@ -114,6 +114,12 @@ alter session set current_schema = &&ut3_owner;
 prompt Installing PLSQL profiler objects into &&ut3_owner schema
 @@core/coverage/proftab.sql
 
+prompt Installing PLSQL profiler objects into &&ut3_owner schema
+@@core/coverage/proftab.sql
+
+prompt Installing DBMSPLSQL Tables objects into &&ut3_owner schema
+@@core/coverage/dbms_plssqlcode.sql
+
 @@install_component.sql 'core/ut_file_mapper.pks'
 @@install_component.sql 'core/ut_file_mapper.pkb'