Enable and Deflake PluginInstanceTest

import android.content.pm.ApplicationInfo;

import android.test.suitebuilder.annotation.SmallTest;

import android.util.Log;

import androidx.test.filters.FlakyTest;

import androidx.test.runner.AndroidJUnit4;

import com.android.systemui.SysuiTestCase;

import java.util.Collections;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicReference;

import java.util.function.Supplier;

@FlakyTest(bugId = 327655994) // Also b/324682425

@SmallTest

@RunWith(AndroidJUnit4.class)

public class PluginInstanceTest extends SysuiTestCase {

    }

    @Test

    public void testLoadUnloadSimultaneous_HoldsUnload() throws Exception {

    public void testLoadUnloadSimultaneous_HoldsUnload() throws Throwable {

        final Semaphore loadLock = new Semaphore(1);

        final Semaphore unloadLock = new Semaphore(1);

            Thread.yield();

            boolean isLocked = getLock(unloadLock, 1000);

            // Ensure the bg thread failed to do delete the plugin

            // Ensure the bg thread failed to delete the plugin

            assertNotNull(mPluginInstance.getPlugin());

            // We expect that bgThread deadlocked holding the semaphore

            assertFalse(isLocked);

        };

        AtomicBoolean isBgThreadFailed = new AtomicBoolean(false);

        AtomicReference<Throwable> bgFailure = new AtomicReference<Throwable>(null);

        Thread bgThread = new Thread(() -> {

            assertTrue(getLock(unloadLock, 10));

            assertTrue(getLock(loadLock, 4000)); // Wait for the foreground thread

            assertTrue(getLock(loadLock, 10000)); // Wait for the foreground thread

            assertNotNull(mPluginInstance.getPlugin());

            // Attempt to delete the plugin, this should block until the load completes

            mPluginInstance.unloadPlugin();

        // This protects the test suite from crashing due to the uncaught exception.

        bgThread.setUncaughtExceptionHandler((Thread t, Throwable ex) -> {

            Log.e("testLoadUnloadSimultaneous_HoldsUnload", "Exception from BG Thread", ex);

            isBgThreadFailed.set(true);

            Log.e("PluginInstanceTest#testLoadUnloadSimultaneous_HoldsUnload",

                    "Exception from BG Thread", ex);

            bgFailure.set(ex);

        });

        loadLock.acquire();

        mPluginInstance.loadPlugin();

        bgThread.join(5000);

        assertFalse(isBgThreadFailed.get());

        // Rethrow final background exception on test thread

        Throwable bgEx = bgFailure.get();

        if (bgEx != null) {

            throw bgEx;

        }

        assertNull(mPluginInstance.getPlugin());

    }

        try {

            return lock.tryAcquire(millis, TimeUnit.MILLISECONDS);

        } catch (InterruptedException ex) {

            Log.e("PluginInstanceTest#getLock",

                    "Interrupted Exception getting lock", ex);

            fail();

            return false;

        }