Question

My Android app should do the following:
The MainActivity launches another thread at the beginning called UdpListener which can receive UDP calls from a remote server. If it receives a packet with a content “UPDATE”, the UdpListener should notify the MainActivity to do something.

(In the real app, the use case looks like this that my app listens on the remote server. If there is any new data available on the remote server, it notifies every client (app) by UDP, so the client knows that it can download the new data by using HTTP).

I tried to simulate this in an JUnit test. The test contains an inner class which mocks the MainActivity as well as it sends the UDP call to the UdpListener:

public class UdpListener extends Thread implements Subject {
    private DatagramSocket serverSocket;
    private DatagramPacket receivedPacket;
    private boolean running = false;
    private String sentence = "";

    private Observer observer;

    private static final String TAG = "UdpListener";

    public UdpListener(Observer o) throws SocketException {
        serverSocket = new DatagramSocket(9800);
        setRunning(true);

        observer = o;
    }

    @Override
    public void run() {
        setName(TAG);
        while (isRunning())  {
            byte[] receivedData = new byte[1024];
            receivedPacket = new DatagramPacket(receivedData, receivedData.length);
            try {
                serverSocket.receive(receivedPacket);
            } 
            catch (IOException e) {
                Log.w(TAG, e.getMessage());
            }

            try {
                sentence = new String(receivedPacket.getData(), 0, receivedPacket.getLength(), "UTF-8");
                if ("UPDATE".equals(sentence))  {
                    notifyObserver();
                }
            } 
            catch (UnsupportedEncodingException e) {
                Log.w(TAG, e.getMessage());
            }
        }
    }

    private boolean isRunning() {
        return running;
    }

    public void setRunning(boolean running) {
        this.running = running;
    }

    @Override
    public void notifyObserver() {
        observer.update();
    }
}

This is the corresponding test:

@RunWith(RobolectricTestRunner.class)
public class UdpListenerTest {

    private MainActivityMock mainActivityMock = new MainActivityMock();

    @Before
    public void setUp() throws Exception {
        mainActivityMock.setUpdate(false);
    }

    @After
    public void tearDown() throws Exception {
        mainActivityMock.setUpdate(false);
    }

    @Test
    public void canNotifyObserver() throws IOException, InterruptedException {
        UdpListener udpListener = new UdpListener(mainActivityMock);
        udpListener.setRunning(true);
        udpListener.start();    

        InetAddress ipAddress = InetAddress.getByName("localhost");
        DatagramSocket datagramSocket = new DatagramSocket();
        DatagramPacket sendPacket = new DatagramPacket("UPDATE".getBytes(), "UPDATE".length(), ipAddress, 9800);
        datagramSocket.send(sendPacket);
        datagramSocket.close();

        assertTrue(mainActivityMock.isUpdate());

        udpListener.setRunning(false);
    }

    private class MainActivityMock implements Observer {

        private boolean update = false;

        @Override
        public void update() {
            update = true;
        }

        public boolean isUpdate()  {
            return update;
        }

        public void setUpdate(boolean update)  {
            this.update = update;
        }
    }
}

The good thing is that my concept works. But, this test doesn’t. That means it only does when I stop with a breakpoint at this line datagramSocket.close(); and wait for about a second. Why this happens is clear. But how can I do that automatically? I thought about using wait() but I have to invoke notify() from the other thread for that. The same problem with CountDownLatch. I’m not sure how to solve that without changing UdpListener.

Answer 1

You could write a simple loop with a specified timeout.

try {
  long timeout = 500; // ms
  long lastTime = System.currentTimeMillis();
  while(timeout > 0 && !mainActivityMock.isUpdate()) {
    Thread.sleep(timeout);
    timeout -= System.currentTimeMillis() - lastTime;
    lastTime = System.currentTimeMillis();
  }
} catch(InterruptedException e) {

} finally {
  assertTrue(mainActivityMock.isUpdate());
}

By the way – you should declare your running attribute to volatile.