test.io.flutter.embedding.engine.FlutterEngineTest Class Reference

Public Member Functions
void	setUp ()
void	tearDown ()
void	itAutomaticallyRegistersPluginsByDefault ()
void	itUpdatesDisplayMetricsOnConstructionWithActivityContext ()
void	itSendLocalesOnEngineInit ()
void	itCatchesAndDisplaysRegistrationExceptions ()
void	itDoesNotAutomaticallyRegistersPluginsWhenFlutterLoaderDisablesIt ()
void	itDoesNotAutomaticallyRegistersPluginsWhenFlutterEngineDisablesIt ()
void	itNotifiesPlatformViewsControllerWhenDevHotRestart ()
void	itNotifiesPlatformViewsControllerAboutJNILifecycle ()
void	itUsesApplicationContext () throws NameNotFoundException
void	itUsesPackageContextForAssetManager () throws NameNotFoundException
void	itCanUseFlutterLoaderInjectionViaFlutterInjector () throws NameNotFoundException
void	itNotifiesListenersForDestruction () throws NameNotFoundException
void	itDoesNotAttachAgainWhenBuiltWithAnAttachedJNI () throws NameNotFoundException
void	itComesWithARunningDartExecutorIfJNIIsAlreadyAttached () throws NameNotFoundException
void	passesEngineGroupToPlugins () throws NameNotFoundException

Package Attributes
FlutterJNI	flutterJNI
boolean	jniAttached

Detailed Description

Definition at line 53 of file FlutterEngineTest.java.

Member Function Documentation

itAutomaticallyRegistersPluginsByDefault()

void test.io.flutter.embedding.engine.FlutterEngineTest.itAutomaticallyRegistersPluginsByDefault ( )

inline

Definition at line 93 of file FlutterEngineTest.java.

                                                         {
    assertTrue(GeneratedPluginRegistrant.getRegisteredEngines().isEmpty());
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    when(mockFlutterLoader.automaticallyRegisterPlugins()).thenReturn(true);
    FlutterEngine flutterEngine = new FlutterEngine(ctx, mockFlutterLoader, flutterJNI);
 
    List<FlutterEngine> registeredEngines = GeneratedPluginRegistrant.getRegisteredEngines();
    assertEquals(1, registeredEngines.size());
    assertEquals(flutterEngine, registeredEngines.get(0));
  }

itCanUseFlutterLoaderInjectionViaFlutterInjector()

void test.io.flutter.embedding.engine.FlutterEngineTest.itCanUseFlutterLoaderInjectionViaFlutterInjector ( ) throws NameNotFoundException

inline

Definition at line 276 of file FlutterEngineTest.java.

                                                                                              {
    FlutterInjector.reset();
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    FlutterInjector.setInstance(
        new FlutterInjector.Builder().setFlutterLoader(mockFlutterLoader).build());
    Context packageContext = mock(Context.class);
 
    when(mockContext.createPackageContext(any(), anyInt())).thenReturn(packageContext);
 
    new FlutterEngine(mockContext, null, flutterJNI);
 
    verify(mockFlutterLoader, times(1)).startInitialization(any());
    verify(mockFlutterLoader, times(1)).ensureInitializationComplete(any(), any());
    FlutterInjector.reset();
  }

itCatchesAndDisplaysRegistrationExceptions()

void test.io.flutter.embedding.engine.FlutterEngineTest.itCatchesAndDisplaysRegistrationExceptions ( )

inline

Definition at line 136 of file FlutterEngineTest.java.

                                                           {
    assertTrue(GeneratedPluginRegistrant.getRegisteredEngines().isEmpty());
    GeneratedPluginRegistrant.pluginRegistrationException =
        new RuntimeException("I'm a bug in the plugin");
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    when(mockFlutterLoader.automaticallyRegisterPlugins()).thenReturn(true);
    FlutterEngine flutterEngine = new FlutterEngine(ctx, mockFlutterLoader, flutterJNI);
 
    List<FlutterEngine> registeredEngines = GeneratedPluginRegistrant.getRegisteredEngines();
    // When it crashes, it doesn't end up registering anything.
    assertEquals(0, registeredEngines.size());
 
    // Check the logs actually says registration failed, so a subsequent MissingPluginException
    // isn't mysterious.
    assertTrue(
        ShadowLog.getLogsForTag("GeneratedPluginsRegister")
            .get(0)
            .msg
            .contains("Tried to automatically register plugins"));
    assertEquals(
        GeneratedPluginRegistrant.pluginRegistrationException,
        ShadowLog.getLogsForTag("GeneratedPluginsRegister").get(1).throwable.getCause());
 
    GeneratedPluginRegistrant.pluginRegistrationException = null;
  }

