bounty将在6天内到期。回答此问题可获得+150声望奖励。user1506104希望引起更多关注这个问题。

我创建了这个短类，它在执行某个进程后向侦听器提供响应。为了使其成为reproducible example，我修改了我的 handleMessage（Message） 函数，使其休眠5秒，并在完成时返回一个随机字符串，而不是实际连接到远程主机。

public class MyService {
    private static final String TAG = MyService.class.getSimpleName();

    private final HandlerThread mInboxHandlerThread;
    private final Handler mInboxHandler;
    private final List<Handler> mListeners = new ArrayList<>();

    public MyService() {
        mInboxHandlerThread = new HandlerThread("Incoming data handler");
        mInboxHandlerThread.start();

        mInboxHandler = new Handler(mInboxHandlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                MyService.this.handleMessage(msg);
            }
        };
    }

    public final void inform(Message msg) {
        if (mInboxHandler != null) {
            mInboxHandler.sendMessage(msg);
        } else {
            Log.w(TAG, "mInboxHandler is null");
        }
    }

    public final void registerListener(Handler listener) {
        mListeners.add(listener);
    }

    public final void unregisterListener(Handler listener) {
        mListeners.remove(listener);
    }

    final void notifyOutboxHandlers(int what, int arg1, int arg2, Object obj) {
        if (mListeners.isEmpty()) {
            Log.w(TAG, String.format("No listener to handle outgoing message (%d)", what));
        } else {
            for (Handler handler : mListeners) {
                Message msg = Message.obtain(handler, what, arg1, arg2, obj);
                msg.sendToTarget();
            }
        }
    }

    private void handleMessage(Message msg) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                try {
                    // Mimic long-running service execution
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                notifyOutboxHandlers(COMMAND_RESPONSE, 0, 0, "<SUCCESS/>");
            }
        };
        thread.start();
    }
}

这门课起作用了。我只需要编写一个单元测试，并确保可以从服务触发侦听器（类型为Handler）。我的视图（类型为Activity）层就像下面这样简单：

public class MainActivity extends AppCompatActivity implements Handler.Callback {

    private final static String TAG = MainActivity.class.getSimpleName();
    private MyService mMyService = null;
    private TextView mMessagesView = null;
    private Handler mHandler = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_cc);
        mMessagesView = findViewById(R.id.messages);

        mMyService = new MyService();
        mHandler = new Handler(this);
        mMyService.registerListener(mHandler);

        Message test = new Message();
        test.what = COMMAND_REQUEST;
        test.arg1 = 1;
        test.arg2 = 2;
        test.obj = "test";
        mMyService.inform(test);
    }

    @Override
    public boolean handleMessage(@NonNull Message msg) {
        String messages = mMessagesView.getText().toString();
        mMessagesView.setText(messages + "\nTransactionManager: " + msg.obj);

        switch (msg.what) {
            case COMMAND_RESPONSE:
                Log.d(TAG, "got response from controller");
                return true;
        }
        return false;
    }

    @Override
    protected void onDestroy() {
        mMyService.unregisterListener(mHandler);
        super.onDestroy();
    }
}

最后，我的问题是，如何对这个回调函数进行单元测试？如何确保视图层中的处理程序被正确触发。具体来说，我想测试/Assert来自服务的回复是<SUCCESS/>。
通过参考其他堆栈溢出帖子，我能够创建此测试脚本，但甚至无法工作：

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {

    private MyService mMyService;
    private Handler mHandler;

    @Mock
    private Handler.Callback mHandlerCallback;

    @Captor
    private ArgumentCaptor<Handler.Callback> callbackCaptor;

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);

        mMyService = new MyService();
        when(mHandlerCallback.handleMessage(any(Message.class)))
                .thenReturn(true);
    }

    @Test
    public void testCallback() {
        String message = "test";

        Message test= new Message();
        test.what = COMMAND_REQUEST;
        test.arg1 = 1;
        test.arg2 = 2;
        test.obj = message;

        mHandler = new Handler(callbackCaptor.capture());
        mMyService.registerListener(mHandler);
        mMyService.inform(test);

        assertTrue(callbackCaptor instanceof Handler.Callback );
    }
}

任何帮助将不胜感激。谢谢！