Esercizio - Adapter di classe e di oggetto per la pila (esempi del corso)

import java.util.NoSuchElementException;

/** ADAPTEE (dal corso, con una correzione): coda circolare a due estremita'. */
public class CircQ<T> {
    private T[] storage;
    protected int size, head, tail;       // protected: li legge il test, come nel corso

    @SuppressWarnings("unchecked")
    public CircQ(int max) {
        storage = (T[]) new Object[max];
    }

    public CircQ() { this(10); }

    public int add(T elem) {
        if (size == storage.length) {
            // il corso lancia NoSuchElementException anche qui, ma "coda piena" non e' "elemento mancante"
            throw new IllegalStateException("coda piena");
        }
        storage[tail] = elem;
        size++;
        tail = (tail + 1) % storage.length;
        return size;
    }

    public T readFromHead() {
        if (size == 0) throw new NoSuchElementException();
        return storage[head];
    }

    public T getFromHead() {
        if (size == 0) throw new NoSuchElementException();
        T retval = storage[head];
        storage[head] = null;
        head = (head + 1) % storage.length;
        size--;
        return retval;
    }

    public T readFromTail() {
        if (size == 0) throw new NoSuchElementException();
        return storage[(tail - 1 + storage.length) % storage.length];
    }

    public T getFromTail() {
        if (size == 0) throw new NoSuchElementException();
        tail = (tail - 1 + storage.length) % storage.length;
        T retval = storage[tail];
        storage[tail] = null;
        size--;
        return retval;
    }

    public int len() { return size; }

    @Override public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < size; i++) {
            if (i != 0) sb.append("; ");
            sb.append(storage[(i + head) % storage.length]);
        }
        return sb.append("]").toString();
    }
}

/** TARGET: l'interfaccia di pila che il client vuole. */
public interface MyStack<T> {
    void push(T el);
    int size();
    T pop();
    T peek();
}

/** ADAPTER di oggetto: ha una CircQ (composizione) e traduce le chiamate. */
public class MyStackObjectAdapter<T> implements MyStack<T> {
    final CircQ<T> adaptee = new CircQ<>();       // package-private: i test di white-box lo ispezionano

    public void push(T el) { adaptee.add(el); }
    public int size()      { return adaptee.len(); }
    public T pop()         { return adaptee.getFromTail(); }
    public T peek()        { return adaptee.readFromTail(); }

    @Override public String toString() { return adaptee.toString(); }
}

/** ADAPTER di classe: eredita CircQ (extends) e realizza MyStack (implements). */
public class MyStackClassAdapter<T> extends CircQ<T> implements MyStack<T> {
    public MyStackClassAdapter() { super(); }

    public void push(T el) { add(el); }
    public int size()      { return len(); }
    public T pop()         { return getFromTail(); }
    public T peek()        { return readFromTail(); }
}

public class MainAdapters {
    /** Il client lavora solo con MyStack: non sa quale adapter c'e' dietro. */
    static void usa(MyStack<String> s, String[] elementi) {
        for (String e : elementi) s.push(e);
        System.out.println(s);
        while (s.size() > 0) System.out.print(s.pop() + " ");
        System.out.println();
    }

    public static void main(String[] argv) {
        String[] dati = {"a", "b", "c"};
        System.out.println("-- adapter di oggetto");
        usa(new MyStackObjectAdapter<>(), dati);
        System.out.println("-- adapter di classe");
        MyStackClassAdapter<String> ca = new MyStackClassAdapter<>();
        usa(ca, dati);
        // Con l'adapter di classe i metodi di CircQ restano visibili a chi usa il tipo concreto:
        ca.push("x");
        System.out.println("getFromHead() e' accessibile (e rompe la disciplina LIFO): " + ca.getFromHead());
    }
}

-- adapter di oggetto
[a; b; c]
c b a 
-- adapter di classe
[a; b; c]
c b a 
getFromHead() e' accessibile (e rompe la disciplina LIFO): x

import static org.junit.Assert.assertEquals;

import java.util.NoSuchElementException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/** Stesso insieme di test su entrambi gli adapter, scritto SOLO contro l'interfaccia MyStack (black-box). */
public class TestMyStacks {
    private MyStack<String> pila;

    @Before
    public void setup() {
        pila = new MyStackObjectAdapter<>();       // cambiare in new MyStackClassAdapter<>() e rieseguire: stessi risultati
    }

    @After
    public void tearDown() { pila = null; }

    @Test
    public void pilaNuovaVuota() { assertEquals(0, pila.size()); }

    @Test
    public void pushSuPilaVuota() {
        pila.push("test");
        assertEquals(1, pila.size());
        assertEquals("test", pila.peek());          // JUnit: assertEquals(ATTESO, EFFETTIVO)
    }

    @Test
    public void ordineLifo() {
        pila.push("a"); pila.push("b"); pila.push("c");
        assertEquals("c", pila.pop());
        assertEquals("b", pila.pop());
        assertEquals("a", pila.pop());
        assertEquals(0, pila.size());
    }

    @Test
    public void peekNonRimuove() {
        pila.push("x");
        pila.peek();
        assertEquals(1, pila.size());
    }

    @Test(expected = NoSuchElementException.class)
    public void popSuPilaVuota() { pila.pop(); }

    @Test
    public void ilBufferCircolareGira() {
        for (int i = 0; i < 25; i++) { pila.push("e" + i); assertEquals("e" + i, pila.pop()); }   // oltre la capacita' 10
        assertEquals(0, pila.size());
    }

    @Test(expected = IllegalStateException.class)
    public void pilaPiena() {
        for (int i = 0; i < 11; i++) pila.push("e" + i);      // capacita' di default 10
    }
}

TestMyStacks: eseguiti 7, falliti 0, ignorati 0