itComesWithARunningDartExecutorIfJNIIsAlreadyAttached()

void test.io.flutter.embedding.engine.FlutterEngineTest.itComesWithARunningDartExecutorIfJNIIsAlreadyAttached ( ) throws NameNotFoundException

inline

Definition at line 331 of file FlutterEngineTest.java.

                                                                                                   {
    Context packageContext = mock(Context.class);
 
    when(mockContext.createPackageContext(any(), anyInt())).thenReturn(packageContext);
    when(flutterJNI.isAttached()).thenReturn(true);
 
    FlutterEngine engineUnderTest =
        new FlutterEngine(
            mockContext,
            mock(FlutterLoader.class),
            flutterJNI,
            /*dartVmArgs=*/ new String[] {},
            /*automaticallyRegisterPlugins=*/ false);
 
    assertTrue(engineUnderTest.getDartExecutor().isExecutingDart());
  }

itDoesNotAttachAgainWhenBuiltWithAnAttachedJNI()

void test.io.flutter.embedding.engine.FlutterEngineTest.itDoesNotAttachAgainWhenBuiltWithAnAttachedJNI ( ) throws NameNotFoundException

inline

Definition at line 313 of file FlutterEngineTest.java.

                                                                                            {
    Context packageContext = mock(Context.class);
 
    when(mockContext.createPackageContext(any(), anyInt())).thenReturn(packageContext);
    when(flutterJNI.isAttached()).thenReturn(true);
 
    FlutterEngine engineUnderTest =
        new FlutterEngine(
            mockContext,
            mock(FlutterLoader.class),
            flutterJNI,
            /*dartVmArgs=*/ new String[] {},
            /*automaticallyRegisterPlugins=*/ false);
 
    verify(flutterJNI, never()).attachToNative();
  }

itDoesNotAutomaticallyRegistersPluginsWhenFlutterEngineDisablesIt()

void test.io.flutter.embedding.engine.FlutterEngineTest.itDoesNotAutomaticallyRegistersPluginsWhenFlutterEngineDisablesIt ( )

inline

Definition at line 174 of file FlutterEngineTest.java.

                                                                                  {
    assertTrue(GeneratedPluginRegistrant.getRegisteredEngines().isEmpty());
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    when(mockFlutterLoader.automaticallyRegisterPlugins()).thenReturn(true);
    new FlutterEngine(
        ctx,
        mockFlutterLoader,
        flutterJNI,
        /*dartVmArgs=*/ new String[] {},
        /*automaticallyRegisterPlugins=*/ false);
 
    List<FlutterEngine> registeredEngines = GeneratedPluginRegistrant.getRegisteredEngines();
    assertTrue(registeredEngines.isEmpty());
  }

itDoesNotAutomaticallyRegistersPluginsWhenFlutterLoaderDisablesIt()

void test.io.flutter.embedding.engine.FlutterEngineTest.itDoesNotAutomaticallyRegistersPluginsWhenFlutterLoaderDisablesIt ( )

inline

Definition at line 163 of file FlutterEngineTest.java.

                                                                                  {
    assertTrue(GeneratedPluginRegistrant.getRegisteredEngines().isEmpty());
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    when(mockFlutterLoader.automaticallyRegisterPlugins()).thenReturn(false);
    new FlutterEngine(ctx, mockFlutterLoader, flutterJNI);
 
    List<FlutterEngine> registeredEngines = GeneratedPluginRegistrant.getRegisteredEngines();
    assertTrue(registeredEngines.isEmpty());
  }

itNotifiesListenersForDestruction()

void test.io.flutter.embedding.engine.FlutterEngineTest.itNotifiesListenersForDestruction ( ) throws NameNotFoundException

inline

Definition at line 293 of file FlutterEngineTest.java.

                                                                               {
    Context packageContext = mock(Context.class);
 
    when(mockContext.createPackageContext(any(), anyInt())).thenReturn(packageContext);
 
    FlutterEngine engineUnderTest =
        new FlutterEngine(
            mockContext,
            mock(FlutterLoader.class),
            flutterJNI,
            /*dartVmArgs=*/ new String[] {},
            /*automaticallyRegisterPlugins=*/ false);
 
    EngineLifecycleListener listener = mock(EngineLifecycleListener.class);
    engineUnderTest.addEngineLifecycleListener(listener);
    engineUnderTest.destroy();
    verify(listener, times(1)).onEngineWillDestroy();
  }

itNotifiesPlatformViewsControllerAboutJNILifecycle()

