Contents

Block Replacements for Unsupported Blocks

This example shows how to use Simulink® Design Verifier™ functions to replace unsupported blocks and to how customize test vector generation for specific requirements.

Model with an Unsupported Block

The example model includes a Switch block whose output is controlled by a Sqrt block. For each switch position, the output of the model is calculated by a 1-D Lookup Table block. For this model, the example concentrates on generating test cases that satisfy the following:

1. Achieve 100% lookup table coverage.

2. Test vectors demonstrate each Switch block position when the values of its first and third input ports differ.

open_system('sldvdemo_sqrt_blockrep');

Checking Model Compatibility

Since the sqrt function is not supported, this model is partially compatible with Simulink Design Verifier.

sldvcompat('sldvdemo_sqrt_blockrep');
Entering Stage: 'SLDV Compatibility Analysis' for Model: 'sldvdemo_sqrt_blockrep'

Checking compatibility of model 'sldvdemo_sqrt_blockrep'
Compiling model... done
Checking compatibility... done
Warning: Simulink Design Verifier has only partial support for some elements of
the model: 'sldvdemo_sqrt_blockrep' is partially compatible with Simulink Design
Verifier.

The model can be analyzed by Simulink Design Verifier.
It contains unsupported elements that will be stubbed
out during analysis. The results of the analysis might
be incomplete.
 
Warning: Block 'sldvdemo_sqrt_blockrep/Sqrt' is configured to operate as
function sqrt. Simulink Design Verifier does not support this function. 

'sldvdemo_sqrt_blockrep' is partially compatible with Simulink Design Verifier.

The model can be analyzed by Simulink Design Verifier.
It contains unsupported elements that will be stubbed
out during analysis. The results of the analysis might
be incomplete.

Exiting Stage: 'SLDV Compatibility Analysis' for Model: 'sldvdemo_sqrt_blockrep'

Creating a Custom Block Replacement Rule to Work Around the Incompatibility

This model can be analyzed for test generation by automatically stubbing the unsupported Sqrt block. However, test cases cannot be generated for the Switch block positions because Simulink Design Verifier does not understand the Sqrt block and the output of this block is effecting the Switch block. Since you want test cases for the Switch block, you need to replace the Sqrt block with a supported block that is functionally equivalent. The library block sldvdemo_custom_blockreplibsldvdemo_custom_blockreplib shown below constrains the input signal to the range [0 10000] and approximates the sqrt function by using a 1-D Lookup Table block.

The table data was calculated to match the values of sqrt, with a maximum error of 0.2 in the range [0 10000]. Refer to the mask initialization pane of the block Sqrt_Approx in the library sldvdemo_custom_blockreplibsldvdemo_custom_blockreplib for the values of the lookup table data.

The replacement rule is in defined the MATLAB-file sldvdemo_custom_blkrep_rule_sqrt.msldvdemo_custom_blkrep_rule_sqrt.m. Since the replacement block sldvdemo_custom_blockreplibsldvdemo_custom_blockreplib for the Sqrt block is only valid for double or single types, this rule ensures that these conditions are satisfied before allowing a block replacement.

   function rule = sldvdemo_custom_blkrep_rule_sqrt
       rule = SldvBlockReplacement.blockreprule;
       rule.fileName = mfilename;
       rule.blockType = 'Sqrt';
       rule.replacementPath = sprintf('sldvdemo_custom_blockreplib/Sqrt_Approx');
       rule.replacementMode = 'Normal';
       parameter.OutMin = '$original.OutMin$';
       parameter.OutMax = '$original.OutMax$';
       parameter.OutDataTypeStr = '$original.OutDataTypeStr$';
       rule.parameterMap = parameter;
       rule.isReplaceableCallBack = @replacementTestFunction;
   end
   function out = replacementTestFunction(blockH)
       out = false;
       acceptedOutDataTypeStr = {'double','single',...
                         'Inherit: Inherit via back propagation',...
                         'Inherit: Same as input'};
       I = strmatch(get_param(blockH,'OutDataTypeStr'),acceptedOutDataTypeStr,'exact');
       if ~isempty(I)
           portDataTypes = get_param(blockH,'CompiledPortDataTypes');
           out = any(strcmp(portDataTypes.Inport,{'double','single'})) &&  ...
                 strcmp(portDataTypes.Inport,portDataTypes.Outport);
       end
   end
open_system('sldvdemo_custom_blockreplib');
open_system('sldvdemo_custom_blockreplib/Sqrt_Approx/1-D Lookup Table');

Configuring Simulink® Design Verifier™ Options for Block Replacement

You will run Simulink Design Verifier in test generation mode with block replacements enabled. In order to generate test cases for positions of Switch block, you must use the custom replacement rule sldvdemo_custom_blkrep_rule_sqrt.msldvdemo_custom_blkrep_rule_sqrt.m.

Since you are also interested in lookup table coverage, you need the built-in block replacement blkrep_rule_lookup_normal.mblkrep_rule_lookup_normal.m, which inserts test objectives for each interval and breakpoint value for a 1-D Lookup Table block. Moreover, you need the built-in rule blkrep_rule_switch_normal.mblkrep_rule_switch_normal.m, which requires that each switch position be exercised when the values of the first and third input ports differ. Please refer to the Block ReplacementBlock Replacement in the Simulink Design Verifier documentation for a list of all built-in replacement rules.

The analysis will run for a maximum of 30 seconds and produce a harness model. Report generation is also enabled. Other Simulink Design Verifier options are set to their default values.

opts = sldvoptions;
opts.Mode = 'TestGeneration';
opts.MaxProcessTime = 30;
opts.BlockReplacement = 'on';
opts.BlockReplacementRulesList = ['sldvdemo_custom_blkrep_rule_sqrt.m,' ...
                                  'blkrep_rule_lookup_normal.m,'...
                                  'blkrep_rule_switch_normal.m'];
opts.SaveHarnessModel = 'on';
opts.ModelReferenceHarness = 'on';
opts.SaveReport = 'on';

Executing Test Generation with Block Replacements

The sldvrun function analyzes the model using the settings defined in a sldvoptions object opts. The generated report includes a chapter summarizing block replacements performed on the model.

[status,fileNames] = sldvrun('sldvdemo_sqrt_blockrep', opts, true);

Executing Tests in the Harness Model

Enable the lookup table coverage metric and then run the test cases using the harness model. You can also execute the suite of tests by clicking the "Run all" button on the Signal Builder dialog box after enabling lookup table coverage from the "Analysis" > "Coverage" > "Settings" menu.

The coverage report shown below indicates that you can reach 100% lookup table coverage with the test vectors that Simulink Design Verifier generated.

[harnessModelPath,harnessModel] = fileparts(fileNames.HarnessModel);
set_param(harnessModel,'covMetricSettings','dcmte');
sldvdemo_playall(harnessModel);

Clean Up

To complete the example, close all models and remove the files that Simulink Design Verifier generated.

close_system('sldvdemo_custom_blockreplib');
close_system(fileNames.HarnessModel,0);
close_system(fileNames.BlockReplacementModel,0);
close_system('sldvdemo_sqrt_blockrep',0);
delete(fileNames.HarnessModel);
delete(fileNames.BlockReplacementModel);
delete(fileNames.DataFile);
Was this topic helpful?