Wie testet man (selbstgeschriebene) Listen sinnvoll?

Hallo.
Ich habe eine Deque Klasse geschrieben, wobei ein Array mit Größenanpassung genutzt wird. Ich wollte mal fragen, wie man solche Listen sinnvoll testet. Ich habe einfach zufällig Werte links und rechts (an den Anfang und an das Ende der Liste) eingefügt und es scheint alles zu funktionieren. Gibt es hierzu Standardfälle die man durchgehen sollte?

Java:
package exercises;

import java.util.Iterator;

//1.3.33 Resizing array deque implementation
public class ResizingArrayDeque<Item> implements Iterable<Item> {

    private Item[] a = (Item[]) new Object[4];
    private int size = 0;
    private int head = 0;
    private int tail = 0;

    public boolean isEmpty() { return size == 0; }
    public int size() { return size; }

    private void resize(int max)
    {
        Item[] tempArray = (Item[]) new Object[max];
        for(int i = 0; i < size; i++)
        {
            tempArray[i] = a[(head + i) % a.length];
        }

        head = 0;
        tail = size;
        a = tempArray;
    }

    public void pushRight(Item item)
    {
        a[tail++] = item;
        size++;

        if(size == a.length) resize(2 * a.length);

        if(tail == a.length) tail = 0;
    }

    public void pushLeft(Item item)
    {
        if(size == a.length) resize(2 * a.length);

        if(head == 0) head = a.length;

        a[--head] = item;
        size++;
    }

    public Item popRight()
    {
        if(isEmpty()) throw new java.util.NoSuchElementException();

        Item item = a[--tail];
        a[tail] = null;
        size--;

        if(size > 0 && size < a.length / 4) resize(a.length / 2);

        return item;
    }

    public Item popLeft()
    {
        if(isEmpty()) throw new java.util.NoSuchElementException();

        Item item = a[head];
        a[head++] = null;
        size--;

        if(size > 0 && size < a.length / 4) resize(a.length / 2);

        return item;
    }

    @Override
    public Iterator<Item> iterator() {
        return new Iterator<Item>()
        {
            private int i = 0;

            @Override
            public boolean hasNext() {
                return i < size;
            }

            @Override
            public Item next() {
                return a[(head + (i++)) % a.length];
            }
        };
    }
}
 
Wenn ich 1,2,3,4 einlese, sollte einmal
1,2,3,4 ausgelesen werden(Queue) und einmal
4,3,2,1 (Stack)

bei beiden sollte die Länge erst 4 dann 0 sein.

Das würde ich schon mal in beide Richtungen testen.
 
Du hast dir ja bei der Implementierung der Liste irgendwas gedacht, dass sie bei bestimmten Eingaben bestimmte Ausgaben bzw. bestimmtes Verhalten an den Tag legt.
Nun testest du es, indem du Unittests schreibst, in denen du die Eingaben übergibst und prüfst, ob die Ausgaben den Erwartungen entsprechen. Wenn du es ganz genau testen willst (du solltest das wollen ;)) dann musst du jeden Fall, also jede if Abfrage testen, inklusive den, in deinem Fall unsichtbaren, else Fällen.
Für deine
Java:
pushLeft(Item item)
Methode würden sich folgende Tests ergeben
ein Test für size == a.length, erwartetes Ergebnis ist das was aus resize rauskommen soll
ein Test für size != a.length erwartetes Ergebnis dass size nur um eins erhöht wird
jeweils ein Test für head == 0 und head != 0
ein Test ob item korrekt eingefügt wird
usw.

Man stellt oft erst beim Testen fest, dass der Quellcode nicht optimal ist.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben