Как должен я модульный тест генератор кода?

Вспомните, что "поблочное тестирование" является только одним видом тестирования. Необходимо быть в состоянии к модульному тесту внутренние части генератора кода. На что Вы действительно смотрите, вот системное тестирование уровня (иначе регрессионное тестирование). Это не просто семантика... существуют различные мышления, подходы, ожидания, и т.д. Это - конечно, больше работы, но, вероятно, необходимо стиснуть зубы и настроить сквозной комплект регрессионного теста: фиксированные файлы C++-> ПОТЯГИВАЮТ интерфейсы-> модули Python-> известный вывод. Вы действительно хотите проверить известный вход (зафиксированный код C++) против ожидаемого вывода (что выходит из заключительной программы Python). Проверка результатов генератора кода непосредственно была бы похожа на diffing объектные файлы...

Да, результатами является ЕДИНСТВЕННАЯ вещь, которая имеет значение. Реальная тяжелая работа пишет платформу, которая позволяет Вашему сгенерированному коду работать, независимо... проводят Ваше время там.

Если Вы работаете *nux, Вы могли бы рассмотреть дамп unittest платформы в пользу сценария удара или make-файла. на окнах Вы могли бы рассмотреть создание приложения/функции оболочки, которое выполняет генератор и затем использует код (в качестве другого процесса) и unittest это.

опция трети А состояла бы в том, чтобы генерировать код и затем создать приложение из него, которое включает только unittest. Снова Вам были бы нужны сценарий оболочки или этажерка для выполнения этого для каждого входа. Относительно того, как закодировать ожидаемое поведение, мне приходит в голову, что это могло быть сделано почти таким же способом, поскольку Вы будете для кода C++ просто использование сгенерированного интерфейса, а не C++ один.

Просто требуемый, чтобы указать, что можно все еще достигнуть мелкомодульного тестирования при проверке результатов: можно протестировать отдельные блоки кода вложением их в некоторой установке и коде подтверждения:

int x = 0;
GENERATED_CODE
assert(x == 100);

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

Модульное тестирование - это просто тестирование определенного модуля. Поэтому, если вы пишете спецификацию для класса A, идеально, если класс A не имеет реальных конкретных версий классов B и C.

Хорошо, я заметил впоследствии, что тег для этого вопроса включает C ++ / Python, но принципы одинаковы:

    public class A : InterfaceA 
    {   
      InterfaceB b;

      InterfaceC c;

      public A(InterfaceB b, InterfaceC c)   {
          this._b = b;
          this._c = c;   }

      public string SomeOperation(string input)   
      {
          return this._b.SomeOtherOperation(input) 
               + this._c.EvenAnotherOperation(input); 
      } 
    }

Поскольку вышеупомянутая система A внедряет интерфейсы в системы B и C, вы можете проводить модульное тестирование только системы A, не имея реальных функциональных возможностей, выполняемых какой-либо другой системой. Это модульное тестирование.

Вот умный способ подхода к Системе от создания до завершения, с разными спецификациями When для каждой части поведения:

public class When_system_A_has_some_operation_called_with_valid_input : SystemASpecification
{
    private string _actualString;

    private string _expectedString;

    private string _input;

    private string _returnB;

    private string _returnC;

    [It]
    public void Should_return_the_expected_string()
    {
        _actualString.Should().Be.EqualTo(this._expectedString);
    }

    public override void GivenThat()
    {
        var randomGenerator = new RandomGenerator();
        this._input = randomGenerator.Generate<string>();
        this._returnB = randomGenerator.Generate<string>();
        this._returnC = randomGenerator.Generate<string>();

        Dep<InterfaceB>().Stub(b => b.SomeOtherOperation(_input))
                         .Return(this._returnB);
        Dep<InterfaceC>().Stub(c => c.EvenAnotherOperation(_input))
                         .Return(this._returnC);

        this._expectedString = this._returnB + this._returnC;
    }

    public override void WhenIRun()
    {
        this._actualString = Sut.SomeOperation(this._input);
    }
}

Итак, в заключение, один модуль / спецификация может иметь несколько поведений, и спецификация растет по мере вы разрабатываете блок / систему; и если ваша тестируемая система зависит от других конкретных систем в ней, будьте осторожны.

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

По сути, вы действительно хотите знать, будет ли ваш генератор производить то, что вы ожидаете, без физического тестирования всех возможных комбинаций (также: невозможно). Убедившись, что ваш генератор работает в соответствии с вашими ожиданиями, вы можете быть уверены в том, что генератор будет успешным во все более сложных ситуациях.

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