Merge "Try to add some more documentation to testables"

    @Before

    public void setUp() throws Exception {

        TestableLooper.get(this).setAsMainLooper();

        mManagers = new ArrayList<>();

        QSTileHost host = new QSTileHost(mContext, null,

                mock(StatusBarIconController.class));

/**

 * A runner with support for extra annotations provided by the Testables library.

 * @see UiThreadTest

 * @see TestableLooper.RunWithLooper

 */

public class AndroidTestingRunner extends BlockJUnit4ClassRunner {

        });

    }

    /**

     * Allows tests to sub-class TestableContext if they want to provide any extended functionality

     * or provide a {@link LeakCheck} to the TestableContext upon instantiation.

     */

    protected TestableContext getContext() {

        return new TestableContext(InstrumentationRegistry.getContext());

    }

package android.testing;

import android.content.Context;

import android.util.ArrayMap;

import android.util.Log;

import java.util.List;

import java.util.Map;

/**

 * Utility for dealing with the facts of Lifecycle. Creates trackers to check that for every

 * call to registerX, addX, bindX, a corresponding call to unregisterX, removeX, and unbindX

 * is performed. This should be applied to a test as a {@link org.junit.rules.TestRule}

 * and will only check for leaks on successful tests.

 * <p>

 * Example that will catch an allocation and fail:

 * <pre class="prettyprint">

 * public class LeakCheckTest {

 *    @Rule public LeakCheck mLeakChecker = new LeakCheck();

 *

 *    @Test

 *    public void testLeak() {

 *        Context context = new ContextWrapper(...) {

 *            public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {

 *                mLeakChecker.getTracker("receivers").addAllocation(new Throwable());

 *            }

 *            public void unregisterReceiver(BroadcastReceiver receiver) {

 *                mLeakChecker.getTracker("receivers").clearAllocations();

 *            }

 *        };

 *        context.registerReceiver(...);

 *    }

 *  }

 * </pre>

 *

 * Note: {@link TestableContext} supports leak tracking when using

 * {@link TestableContext#TestableContext(Context, LeakCheck)}.

 */

public class LeakCheck extends TestWatcher {

    private final Map<String, Tracker> mTrackers = new HashMap<>();

        verify();

    }

    /**

     * Acquire a {@link Tracker}. Gets a tracker for the specified tag, creating one if necessary.

     * There should be one tracker for each pair of add/remove callbacks (e.g. one tracker for

     * registerReceiver/unregisterReceiver).

     *

     * @param tag Unique tag to use for this set of allocation tracking.

     */

    public Tracker getTracker(String tag) {

        Tracker t = mTrackers.get(tag);

        if (t == null) {

        return t;

    }

    public void verify() {

    private void verify() {

        mTrackers.values().forEach(Tracker::verify);

    }

    /**

     * Holds allocations associated with a specific callback (such as a BroadcastReceiver).

     */

    public static class LeakInfo {

        private static final String TAG = "LeakInfo";

        private List<Throwable> mThrowables = new ArrayList<>();

        LeakInfo() {

        }

        /**

         * Should be called once for each callback/listener added. addAllocation may be

         * called several times, but it only takes one clearAllocations call to remove all

         * of them.

         */

        public void addAllocation(Throwable t) {

            // TODO: Drop off the first element in the stack trace here to have a cleaner stack.

            mThrowables.add(t);

        }

        /**

         * Should be called when the callback/listener has been removed. One call to

         * clearAllocations will counteract any number of calls to addAllocation.

         */

        public void clearAllocations() {

            mThrowables.clear();

        }

        }

    }

    /**

     * Tracks allocations related to a specific tag or method(s).

     * @see #getTracker(String)

     */

    public static class Tracker {

        private Map<Object, LeakInfo> mObjects = new ArrayMap<>();

        private Tracker() {

        }

        public LeakInfo getLeakInfo(Object object) {

            LeakInfo leakInfo = mObjects.get(object);

            if (leakInfo == null) {

import java.util.Map;

/**

 * Alternative to a MockContentResolver that falls back to real providers.

 * A version of ContentResolver that allows easy mocking of providers.

 * By default it acts as a normal ContentResolver and returns all the

 * same providers.

 * @see #addProvider(String, ContentProvider)

 * @see #setFallbackToExisting(boolean)

 */

public class TestableContentResolver extends ContentResolver {