Вопрос о том, как выполнить юнит-тестирование такого «большого» (не так уж много!) Метода

Question

Итак, у меня есть этот очень длинный метод, который я хочу проверить.Я мог бы сломать его некоторыми другими 4-5 методами, но я не хочу делать эти методы общедоступными (и хотя я могу , я бы хотел, если возможно, держаться подальше от превращения их впакет-защищенный / внутренний):

Если моя математика не ошибается, чтобы проверить это как есть, мне понадобится что-то вроде 8 тестов.Разделение этого на меньшие методы не заставило бы меня делать меньше юнит-тестов, не так ли?Большая проблема, которую я вижу с созданием меньших методов (для тестирования), кроме проблемы с видимостью, заключается в необходимости передавать этим маленьким методам множество аргументов.

Хотя изначально я написал этот код, я все же нахожу еготрудно понять.Так что мой вопрос ... как это проверить?!?Как бы вы это сделали?Должен ли я каким-либо образом реструктурировать это?

    public Genoma GenerateOffspring(Genoma genoma1, Genoma genoma2) {
        if (genoma1.NumberOfGenes != genoma2.NumberOfGenes) throw new ArgumentException("Both individuals must have the same size!");
        if (genoma1.NumberOfGenes == 0 || genoma2.NumberOfGenes == 0) throw new ArgumentException("0-sized genomas not allowed!");

        if (genoma1.NumberOfGenes == 1) {
            if (numberGenerator.GenerateInteger(0, 2) == 0) {
                return genoma1;
            } else {
                return genoma2;
            }
        }

        int cutPoint = numberGenerator.GenerateInteger(1, genoma1.NumberOfGenes);

        Genoma parent1;
        Genoma parent2;

        if (numberGenerator.GenerateBool()) {
            parent1 = genoma1;
            parent2 = genoma2;
        } else {
            parent1 = genoma2;
            parent2 = genoma1;
        }

        Genoma offspring = parent1.Clone();

        if (numberGenerator.GenerateBool()) {
            for (int i = 0; i < cutPoint; ++i) {
                offspring.SetGeneAt(i, parent2.GetGeneAt(i));
            }
        } else {
            for (int i = cutPoint; i < offspring.NumberOfGenes; ++i) {
                offspring.SetGeneAt(i, parent2.GetGeneAt(i));
            }
        }

        return offspring;
    }

Спасибо

Answer 1

Главное, что нужно иметь в виду, когда вы начнете тестирование, вы запустите все тесты, но для данного теста, если в какой-то момент оно не выполнит одно утверждение, оно остановится, то есть то, что после него, не будет быть проверенным, потому что предполагается, что требуется то, что уже было неверно заявлено.

Хорошая вещь о разделении его на более мелкие методы состоит в том, что вы в конечном итоге получите больше вещей, которые можно протестировать независимо, но увеличение количества аргументов, которые вы упоминаете, предполагает, что это не было бы "естественным", поэтому вы должны держать все это в одном и том же тесте, потому что, по вашим словам, вы видите всю функцию как саму единицу, и поэтому один блок-тест должен проверить эту единицу.

Кроме того, увеличение аргументов также сделает ваш код менее привлекательным и менее эффективным, я думаю.

Надеюсь, это поможет.

Answer 2

Просматривая код, вы должны по крайней мере проверить следующие условия

• genoma1.NumberofGenes = genoma2.NumberOfGenes
• genoma1.NumberofGenes <> genoma2.NumberOfGenes
• genoma1.NumberofGenes = -1
• genoma1.NumberofGenes = 0
• genoma1.NumberofGenes = 1
• genoma2.NumberofGenes = -1
• genoma2.NumberofGenes = 0
• genoma2.NumberofGenes = 1
• genoma1.NumberOfGenes = HighBound - 1
• genoma1.NumberOfGenes = HighBound (Макс. Целое число?)
• genoma1.NumberOfGenes = HighBound + 1
• genoma2.NumberOfGenes = HighBound - 1
• genoma2.NumberOfGenes = HighBound (Макс. Целое число?)
• генома2.NumberOfGenes =HighBound + 1

Ваши усилия по тестированию могли бы значительно выиграть от насмешки над объектом numberGenerator и возвращения ему фиксированного значения.
Это даст вам следующие дополнительные условия для тестирования

