/******************************************************************************
 * (C) Copyright 2015 AMIQ Consulting
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * MODULE:       svaunit_vpi_wrapper.svh
 * PROJECT:      svaunit
 * Description:  VPI wrapper - it contains a pointer to VPI interface and SVAUnit API's
 *******************************************************************************/

`ifndef SVAUNIT_VPI_WRAPPER_SVH
`define SVAUNIT_VPI_WRAPPER_SVH

//  VPI wrapper - it contains a pointer to VPI interface and SVAUnit API's
class svaunit_vpi_wrapper extends uvm_object;

   // Pointer to VPI interface with SVAs, imports and exports to VPI API
   virtual svaunit_vpi_interface vpi_vif;

   // String with the name of the test which is currently running
   local string test_name;

   // Provide implementations of virtual methods such as get_type_name and create
   `uvm_object_utils(svaunit_vpi_wrapper)

   // List of string which represents all the immediate assertions which can be tested
   local const string LOF_ALL_SVAUNIT_CHECKS[9];

   // List of immediate assertions tested during a specific test
   local svaunit_immediate_assertion_info lof_checks[$];

   // When this bit is 1, the test should stop
   bit stop_test;

   // Stores the current status of the check used
   svaunit_status_type current_check_status;

   /* Constructor for an svaunit_vpi_wrapper
    * @param name   : instance name for svaunit_vpi_wrapper object
    */
   function new(string name = "svaunit_vpi_wrapper");
      super.new(name);

      // Get the VPI interface from UVM config db
      if (!uvm_config_db#(virtual svaunit_vpi_interface)::get(uvm_root::get(), "*", "VPI_VIF", vpi_vif)) begin
         `uvm_fatal("SVAUNIT_VPI_WRAPPER_NO_VIF_ERR",
            "SVAUnit VPI interface for vpi_wrapper class is not set! Please enable SVAUnit package!")
      end

      LOF_ALL_SVAUNIT_CHECKS = '{
         "CHECK_SVA_EXISTS",
         "CHECK_SVA_ENABLED",
         "CHECK_SVA_DISABLED",
         "CHECK_SVA_PASSED",
         "CHECK_SVA_FAILED",
         "CHECK_SVA_FINISHED",
         "CHECK_SVA_NOT_FINISHED",
         "CHECK_ALL_SVA_PASSED",
         "CHECK_THAT"
      };

      current_check_status = SVAUNIT_DID_NOT_RUN;
   endfunction

   // Update the test's status according to the number of failed assertions
   virtual function void update_coverage();
      // Update status for SVA coverage
      vpi_vif.update_coverage(test_name);
   endfunction

   /* Will return the name of the test where the VPI wrapper is instantiated
    * @return a string with the name of the test where this component is instantiated
    */
   virtual function string get_test_name();
      return test_name;
   endfunction

   /* Set test name in VPI interface
    * @param a_test_name : the name of the test to be added inside VPI interface
    */
   virtual function void set_test_name_vpi(string a_test_name);
      test_name = a_test_name;

      vpi_vif.set_test_name(a_test_name);
   endfunction

   // {{{ Functions used for immediate assertions

   /* Create the list of immediate assertion if it doesn't exist any with the given name
    * @param a_sva : the SVA which was tested with immediate assertion
    * @param a_check_name : immediate assertion to be added
    * @param a_time : current time at which the immediate assertion has been tested
    * @param a_status : current status of the immediate assertion tested
    */
   local function void add_check(svaunit_concurrent_assertion_info a_sva, string a_check_name,
         time a_time, svaunit_status_type a_status);

      // Stores the fact that the SVA was tested before or not
      int check_index[$];

      // Verify if SVA was tested before or not - in this case add new detail to immediate assertion list
      check_index = lof_checks.find_index() with (item.get_sva_tested() == a_sva);

      if(check_index.size() > 0) begin
         foreach(check_index[index]) begin
            lof_checks[check_index[index]].add_new_check_detail(a_check_name, test_name, a_time, a_status);
         end
      end else begin
         svaunit_immediate_assertion_info check = svaunit_immediate_assertion_info::type_id::create($sformatf(
               "%s_immediate_assertions_%0d", get_name(), lof_checks.size() - 1));
         check.set_sva(a_sva);
         check.add_new_check_detail(a_check_name, test_name, a_time, a_status);

         lof_checks.push_back(check);
      end
   endfunction

   /* Get the immediate assertion info which corresponds to a given SVA
    * @param a_sva_name : a string represents the SVA name used to select the immediate assertion
    * @return the immediate assertion info which corresponds to a given SVA
    */
   virtual function svaunit_immediate_assertion_info get_check_for_sva(string a_sva_name);
      svaunit_immediate_assertion_info checks[$];

      checks = lof_checks.find_first() with (item.sva_tested.get_sva_name() == a_sva_name);

      return checks[0];
   endfunction

   /* Get the immediate assertions info which corresponds to a given test
    * @param a_test_name : a string represents the test name used to select the immediate assertion
    * @param a_checks_for_test : a list of immediate assertions info which corresponds to a given test
    */
   virtual function void get_checks_for_test(string a_test_name,
         ref svaunit_immediate_assertion_info a_checks_for_test[$]);

      foreach(lof_checks[check_index]) begin
         svaunit_immediate_assertion_info check = lof_checks[check_index].get_checks(a_test_name);

         if(check != null) begin
            int test_check_index[$];

            if(lof_checks[check_index].sva_tested != null) begin
               test_check_index = a_checks_for_test.find_index()
               with (item.sva_tested.get_sva_name() == check.sva_tested.get_sva_name());

               if(test_check_index.size() > 0) begin
                  foreach(test_check_index[index]) begin
                     foreach(check.checks_details[details_index]) begin
                        // Add new detail to this check
                        for(int time_idx = 0;
                              time_idx < check.checks_details[details_index].attempt_time.size(); time_idx++) begin
                           a_checks_for_test[test_check_index[index]].add_new_check_detail(
                              check.checks_details[details_index].get_check_name(),
                              a_test_name,
                              check.checks_details[details_index].attempt_time[time_idx],
                              check.checks_details[details_index].check_states[time_idx]);
                        end
                     end
                  end
               end else begin
                  a_checks_for_test.push_back(check);
               end
            end
         end
      end
   endfunction

   /* Get a list with names for all immediate assertion used
    * @param a_lof_used_checks : list of immediate assertions from where the report is made
    * @param a_lof_used_checks_names : list which contains the names of the checks used in this unit test
    */
   virtual function void get_checks_names(ref svaunit_immediate_assertion_info a_lof_used_checks[$],
         ref string a_lof_used_checks_names[$]);
      foreach(a_lof_used_checks[check_index]) begin
         foreach(a_lof_used_checks[check_index].checks_details[detail_index]) begin
            int indexes[$];

            indexes =  a_lof_used_checks_names.find_index() with (
                  a_lof_used_checks[check_index].checks_details[detail_index].get_check_name() == item);

            if(indexes.size() == 0) begin
               a_lof_used_checks_names.push_back(
                  a_lof_used_checks[check_index].checks_details[detail_index].get_check_name());
            end
         end
      end
   endfunction

   /* Get a list with names for all immediate assertion used which were not used
    * @param a_lof_used_checks : list of immediate assertions from where the report is made
    * @param a_lof_not_used_checks_names : list which contains the name of the checks not used in this unit test
    */
   virtual function void get_checks_not_used_names(ref svaunit_immediate_assertion_info a_lof_used_checks[$],
         ref string a_lof_not_used_checks_names[$]);
      // Variable used to store the indexes of the elements from a list which satisfied a given condition
      int check_index[$];

      // Variable used to store the indexes of the elements from a list which satisfied a given condition
      int string_index[$];

      // Iterate all over the lof_all_svaunit_checks to see if the check was used or not
      foreach(LOF_ALL_SVAUNIT_CHECKS[name_index]) begin

         // Iterate all over the immediate assertions used and all over the details to see if exits or not
         check_index = a_lof_used_checks.find_index() with (item.check_exists(LOF_ALL_SVAUNIT_CHECKS[name_index]));

         // If it was not found the check iterate all over the string queue to see if already exists in that list
         if(check_index.size() == 0) begin
            // Verify if the string exists or not
            string_index = a_lof_not_used_checks_names.find_index() with (item == LOF_ALL_SVAUNIT_CHECKS[name_index]);

            // If the string does not exists add to the string queue it's name
            if(string_index.size() == 0) begin
               a_lof_not_used_checks_names.push_back(LOF_ALL_SVAUNIT_CHECKS[name_index]);
            end
         end
      end
   endfunction

   /* Get immediate assertions from all tests
    * @return the total number of immediate assertions
    */
   virtual function int unsigned get_total_nof_checks();
      return lof_checks.size();
   endfunction

   /* Get the number of times an immediate assertion was tested during simulation
    * @param a_check_name : the check name
    * @param a_lof_used_checks : list of immediate assertions from where the report is made
    * @return the number of times an immediate assertion was tested during simulation
    */
   virtual function int unsigned get_nof_times_check_was_tested(string a_check_name,
         ref svaunit_immediate_assertion_info a_lof_used_checks[$]);
      // Variable used to store the number of times a check was tested
      int unsigned nof_times_check_was_tested = 0;

      // Iterate over the check list and it's detail to see if the given check name was tested and
      // increase the number with the proper number of times the check was tested
      foreach(a_lof_used_checks[check_index]) begin
         foreach(a_lof_used_checks[check_index].checks_details[details_index])begin
            if(a_lof_used_checks[check_index].checks_details[details_index].get_check_name() == a_check_name) begin
               nof_times_check_was_tested = nof_times_check_was_tested +
               a_lof_used_checks[check_index].checks_details[details_index].get_nof_times_check_was_tested();
            end
         end
      end

      return nof_times_check_was_tested;
   endfunction

   /* Get the number of times an immediate assertion passed during simulation
    * @param a_check_name : the check name
    * @param a_lof_used_checks : list of immediate assertions from where the report is made
    * @return the number of times an immediate assertion passed during simulation
    */
   virtual function int unsigned get_nof_times_check_has_passed(string a_check_name,
         ref svaunit_immediate_assertion_info a_lof_used_checks[$]);
      // Variable used to store the number of times a check has passed
      int unsigned nof_times_check_has_passed = 0;

      // Iterate over the check list and it's detail to see if the given check name was tested and
      // increase the number with the proper number of times the check has tested
      foreach(a_lof_used_checks[check_index]) begin
         foreach(a_lof_used_checks[check_index].checks_details[details_index])begin
            if(a_lof_used_checks[check_index].checks_details[details_index].get_check_name() == a_check_name) begin
               nof_times_check_has_passed = nof_times_check_has_passed +
               a_lof_used_checks[check_index].checks_details[details_index].get_nof_times_check_has_passed();
            end
         end
      end

      return nof_times_check_has_passed;
   endfunction
   // }}}

   // {{{ Functions used to find out SVA properties

   /* Get an assertion with a path from list
    * @param a_sva_path : assertion path to be found in SVA list
    * @return the assertion from SVA list
    */
   local function svaunit_concurrent_assertion_info get_assertion_by_path(string a_sva_path);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = vpi_vif.get_assertion_from_path(a_sva_path);

      // Verify that the SVA exists or not
      check_sva_exists(a_sva_path, $sformatf("Assertion %s doesn't exist.", a_sva_path));

      return assertion;
   endfunction

   /* Get an assertion with a name from list
    * @param a_sva_name : assertion name to be found in SVA list
    * @return the assertion from SVA list
    */
   local function svaunit_concurrent_assertion_info get_assertion_by_name(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = vpi_vif.get_assertion_by_name(a_sva_name);

      // Verify that the SVA exists or not
      check_sva_exists(a_sva_name, $sformatf("Assertion %s doesn't exist.", a_sva_name));

      return assertion;
   endfunction

   /* Get an assertion with a given name or path from list
    * @param a_sva : the assertion name or path to be found in SVA list
    * @return the assertion from SVA list
    */
   virtual function svaunit_concurrent_assertion_info get_assertion(string a_sva);
      if(is_a_path(a_sva)) begin
         return get_assertion_by_path(a_sva);
      end else begin
         return get_assertion_by_name(a_sva);
      end
   endfunction


   /* Verify that the SVA with a given name or path succeeded
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @return 1 if the assertion succeeded and 0 otherwise
    */
   virtual function bit assertion_succeeded(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         return assertion.sva_passed();
      end else begin
         return 0;
      end
   endfunction


   /* Get the state of an SVA with a given name or path
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @return the state of assertion
    */
   virtual function svaunit_concurrent_assertion_state_type get_state(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         return assertion.get_sva_state();
      end else begin
         return svaunit_concurrent_assertion_state_type'(0);
      end
   endfunction

   /* Verify that an SVA with a given name or path has finished
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @return 1 if the assertion has finished and 0 otherwise
    */
   virtual function bit is_finished(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         return assertion.sva_finished();
      end else begin
         return 0;
      end
   endfunction

   /* Verify that an SVA with a given name or path has not finished
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @return 1 if the assertion has not finished and 0 otherwise
    */
   virtual function bit is_not_finished(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         return assertion.sva_not_finished();
      end else begin
         return 0;
      end
   endfunction

   /* Verify that an SVA with a given name or path is enable
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @return 1 if the assertion is enable and 0 otherwise
    */
   virtual function bit is_enable(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         return assertion.sva_enabled(get_test_name());
      end else begin
         return 0;
      end
   endfunction

   /* Compute the number of times an SVA with a given name or path has failed
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @return the number of times an assertion failed
    */
   virtual function int get_nof_times_assertion_failed(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         return assertion.get_nof_times_sva_fails();
      end else begin
         return -1;
      end
   endfunction

   /* Compute the number of times an SVA with a given name or path succeeded
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @return the number of times an assertion succeeded
    */
   virtual function int get_nof_times_assertion_succeeded(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         return assertion.get_nof_times_sva_succeeded();
      end else begin
         return -1;
      end
   endfunction

   /* Get a list of all SVAs which have been tested from a_test_name
    * @param a_test_name : the name of the test where the SVA was exercised
    * @param a_sva_tested : a list of all SVAs which have the same tested status
    */
   virtual function void get_sva_tested(string a_test_name, ref svaunit_concurrent_assertion_info a_sva_tested[$]);
      foreach(vpi_vif.sva_info[index]) begin
         if(vpi_vif.sva_info[index].was_tested(a_test_name) == SVAUNIT_WAS_TESTED) begin
            if(!vpi_vif.sva_exists(vpi_vif.sva_info[index].get_sva_name(),
                     vpi_vif.sva_info[index].get_sva_path(), a_sva_tested)) begin
               a_sva_tested.push_back(vpi_vif.sva_info[index]);
            end
         end
      end
   endfunction

   // Get the total number of SVAs
   virtual function int unsigned get_nof_sva();
      return vpi_vif.get_nof_sva();
   endfunction

   /* Get the total number of SVAs tested from all tests
    * @param a_test_name : the name of the test where the SVA was exercised
    * @return the total number of SVAs tested from all tests
    */
   virtual function int unsigned get_nof_tested_sva(string a_test_name);
      // Variable used to store the tested SVAs
      svaunit_concurrent_assertion_info tested_sva[$];

      // Get all SVA tested
      get_sva_tested(a_test_name, tested_sva);

      return tested_sva.size();
   endfunction

   /* Get the names of the SVAs which were tested during test
    * @param a_tested_sva : the SVAs which were tested during a given test
    * @param a_tested_sva_names : list of SVAs names which were tested during test
    */
   virtual function void get_sva_tested_names(ref svaunit_concurrent_assertion_info a_tested_sva[$],
         string a_tested_sva_names[$]);

      foreach(a_tested_sva[index]) begin
         // Variable used to store the indexes of the elements which satisfied a given condition
         int tested_sva_index[$];

         // Iterate all over the SVA names to see if the SVA name exists or not
         tested_sva_index = a_tested_sva_names.find_index() with (item == a_tested_sva[index].get_sva_path());

         // If it does not exists add into out list the SVA path
         if(tested_sva_index.size() == 0) begin
            a_tested_sva_names.push_back(a_tested_sva[index].get_sva_path());
         end
      end
   endfunction

   /* Get the names of the SVAs which were not tested during test
    * @param a_not_tested_sva : the SVAs which were not tested during a given test
    * @param a_not_tested_sva_names : list of SVAUnit checks names which have not been tested
    */
   virtual function void get_sva_not_tested_names(ref svaunit_concurrent_assertion_info a_not_tested_sva[$],
         string a_not_tested_sva_names[$]);

      // Verify if the not tested SVA name exists into out list
      foreach(a_not_tested_sva[index]) begin
         // Variable used to store the indexes of the elements which satisfied a given condition
         int not_tested_index[$];

         // Iterate all over the SVA names to see if the SVA name exists or not
         not_tested_index = a_not_tested_sva_names.find_index() with (item == a_not_tested_sva[index].get_sva_path());

         // If it does not exists add into out list the SVA path
         if(not_tested_index.size() == 0) begin
            a_not_tested_sva_names.push_back(a_not_tested_sva[index].get_sva_path());
         end
      end
   endfunction

   /* Get all SVA from all tests which have not been tested
    * @param a_test_name : the name of the test where the SVA was exercised
    * @param a_sva_not_tested : list of all SVAs which have not been tested
    */
   virtual function void get_sva_not_tested(string a_test_name,
         ref svaunit_concurrent_assertion_info a_sva_not_tested[$]);

      // Variable used to store the tested SVAs
      svaunit_concurrent_assertion_info sva_tested[$];

      // Get all SVA tested
      get_sva_tested(a_test_name, sva_tested);

      // Verify if the not tested SVA name exists into out list
      foreach(vpi_vif.sva_info[index]) begin
         // Variable used to store the indexes for the list which satisfied the given condition
         int not_tested_index[$];

         // Iterate all over the SVAs to see if the SVA exists or not
         not_tested_index = sva_tested.find_index() with (item == vpi_vif.sva_info[index]);

         // If it does not exists add into out list
         if(not_tested_index.size() == 0) begin
            a_sva_not_tested.push_back(vpi_vif.sva_info[index]);
         end
      end
   endfunction
   // }}}


   // {{{ Functions used to control SVA

   //------------------------------- RESET --------------------------------
   /* Will discard all current attempts in progress for an SVA with a given name or path
    * and resets the SVA to its initial state
    * @param a_sva_name : assertion name or path to be found in SVA list
    */
   virtual function void reset_assertion(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         vpi_vif.reset_assertion(get_test_name(), assertion);
      end
   endfunction

   // Will discard all current attempts in progress for all SVAs and resets the SVAs to initial state
   virtual function void reset_all_assertions();
      vpi_vif.reset_all_assertions(get_test_name());
   endfunction

   //------------------------------- DISABLE --------------------------------
   /* Will disable the starting of any new attempt for a given SVA
    * (this will have no effect on any existing attempts or if SVA was already disable;
    * on default all SVAs are enable)
    * @param a_sva_name : assertion name or path to be found in SVA list
    */
   virtual function void disable_assertion(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         vpi_vif.disable_assertion(get_test_name(), assertion);
      end
   endfunction

   /* Will disable the starting of any new attempt for all SVAs
    * (this will have no effect on any existing attempts or if SVA was already disable;
    * on default all SVAs are enable)
    */
   virtual function void disable_all_assertions();
      vpi_vif.disable_all_assertions(get_test_name());
   endfunction

   //------------------------------- ENABLE --------------------------------
   /* Will enable starting any new attempts for a given SVA
    * (this will have no effect if SVA was already enable or on any current attempt)
    * @param a_sva_name : assertion name or path to be found in SVA list
    */
   virtual function void enable_assertion(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         vpi_vif.enable_assertion(get_test_name(), assertion);
      end
   endfunction

   /* Will enable starting any new attempts for all SVAs
    * (this will have no effect if SVA was already enable or on any current attempt)
    */
   virtual function void enable_all_assertions();
      vpi_vif.enable_all_assertions(get_test_name());
   endfunction

   //------------------------------- KILL --------------------------------
   /* Will discard any attempts of a given SVA
    * (the SVA will remain enabled and does not reset any state used by this SVA)
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_sim_time : the simulation time from which the SVA attempts will be killed
    */
   virtual function void kill_assertion(string a_sva_name, time a_sim_time);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         vpi_vif.kill_assertion(get_test_name(), assertion, a_sim_time);
      end
   endfunction

   /* Will discard any attempts of all SVAs
    * (the SVA will remain enabled and does not reset any state used by any SVA)
    * @param a_sim_time : the simulation time from which the SVA attempts will be killed
    */
   virtual function void kill_all_assertions(time a_sim_time);
      vpi_vif.kill_all_assertions(get_test_name(), a_sim_time);
   endfunction

   //------------------------------- DISABLE STEP --------------------------------
   /* Will disable step callback for a given SVA
    * (this will have no effect if step callback is not enabled or it was already disabled)
    * @param a_sva_name : assertion name or path to be found in SVA list
    */
   virtual function void disable_step_assertion(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         vpi_vif.disable_step_assertion(get_test_name(), assertion);
      end
   endfunction

   /* Will disable step callback for all SVAs
    * (this will have no effect if step callback is not enabled or it was already disabled)
    */
   virtual function void disable_step_all_assertions();
      vpi_vif.disable_step_all_assertions(get_test_name());
   endfunction

   //------------------------------- ENABLE STEP --------------------------------

   /* Will enable step callback for a given SVA
    * (by default, stepping is disabled; this will have no effect if stepping was already enabled;
    * the stepping mode cannot be modified after the assertion attempt has started)
    * @param a_sva_name : assertion name or path to be found in SVA list
    */
   virtual function void enable_step_assertion(string a_sva_name);
      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         vpi_vif.enable_step_assertion(get_test_name(), assertion);
      end
   endfunction

   /* Will enable step callback for all SVAs
    * (by default, stepping is disabled; this will have no effect if stepping was already enabled;
    * the stepping mode cannot be modified after the assertion attempt has started)
    */
   virtual function void enable_step_all_assertions();
      vpi_vif.enable_step_all_assertions(get_test_name());
   endfunction

   //------------------------------- SYSTEM RESET --------------------------------
   /* Will discard all attempts in progress for all SVAs and restore the entire assertion system to its initial state.
    * (The vpiAssertionStepSuccess and vpiAssertionStepFailure callbacks will be removed)
    */
   virtual function void system_reset_all_assertions();
      vpi_vif.system_reset_all_assertions();
   endfunction

   //------------------------------- SYSTEM ON --------------------------------
   // Will restart the SVAs after it was stopped
   virtual function void system_on_all_assertions();
      vpi_vif.system_on_all_assertions(get_test_name());
   endfunction

   //------------------------------- SYSTEM OFF --------------------------------
   // Will disable any SVA to being started and all current attempts will be considered as unterminated
   virtual function void system_off_all_assertions();
      vpi_vif.system_off_all_assertions(get_test_name());
   endfunction

   //------------------------------- SYSTEM END --------------------------------
   /* Will discard any attempt in progress and disable any SVA to be started
    * (all callbacks will be removed)
    */
   virtual function void system_end_all_assertions();
      vpi_vif.system_end_all_assertions(get_test_name());
   endfunction
   // }}}

   // {{{ Functions used to check

   /* Find the position of the first character of the first match of s2 in s1
    * @param a_s1 : the string used to search in the s2
    * @param a_s2 : the string to search for.
    * @return the position of the first character of the first match.
    *         If no matches were found, the function will return -1
    */
   virtual function int find(string a_s1, string a_s2);
      if(a_s1.len() < a_s2.len()) begin
         return -1;
      end else begin
         for(int char_index = 0; char_index < a_s1.len(); char_index = char_index + 1) begin
            if(a_s1.substr(char_index, char_index + a_s2.len() - 1) == a_s2) begin
               return char_index;
            end
         end
      end

      return -1;
   endfunction

   /* Verify if the name as a string is a path or not
    * @param a_sva_name : the name or the path given to the SVAUnit APIs
    * @return 1 if a_sva_name is actually a path and 0 if a_sva_name represents a name
    */
   local function bit is_a_path(string a_sva_name);
      if(find(a_sva_name, ".") != -1) begin
         // There was found a "." into a_sva_name -> that means that actually represents a path
         return 1;
      end else begin
         // There was not found a "." into a_sva_name -> that means that actually represents a name
         return 0;
      end
   endfunction

   /* Verify if the test should fail according to expression and increase the test statistics
    * The test will fail if the expression is false
    * @param a_expression : the expression bit
    * @return 1 if the expression is TRUE and 0 otherwise
    */
   local function bit check_expression(bit a_expression);
      // Verify if the expression is FALSE or TRUE. If it is FALSE return 0 and increase the failures number
      // else return 1
      if (a_expression) begin
         current_check_status = SVAUNIT_PASS;
         return 1;
      end else begin
         stop_test = 1;
         current_check_status = SVAUNIT_FAIL;
         return 0;
      end
   endfunction

   /* Get the status after check used
    * @return the current check status to be updated
    */
   local function svaunit_status_type get_current_check_status();
      return current_check_status;
   endfunction

   /* Check that an assertion is enabled - it will wait for the "End of time slot"
    * @param a_sva_name : the SVA name or the SVA path
    */
   local task check_assertion_is_enabled(string a_sva_name);
      vpi_vif.wait_for_eots();
      vpi_vif.get_info_from_c(get_test_name());
      check_sva_enabled(a_sva_name, $sformatf("Assertion %s is not enabled", a_sva_name));
   endtask

   // ------------------ CHECK ENABLED -------------------------
   /* Verify if a given SVA is enabled - the test will pass if SVA is not enabled
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual function void check_sva_enabled(string a_sva_name, string a_error_msg = "The SVA should have been enabled.",
         int unsigned a_line = 0, string a_filename = "");

      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         CHECK_SVA_ENABLED : assert(check_expression(assertion.sva_enabled(test_name)) == 1)
         else begin
            if((a_line != 0) && (a_filename != "")) begin
               `uvm_error("CHECK_SVA_ENABLED_ERR", $sformatf("%s (%0d) [%s::%s %s] %s", a_filename, a_line,
                     get_test_name(), get_type_name(), a_sva_name, a_error_msg))
            end else begin
               `uvm_error("CHECK_SVA_ENABLED_ERR", $sformatf("[%s::%s %s] %s", get_test_name(),
                     get_type_name(), a_sva_name, a_error_msg))
            end
         end
         add_check(assertion, "CHECK_SVA_ENABLED", $time(), get_current_check_status());
      end
   endfunction

   // ------------------ CHECK DISABLED -------------------------
   /* Verify if a given SVA is disabled - the test will pass if SVA is enabled
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual function void check_sva_disabled(string a_sva_name, string a_error_msg = "The SVA should have been disabled.",
         int unsigned a_line = 0, string a_filename = "");

      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         CHECK_SVA_DISABLED : assert(check_expression(assertion.sva_disabled(test_name)) == 1)
         else begin
            if((a_line != 0) && (a_filename != "")) begin
               `uvm_error("CHECK_SVA_DISABLED_ERR", $sformatf("%s (%0d) [%s::%s %s] %s", a_filename, a_line,
                     get_test_name(), get_type_name(), a_sva_name, a_error_msg))
            end else begin
               `uvm_error("CHECK_SVA_DISABLED_ERR", $sformatf("[%s::%s %s] %s", get_test_name(),
                     get_type_name(), a_sva_name, a_error_msg))
            end
         end
         add_check(assertion, "CHECK_SVA_DISABLED", $time(), get_current_check_status());
      end
   endfunction

   // ------------------ CHECK EXISTS -------------------------
   /* Verify if a given SVA exists - the test will fail if SVA does not exist
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual function void check_sva_exists(string a_sva_name, string a_error_msg = "The SVA does not exist.",
         int unsigned a_line = 0, string a_filename = "");

      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion;
      if(is_a_path(a_sva_name)) begin
         assertion = vpi_vif.get_assertion_from_path(a_sva_name);
      end else begin
         assertion = vpi_vif.get_assertion_by_name(a_sva_name);
      end

      CHECK_SVA_EXISTS : assert((check_expression(assertion != null)) == 1)  begin
         assertion.set_tested(get_test_name());
      end else begin
         if((a_line != 0) && (a_filename != "")) begin
            `uvm_error("CHECK_SVA_EXISTS_ERR", $sformatf("%s (%0d) [%s::%s %s] %s", a_filename,
                  a_line, get_test_name(), get_type_name(), a_sva_name, a_error_msg))
         end else begin
            `uvm_error("CHECK_SVA_EXISTS_ERR", $sformatf("[%s::%s %s] %s", get_test_name(),
                  get_type_name(), a_sva_name, a_error_msg))
         end

         begin
            string sva_name = a_sva_name;
            string sva_path = "";
            string sva_type = "";

            assertion = svaunit_concurrent_assertion_info::type_id::create( "new_assertion");

            assertion.create_new_sva(sva_name, sva_path, sva_type);
         end
      end

      add_check(assertion, "CHECK_SVA_EXISTS", $time(), get_current_check_status());
   endfunction


   // ------------------ CHECK PASSED-------------------------
   /* Verify if a given SVA succeeded - the test will fail if SVA failed
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual task check_sva_passed(string a_sva_name, string a_error_msg = "The SVA should have passed.",
         int unsigned a_line = 0, string a_filename = "");

      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         check_assertion_is_enabled(a_sva_name);

         CHECK_SVA_PASSED : assert(check_expression(assertion.sva_passed()) == 1)
         else begin
            if((a_line != 0) && (a_filename != "")) begin
               `uvm_error("CHECK_SVA_PASSED_ERR", $sformatf("%s (%0d) [%s::%s %s] %s", a_filename, a_line,
                     get_test_name(), get_type_name(), a_sva_name, a_error_msg))
            end else begin
               `uvm_error("CHECK_SVA_PASSED_ERR", $sformatf("[%s::%s %s] %s", get_test_name(),
                     get_type_name(), a_sva_name, a_error_msg))
            end
         end

         add_check(assertion, "CHECK_SVA_PASSED", $time(), get_current_check_status());
      end
   endtask


   // ------------------ CHECK FAILED -------------------------
   /* Verify if a given SVA didn't succeed; the test should fail if the SVA passed
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual task check_sva_failed(string a_sva_name, string a_error_msg = "The SVA should have failed.",
         int unsigned a_line = 0, string a_filename = "");

      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin

         check_assertion_is_enabled(a_sva_name);

         CHECK_SVA_FAILED :  assert(check_expression(!assertion.sva_passed()) == 1)
         else begin
            if((a_line != 0) && (a_filename != "")) begin
               `uvm_error("CHECK_SVA_FAILED_ERR", $sformatf("%s (%0d) [%s::%s %s] %s", a_filename,
                     a_line, get_test_name(), get_type_name(), a_sva_name, a_error_msg))
            end else begin
               `uvm_error("CHECK_SVA_FAILED_ERR", $sformatf("[%s::%s %s] %s", get_test_name(),
                     get_type_name(), a_sva_name, a_error_msg))
            end

         end

         add_check(assertion, "CHECK_SVA_FAILED", $time(), get_current_check_status());
      end
   endtask


   // ------------------ CHECK FINISHED-------------------------
   /* Verify if a given SVA finished - the test will fail if the assertion did not finish
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual task check_sva_finished(string a_sva_name, string a_error_msg = "The SVA should have finished.",
         int unsigned a_line = 0, string a_filename = "");

      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         check_assertion_is_enabled(a_sva_name);

         CHECK_SVA_FINISHED : assert(check_expression(assertion.sva_finished()) == 1)
         else begin

            if((a_line != 0) && (a_filename != "")) begin
               `uvm_error("CHECK_SVA_FINISHED_ERR", $sformatf("%s (%0d) [%s::%s %s] %s", a_filename, a_line,
                     get_test_name(), get_type_name(), a_sva_name, a_error_msg))
            end else begin
               `uvm_error("CHECK_SVA_FINISHED_ERR", $sformatf("[%s::%s %s] %s", get_test_name(),
                     get_type_name(), a_sva_name, a_error_msg))
            end
         end

         add_check(assertion, "CHECK_SVA_FINISHED", $time(), get_current_check_status());
      end
   endtask


   // ------------------ CHECK NOT FINISHED -------------------------
   /* Verify if a given SVA didn't finish; fail if it finished
    * @param a_sva_name : assertion name or path to be found in SVA list
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual task check_sva_not_finished(string a_sva_name, string a_error_msg = "The SVA should not have finished.",
         int unsigned a_line = 0, string a_filename = "");

      // Get the SVA from the SVA list
      svaunit_concurrent_assertion_info assertion = get_assertion(a_sva_name);

      if(assertion != null) begin
         check_assertion_is_enabled(a_sva_name);

         CHECK_SVA_NOT_FINISHED : assert(check_expression(assertion.sva_not_finished()) == 1)
         else begin
            if((a_line != 0) && (a_filename != "")) begin
               `uvm_error("CHECK_SVA_NOT_FINISHED_ERR", $sformatf("%s (%0d) [%s::%s %s] %s", a_filename,
                     a_line, get_test_name(), get_type_name(), a_sva_name, a_error_msg))
            end else begin
               `uvm_error("CHECK_SVA_NOT_FINISHED_ERR", $sformatf("[%s::%s %s] %s", get_test_name(),
                     get_type_name(), a_sva_name, a_error_msg))
            end
         end

         add_check(assertion, "CHECK_SVA_NOT_FINISHED", $time(), get_current_check_status());
      end
   endtask


   // ------------------ CHECK THAT  -------------------------
   /* Verify if the expression is true; the check fails if the expression is false
    * @param a_expression : the expression to be checked
    * @param a_error_msg : user error message to be printed if the check fails
    * @param a_line : the line number where the check is exercised
    * @param a_filename : the file name where the check is exercised
    */
   virtual function void check_that(bit a_expression, string a_error_msg = "The expression should have passed.", int unsigned a_line = 0,
         string a_filename = "");

      svaunit_concurrent_assertion_info new_assertion = svaunit_concurrent_assertion_info::type_id::create(
         "new_assertion");
      string sva_name = "";
      string sva_path = "";
      string sva_type = "";

      new_assertion.create_new_sva(sva_name, sva_path, sva_type);

      CHECK_THAT : assert(check_expression(a_expression) == 1)
      else begin
         if((a_line != 0) && (a_filename != "")) begin
            `uvm_error("CHECK_THAT_ERR", $sformatf("%s (%0d) [%s::%s] %s", a_filename, a_line,
                  get_test_name(), get_type_name(), a_error_msg))
         end else begin
            `uvm_error("CHECK_THAT_ERR",  $sformatf("[%s::%s] %s", get_test_name(), get_type_name(), a_error_msg))
         end
      end

      add_check(new_assertion, "CHECK_THAT", $time(), get_current_check_status());
   endfunction


   // Automatic check verified at the end of test for all enabled SVAs, if there are not any checks in unit test
   virtual task pass_assertion();
      if(lof_checks.size() == 0) begin
         if(vpi_vif.sva_info.size() > 0) begin
            foreach(vpi_vif.sva_info[sva_index]) begin
               if(is_enable(vpi_vif.sva_info[sva_index].get_sva_name())) begin
                  check_sva_failed(vpi_vif.sva_info[sva_index].get_sva_name(), $sformatf(
                        "Assertion %s should have succeeded, found instead: %s",
                        vpi_vif.sva_info[sva_index].get_sva_name(), vpi_vif.sva_info[sva_index].get_sva_state()));
               end
            end
         end
      end
   endtask


   /* Verify if all SVAs succeeded - the test will fail if any SVA failed
    * @param a_error_msg : custom error message which will be printed when the check fails
    */
   virtual function void check_all_sva_passed(string a_error_msg);

      // Shows that all SVAs succeeded in this test
      bit all_succeeded = 1;

      foreach(vpi_vif.sva_info[sva_index]) begin
         if(vpi_vif.sva_info[sva_index].sva_enabled(get_test_name())) begin
            string sva_name = vpi_vif.sva_info[sva_index].get_sva_name();
            if((get_nof_times_assertion_failed(sva_name) != 0) ||
                  (get_nof_times_assertion_succeeded(sva_name) == 0)) begin
               all_succeeded = 0;
            end
         end
      end

      CHECK_ALL_SVA_PASSED : assert((check_expression(all_succeeded == 1)) == 1)
      else begin
         `uvm_error("CHECK_ALL_SVA_PASSED_ERR", $sformatf("[%s::%s] %s",
               get_test_name(), get_type_name(), a_error_msg))
      end

      foreach(vpi_vif.sva_info[sva_index]) begin
         if(vpi_vif.sva_info[sva_index].sva_enabled(get_test_name())) begin
            add_check(vpi_vif.sva_info[sva_index], "CHECK_ALL_SVA_PASSED", $time(),
               get_current_check_status());
         end
      end
   endfunction

   /* Form the status to be printed
    * @return a string represents the status to be printed
    */
   virtual function void print_status();
      string report = "";

      report = $sformatf("\n\n-------------------- %s : Status statistics --------------------", get_test_name());
      report = $sformatf("%s\n\t%s\n", report, get_status_as_string());

      `uvm_info(get_test_name(), report, UVM_LOW)
   endfunction

   /* Form the status to be printed as a string
    * @return a string represents the status to be printed
    */
   virtual function string get_status_as_string();
      string star = " ";

      // Stored how many times the immediate assertion which were exercised passed
      int unsigned nof_times_check_has_passed = 0;

      // Stored how many times the immediate assertion were exercised
      int unsigned nof_times_check_was_tested = 0;

      // Stored the name of immediate assertions that were used
      string checks_names[$];
      get_checks_names(lof_checks, checks_names);

      // Compute how many immediate assertion passed and how many were exercised
      foreach(checks_names[index]) begin
         foreach(lof_checks[check_index]) begin
            foreach(lof_checks[check_index].checks_details[details_index])begin
               if(lof_checks[check_index].checks_details[details_index].get_check_name() == checks_names[index]) begin
                  nof_times_check_was_tested = nof_times_check_was_tested +
                  get_nof_times_check_was_tested(checks_names[index], lof_checks);
                  nof_times_check_has_passed = nof_times_check_has_passed +
                  get_nof_times_check_has_passed(checks_names[index], lof_checks);
               end
            end
         end
      end

      if(nof_times_check_was_tested > nof_times_check_has_passed) begin
         star = "* FAILED";
      end else begin
         star = "PASSED";
      end

      return $sformatf("\n\t%s   (%0d/%0d assertions PASSED)", star, nof_times_check_was_tested -
         nof_times_check_has_passed, nof_times_check_was_tested);
   endfunction

   /* Print a report for all checks tested from a specific list with immediate assertions
    * @param a_lof_used_checks : list of immediate assertions from where the report is made
    * @param a_test_name : the name of the test used to print it's checks
    */
   virtual function void print_checks_from_specific_list(string a_test_name,
         ref svaunit_immediate_assertion_info a_lof_used_checks[$]);

      string report = "";
      string star = "";
      string extra = "";
      string lof_used_checks_names[$];
      string lof_not_used_checks_names[$];
      int unsigned nof_times_check_was_tested;
      int unsigned nof_times_check_has_passed;

      get_checks_names(a_lof_used_checks, lof_used_checks_names);
      get_checks_not_used_names(a_lof_used_checks, lof_not_used_checks_names);

      report = $sformatf("\n\n-------------------- %s: Checks status summary --------------------\n\n", a_test_name);

      foreach(lof_used_checks_names[index]) begin
         nof_times_check_was_tested = 0;
         nof_times_check_has_passed = 0;
         star = " ";
         extra = "";

         nof_times_check_was_tested = get_nof_times_check_was_tested(lof_used_checks_names[index], a_lof_used_checks);
         nof_times_check_has_passed = get_nof_times_check_has_passed(lof_used_checks_names[index], a_lof_used_checks);

         if(nof_times_check_has_passed < nof_times_check_was_tested) begin
            star = "*";
         end

         extra = $sformatf("%0d/%0d PASSED", nof_times_check_has_passed, nof_times_check_was_tested);

         report = $sformatf("%s\t   %s   %s %s \n", report, star, lof_used_checks_names[index], extra);
      end


      `uvm_info(a_test_name, $sformatf("%s\n", report), UVM_LOW)
   endfunction

   // Print a report for all checks tested for the current unit test
   virtual function void print_checks();
      print_checks_from_specific_list(get_test_name(), lof_checks);
   endfunction

   /* Print a report for all checks tested for the SVAs from a specific list with immediate assertions
    * @param a_test_name : the name of the test used to print it's checks
    * @param a_lof_used_checks : list of immediate assertions from where the report is made
    */
   virtual function void print_sva_and_checks_for_specific_list(ref string a_test_name,
         svaunit_immediate_assertion_info a_lof_used_checks[$]);

      string report = "";

      report = $sformatf("\n\n-------------------- %s: Checks for each SVA statistics --------------------\n", a_test_name);

      foreach(a_lof_used_checks[check_index]) begin
         report = $sformatf("%s\n\t%s", report, a_lof_used_checks[check_index].get_checks_for_sva());
      end

      report = $sformatf("%s", report);

      `uvm_info(a_test_name, $sformatf("%s\n", report), UVM_NONE)
   endfunction

   // Print a report for all checks tested for the SVAs
   virtual function void print_sva_and_checks();
      string a_test_name = get_test_name();

      print_sva_and_checks_for_specific_list(a_test_name, lof_checks);
   endfunction

   /* Print a report for all SVA which have failed
    * @param a_test_name : the name of the test used to print it's checks
    * @param a_lof_used_checks : list of immediate assertions from where the report is made
    */
   virtual function void print_failed_sva_for_specific_list(ref string a_test_name,
         ref svaunit_immediate_assertion_info a_lof_used_checks[$]);

      string report = "";
      string details = "";

      foreach(a_lof_used_checks[check_index]) begin
         details = a_lof_used_checks[check_index].get_sva_failed_details();
         if(details != "") begin
            report = $sformatf("\n\n-------------------- %s: Failed SVAs --------------------\n", a_test_name);
            report = $sformatf("%s\n\t%s", report, a_lof_used_checks[check_index].get_sva_failed_details());
         end else begin
            report = $sformatf("\n\n-------------------- %s: All SVAs passed --------------------\n", a_test_name);
         end
      end

      report = $sformatf("%s", report);

      `uvm_info(a_test_name, $sformatf("%s\n\n\n", report), UVM_NONE)
   endfunction

   // Print a report for all SVA which have failed
   virtual function void print_failed_sva();
      string crt_test_name = get_test_name();

      print_failed_sva_for_specific_list(crt_test_name, lof_checks);
   endfunction

   // Will print the report for the current immediate assertions
   virtual function void print_report();
      print_status();
      print_sva();
      print_checks();
      print_sva_and_checks();
      print_failed_sva();
   endfunction

   // Print a list with all SVAs and with its status
   virtual function void print_sva();
      `uvm_info(get_test_name(), $sformatf("%s\n", vpi_vif.report_for_sva(get_test_name(), get_type_name())), UVM_LOW)
   endfunction

   /* Will print assertion info for an SVA with a given name
    * @param a_sva_name : assertion name to be found in SVA list
    */
   virtual function void print_sva_info(ref string a_sva_name);
      svaunit_concurrent_assertion_info assertion = get_assertion_by_name(a_sva_name);

      vpi_vif.get_info_from_c(get_test_name());

      if(assertion != null) begin
         assertion.print_sva_info(get_test_name());
      end
   endfunction
endclass

`endif