Создание юнит тестов. C#

Имеется программа с графическим редактором. Программа позволяет создавать вершины, соединять их дорогами и считать кратчайший путь. Прикрепляю кусочек кода. Я в юнит тестах полный 0, но требуют обязательно. Сам код:

        public StepInfo Step()
        {
            if (this.queue.Count > 0)
            {
                /// Берем новую вершину, если с текущей уже все обошли
                if (lastVisitedVertex == this.vertexCount)
                {                    
                    currentVertex = this.GetNextVertex();
                }
 
 
 
                /// Проверяем текущую вершину
                if (this.G[currentVertex, lastVisitedVertex] < 0.0)
                    throw new ArgumentException("Граф содержит отрицательные дуги!");
 
                if (this.G[currentVertex, lastVisitedVertex] > 0.0 && this.dist[lastVisitedVertex] > this.dist[currentVertex] + this.G[currentVertex, lastVisitedVertex])
                {
                    this.dist[lastVisitedVertex] = this.dist[currentVertex] + G[currentVertex, lastVisitedVertex];
                    this.path[lastVisitedVertex] = currentVertex;
                }
 
                /// Создаем структуру, в которой будем хранить информацию о текущем шаге
                StepInfo stepInfo = new StepInfo()
                {
                    From = currentVertex,
                    To = lastVisitedVertex,
                    Dist = new double[this.dist.Length]
                };
 
                /// Копируем текущее состояние путей в историю шага
                Array.Copy(dist, stepInfo.Dist, this.dist.Length);               
 
                /// Переходим к следующей вершине                                
                lastVisitedVertex++;
 
                /// Возвращаем информацию о текущем шаге
                return stepInfo;
            }
 
            return new StepInfo()
            {
                From = -1,
                To = -1,
                Dist = new double[dist.Length]
            };
           
        }
    }
}

Сделал такой тестик, но как понял, сформирован он неправильно:

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
 
namespace Step1
{
    [TestClass]
    public class Step1Test
    {
        [TestMethod]
        public void Doroga_20and40_60returned()
        {
            //arrange
            int x = 20;
 
            int y = 40;
 
            int expected = 60;
 
            //act
            Step1Test c = new Step1Test();
 
            int actual = c.Sum(x, y);
 
            //assert
            Assert.AreEqual(expected, actual);
        }
    }
}

По итогу имею такой вид

using Microsoft.VisualStudio.TestTools.UnitTesting;
using ProgLineal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ProgLineal.Tests
{
    [TestClass()]
    public class DijkstraTests
    {
        [TestMethod()]
        public void StepTest()
        {
            //arrange
            int x = 20;
 
            int y = 40;
 
            int expected = 60;
 
            //StepTest c = new StepTest();
 
            int actual = ...
 
            Assert.AreEqual(expected, actual);
        }
    }
}

Что именно мне нужно написать в actual, чтобы получить сумму 20 и 40? И нужно ли писать StepTest c = new StepTest(); или там что-то другое должно быть?

Моя конструкция теста, если так можно сказать, скорее подходит для проверки данного блока:

                {
                    this.dist[lastVisitedVertex] = this.dist[currentVertex] + G[currentVertex, lastVisitedVertex];
                    this.path[lastVisitedVertex] = currentVertex;
                }

Решил добавить весь файлик:

using System;
using System.Collections.Generic;

namespace ProgLineal
{
    /// Структура, которая хранит информацию о том, что было сделано в определенном шаге.
    public struct StepInfo
    {
        public int From { get; set; }
        public int To { get; set; }

        /// Хранит состояние путей в каждом отдельном шаге
        public double[] Dist { get; set; }
    }

    public class Dijkstra
    {
        private double[,] G;

        private int vertexCount;

        /// Содержит последнюю просмотренную вершину
        private int lastVisitedVertex = 0;
        
        /// Отвечает за текущую вершину, в которой сейчас находится алгоритм
        private int currentVertex;

        private List<int> queue = new List<int>();

        /// Массивы с расстояниями до узлов и как туда добраться 
        public double[] dist { get; private set; }
        public int[] path { get; private set; }

        /// Начальные "настройки"
        private void Initialize(int s, int len)
        {
            this.dist = new double[len];
            this.path = new int[len];
            for (int index = 0; index < len; ++index)
            {
                this.dist[index] = double.PositiveInfinity;
                this.queue.Add(index);
            }

            /// Устанавливаем расстояние 0 для начальной точки
            this.dist[s] = 0.0;
            this.path[s] = -1;
        }

        /// Извлекает из очереди следующий узел для оценки
        private int GetNextVertex()
        {
            double num1 = double.PositiveInfinity;
            int num2 = -1;

            /// Поиск в очереди, чтобы найти следующий узел с наименьшим расстоянием
            foreach (int index in this.queue)
            {
                if (this.dist[index] <= num1)
                {
                    num1 = this.dist[index];
                    num2 = index;
                }
            }
            this.queue.Remove(num2);
            lastVisitedVertex = 0;
            return num2;
        }

        public Dijkstra(double[,] G, int s)
        {
            /// Проверяем график что он действительно что-то содержит
            int len = G.GetLength(0) >= 1 && G.GetLength(0) == G.GetLength(1) ? G.GetLength(0) : throw new ArgumentException("Error, Нет узлов для расчёта");
            this.G = G;
            this.vertexCount = len;
            this.Initialize(s, len);
            
            // получаем первую вершину для обсмотра
            currentVertex = this.GetNextVertex();
        }

        public StepInfo Step()
        {
            if (this.queue.Count > 0)
            {
                /// Берем новую вершину, если с текущей уже все обошли
                if (lastVisitedVertex == this.vertexCount)
                {                    
                    currentVertex = this.GetNextVertex();
                }



                /// Проверяем текущую вершину
                if (this.G[currentVertex, lastVisitedVertex] < 0.0)
                    throw new ArgumentException("Граф содержит отрицательные дуги!");

                if (this.G[currentVertex, lastVisitedVertex] > 0.0 && this.dist[lastVisitedVertex] > this.dist[currentVertex] + this.G[currentVertex, lastVisitedVertex])
                {
                    this.dist[lastVisitedVertex] = this.dist[currentVertex] + G[currentVertex, lastVisitedVertex];
                    this.path[lastVisitedVertex] = currentVertex;
                }

                /// Создаем структуру, в которой будем хранить информацию о текущем шаге
                StepInfo stepInfo = new StepInfo()
                {
                    From = currentVertex,
                    To = lastVisitedVertex,
                    Dist = new double[this.dist.Length]
                };

                /// Копируем текущее состояние путей в историю шага
                Array.Copy(dist, stepInfo.Dist, this.dist.Length);               

                /// Переходим к следующей вершине                                
                lastVisitedVertex++;

                /// Возвращаем информацию о текущем шаге
                return stepInfo;
            }

            return new StepInfo()
            {
                From = -1,
                To = -1,
                Dist = new double[dist.Length]
            };
           
        }
    }
}