Qual è l'approccio corretto per testare le classi con ereditarietà?

Nei tuoi test per BarDerived vuoi dimostrare che tutti i metodi (pubblici) di BarDerived funzionano correttamente (per le situazioni che hai testato). Allo stesso modo per BazDerived .

Il fatto che alcuni metodi siano implementati in una classe base non modifica questo obiettivo di test per BarDerived e BazDerived . Ciò porta alla conclusione che Base::doOtherThings deve essere testato sia nel contesto di BarDerived che BazDerived e che si ottengano test molto simili per quella funzione.

Il vantaggio di testare doOtherThings per ogni classe derivata è che se i requisiti per BarDerived cambiano in modo che BarDerived::doOtherThings debba restituire 24, allora il test fallito nel test BazDerived ti dice che potresti essere in rottura i requisiti di un'altra classe.

But how should doOtherThings be handled? Is it good practice to essentially duplicate the test case in both derived classes?

Normalmente mi aspetto che la Base abbia le sue specifiche, che puoi verificare per qualsiasi implementazione conforme, comprese le classi derivate.

void verifyBaseCompliance(const Base & systemUnderTest) {
    // checks that systemUnderTest conforms to the Base API
    // specification
}

void testBase () { verifyBaseCompliance(new Base()); }
void testBar () { verifyBaseCompliance(new BarDerived()); }
void testBaz () { verifyBaseCompliance(new BazDerived()); }

Hai un conflitto qui.

Vuoi testare il valore di ritorno di doThings() , che si basa su un valore letterale (valore const).

Ogni test che scrivi per questo è in grado di riassumere testare un valore const , che è privo di senso.

Per mostrarti un esempio più sensato (sono più veloce con C #, ma il principio è lo stesso)

public class TriplesYourInput : Base
{
    public TriplesYourInput(int input)
    {
        this.foo = 3 * input;
    }
}

Questa classe può essere testata in modo significativo:

var inputValue = 123;

var expectedOutputValue = inputValue * 3;
var receivedOutputValue = new TriplesYourInput(inputValue).doThings();

Assert.AreEqual(receivedOutputValue, expectedOutputValue);

Questo ha più senso da testare. Il suo output si basa sull'input che ha scelto per darlo. In tal caso, puoi assegnare a una classe un input scelto arbitrariamente, osservarne l'output e verificare se corrisponde alle tue aspettative.

Alcuni esempi di questo principio di prova. Si noti che i miei esempi hanno sempre un controllo diretto su quale sia l'input del metodo testabile.

• Test if GetFirstLetterOfString() return "F" when I input "Flater".
• Test if CountLettersInString() returns 6 when I input "Flater".
• Test if ParseStringThatBeginsWithAnA() returns an exception when I input "Flater".

Tutti questi test possono inserire qualsiasi valore vogliano , a patto che le loro aspettative siano in linea con quello che stanno inserendo.

Ma se il tuo output è deciso da un valore costante, dovrai creare un'aspettativa costante, quindi testare se il primo corrisponde al secondo. Il che è sciocco, questo è sempre o mai che passerà; nessuno dei quali è un risultato significativo.

Alcuni esempi di questo principio di prova. Nota che questi esempi non hanno alcun controllo su almeno uno dei valori che vengono confrontati.

• Test if Math.Pi == 3.1415...
• Test if MyApplication.ThisConstValue == 123

Questi test per uno valore particolare. Se cambi questo valore, i tuoi test falliranno. In sostanza, non stai testando se la tua logica funziona per qualsiasi input valido, stai semplicemente testando se qualcuno è in grado di prevedere con precisione un risultato su cui non hanno alcun controllo.

class BarDerived : public Base
{
  public:
    BarDerived() : Base(12) { };
    ~BarDerived() { };
    int doBarThings() { return foo + 1; };
}

public class Base
{
    public int MultiplyFactor;
    protected int InitialValue;

    public Base(int value, int factor)
    {
        this.InitialValue = value;
        this.MultiplyFactor= factor;
    }

    public int GetMultipliedValue()
    {
         return this.InitialValue * this.MultiplyFactor;
    }
}

public class DoublesYourNumber : Base
{
    public DoublesYourNumber(int value) :  base(value, 2) {}
}

public class TriplesYourNumber : Base
{
    public TriplesYourNumber(int value) : base(value, 3) {}
}

var inputValue = 123;

var expectedDoubledOutputValue = inputValue * 2;
var receivedDoubledOutputValue = new DoublesYourNumber(inputValue).GetMultipliedValue();

Assert.AreEqual(expectedDoubledOutputValue , receivedDoubledOutputValue);

var expectedTripledOutputValue = inputValue * 3;
var receivedTripledOutputValue = new TriplesYourNumber(inputValue).GetMultipliedValue();

Assert.AreEqual(expectedTripledOutputValue , receivedTripledOutputValue);