android - 观察由另一个线程修改的对象时 Android JUnit 测试中的计时问题

Question

我的 Android 应用应该执行以下操作:MainActivity 在开始时启动另一个名为 UdpListener 的线程，它可以接收来自远程服务器的 UDP 调用。如果它收到一个内容为“UPDATE”的数据包，UdpListener 应该通知 MainActivity 做一些事情。

(在真实的应用程序中，用例看起来是这样的，我的应用程序在远程服务器上监听。如果远程服务器上有任何可用的新数据，它会通过 UDP 通知每个客户端(应用程序)，因此客户端知道它可以使用 HTTP 下载新数据)。

我试图在 JUnit 测试中对此进行模拟。该测试包含一个内部类，它模拟 MainActivity 并将 UDP 调用发送到 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();
    }
}

这是相应的测试:

@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;
        }
    }
}

好消息是我的概念可行。但是，这个测试没有。这意味着只有当我在 datagramSocket.close(); 行的断点处停止并等待大约一秒钟时，它才会执行。为什么会发生这种情况很清楚。但是我怎样才能自动做到这一点呢？我考虑过使用 wait() 但我必须为此从另一个线程调用 notify() 。 CountDownLatch 也有同样的问题。我不确定如何在不更改 UdpListener 的情况下解决这个问题。

Answer 1

您可以编写一个带有指定超时的简单循环。

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());
}

顺便说一句 - 您应该将 running 属性声明为 volatile。