Java wait() and deadlocks

Question

I am testing a class I use for communication in a multithreading application. While a simple use of pop and add works without issues, things break when I try to check if the Stack is empty and then wait until someone adds an element to it.

My class:

public class SynchronizedStack<T>{
private final Stack<T> data;
public SynchronizedStack(){
    this.data = new Stack<>();
}

public T pop(){
    synchronized (this.data) {
        if(this.data.isEmpty())
            return null;
        T object = this.data.pop();
        this.data.notifyAll();
        return object;
    }
}

public void add(T e){
    synchronized (this.data){
        this.data.add(e);
        this.data.notifyAll();
    }
}

public void waitUntilFilled() throws InterruptedException {
    synchronized (this.data){
        while(this.data.isEmpty())
            this.data.wait();
    }
}

My issue is with the waitUntilFilled method. When it's called and the Stack is filled, nothing is wrong, but when it's called on an empty Stack it causes a deadlock.

My test case:

@Test
public void testWaitUntilFilled(){
    SynchronizedStack<Integer> ss = new SynchronizedStack<>();
    Runnable producer = ()->{
        ss.add(1);
    };

    Runnable consumer = ()->{
        try {
            ss.waitUntilFilled();
        } catch (InterruptedException e) {
            fail(e);
        }
        assertNotNull(ss.pop());
    };

    Thread p = new Thread(producer, "producer");
    Thread c = new Thread(consumer, "consumer");

    c.run();
    p.run();
}