rapporto di test delle mutazioni con unità di test e codice originale

3

Ho letto dei test sulle mutazioni e anche se il suo funzionamento interno o come farlo è chiaro per me; Sto avendo qualche problema a capire la relazione tra un programma che vuole essere testato e test di mutazione. Ho letto materiale su questo argomento, ma non è ancora chiaro per me.

Ad esempio, immagina di aver creato un programma che utilizza la ricerca binaria per trovare un valore. Quindi ho qualcosa di simile a questo:

public int runBinarySearchIteratively(
  int[] sortedArray, int key, int low, int high) {
    int index = Integer.MAX_VALUE;

    while (low <= high) {
        int mid = (low + high) / 2;
        if (sortedArray[mid] < key) {
            low = mid + 1;
        } else if (sortedArray[mid] > key) {
            high = mid - 1;
        } else if (sortedArray[mid] == key) {
            index = mid;
            break;
        }
    }
    return index;
}

Quindi, ho una serie di test che mi serviranno per dimostrare questo programma; ad esempio:

arrayToTest={1,2,3,4,5,6}
key=3
will return 2

arrayToTest={10,20,30,40,50,60}
key=60
will return 5

arrayToTest={10,20,30,40,50,60}
key=100
will return Max_VAlue

Ma quando applico il test delle mutazioni, posso generare mutanti che modificano il comportamento originale del programma, ad esempio:

mutant 1:
while (low > high) {
            int mid = (low + high) / 2;
            if (sortedArray[mid] < key) {
                low = mid + 1;
            } else if (sortedArray[mid] > key) {

mutant 2:

if (sortedArray[mid] > key) {
                low = mid + 1;
            } else if (sortedArray[mid] > key) {
                high = mid - 1;

e così via. Per quello che so se i test case rilevano il mutante (la risposta fornita dal programma mutato differisce da quella dichiarata sul test) allora il mutante viene ucciso; e in altri casi il mutante sopravvive. Per quello che ho letto nel caso in cui sopravvivono molti mutanti che indicherebbero che i nostri casi di test hanno bisogno di raffinamento; e qui arrivano le domande che ho:

  • Potrebbe essere un punto di test di mutazione per probabili difetti che il mio programma originale potrebbe avere? Se questo è il caso, come? perché un mutante sarebbe un programma obbligato a eseguire un'azione a cui il programma originale non era destinato.

    • Il test della mutazione potrebbe essere usato per testare o generare piccoli programmi che fungeranno da test unitario?

In sintesi, quale sarebbe la relazione tra il programma originale e il test delle mutazioni? o come questa tecnica potrebbe essere utile per testare un programma. Forse la domanda sembrerebbe sciocca perché è un'area già studiata, ma non sono stato in grado di trovare buoni esempi sul web che potrebbero aiutarmi con questi dubbi.

Grazie

    
posta asgard 12.12.2018 - 17:32
fonte

1 risposta

3

Il test delle mutazioni non espone difetti nel programma, ma difetti nella suite di test.

L'idea è che la suite di test debba essere sufficientemente dettagliata in modo da rilevare eventuali deviazioni dal comportamento previsto. Una suite di test con copertura di codice elevata è necessaria ma non sufficiente per tale obiettivo. Ad esempio, una suite di test ad alta copertura potrebbe non riuscire a testare gli errori "off-one".

Un test di mutazione modifica il programma in modo sottile, ad esempio modificando un confronto inferiore a < con <= minore o uguale. Una buona suite di test dovrebbe contenere casi limite che chiariscano le nostre aspettative su ciò che dovrebbe accadere qui. Ma se quella mutazione non causa il fallimento dei test, entrambi gli operatori potrebbero essere corretti per quanto riguarda la nostra suite di test. Forse l'originale è corretto, forse il codice mutato è corretto! Ma uno di loro deve essere sbagliato. Quindi potremmo voler chiarire i test.

In pratica, i test di mutazione sono piuttosto rari e sono disponibili pochi strumenti per farlo. È anche soggetto a falsi positivi, perché non tutto il codice esiste puramente per la correttezza. Il codice è anche soggetto a requisiti non funzionali che di solito non si riflettono in una suite di test, ad esempio che produce un output di registrazione. Pertanto, il test delle mutazioni è meno adatto per la ricerca di difetti specifici ma è più adatto per trovare regioni di codice che hanno test di bassa qualità (cioè, le mutazioni in questa regione sono improbabili che vengano uccise).

Le tecniche correlate includono:

  • Iniezione di errori, in cui viene generato un errore nel nostro software per testare la gestione degli errori del software
  • Fuzzing, che è come un test di mutazione per l'input del software. Il test fuzz è utile per garantire che un programma sia in grado di gestire l'input danneggiato in modo sicuro. Questo tende ad essere applicato a software sensibili alla sicurezza come i parser dei formati di file oi server web.
risposta data 12.12.2018 - 18:37
fonte

Leggi altre domande sui tag