{"id":3150,"date":"2023-10-26T06:36:45","date_gmt":"2023-10-26T10:36:45","guid":{"rendered":"https:\/\/blogs.mathworks.com\/developer\/?p=3150"},"modified":"2023-10-26T06:37:43","modified_gmt":"2023-10-26T10:37:43","slug":"equivalence-testing","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/developer\/2023\/10\/26\/equivalence-testing\/","title":{"rendered":"Equivalence Testing"},"content":{"rendered":"
This is part 4 in my series on <\/span>MATLAB Test<\/span><\/a> in which we\u2019ll look at the new equivalence testing functionality it provides for MATLAB code. Previously, I have covered:<\/span><\/div>
  1. An introduction to MATLAB Test and the Test Manager<\/span><\/a> <\/span><\/li>
  2. The use of advanced coverage metrics<\/span><\/a><\/li>
  3. Measuring and monitoring code quality<\/span><\/a>.<\/span><\/li><\/ol>

    What is equivalence testing and why do I need it?<\/span><\/h2>
    In MATLAB, we can transform MATLAB code to C or C++ using <\/span>MATLAB Coder<\/span><\/a>, or to .NET assemblies, Java classes, or Python packages using <\/span>MATLAB Compiler SDK<\/span><\/a>. In such cases, we will often want to verify that the transformed version of our code behaves in exactly the same way as the original MATLAB code. This is particularly important in safety critical environments such as medical devices or <\/span>ADAS<\/span><\/a> where it is the transformed code that is used in the final product.<\/span><\/div>
    Equivalence (or back-to-back) testing is a form of dynamic testing that checks that these two software systems produce the same output when given the same inputs. MATLAB Test provides a new framework that makes it easy to write such equivalence tests.<\/span><\/div>

    Basic syntax<\/span><\/h2>

    C\/C++ code<\/span><\/h3>
    The syntax for writing equivalence tests using the framework provided by MATLAB Test will be very familiar if you\u2019re used to writing class-based unit tests. Given a function <\/span>myAdd<\/span> defined as:<\/span><\/div>
    function <\/span>y = myAdd(a,b)<\/span><\/span><\/div>
    y = a + b;<\/span><\/span><\/div>
    end<\/span><\/span><\/div><\/div>
    The equivalence test for C code is:<\/span><\/div>
    classdef <\/span>tEquivalence < matlabtest.coder.TestCase<\/span><\/span><\/div>
    <\/span>methods<\/span>(Test)<\/span><\/span><\/div>
    <\/span>function <\/span>tMyAdd(testCase)<\/span><\/span><\/div>
    buildResults = build(testCase,<\/span>\"myAdd\"<\/span>,Inputs={1,2});<\/span><\/span><\/div>
    executionResults = execute(testCase,buildResults);<\/span><\/span><\/div>
    verifyExecutionMatchesMATLAB(testCase,executionResults)<\/span><\/span><\/div>
    <\/span>end<\/span><\/span><\/div>
    <\/span>end<\/span><\/span><\/div>
    end<\/span><\/span><\/div><\/div>
    There are a few things to note:<\/span><\/div>
    1. Our test class inherits from <\/span>matlabtest.coder.TestCase<\/span><\/a> rather than the usual <\/span>matlab.unittest.TestCase<\/span><\/a>.<\/span><\/li>
    2. The new <\/span>build<\/span><\/a> method builds the C binary that we will execute as part of the test. We specify the name of the entry point function we want to build (<\/span>myAdd<\/span>) and some default inputs. These \"compile-time\" inputs are required for code generation and are similar to codegen\u2019s \u00ad<\/span>-args<\/span> flag. It\u2019s an optional argument as it\u2019s possible to write functions with no input arguments.<\/span><\/li>
    3. The new <\/span>execute<\/span><\/a> method executes the C binary using the default inputs. You can also specify different \"run-time\" inputs here if you so wish.<\/span><\/li>
    4. The <\/span>verifyExecutionMatchesMATLAB<\/span><\/a> method does what it says \u2013 it produces a verification failure if the output from the C code does not match that of MATLAB.<\/span><\/li><\/ol>
      The <\/span>documentation<\/span><\/a> contains more detailed information such as how to configure additional code generation options, reuse existing generated C or C++ code, or <\/span>test generated code with multiple entry points<\/span><\/a>.<\/span><\/div>

      .NET, Java, Python<\/span><\/h3>
      For MATLAB Compiler SDK workflows, the syntax is very similar:<\/span><\/div>
      classdef <\/span>tDeployment < matlabtest.compiler.TestCase<\/span><\/span><\/div>
      <\/span>methods <\/span>(Test)<\/span><\/span><\/div>
      <\/span>function <\/span>pythonEquivalence(testCase)<\/span><\/span><\/div>
      buildResults = build(testCase,<\/span>\"myAdd.m\"<\/span>,<\/span>\"pythonPackage\"<\/span>); <\/span><\/span><\/div>
      executionResults = execute(testCase,buildResults,{1,2});<\/span><\/span><\/div>
      verifyExecutionMatchesMATLAB(testCase,executionResults);<\/span><\/span><\/div>
      <\/span>end<\/span><\/span><\/div>
      <\/span>end<\/span><\/span><\/div>
      end<\/span><\/span><\/div><\/div>
      We now inherit from <\/span>matlabtest.compiler.TestCase<\/span><\/a> and the signatures of the <\/span>build<\/span><\/a> and <\/span>execute<\/span><\/a> functions are very slightly different to those of <\/span>matlabtest.coder.TestCase<\/span> that we looked at above.<\/span><\/div>
      Again, the <\/span>documentation<\/span><\/a> gives full details of the syntax such as how to specify additional MATLAB Compiler SDK options.<\/span><\/div>

      Reusing unit tests for equivalence testing<\/span><\/h2>
      In this section I\u2019m going to show how tests that have be written to verify a MATLAB algorithm can be repurposed for equivalence testing. The implementation <\/span>shortestPath<\/span> and corresponding 14 test points are based on the <\/span>example project that comes with MATLAB Test<\/span><\/a>.<\/span><\/div>

      Overview<\/span><\/h3>
      The basic structure of the tests is:<\/span><\/div>
      classdef <\/span>tMATLABTests < matlab.unittest.TestCase<\/span><\/span><\/div>
      <\/span>methods <\/span>(Test)<\/span><\/span><\/div>
      <\/span>function <\/span>aTestPoint(testCase)<\/span><\/span><\/div>
      <\/span>% Generate inputs <\/span><\/span><\/div>
      adjacency = <\/span>\u2026<\/span><\/span><\/div>
      startIdx = <\/span>\u2026<\/span><\/span><\/div>
      endIdx = <\/span>\u2026<\/span><\/span><\/div>
      expectedResult = <\/span>\u2026<\/span><\/span><\/div>
      debugTxt = <\/span>\u2026<\/span><\/span><\/div>
      verifyPathLength(testCase, adjacency,startIdx,endIdx, expectedResult,debugTxt);<\/span><\/span><\/div>
      <\/span>end<\/span><\/span><\/div>
      <\/span>end<\/span><\/span><\/div>
      end<\/span><\/span><\/div><\/div>
      where the method <\/span>verifyPathLength<\/span> is of the form:<\/span><\/div>
      function <\/span>verifyPathLength(testCase,adjacency,startIdx,endIdx, expectedResult,debugTxt)<\/span><\/span><\/div>
      <\/span><\/span><\/div>
      <\/span>% Execute the design<\/span><\/span><\/div>
      actualResult = shortestPath(adjacency, startIdx, endIdx);<\/span><\/span><\/div>
       <\/div>
      <\/span>% Confirm the expected<\/span><\/span><\/div>
      msgTxt = sprintf(<\/span>'Failure context: %s'<\/span>, debugTxt);<\/span><\/span><\/div>
      testCase.verifyEqual(actualResult, expectedResult, msgTxt);<\/span><\/span><\/div>
      <\/span><\/span><\/div>
      end<\/span><\/span><\/div><\/div>
      I can use the Test Browser to add <\/span>tMATLABTests<\/span> to my list of tests and run them:<\/span><\/div>
      \"testBrowser-matlab.png\"<\/img><\/div>
      Output of tMATLABTests in the Test Browser.<\/span><\/div>
      verifyPathLength<\/span> contains all the code that we will need to modify to switch the tests from being standard MATLAB unit tests to equivalence tests. However, it would be nice to retain the original tests whilst adding the ability to run equivalence tests without duplicating code. We can do this by subclassing <\/span>tMATLABTests<\/span> and overloading the <\/span>verifyPathLength <\/span>method.<\/span><\/div>

      Equivalence test for C code<\/span><\/h3>
      To support the equivalence testing of C code, I\u2019m going to create a subclass of <\/span>tMATLABTests<\/span> called <\/span>tEquivalenceTestsForC<\/span>. This code needs to do 4 things:<\/span><\/div>
      1. Inherit from <\/span>matlabtest.coder.TestCase<\/span> in addition to <\/span>tMATLABTests<\/span> so that we have access to the equivalence testing functionality that we need.<\/span><\/li>
      2. Build the code \u2013 it\u2019s most efficient if we do this once for the test class rather than for each test point individually. We can use a <\/span>TestClassSetup<\/span> block to do this and store the result as a property. There\u2019s an additional catch that the <\/span>adjacency<\/span> input is not of fixed size. We need to tell MATLAB Coder about this using the <\/span>coder.typeof<\/span><\/a> function.<\/span><\/li>
      3. Execute the code for the given inputs.<\/span><\/li>
      4. Compare the results to MATLAB.<\/span><\/li><\/ol>
        Here\u2019s the code:<\/span><\/div>
        classdef <\/span>tEquivalenceTestsForC < tMATLABTests & matlabtest.coder.TestCase<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>properties <\/span>(Access = private)<\/span><\/span><\/div>
        BuildResults<\/span><\/span><\/div>
        <\/span>end<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>methods <\/span>(TestClassSetup)<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>function <\/span>generateCode(testCase)<\/span><\/span><\/div>
        <\/span>% Build the function once and store the results for reuse -<\/span><\/span><\/div>
        <\/span>% much more efficient that building for every test point.<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>% Define input arguments that will allow shortestPath to build.<\/span><\/span><\/div>
        <\/span>% Since adjacency can be of variable size, we use coder.typeof<\/span><\/span><\/div>
        <\/span>% to declare that it's a double matrix that can be up to 20x20<\/span><\/span><\/div>
        <\/span>% and that both rows and columns can change size.<\/span><\/span><\/div>
        adjacency = coder.typeof(0,[20 20],[true true]);<\/span><\/span><\/div>
        inputs = { adjacency -1 2};<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>% Build the function<\/span><\/span><\/div>
        testCase.BuildResults = testCase.build(<\/span>\"shortestPath\"<\/span>,Inputs=inputs);<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>end<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>end<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>methods<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>function <\/span>verifyPathLength(testCase,adjacency,startIdx,endIdx,~,~)<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>% Execute the function in both MATLAB and C using the inputs<\/span><\/span><\/div>
        <\/span>% provided by each test point.<\/span><\/span><\/div>
        executionResults = testCase.execute(testCase.BuildResults,Inputs={adjacency,startIdx,endIdx});<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>% Verify C matches MATLAB.<\/span><\/span><\/div>
        testCase.verifyExecutionMatchesMATLAB(executionResults)<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>end<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        <\/span>end<\/span><\/span><\/div>
        <\/span><\/span><\/div>
        end<\/span><\/span><\/div><\/div>
        As before, we can add <\/span>tEquivalenceTestsForC<\/span> to the Test Browser and run the tests:<\/span><\/div>
        \"testBrowser-c.png\"<\/img><\/div>
        Output of tEquivalenceTestsForC in the Test Browser.<\/span><\/div>

        Equivalence test for Python<\/span><\/h3>
        To support the equivalence testing of Python code, I\u2019m going to create a second subclass of <\/span>MATLABTests<\/span> called <\/span>tEquivalenceTestsForPython<\/span>. Whilst this example is for Python, you can follow the same procedure for Java or .NET. Our code needs to do 4 things:<\/span><\/div>
        1. Inherit from <\/span>matlabtest.compiler.TestCase <\/span>(note compiler, not coder!) in addition to <\/span>tMATLABTests<\/span> so that we have access to the equivalence testing functionality that we need.<\/span><\/li>
        2. Build the code \u2013 it\u2019s most efficient if we do this once for the test class rather than for each test point individually. We can use a <\/span>TestClassSetup<\/span> block to do this and store the result as a property.<\/span><\/li>
        3. Execute the code for the given inputs.<\/span><\/li>
        4. Compare the results to MATLAB.<\/span><\/li><\/ol>
          Note that since Python is a dynamically typed language, we don\u2019t need to use the <\/span>coder.typeof<\/span> construct that we had for C.<\/span><\/div>
          Here\u2019s the code:<\/span><\/div>
          classdef <\/span>tEquivalenceTestsForPython < tMATLABTests & matlabtest.compiler.TestCase<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>properties <\/span>(Access = private)<\/span><\/span><\/div>
          BuildResults<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>methods <\/span>(TestClassSetup)<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>function <\/span>generateCode(testCase)<\/span><\/span><\/div>
          <\/span>% Build the function once and store the results for reuse -<\/span><\/span><\/div>
          <\/span>% much more efficient that building for every test point.<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          testCase.BuildResults = testCase.build(<\/span>\"shortestPath.m\"<\/span>,<\/span>\"pythonPackage\"<\/span>);<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>methods<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>function <\/span>verifyPathLength(testCase,adjacency,startIdx,endIdx,~,~)<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>% Execute the function in both MATLAB and Python using the<\/span><\/span><\/div>
          <\/span>% inputs provided by each test point.<\/span><\/span><\/div>
          executionResults = testCase.execute(testCase.BuildResults,{adjacency,startIdx,endIdx});<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>% Verify Python matches MATLAB.<\/span><\/span><\/div>
          testCase.verifyExecutionMatchesMATLAB(executionResults)<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          end<\/span><\/span><\/div><\/div>
          We can then run the tests in the Test Browser. Note that you must have a compatible version of Python installed \u2013 see <\/span>pyenv<\/span><\/a> for more details.<\/span><\/div>
          \"testBrowser-python.png\"<\/img><\/div>
          Output of tEquivalenceTestsForPython in the Test Browser.<\/span><\/div>
          In this case we have a test failure which we will need to investigate further.<\/span><\/div>

          Conclusion<\/span><\/h2>
          In this blog post we\u2019ve looked at the new functionality available in MATLAB Test to support equivalence testing when transforming MATLAB code to C, C++, Python, Java, or .NET. Equivalence testing is particularly important in safety critical environments such as medical devices or ADAS. We also looked at how inheritance can be leveraged to reuse existing MATLAB tests for equivalence testing.<\/span><\/div>
          In the next and final post in the series, I will explore dependency-based test selection.<\/span><\/div>

          Code listing<\/span><\/h2>

          shortestPath<\/span><\/h3>
          function <\/span>pathLength = shortestPath(adjMatrix, startIdx, endIdx) <\/span>%#codegen<\/span><\/span><\/div>
          % SHORTEST_PATH - Finds length of shortest path between nodes in a graph<\/span><\/span><\/div>
          % <\/span><\/span><\/div>
          % OUT = SHORTEST_PATH(ADJMTX, STARTIDX, ENDIDX) Takes a graph represented by<\/span><\/span><\/div>
          % its adjacency matrix ADJMTX along with two node STARTIDX, ENDIDX as<\/span><\/span><\/div>
          % inputs and returns a integer containing the length of the shortest path<\/span><\/span><\/div>
          % from STARTIDX to ENDIDX in the graph.<\/span><\/span><\/div>
           <\/div>
          % Copyright 2021 The MathWorks, Inc.<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          %% Validy testing on the inputs <\/span><\/span><\/div>
          <\/span>% This code should never throw an error and instead should return<\/span><\/span><\/div>
          <\/span>% error codes for invlid inputs.<\/span><\/span><\/div>
          ErrorCode = 0;<\/span><\/span><\/div>
          pathLength = -1;<\/span><\/span><\/div>
           <\/div>
          <\/span>% Check the validity of the adjacency matrix<\/span><\/span><\/div>
          <\/span>if <\/span>(~isAdjMatrixValid(adjMatrix))<\/span><\/span><\/div>
          ErrorCode = -9;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>% Check the validity of the startIdx<\/span><\/span><\/div>
          <\/span>if <\/span>~isNodeValid(startIdx)<\/span><\/span><\/div>
          ErrorCode = -19;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>% Check the validity of the endIdx<\/span><\/span><\/div>
          <\/span>if <\/span>~isNodeValid(endIdx)<\/span><\/span><\/div>
          ErrorCode = -29;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          [nodeCnt, n] = size(adjMatrix);<\/span><\/span><\/div>
           <\/div>
          <\/span>% Start or end node is too large<\/span><\/span><\/div>
          <\/span>if <\/span>startIdx > nodeCnt || endIdx > nodeCnt<\/span><\/span><\/div>
          ErrorCode = -99;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>% Start or end node is too small<\/span><\/span><\/div>
          <\/span>if <\/span>startIdx < 1 || endIdx < 1<\/span><\/span><\/div>
          ErrorCode = -199;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>if <\/span>(ErrorCode<0)<\/span><\/span><\/div>
          pathLength = ErrorCode;<\/span><\/span><\/div>
          <\/span>return<\/span>;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          %% Self-loop path is always 0<\/span><\/span><\/div>
          <\/span>if <\/span>startIdx == endIdx<\/span><\/span><\/div>
          pathLength = 0;<\/span><\/span><\/div>
          <\/span>return<\/span>;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          %% Dijkstra's Algorithm <\/span><\/span><\/div>
          <\/span>% Dijkstra's Algorithm is used to iteratively explore the graph breadth<\/span><\/span><\/div>
          <\/span>% first and update the shortest path until we reach the end node.<\/span><\/span><\/div>
           <\/div>
          <\/span>% Initialization<\/span><\/span><\/div>
          max = realmax;<\/span><\/span><\/div>
          visited = false(1, nodeCnt);<\/span><\/span><\/div>
           <\/div>
          <\/span>% The distance vector maintains the current known shortest path from <\/span><\/span><\/div>
          <\/span>% the start node to every node. As nodes are processed one by one <\/span><\/span><\/div>
          <\/span>% the distance vestor is updated<\/span><\/span><\/div>
          distance = repmat(max, 1, nodeCnt);<\/span><\/span><\/div>
          distance(startIdx) = 0;<\/span><\/span><\/div>
           <\/div>
          <\/span>for <\/span>iterStep = 1:nodeCnt<\/span><\/span><\/div>
          <\/span>% At each iteration identify the current node to process that <\/span><\/span><\/div>
          <\/span>% is not yet visited and has the smallest distance from the start.<\/span><\/span><\/div>
          <\/span>% This breadth first search ensures that we will always reach nodes<\/span><\/span><\/div>
          <\/span>% by the shortest possible path.<\/span><\/span><\/div>
          min = max;<\/span><\/span><\/div>
          nodeIdx = -1;<\/span><\/span><\/div>
          <\/span>for <\/span>v = 1:n<\/span><\/span><\/div>
          <\/span>if <\/span>~visited(v) && distance(v) <= min<\/span><\/span><\/div>
          min = distance(v);<\/span><\/span><\/div>
          nodeIdx = v;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>% Stop iterating when the current distance is maximum because<\/span><\/span><\/div>
          <\/span>% this indicates no remaining nodes are reachable<\/span><\/span><\/div>
          <\/span>if <\/span>(min==max)<\/span><\/span><\/div>
          <\/span>return<\/span>;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>% Mark the current node visited and check if this is end index<\/span><\/span><\/div>
          visited(nodeIdx) = true;<\/span><\/span><\/div>
          <\/span>if <\/span>nodeIdx == endIdx<\/span><\/span><\/div>
          pathLength = distance(nodeIdx);<\/span><\/span><\/div>
           <\/div>
          <\/span>if <\/span>(pathLength==realmax)<\/span><\/span><\/div>
          <\/span>% No path exists so set distance to -1;<\/span><\/span><\/div>
          pathLength = -1;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>return<\/span>;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>% Update distances of unvisited nodes adjacent to the current node <\/span><\/span><\/div>
          <\/span>for <\/span>v = 1:nodeCnt<\/span><\/span><\/div>
          <\/span>if<\/span>(~visited(v) && adjMatrix(nodeIdx, v) ~= 0 && distance(nodeIdx) ~= max)<\/span><\/span><\/div>
          distVal = distance(nodeIdx) + adjMatrix(nodeIdx, v);<\/span><\/span><\/div>
          <\/span>if <\/span>distVal < distance(v)<\/span><\/span><\/div>
          distance(v) = distVal;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          end<\/span><\/span><\/div>
           <\/div>
          function <\/span>out = isNodeValid(node)<\/span><\/span><\/div>
          <\/span>% For full coverage we need to create negative tests that make each<\/span><\/span><\/div>
          <\/span>% successively make each validity condition false<\/span><\/span><\/div>
          <\/span>if<\/span>(isscalar(node) && isnumeric(node) && ~isinf(node) && floor(node) == node)<\/span><\/span><\/div>
          out = true;<\/span><\/span><\/div>
          <\/span>else<\/span><\/span><\/div>
          out = false;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          end<\/span><\/span><\/div>
           <\/div>
          function <\/span>out = isAdjMatrixValid(adjMatrix)<\/span><\/span><\/div>
          <\/span>% need to be a square matrix with only 0, 1, or realmax entries. <\/span><\/span><\/div>
          [m, n] = size(adjMatrix);<\/span><\/span><\/div>
           <\/div>
          <\/span>% For full coverage we need to create negative tests that make each<\/span><\/span><\/div>
          <\/span>% successively make each validity condition false<\/span><\/span><\/div>
          <\/span>if <\/span>(m==n) && isempty(find((adjMatrix ~= 0) & (adjMatrix ~= 1), 1))<\/span><\/span><\/div>
          out = true;<\/span><\/span><\/div>
          <\/span>else<\/span><\/span><\/div>
          out = false;<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          end<\/span><\/span><\/div><\/div>

          tMATLABTests<\/span><\/h3>
          classdef <\/span>tMATLABTests < tCommon<\/span><\/span><\/div>
          <\/span>% Copyright 2021 The MathWorks, Inc.<\/span><\/span><\/div>
           <\/div>
          <\/span>methods <\/span>(Test,TestTags=<\/span>\"InputTests\"<\/span>)<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_invalid_start_1(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_straight_seq();<\/span><\/span><\/div>
          startIdx = -1;<\/span><\/span><\/div>
          endIdx = 2;<\/span><\/span><\/div>
          expOut = -199;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Invalid start index, idx<1'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_invalid_start_2(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_straight_seq();<\/span><\/span><\/div>
          startIdx = 12;<\/span><\/span><\/div>
          endIdx = 2;<\/span><\/span><\/div>
          expOut = -99;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Invalid start index, idx>NodeCnt'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_invalid_end_1(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_straight_seq();<\/span><\/span><\/div>
          startIdx = 1;<\/span><\/span><\/div>
          endIdx = -3;<\/span><\/span><\/div>
          expOut = -199;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Invalid end index, idx<1'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_invalid_end_2(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_straight_seq();<\/span><\/span><\/div>
          startIdx = 1;<\/span><\/span><\/div>
          endIdx = 12;<\/span><\/span><\/div>
          expOut = -99;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Invalid end index, idx>NodeCnt'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>methods<\/span>(Test,TestTags=<\/span>\"EdgelessTests\"<\/span>)<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_edgeless_graph(testCase)<\/span><\/span><\/div>
          adjMatrix = zeros(20,20);<\/span><\/span><\/div>
          startIdx = 1;<\/span><\/span><\/div>
          endIdx = 18;<\/span><\/span><\/div>
          expOut = -1;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Edgeless graph'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_edgeless_start(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_some_nodes_edgeless();<\/span><\/span><\/div>
          startIdx = 1;<\/span><\/span><\/div>
          endIdx = 4;<\/span><\/span><\/div>
          expOut = -1;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Edgeless graph'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_edgeless_end(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_some_nodes_edgeless();<\/span><\/span><\/div>
          startIdx = 3;<\/span><\/span><\/div>
          endIdx = 1;<\/span><\/span><\/div>
          expOut = -1;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Edgeless graph'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>function <\/span>check_edgeless_graph_self_loop(testCase)<\/span><\/span><\/div>
          adjMatrix = zeros(20,20);<\/span><\/span><\/div>
          startIdx = 16;<\/span><\/span><\/div>
          endIdx = 16;<\/span><\/span><\/div>
          expOut = 0;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Self loop in edgeless graph'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>methods <\/span>(Test)<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_longest_path(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_straight_seq();<\/span><\/span><\/div>
          startIdx = 1;<\/span><\/span><\/div>
          endIdx = 4;<\/span><\/span><\/div>
          expOut = 3;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Longest theoretic path'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_unity_path(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_all_edge();<\/span><\/span><\/div>
          startIdx = 2;<\/span><\/span><\/div>
          endIdx = 3;<\/span><\/span><\/div>
          expOut = 1;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Path length 1'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_non_unique(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_square();<\/span><\/span><\/div>
          startIdx = 4;<\/span><\/span><\/div>
          endIdx = 2;<\/span><\/span><\/div>
          expOut = 2;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Non-unique path'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_no_path(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_disconnected_components();<\/span><\/span><\/div>
          startIdx = 1;<\/span><\/span><\/div>
          endIdx = 5;<\/span><\/span><\/div>
          expOut = -1;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'No path'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_start_end_same(testCase)<\/span><\/span><\/div>
          adjMatrix = testCase.graph_all_edge();<\/span><\/span><\/div>
          startIdx = 3;<\/span><\/span><\/div>
          endIdx = 3;<\/span><\/span><\/div>
          expOut = 0;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Start and end index same'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>check_invalid_idx_empty_adj(testCase)<\/span><\/span><\/div>
          adjMatrix = [];<\/span><\/span><\/div>
          startIdx = 1;<\/span><\/span><\/div>
          endIdx = 1;<\/span><\/span><\/div>
          expOut = -99;<\/span><\/span><\/div>
          verifyPathLength(testCase, adjMatrix, startIdx, endIdx, expOut, <\/span>'Degenerate empty graph'<\/span>);<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>methods <\/span>(Static)<\/span><\/span><\/div>
          <\/span>% Utility functions to create common adjacency graph matrices<\/span><\/span><\/div>
          <\/span>function <\/span>adj = graph_straight_seq()<\/span><\/span><\/div>
          <\/span>% Create the graph:<\/span><\/span><\/div>
          <\/span>% 1---2---3---4<\/span><\/span><\/div>
           <\/div>
          adj = [0 1 0 0; <\/span>...<\/span><\/span><\/div>
          1 0 1 0; <\/span>...<\/span><\/span><\/div>
          0 1 0 1; <\/span>...<\/span><\/span><\/div>
          0 0 1 0];<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>adj = graph_square()<\/span><\/span><\/div>
          <\/span>% Create the graph:<\/span><\/span><\/div>
          <\/span>% 1---2<\/span><\/span><\/div>
          <\/span>% | |<\/span><\/span><\/div>
          <\/span>% 4---3<\/span><\/span><\/div>
           <\/div>
          adj = [0 1 0 1; <\/span>...<\/span><\/span><\/div>
          1 0 1 0; <\/span>...<\/span><\/span><\/div>
          0 1 0 1; <\/span>...<\/span><\/span><\/div>
          1 0 1 0];<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>adj = graph_all_edge()<\/span><\/span><\/div>
          <\/span>% Create the graph:<\/span><\/span><\/div>
          <\/span>% 1---2<\/span><\/span><\/div>
          <\/span>% |\\ \/|<\/span><\/span><\/div>
          <\/span>% |\/ \\|<\/span><\/span><\/div>
          <\/span>% 4---3<\/span><\/span><\/div>
           <\/div>
          adj = [0 1 1 1; <\/span>...<\/span><\/span><\/div>
          1 0 1 1; <\/span>...<\/span><\/span><\/div>
          1 1 0 1; <\/span>...<\/span><\/span><\/div>
          1 1 1 0];<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>adj = graph_disconnected_components()<\/span><\/span><\/div>
          <\/span>% Create the graph:<\/span><\/span><\/div>
          <\/span>% 2 5<\/span><\/span><\/div>
          <\/span>% \/ \\ \/ \\<\/span><\/span><\/div>
          <\/span>% 1---3 4---6<\/span><\/span><\/div>
           <\/div>
          adj = [0 1 1 0 0 0; <\/span>...<\/span><\/span><\/div>
          1 0 1 0 0 0; <\/span>...<\/span><\/span><\/div>
          1 1 0 0 0 0; <\/span>...<\/span><\/span><\/div>
          0 0 0 0 1 1; <\/span>...<\/span><\/span><\/div>
          0 0 0 1 0 1; <\/span>...<\/span><\/span><\/div>
          0 0 0 1 1 0];<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>adj = graph_some_nodes_edgeless()<\/span><\/span><\/div>
          <\/span>% Create the graph:<\/span><\/span><\/div>
          <\/span>% 2<\/span><\/span><\/div>
          <\/span>% \/ \\<\/span><\/span><\/div>
          <\/span>% 4---3<\/span><\/span><\/div>
          <\/span>%<\/span><\/span><\/div>
          <\/span>% Nodes 1, 5, 6 are edgeless<\/span><\/span><\/div>
           <\/div>
          adj = [0 0 0 0 0 0; <\/span>...<\/span><\/span><\/div>
          0 0 1 1 0 0; <\/span>...<\/span><\/span><\/div>
          0 1 0 1 0 0; <\/span>...<\/span><\/span><\/div>
          0 1 1 0 0 0; <\/span>...<\/span><\/span><\/div>
          0 0 0 0 0 0; <\/span>...<\/span><\/span><\/div>
          0 0 0 0 0 0];<\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>methods<\/span><\/span><\/div>
           <\/div>
          <\/span>function <\/span>verifyPathLength(testCase,adjacency,startIdx,endIdx,expectedResult,debugTxt)<\/span><\/span><\/div>
           <\/div>
          <\/span>% Execute the design<\/span><\/span><\/div>
          actualResult = shortestPath(adjacency, startIdx, endIdx);<\/span><\/span><\/div>
           <\/div>
          <\/span>% Confirm the expected<\/span><\/span><\/div>
          msgTxt = sprintf(<\/span>'Failure context: %s'<\/span>, debugTxt);<\/span><\/span><\/div>
          testCase.verifyEqual(actualResult, expectedResult, msgTxt);<\/span><\/span><\/div>
          <\/span><\/span><\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          <\/span>end<\/span><\/span><\/div>
           <\/div>
          end<\/span><\/span><\/div><\/div>
          <\/div>\r\n<\/div>