Выполнение нескольких вызовов в модульном тесте без использования цикла for

Question

Допустим, у меня есть модульный тест, похожий на приведенный ниже, есть ли способ написать один модульный тест вместо нескольких, но также избежать использования цикла for в модульном тесте?

[Test]
public void RunTestWithMultipleOptions()
{
  MyClass code = new MyClass();
  code.Prefix = "{DS1}";  //Options are {DS1}, {DS2}, {DS3}, {DS4}
  //Property could be set to
  //code.Prefix = "{DS1}{DS2}";
  //code.Prefix = "{DS1}{DS2}{DS3}";

  //And so on

 //Based on how many {DS} used a method needs calling

  code.InputDataStore(1,"Data1");

  //If used {DS1}{DS2} in Prefix then
  //code.InputDataStore(1,"Data1");
  //code.InputDataStore(2,"Data2");

  //If used {DS1}{DS2}{DS3} in Prefix then
  //code.InputDataStore(1,"Data1");
  //code.InputDataStore(2,"Data2");
  //code.InputDataStore(3,"Data3");

  string OutputData = String.Empty;

  code.Output += delegate(int Id, string Data) 
                 { 
                    if (Id == (int)OutputsEnum.OutputModified)
                      OutputData = Data; 
                 };



  //Call the input method which will raise the Output event which we can assert against
  code.Input("hi there");

  //Assert that output has replace the prefix {DS} with the data in the datastorecontent list

  Assert.AreEqual("Data1hi there", OutputData);
}

Я могу передать значение свойства методу модульного теста и использовать контрольные примеры, но в зависимости от того, что это свойство, MyMethod нужно вызывать x раз. Без зацикливания в тесте я не могу придумать способ, не имея всех проницаемостей в качестве отдельных модульных тестов.

ОБНОВЛЕНИЕ: Вот основное содержание класса:

    public event Action<int, string> Output;

    public string Prefix { get; set; }

    public string Postfix { get; set; }

    private List<string> DataStoreContents = new List<string>() { "", "", "", "" };

    public void Input(string Data)
    {
        if (Output != null)
            {
                if (!String.IsNullOrEmpty(Prefix))
                {
                    Prefix = Prefix.Replace("{DS1}", DataStoreContents[0]);
                    Prefix = Prefix.Replace("{DS2}", DataStoreContents[1]);
                    Prefix = Prefix.Replace("{DS3}", DataStoreContents[2]);
                    Prefix = Prefix.Replace("{DS4}", DataStoreContents[3]);
                }

                if (!String.IsNullOrEmpty(Postfix))
                {
                    Postfix = Postfix.Replace("{DS1}", DataStoreContents[0]);
                    Postfix = Postfix.Replace("{DS2}", DataStoreContents[1]);
                    Postfix = Postfix.Replace("{DS3}", DataStoreContents[2]);
                    Postfix = Postfix.Replace("{DS4}", DataStoreContents[3]);
                }

                Output((int)OutputsEnum.OutputBeforeModified, Data);
                Output((int)OutputsEnum.OutputModified, Prefix + Data + Postfix);
                Output((int)OutputsEnum.OutputAfterModified, Data);
            }
        }
    } 

    public void InputDataStore(int DataStore, string Data)
    {
        if (DataStore < 1 || DataStore > 4)
            throw new ArgumentOutOfRangeException("Datastore number out of range");

        DataStoreContents[DataStore - 1] = Data;
    }

}

Я хочу проверить, что когда я вызываю InputDataStore(1,"MyData1"); InputDataStore(2, "MyData");, Output фактически заменяет соответствующие значения {DS1} соответствующей строкой, а также объединяет их с любыми другими значениями {DS}

Answer 1

