| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package org.chromium.test.reporter; |
| |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| |
| import org.chromium.base.Log; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** Receives test status broadcasts send from |
| {@link org.chromium.test.reporter.TestStatusReporter}. |
| */ |
| public class TestStatusReceiver extends BroadcastReceiver { |
| |
| private static final String TAG = "test_reporter"; |
| |
| private final List<FailCallback> mFailCallbacks = new ArrayList<FailCallback>(); |
| private final List<HeartbeatCallback> mHeartbeatCallbacks = new ArrayList<HeartbeatCallback>(); |
| private final List<PassCallback> mPassCallbacks = new ArrayList<PassCallback>(); |
| private final List<StartCallback> mStartCallbacks = new ArrayList<StartCallback>(); |
| private final List<TestRunCallback> mTestRunCallbacks = new ArrayList<TestRunCallback>(); |
| |
| /** An IntentFilter that matches the intents that this class can receive. */ |
| private static final IntentFilter INTENT_FILTER; |
| static { |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(TestStatusReporter.ACTION_HEARTBEAT); |
| filter.addAction(TestStatusReporter.ACTION_TEST_FAILED); |
| filter.addAction(TestStatusReporter.ACTION_TEST_PASSED); |
| filter.addAction(TestStatusReporter.ACTION_TEST_STARTED); |
| filter.addAction(TestStatusReporter.ACTION_TEST_RUN_STARTED); |
| filter.addAction(TestStatusReporter.ACTION_TEST_RUN_FINISHED); |
| filter.addAction(TestStatusReporter.ACTION_UNCAUGHT_EXCEPTION); |
| try { |
| filter.addDataType(TestStatusReporter.DATA_TYPE_HEARTBEAT); |
| filter.addDataType(TestStatusReporter.DATA_TYPE_RESULT); |
| } catch (IntentFilter.MalformedMimeTypeException e) { |
| Log.wtf(TAG, "Invalid MIME type", e); |
| } |
| INTENT_FILTER = filter; |
| } |
| |
| /** A callback used when a test has failed. */ |
| public interface FailCallback { |
| void testFailed(String testClass, String testMethod, String stackTrace); |
| } |
| |
| /** A callback used when a heartbeat is received. */ |
| public interface HeartbeatCallback { |
| void heartbeat(); |
| } |
| |
| /** A callback used when a test has passed. */ |
| public interface PassCallback { |
| void testPassed(String testClass, String testMethod); |
| } |
| |
| /** A callback used when a test has started. */ |
| public interface StartCallback { |
| void testStarted(String testClass, String testMethod); |
| } |
| |
| /** A callback used when a test run has started or finished. */ |
| public interface TestRunCallback { |
| void testRunStarted(int pid); |
| void testRunFinished(int pid); |
| void uncaughtException(int pid, String stackTrace); |
| } |
| |
| /** Register a callback for when a test has failed. */ |
| public void registerCallback(FailCallback c) { |
| mFailCallbacks.add(c); |
| } |
| |
| /** Register a callback for when a heartbeat is received. */ |
| public void registerCallback(HeartbeatCallback c) { |
| mHeartbeatCallbacks.add(c); |
| } |
| |
| /** Register a callback for when a test has passed. */ |
| public void registerCallback(PassCallback c) { |
| mPassCallbacks.add(c); |
| } |
| |
| /** Register a callback for when a test has started. */ |
| public void registerCallback(StartCallback c) { |
| mStartCallbacks.add(c); |
| } |
| |
| /** Register a callback for when a test run has started or finished. */ |
| public void registerCallback(TestRunCallback c) { |
| mTestRunCallbacks.add(c); |
| } |
| |
| /** Register this receiver using the provided context. */ |
| public void register(Context c) { |
| c.registerReceiver(this, INTENT_FILTER); |
| } |
| |
| /** Receive a broadcast intent. |
| * |
| * @param context The Context in which the receiver is running. |
| * @param intent The intent received. |
| */ |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| int pid = intent.getIntExtra(TestStatusReporter.EXTRA_PID, 0); |
| String testClass = intent.getStringExtra(TestStatusReporter.EXTRA_TEST_CLASS); |
| String testMethod = intent.getStringExtra(TestStatusReporter.EXTRA_TEST_METHOD); |
| String stackTrace = intent.getStringExtra(TestStatusReporter.EXTRA_STACK_TRACE); |
| |
| switch (intent.getAction()) { |
| case TestStatusReporter.ACTION_TEST_STARTED: |
| for (StartCallback c : mStartCallbacks) { |
| c.testStarted(testClass, testMethod); |
| } |
| break; |
| case TestStatusReporter.ACTION_TEST_PASSED: |
| for (PassCallback c : mPassCallbacks) { |
| c.testPassed(testClass, testMethod); |
| } |
| break; |
| case TestStatusReporter.ACTION_TEST_FAILED: |
| for (FailCallback c : mFailCallbacks) { |
| c.testFailed(testClass, testMethod, stackTrace); |
| } |
| break; |
| case TestStatusReporter.ACTION_HEARTBEAT: |
| for (HeartbeatCallback c : mHeartbeatCallbacks) { |
| c.heartbeat(); |
| } |
| break; |
| case TestStatusReporter.ACTION_TEST_RUN_STARTED: |
| for (TestRunCallback c: mTestRunCallbacks) { |
| c.testRunStarted(pid); |
| } |
| break; |
| case TestStatusReporter.ACTION_TEST_RUN_FINISHED: |
| for (TestRunCallback c: mTestRunCallbacks) { |
| c.testRunFinished(pid); |
| } |
| break; |
| case TestStatusReporter.ACTION_UNCAUGHT_EXCEPTION: |
| for (TestRunCallback c: mTestRunCallbacks) { |
| c.uncaughtException(pid, stackTrace); |
| } |
| break; |
| default: |
| Log.e(TAG, "Unrecognized intent received: %s", intent.toString()); |
| break; |
| } |
| } |
| |
| } |
| |