void test.io.flutter.embedding.engine.FlutterEngineTest.itNotifiesPlatformViewsControllerAboutJNILifecycle ( )

inline

Definition at line 225 of file FlutterEngineTest.java.

                                                                   {
    PlatformViewsController platformViewsController = mock(PlatformViewsController.class);
 
    // Execute behavior under test.
    FlutterEngine engine =
        new FlutterEngine(
            ctx,
            mock(FlutterLoader.class),
            flutterJNI,
            platformViewsController,
            /*dartVmArgs=*/ new String[] {},
            /*automaticallyRegisterPlugins=*/ false);
    verify(platformViewsController, times(1)).onAttachedToJNI();
 
    engine.destroy();
    verify(platformViewsController, times(1)).onDetachedFromJNI();
  }

itNotifiesPlatformViewsControllerWhenDevHotRestart()

void test.io.flutter.embedding.engine.FlutterEngineTest.itNotifiesPlatformViewsControllerWhenDevHotRestart ( )

inline

Definition at line 190 of file FlutterEngineTest.java.

                                                                   {
    // Setup test.
    FlutterJNI mockFlutterJNI = mock(FlutterJNI.class);
    when(mockFlutterJNI.isAttached()).thenReturn(true);
 
    PlatformViewsController platformViewsController = mock(PlatformViewsController.class);
 
    ArgumentCaptor<FlutterEngine.EngineLifecycleListener> engineLifecycleListenerArgumentCaptor =
        ArgumentCaptor.forClass(FlutterEngine.EngineLifecycleListener.class);
 
    // Execute behavior under test.
    new FlutterEngine(
        ctx,
        mock(FlutterLoader.class),
        mockFlutterJNI,
        platformViewsController,
        /*dartVmArgs=*/ new String[] {},
        /*automaticallyRegisterPlugins=*/ false);
 
    // Obtain the EngineLifecycleListener within FlutterEngine that was given to FlutterJNI.
    verify(mockFlutterJNI)
        .addEngineLifecycleListener(engineLifecycleListenerArgumentCaptor.capture());
    FlutterEngine.EngineLifecycleListener engineLifecycleListener =
        engineLifecycleListenerArgumentCaptor.getValue();
    assertNotNull(engineLifecycleListener);
 
    // Simulate a pre-engine restart, AKA hot restart.
    engineLifecycleListener.onPreEngineRestart();
 
    // Verify that FlutterEngine notified PlatformViewsController of the pre-engine restart,
    // AKA hot restart.
    verify(platformViewsController, times(1)).onPreEngineRestart();
  }

itSendLocalesOnEngineInit()

void test.io.flutter.embedding.engine.FlutterEngineTest.itSendLocalesOnEngineInit ( )

inline

Definition at line 120 of file FlutterEngineTest.java.

                                          {
    FlutterJNI mockFlutterJNI = mock(FlutterJNI.class);
    when(mockFlutterJNI.isAttached()).thenReturn(true);
 
    assertTrue(GeneratedPluginRegistrant.getRegisteredEngines().isEmpty());
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    when(mockFlutterLoader.automaticallyRegisterPlugins()).thenReturn(true);
    FlutterEngine flutterEngine = new FlutterEngine(ctx, mockFlutterLoader, mockFlutterJNI);
 
    verify(mockFlutterJNI, times(1))
        .dispatchPlatformMessage(eq("flutter/localization"), any(), anyInt(), anyInt());
  }

itUpdatesDisplayMetricsOnConstructionWithActivityContext()

void test.io.flutter.embedding.engine.FlutterEngineTest.itUpdatesDisplayMetricsOnConstructionWithActivityContext ( )

inline

Definition at line 105 of file FlutterEngineTest.java.

                                                                         {
    // Needs an activity. ApplicationContext won't work for this.
    ActivityController<Activity> activityController = Robolectric.buildActivity(Activity.class);
    FlutterJNI mockFlutterJNI = mock(FlutterJNI.class);
    when(mockFlutterJNI.isAttached()).thenReturn(true);
 
    FlutterLoader mockFlutterLoader = mock(FlutterLoader.class);
    FlutterEngine flutterEngine =
        new FlutterEngine(activityController.get(), mockFlutterLoader, mockFlutterJNI);
 
    verify(mockFlutterJNI, times(1))
        .updateDisplayMetrics(eq(0), any(Float.class), any(Float.class), any(Float.class));
  }

itUsesApplicationContext()

void test.io.flutter.embedding.engine.FlutterEngineTest.itUsesApplicationContext ( ) throws NameNotFoundException

inline