• numberGenerator.GenerateInteger = LowBound - 1
• numberGenerator.GenerateInteger = LowBound
• numberGenerator.GenerateInteger = LowBound + 1
• numberGenerator.GenerateInteger = HighBound - 1
• numberGenerator.GenerateInteger = HighBound + 1
• numberGenerator.Generate = True
• numberGenerator.GenerateBool = False

Тестирование ВСЕХ возможных комбинаций с заданными входами требует 432 тестовых случая (6.6.6.2)

Использование инструмента парного тестирования сокращает это до 39testcases.

Когда все ваши тесты пройдены, вы должны запустить профилировщик покрытия, чтобы убедиться, что вы не пропустили путь кодирования. Каждый путь должен выполняться хотя бы один раз.

• К настоящему времени у вас есть код, в котором устранено большинство ошибок.
• К настоящему времени у вас есть код, который, скорее всего, все еще содержит некоторые ошибки.(печально, но верно).

---

Модель PICT

genoma1_NumberOfGenes: -1, 0, 1, HighboundMinOne, HighBound, HighBoundPlusOne
genoma2_NumberOfGenes: -1, 0, 1, HighboundMinOne, HighBound, HighBoundPlusOne

numberGenerator.GenerateInteger: LowBoundMinOne, LowBound, LowBoundPlusOne, HighBoundMinOne, HighBound, HighBoundPlusOne
numberGenerator.GenerateBool: True, False

PICT Сгенерированные параметры тестового набора

genoma1_NumberOfGenes    genoma2_NumberOfGenes   numberGenerator.GenerateInteger     numberGenerator.GenerateBool
HighBoundPlusOne         -1                      HighBoundPlusOne                    True
HighBound                1                       HighBoundPlusOne                    False
-1                       HighBoundPlusOne        HighBound                           True
HighBoundPlusOne         0                       LowBound                            False
0                        HighBoundPlusOne        HighBoundPlusOne                    False
0                        1                       HighBoundMinOne                     True
-1                       0                       HighBoundMinOne                     False
HighBound                0                       LowBoundPlusOne                     True
1                        HighboundMinOne         LowBound                            True
HighboundMinOne          HighBound               LowBoundMinOne                      False
-1                       HighBound               HighBoundPlusOne                    True
1                        0                       HighBound                           False
HighBoundPlusOne         HighboundMinOne         HighBoundMinOne                     False
HighboundMinOne          HighboundMinOne         LowBoundMinOne                      True
HighBound                -1                      LowBoundMinOne                      False
HighBoundPlusOne         1                       LowBoundMinOne                      True
HighBoundPlusOne         HighBound               LowBoundPlusOne                     False
1                        -1                      HighBoundMinOne                     True
HighBound                HighBound               HighBoundMinOne                     False
1                        HighboundMinOne         HighBoundPlusOne                    True
HighBound                HighboundMinOne         HighBound                           False
1                        1                       LowBoundPlusOne                     False
HighBoundPlusOne         -1                      HighBound                           True
0                        0                       LowBoundMinOne                      True
1                        HighBound               LowBound                            True
0                        HighBound               HighBound                           False
HighBound                HighBoundPlusOne        LowBound                            True
-1                       -1                      LowBoundMinOne                      True
0                        HighboundMinOne         LowBoundPlusOne                     True
HighBoundPlusOne         HighBoundPlusOne        LowBoundPlusOne                     False
HighboundMinOne          1                       HighBound                           True
-1                       1                       LowBound                            True
HighboundMinOne          -1                      LowBound                            True
HighboundMinOne          -1                      LowBoundPlusOne                     False
-1                       HighboundMinOne         LowBoundPlusOne                     False
HighboundMinOne          HighBoundPlusOne        HighBoundMinOne                     False
HighboundMinOne          0                       HighBoundPlusOne                    False
1                        HighBoundPlusOne        LowBoundMinOne                      False
0                        -1                      LowBound                            False

Answer 3

Я говорю, что нет простого способа обойти это.Кажется, вы генерируете некоторые значения случайным образом, а затем решаете, как установить переменные экземпляра, чтобы что-то вроде таблицы истинности могло вам помочь, чтобы проверить все возможные значения переменных, которые вы устанавливаете.Также я проверил бы операторы if в верхней части, чтобы убедиться, что эти условия выполняются, прежде чем переходить к остальным.Теперь есть способ проверить легко, только тщательно.