Один из вариантов - проверить каждый вызов отдельно и все вместе.Если вы тестируете A & B и C, вы можете ограничиться тестированием A, B, C отдельно и A & B & C вместе.Одним из вариантов является следующий код (сделаны некоторые предположения):

 [TestFixture]
    public class ToTestFixture
    {
        [SetUp]
        public void SetUp()
        {
            _instance = new ToTest();
            _instance.InputDataStore(1, "1");
            _instance.InputDataStore(2, "2");
            _instance.InputDataStore(3, "3");
            _instance.InputDataStore(4, "4");
        }

        private ToTest _instance;
        [TestCase("{DS1}","1")]
        [TestCase("{DS2}", "2")]
        [TestCase("{DS3}", "3")]
        [TestCase("{DS4}", "4")]
        [TestCase("{DS1}{DS2}{DS3}{DS4}", "1234")]
        [Test]
        public void TestPrefixReplacements(string input, string expectedResult)
        {

            _instance.Prefix = input;

            //Call the input method which will raise the Output event which we can test
            _instance.Input("Any string goes here as we test only prefix." );

            Assert.AreEqual(expectedResult, _instance.Prefix);
        }

    }

    internal enum OutputsEnum
    {
        OutputBeforeModified,
        OutputModified,
        OutputAfterModified
    }

    public class ToTest
    {
        public event Action<int, string> Output = (x, result) => Console.WriteLine(x.ToString() + result);

        public string Prefix { get; set; }

        public string Postfix { get; set; }

        private List<string> DataStoreContents = new List<string>() {"1", "2", "3", "4"};

        public void Input(string Data)
        {
            if (Output != null)
            {
                if (!String.IsNullOrEmpty(Prefix))
                {
                    Prefix = Prefix.Replace("{DS1}", DataStoreContents[0]);
                    Prefix = Prefix.Replace("{DS2}", DataStoreContents[1]);
                    Prefix = Prefix.Replace("{DS3}", DataStoreContents[2]);
                    Prefix = Prefix.Replace("{DS4}", DataStoreContents[3]);
                }

                if (!String.IsNullOrEmpty(Postfix))
                {
                    Postfix = Postfix.Replace("{DS1}", DataStoreContents[0]);
                    Postfix = Postfix.Replace("{DS2}", DataStoreContents[1]);
                    Postfix = Postfix.Replace("{DS3}", DataStoreContents[2]);
                    Postfix = Postfix.Replace("{DS4}", DataStoreContents[3]);
                }

                Output((int) OutputsEnum.OutputBeforeModified, Data);
                Output((int) OutputsEnum.OutputModified, Prefix + Data + Postfix);
                Output((int) OutputsEnum.OutputAfterModified, Data);
            }
        }
        public void InputDataStore(int DataStore, string Data)
        {
            if (DataStore < 1 || DataStore > 4)
                throw new ArgumentOutOfRangeException("Datastore number out of range");

            DataStoreContents[DataStore - 1] = Data;
        }
    }

Во всяком случае, я чувствую, что существует связь между "DS1" и индексом массива.(1-0, 2-1).Это означает, что возможен следующий рефакторинг:

Prefix = Prefix.Replace("{DS"+index+"}", DataStoreContents[index-1]);

Более того, я думаю, что решение о выходном действии странно, и два if-s являются дублирующим кодом.Вот что я имею в виду:

   public void Input(string Data)
    {
        if (Output != null)
        {
            Prefix = ApplyReplaceRules(Prefix);

            Postfix = ApplyReplaceRules(Postfix);

            Output((int) OutputsEnum.OutputBeforeModified, Data);
            Output((int) OutputsEnum.OutputModified, Prefix + Data + Postfix);
            Output((int) OutputsEnum.OutputAfterModified, Data);
        }
    }

    private string ApplyReplaceRules(string patternString)
    {
        if (!String.IsNullOrEmpty(Postfix))
        {
            patternString = patternString.Replace("{DS1}", DataStoreContents[0]);
            patternString = patternString.Replace("{DS2}", DataStoreContents[1]);
            patternString = patternString.Replace("{DS3}", DataStoreContents[2]);
            patternString = patternString.Replace("{DS4}", DataStoreContents[3]);
        }

        return patternString;
    }