Definition at line 244 of file FlutterEngineTest.java.

                                                                      {
    Context packageContext = mock(Context.class);
 
    when(mockContext.createPackageContext(any(), anyInt())).thenReturn(packageContext);
 
    new FlutterEngine(
        mockContext,
        mock(FlutterLoader.class),
        flutterJNI,
        /*dartVmArgs=*/ new String[] {},
        /*automaticallyRegisterPlugins=*/ false);
 
    verify(mockContext, atLeast(1)).getApplicationContext();
  }

itUsesPackageContextForAssetManager()

void test.io.flutter.embedding.engine.FlutterEngineTest.itUsesPackageContextForAssetManager ( ) throws NameNotFoundException

inline

Definition at line 260 of file FlutterEngineTest.java.

                                                                                 {
    Context packageContext = mock(Context.class);
    when(mockContext.createPackageContext(any(), anyInt())).thenReturn(packageContext);
 
    new FlutterEngine(
        mockContext,
        mock(FlutterLoader.class),
        flutterJNI,
        /*dartVmArgs=*/ new String[] {},
        /*automaticallyRegisterPlugins=*/ false);
 
    verify(packageContext, atLeast(1)).getAssets();
    verify(mockContext, times(0)).getAssets();
  }

passesEngineGroupToPlugins()

void test.io.flutter.embedding.engine.FlutterEngineTest.passesEngineGroupToPlugins ( ) throws NameNotFoundException

inline

Definition at line 349 of file FlutterEngineTest.java.

                                                                        {
    Context packageContext = mock(Context.class);
 
    when(mockContext.createPackageContext(any(), anyInt())).thenReturn(packageContext);
    when(flutterJNI.isAttached()).thenReturn(true);
 
    FlutterEngineGroup mockGroup = mock(FlutterEngineGroup.class);
 
    FlutterEngine engineUnderTest =
        new FlutterEngine(
            mockContext,
            mock(FlutterLoader.class),
            flutterJNI,
            new PlatformViewsController(),
            /*dartVmArgs=*/ new String[] {},
            /*automaticallyRegisterPlugins=*/ false,
            /*waitForRestorationData=*/ false,
            mockGroup);
 
    PluginRegistry registry = engineUnderTest.getPlugins();
    FlutterPlugin mockPlugin = mock(FlutterPlugin.class);
    ArgumentCaptor<FlutterPlugin.FlutterPluginBinding> pluginBindingCaptor =
        ArgumentCaptor.forClass(FlutterPlugin.FlutterPluginBinding.class);
    registry.add(mockPlugin);
    verify(mockPlugin).onAttachedToEngine(pluginBindingCaptor.capture());
    assertNotNull(pluginBindingCaptor.getValue());
    assertEquals(mockGroup, pluginBindingCaptor.getValue().getEngineGroup());
  }

setUp()

void test.io.flutter.embedding.engine.FlutterEngineTest.setUp ( )

inline

Definition at line 60 of file FlutterEngineTest.java.

                      {
    MockitoAnnotations.openMocks(this);
 
    Resources mockResources = mock(Resources.class);
    Configuration mockConfiguration = mock(Configuration.class);
    doReturn(mockResources).when(mockContext).getResources();
    doReturn(mockConfiguration).when(mockResources).getConfiguration();
    doReturn(LocaleList.getEmptyLocaleList()).when(mockConfiguration).getLocales();
 
    jniAttached = false;
    when(flutterJNI.isAttached()).thenAnswer(invocation -> jniAttached);
    doAnswer(
            new Answer() {
              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {
                jniAttached = true;
                return null;
              }
            })
        .when(flutterJNI)
        .attachToNative();
    GeneratedPluginRegistrant.clearRegisteredEngines();
  }

tearDown()

void test.io.flutter.embedding.engine.FlutterEngineTest.tearDown ( )

inline

Definition at line 85 of file FlutterEngineTest.java.

                         {
    GeneratedPluginRegistrant.clearRegisteredEngines();
    // Make sure to not forget to remove the mock exception in the generated plugin registration
    // mock, or everything subsequent will break.
    GeneratedPluginRegistrant.pluginRegistrationException = null;
  }

Member Data Documentation

flutterJNI

FlutterJNI test.io.flutter.embedding.engine.FlutterEngineTest.flutterJNI

package

Definition at line 56 of file FlutterEngineTest.java.

jniAttached

boolean test.io.flutter.embedding.engine.FlutterEngineTest.jniAttached

package

Definition at line 57 of file FlutterEngineTest.java.

---

The documentation for this class was generated from the following file:

• shell/platform/android/test/io/flutter/embedding/engine/FlutterEngineTest.java