services/tests/servicestests/src/com/android/server/display/DisplayManagerServiceTest.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server.display;

 import static com.android.server.display.VirtualDisplayAdapter.UNIQUE_ID_PREFIX;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

 import android.content.Context;
 import android.hardware.display.BrightnessConfiguration;
 import android.hardware.display.Curve;
 import android.hardware.display.DisplayManager;
 import android.hardware.display.DisplayViewport;
 import android.hardware.display.DisplayedContentSample;
 import android.hardware.display.DisplayedContentSamplingAttributes;
 import android.hardware.display.IVirtualDisplayCallback;
 import android.hardware.input.InputManagerInternal;
 import android.os.Handler;
 import android.os.IBinder;
 import android.view.Display;
 import android.view.DisplayInfo;
 import android.view.SurfaceControl;

 import androidx.test.InstrumentationRegistry;
 import androidx.test.filters.SmallTest;
 import androidx.test.runner.AndroidJUnit4;

 import com.android.server.LocalServices;
 import com.android.server.SystemService;
 import com.android.server.display.DisplayDeviceInfo;
 import com.android.server.display.DisplayManagerService.SyncRoot;
 import com.android.server.lights.LightsManager;
 import com.android.server.wm.WindowManagerInternal;

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;

 import java.util.List;
 import java.util.stream.LongStream;

 @SmallTest
 @RunWith(AndroidJUnit4.class)
 public class DisplayManagerServiceTest {
     private static final int MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS = 1;
     private static final long SHORT_DEFAULT_DISPLAY_TIMEOUT_MILLIS = 10;

     private Context mContext;

     private final DisplayManagerService.Injector mShortMockedInjector =
             new DisplayManagerService.Injector() {
                 @Override
                 VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot,
                         Context context, Handler handler, DisplayAdapter.Listener listener) {
                     return mMockVirtualDisplayAdapter;
                 }

                 @Override
                 long getDefaultDisplayDelayTimeout() {
                     return SHORT_DEFAULT_DISPLAY_TIMEOUT_MILLIS;
                 }
             };
     private final DisplayManagerService.Injector mBasicInjector =
             new DisplayManagerService.Injector() {
                 @Override
                 VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot,
                         Context context, Handler handler,
                         DisplayAdapter.Listener displayAdapterListener) {
                     return new VirtualDisplayAdapter(syncRoot, context, handler,
                             displayAdapterListener,
                             (String name, boolean secure) -> mMockDisplayToken);
                 }
             };

     @Mock InputManagerInternal mMockInputManagerInternal;
     @Mock IVirtualDisplayCallback.Stub mMockAppToken;
     @Mock WindowManagerInternal mMockWindowManagerInternal;
     @Mock LightsManager mMockLightsManager;
     @Mock VirtualDisplayAdapter mMockVirtualDisplayAdapter;
     @Mock IBinder mMockDisplayToken;

     @Before
     public void setUp() throws Exception {
         MockitoAnnotations.initMocks(this);

         LocalServices.removeServiceForTest(InputManagerInternal.class);
         LocalServices.addService(InputManagerInternal.class, mMockInputManagerInternal);
         LocalServices.removeServiceForTest(WindowManagerInternal.class);
         LocalServices.addService(WindowManagerInternal.class, mMockWindowManagerInternal);
         LocalServices.removeServiceForTest(LightsManager.class);
         LocalServices.addService(LightsManager.class, mMockLightsManager);

         mContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
     }

     @Test
     public void testCreateVirtualDisplay_sentToInputManager() {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mBasicInjector);
         registerDefaultDisplays(displayManager);
         displayManager.systemReady(false /* safeMode */, true /* onlyCore */);
         displayManager.windowManagerAndInputReady();

         // This is effectively the DisplayManager service published to ServiceManager.
         DisplayManagerService.BinderService bs = displayManager.new BinderService();

         String uniqueId = "uniqueId --- Test";
         String uniqueIdPrefix = UNIQUE_ID_PREFIX + mContext.getPackageName() + ":";
         int width = 600;
         int height = 800;
         int dpi = 320;
         int flags = DisplayManager.VIRTUAL_DISPLAY_FLAG_SUPPORTS_TOUCH;

         when(mMockAppToken.asBinder()).thenReturn(mMockAppToken);
         int displayId = bs.createVirtualDisplay(mMockAppToken /* callback */,
                 null /* projection */, "com.android.frameworks.servicestests",
                 "Test Virtual Display", width, height, dpi, null /* surface */, flags /* flags */,
                 uniqueId);

         displayManager.performTraversalInternal(mock(SurfaceControl.Transaction.class));

         // flush the handler
         displayManager.getDisplayHandler().runWithScissors(() -> {}, 0 /* now */);

         ArgumentCaptor<List<DisplayViewport>> viewportCaptor = ArgumentCaptor.forClass(List.class);
         verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());
         List<DisplayViewport> viewports = viewportCaptor.getValue();

         // Expect to receive 2 viewports: internal, and virtual
         assertEquals(2, viewports.size());

         DisplayViewport virtualViewport = null;
         DisplayViewport internalViewport = null;
         for (int i = 0; i < viewports.size(); i++) {
             DisplayViewport v = viewports.get(i);
             switch (v.type) {
                 case DisplayViewport.VIEWPORT_INTERNAL: {
                     internalViewport = v;
                     break;
                 }
                 case DisplayViewport.VIEWPORT_EXTERNAL: {
                     fail("EXTERNAL viewport should not exist.");
                     break;
                 }
                 case DisplayViewport.VIEWPORT_VIRTUAL: {
                     virtualViewport = v;
                     break;
                 }
             }
         }
         // INTERNAL viewport gets created upon access.
         assertNotNull(internalViewport);
         assertNotNull(virtualViewport);

         // INTERNAL
         assertTrue(internalViewport.valid);

         // VIRTUAL
         assertEquals(height, virtualViewport.deviceHeight);
         assertEquals(width, virtualViewport.deviceWidth);
         assertEquals(uniqueIdPrefix + uniqueId, virtualViewport.uniqueId);
         assertEquals(displayId, virtualViewport.displayId);
     }

     @Test
     public void testPhysicalViewports() {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mBasicInjector);
         registerDefaultDisplays(displayManager);
         displayManager.systemReady(false /* safeMode */, true /* onlyCore */);
         displayManager.windowManagerAndInputReady();

         // This is effectively the DisplayManager service published to ServiceManager.
         DisplayManagerService.BinderService bs = displayManager.new BinderService();

         when(mMockAppToken.asBinder()).thenReturn(mMockAppToken);

         final int displayIds[] = bs.getDisplayIds();
         assertEquals(1, displayIds.length);
         final int displayId = displayIds[0];
         DisplayInfo info = bs.getDisplayInfo(displayId);
         assertEquals(info.type, Display.TYPE_BUILT_IN);

         displayManager.performTraversalInternal(mock(SurfaceControl.Transaction.class));

         // flush the handler
         displayManager.getDisplayHandler().runWithScissors(() -> {}, 0 /* now */);

         ArgumentCaptor<List<DisplayViewport>> viewportCaptor = ArgumentCaptor.forClass(List.class);
         verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());
         List<DisplayViewport> viewports = viewportCaptor.getValue();

         // Expect to receive actual viewports: 1 internal
         assertEquals(1, viewports.size());

         DisplayViewport internalViewport = viewports.get(0);

         // INTERNAL is the only one actual display.
         assertNotNull(internalViewport);
         assertEquals(DisplayViewport.VIEWPORT_INTERNAL, internalViewport.type);
         assertTrue(internalViewport.valid);
         assertEquals(displayId, internalViewport.displayId);
     }

     @Test
     public void testCreateVirtualDisplayRotatesWithContent() throws Exception {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mBasicInjector);
         registerDefaultDisplays(displayManager);

         // This is effectively the DisplayManager service published to ServiceManager.
         DisplayManagerService.BinderService bs = displayManager.new BinderService();

         String uniqueId = "uniqueId --- Rotates With Content Test";
         int width = 600;
         int height = 800;
         int dpi = 320;
         int flags = DisplayManager.VIRTUAL_DISPLAY_FLAG_ROTATES_WITH_CONTENT;

         when(mMockAppToken.asBinder()).thenReturn(mMockAppToken);
         int displayId = bs.createVirtualDisplay(mMockAppToken /* callback */,
                 null /* projection */, "com.android.frameworks.servicestests",
                 "Test Virtual Display", width, height, dpi, null /* surface */, flags /* flags */,
                 uniqueId);

         displayManager.performTraversalInternal(mock(SurfaceControl.Transaction.class));

         // flush the handler
         displayManager.getDisplayHandler().runWithScissors(() -> {}, 0 /* now */);

         DisplayDeviceInfo ddi = displayManager.getDisplayDeviceInfoInternal(displayId);
         assertNotNull(ddi);
         assertTrue((ddi.flags & DisplayDeviceInfo.FLAG_ROTATES_WITH_CONTENT) != 0);
     }

     /**
      * Tests that the virtual display is created along-side the default display.
      */
     @Test
     public void testStartVirtualDisplayWithDefaultDisplay_Succeeds() throws Exception {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mShortMockedInjector);
         registerDefaultDisplays(displayManager);
         displayManager.onBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
     }

     /**
      * Tests that we get a Runtime exception when we cannot initialize the default display.
      */
     @Test
     public void testStartVirtualDisplayWithDefDisplay_NoDefaultDisplay() throws Exception {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mShortMockedInjector);
         Handler handler = displayManager.getDisplayHandler();
         handler.runWithScissors(() -> {}, 0 /* now */);

         try {
             displayManager.onBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
         } catch (RuntimeException e) {
             return;
         }
         fail("Expected DisplayManager to throw RuntimeException when it cannot initialize the"
                 + " default display");
     }

     /**
      * Tests that we get a Runtime exception when we cannot initialize the virtual display.
      */
     @Test
     public void testStartVirtualDisplayWithDefDisplay_NoVirtualDisplayAdapter() throws Exception {
         DisplayManagerService displayManager = new DisplayManagerService(mContext,
                 new DisplayManagerService.Injector() {
                     @Override
                     VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot,
                             Context context, Handler handler, DisplayAdapter.Listener listener) {
                         return null;  // return null for the adapter.  This should cause a failure.
                     }

                     @Override
                     long getDefaultDisplayDelayTimeout() {
                         return SHORT_DEFAULT_DISPLAY_TIMEOUT_MILLIS;
                     }
                 });
         try {
             displayManager.onBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
         } catch (RuntimeException e) {
             return;
         }
         fail("Expected DisplayManager to throw RuntimeException when it cannot initialize the"
                 + " virtual display adapter");
     }

     /**
      * Tests that an exception is raised for too dark a brightness configuration.
      */
     @Test
     public void testTooDarkBrightnessConfigurationThrowException() {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mShortMockedInjector);
         Curve minimumBrightnessCurve = displayManager.getMinimumBrightnessCurveInternal();
         float[] lux = minimumBrightnessCurve.getX();
         float[] minimumNits = minimumBrightnessCurve.getY();
         float[] nits = new float[minimumNits.length];
         // For every control point, assert that making it slightly lower than the minimum throws an
         // exception.
         for (int i = 0; i < nits.length; i++) {
             for (int j = 0; j < nits.length; j++) {
                 nits[j] = minimumNits[j];
                 if (j == i) {
                     nits[j] -= 0.1f;
                 }
                 if (nits[j] < 0) {
                     nits[j] = 0;
                 }
             }
             BrightnessConfiguration config =
                     new BrightnessConfiguration.Builder(lux, nits).build();
             Exception thrown = null;
             try {
                 displayManager.validateBrightnessConfiguration(config);
             } catch (IllegalArgumentException e) {
                 thrown = e;
             }
             assertNotNull("Building too dark a brightness configuration must throw an exception");
         }
     }

     /**
      * Tests that no exception is raised for not too dark a brightness configuration.
      */
     @Test
     public void testBrightEnoughBrightnessConfigurationDoesNotThrowException() {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mShortMockedInjector);
         Curve minimumBrightnessCurve = displayManager.getMinimumBrightnessCurveInternal();
         float[] lux = minimumBrightnessCurve.getX();
         float[] nits = minimumBrightnessCurve.getY();
         BrightnessConfiguration config = new BrightnessConfiguration.Builder(lux, nits).build();
         displayManager.validateBrightnessConfiguration(config);
     }

     /**
      * Tests that null brightness configurations are alright.
      */
     @Test
     public void testNullBrightnessConfiguration() {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mShortMockedInjector);
         displayManager.validateBrightnessConfiguration(null);
     }

     /**
      * Tests that collection of display color sampling results are sensible.
      */
     @Test
     public void testDisplayedContentSampling() {
         DisplayManagerService displayManager =
                 new DisplayManagerService(mContext, mShortMockedInjector);
         registerDefaultDisplays(displayManager);

         DisplayDeviceInfo ddi = displayManager.getDisplayDeviceInfoInternal(0);
         assertNotNull(ddi);

         DisplayedContentSamplingAttributes attr =
                 displayManager.getDisplayedContentSamplingAttributesInternal(0);
         if (attr == null) return; //sampling not supported on device, skip remainder of test.

         boolean enabled = displayManager.setDisplayedContentSamplingEnabledInternal(0, true, 0, 0);
         assertTrue(enabled);

         displayManager.setDisplayedContentSamplingEnabledInternal(0, false, 0, 0);
         DisplayedContentSample sample = displayManager.getDisplayedContentSampleInternal(0, 0, 0);
         assertNotNull(sample);

         long numPixels = ddi.width * ddi.height * sample.getNumFrames();
         long[] samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL0);
         assertTrue(samples.length == 0 || LongStream.of(samples).sum() == numPixels);

         samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL1);
         assertTrue(samples.length == 0 || LongStream.of(samples).sum() == numPixels);

         samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL2);
         assertTrue(samples.length == 0 || LongStream.of(samples).sum() == numPixels);

         samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL3);
         assertTrue(samples.length == 0 || LongStream.of(samples).sum() == numPixels);
     }

     private void registerDefaultDisplays(DisplayManagerService displayManager) {
         Handler handler = displayManager.getDisplayHandler();
         // Would prefer to call displayManager.onStart() directly here but it performs binderService
         // registration which triggers security exceptions when running from a test.
         handler.sendEmptyMessage(MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS);
         // flush the handler
         handler.runWithScissors(() -> {}, 0 /* now */);
     }
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server.display;

	import static com.android.server.display.VirtualDisplayAdapter.UNIQUE_ID_PREFIX;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.when;

	import android.content.Context;
	import android.hardware.display.BrightnessConfiguration;
	import android.hardware.display.Curve;
	import android.hardware.display.DisplayManager;
	import android.hardware.display.DisplayViewport;
	import android.hardware.display.DisplayedContentSample;
	import android.hardware.display.DisplayedContentSamplingAttributes;
	import android.hardware.display.IVirtualDisplayCallback;
	import android.hardware.input.InputManagerInternal;
	import android.os.Handler;
	import android.os.IBinder;
	import android.view.Display;
	import android.view.DisplayInfo;
	import android.view.SurfaceControl;

	import androidx.test.InstrumentationRegistry;
	import androidx.test.filters.SmallTest;
	import androidx.test.runner.AndroidJUnit4;

	import com.android.server.LocalServices;
	import com.android.server.SystemService;
	import com.android.server.display.DisplayDeviceInfo;
	import com.android.server.display.DisplayManagerService.SyncRoot;
	import com.android.server.lights.LightsManager;
	import com.android.server.wm.WindowManagerInternal;

	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.ArgumentCaptor;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;

	import java.util.List;
	import java.util.stream.LongStream;

	@SmallTest
	@RunWith(AndroidJUnit4.class)
	public class DisplayManagerServiceTest {
	private static final int MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS = 1;
	private static final long SHORT_DEFAULT_DISPLAY_TIMEOUT_MILLIS = 10;

	private Context mContext;

	private final DisplayManagerService.Injector mShortMockedInjector =
	new DisplayManagerService.Injector() {
	@Override
	VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot,
	Context context, Handler handler, DisplayAdapter.Listener listener) {
	return mMockVirtualDisplayAdapter;
	}

	@Override
	long getDefaultDisplayDelayTimeout() {
	return SHORT_DEFAULT_DISPLAY_TIMEOUT_MILLIS;
	}
	};
	private final DisplayManagerService.Injector mBasicInjector =
	new DisplayManagerService.Injector() {
	@Override
	VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot,
	Context context, Handler handler,
	DisplayAdapter.Listener displayAdapterListener) {
	return new VirtualDisplayAdapter(syncRoot, context, handler,
	displayAdapterListener,
	(String name, boolean secure) -> mMockDisplayToken);
	}
	};

	@Mock InputManagerInternal mMockInputManagerInternal;
	@Mock IVirtualDisplayCallback.Stub mMockAppToken;
	@Mock WindowManagerInternal mMockWindowManagerInternal;
	@Mock LightsManager mMockLightsManager;
	@Mock VirtualDisplayAdapter mMockVirtualDisplayAdapter;
	@Mock IBinder mMockDisplayToken;

	@Before
	public void setUp() throws Exception {
	MockitoAnnotations.initMocks(this);

	LocalServices.removeServiceForTest(InputManagerInternal.class);
	LocalServices.addService(InputManagerInternal.class, mMockInputManagerInternal);
	LocalServices.removeServiceForTest(WindowManagerInternal.class);
	LocalServices.addService(WindowManagerInternal.class, mMockWindowManagerInternal);
	LocalServices.removeServiceForTest(LightsManager.class);
	LocalServices.addService(LightsManager.class, mMockLightsManager);

	mContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
	}

	@Test
	public void testCreateVirtualDisplay_sentToInputManager() {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mBasicInjector);
	registerDefaultDisplays(displayManager);
	displayManager.systemReady(false /* safeMode /, true / onlyCore */);
	displayManager.windowManagerAndInputReady();

	// This is effectively the DisplayManager service published to ServiceManager.
	DisplayManagerService.BinderService bs = displayManager.new BinderService();

	String uniqueId = "uniqueId --- Test";
	String uniqueIdPrefix = UNIQUE_ID_PREFIX + mContext.getPackageName() + ":";
	int width = 600;
	int height = 800;
	int dpi = 320;
	int flags = DisplayManager.VIRTUAL_DISPLAY_FLAG_SUPPORTS_TOUCH;

	when(mMockAppToken.asBinder()).thenReturn(mMockAppToken);
	int displayId = bs.createVirtualDisplay(mMockAppToken /* callback */,
	null /* projection */, "com.android.frameworks.servicestests",
	"Test Virtual Display", width, height, dpi, null /* surface /, flags / flags */,
	uniqueId);

	displayManager.performTraversalInternal(mock(SurfaceControl.Transaction.class));

	// flush the handler
	displayManager.getDisplayHandler().runWithScissors(() -> {}, 0 /* now */);

	ArgumentCaptor<List<DisplayViewport>> viewportCaptor = ArgumentCaptor.forClass(List.class);
	verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());
	List<DisplayViewport> viewports = viewportCaptor.getValue();

	// Expect to receive 2 viewports: internal, and virtual
	assertEquals(2, viewports.size());

	DisplayViewport virtualViewport = null;
	DisplayViewport internalViewport = null;
	for (int i = 0; i < viewports.size(); i++) {
	DisplayViewport v = viewports.get(i);
	switch (v.type) {
	case DisplayViewport.VIEWPORT_INTERNAL: {
	internalViewport = v;
	break;
	}
	case DisplayViewport.VIEWPORT_EXTERNAL: {
	fail("EXTERNAL viewport should not exist.");
	break;
	}
	case DisplayViewport.VIEWPORT_VIRTUAL: {
	virtualViewport = v;
	break;
	}
	}
	}
	// INTERNAL viewport gets created upon access.
	assertNotNull(internalViewport);
	assertNotNull(virtualViewport);

	// INTERNAL
	assertTrue(internalViewport.valid);

	// VIRTUAL
	assertEquals(height, virtualViewport.deviceHeight);
	assertEquals(width, virtualViewport.deviceWidth);
	assertEquals(uniqueIdPrefix + uniqueId, virtualViewport.uniqueId);
	assertEquals(displayId, virtualViewport.displayId);
	}

	@Test
	public void testPhysicalViewports() {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mBasicInjector);
	registerDefaultDisplays(displayManager);
	displayManager.systemReady(false /* safeMode /, true / onlyCore */);
	displayManager.windowManagerAndInputReady();

	// This is effectively the DisplayManager service published to ServiceManager.
	DisplayManagerService.BinderService bs = displayManager.new BinderService();

	when(mMockAppToken.asBinder()).thenReturn(mMockAppToken);

	final int displayIds[] = bs.getDisplayIds();
	assertEquals(1, displayIds.length);
	final int displayId = displayIds[0];
	DisplayInfo info = bs.getDisplayInfo(displayId);
	assertEquals(info.type, Display.TYPE_BUILT_IN);

	displayManager.performTraversalInternal(mock(SurfaceControl.Transaction.class));

	// flush the handler
	displayManager.getDisplayHandler().runWithScissors(() -> {}, 0 /* now */);

	ArgumentCaptor<List<DisplayViewport>> viewportCaptor = ArgumentCaptor.forClass(List.class);
	verify(mMockInputManagerInternal).setDisplayViewports(viewportCaptor.capture());
	List<DisplayViewport> viewports = viewportCaptor.getValue();

	// Expect to receive actual viewports: 1 internal
	assertEquals(1, viewports.size());

	DisplayViewport internalViewport = viewports.get(0);

	// INTERNAL is the only one actual display.
	assertNotNull(internalViewport);
	assertEquals(DisplayViewport.VIEWPORT_INTERNAL, internalViewport.type);
	assertTrue(internalViewport.valid);
	assertEquals(displayId, internalViewport.displayId);
	}

	@Test
	public void testCreateVirtualDisplayRotatesWithContent() throws Exception {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mBasicInjector);
	registerDefaultDisplays(displayManager);

	// This is effectively the DisplayManager service published to ServiceManager.
	DisplayManagerService.BinderService bs = displayManager.new BinderService();

	String uniqueId = "uniqueId --- Rotates With Content Test";
	int width = 600;
	int height = 800;
	int dpi = 320;
	int flags = DisplayManager.VIRTUAL_DISPLAY_FLAG_ROTATES_WITH_CONTENT;

	when(mMockAppToken.asBinder()).thenReturn(mMockAppToken);
	int displayId = bs.createVirtualDisplay(mMockAppToken /* callback */,
	null /* projection */, "com.android.frameworks.servicestests",
	"Test Virtual Display", width, height, dpi, null /* surface /, flags / flags */,
	uniqueId);

	displayManager.performTraversalInternal(mock(SurfaceControl.Transaction.class));

	// flush the handler
	displayManager.getDisplayHandler().runWithScissors(() -> {}, 0 /* now */);

	DisplayDeviceInfo ddi = displayManager.getDisplayDeviceInfoInternal(displayId);
	assertNotNull(ddi);
	assertTrue((ddi.flags & DisplayDeviceInfo.FLAG_ROTATES_WITH_CONTENT) != 0);
	}

	/**
	* Tests that the virtual display is created along-side the default display.
	*/
	@Test
	public void testStartVirtualDisplayWithDefaultDisplay_Succeeds() throws Exception {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mShortMockedInjector);
	registerDefaultDisplays(displayManager);
	displayManager.onBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
	}

	/**
	* Tests that we get a Runtime exception when we cannot initialize the default display.
	*/
	@Test
	public void testStartVirtualDisplayWithDefDisplay_NoDefaultDisplay() throws Exception {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mShortMockedInjector);
	Handler handler = displayManager.getDisplayHandler();
	handler.runWithScissors(() -> {}, 0 /* now */);

	try {
	displayManager.onBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
	} catch (RuntimeException e) {
	return;
	}
	fail("Expected DisplayManager to throw RuntimeException when it cannot initialize the"
	+ " default display");
	}

	/**
	* Tests that we get a Runtime exception when we cannot initialize the virtual display.
	*/
	@Test
	public void testStartVirtualDisplayWithDefDisplay_NoVirtualDisplayAdapter() throws Exception {
	DisplayManagerService displayManager = new DisplayManagerService(mContext,
	new DisplayManagerService.Injector() {
	@Override
	VirtualDisplayAdapter getVirtualDisplayAdapter(SyncRoot syncRoot,
	Context context, Handler handler, DisplayAdapter.Listener listener) {
	return null; // return null for the adapter. This should cause a failure.
	}

	@Override
	long getDefaultDisplayDelayTimeout() {
	return SHORT_DEFAULT_DISPLAY_TIMEOUT_MILLIS;
	}
	});
	try {
	displayManager.onBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
	} catch (RuntimeException e) {
	return;
	}
	fail("Expected DisplayManager to throw RuntimeException when it cannot initialize the"
	+ " virtual display adapter");
	}

	/**
	* Tests that an exception is raised for too dark a brightness configuration.
	*/
	@Test
	public void testTooDarkBrightnessConfigurationThrowException() {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mShortMockedInjector);
	Curve minimumBrightnessCurve = displayManager.getMinimumBrightnessCurveInternal();
	float[] lux = minimumBrightnessCurve.getX();
	float[] minimumNits = minimumBrightnessCurve.getY();
	float[] nits = new float[minimumNits.length];
	// For every control point, assert that making it slightly lower than the minimum throws an
	// exception.
	for (int i = 0; i < nits.length; i++) {
	for (int j = 0; j < nits.length; j++) {
	nits[j] = minimumNits[j];
	if (j == i) {
	nits[j] -= 0.1f;
	}
	if (nits[j] < 0) {
	nits[j] = 0;
	}
	}
	BrightnessConfiguration config =
	new BrightnessConfiguration.Builder(lux, nits).build();
	Exception thrown = null;
	try {
	displayManager.validateBrightnessConfiguration(config);
	} catch (IllegalArgumentException e) {
	thrown = e;
	}
	assertNotNull("Building too dark a brightness configuration must throw an exception");
	}
	}

	/**
	* Tests that no exception is raised for not too dark a brightness configuration.
	*/
	@Test
	public void testBrightEnoughBrightnessConfigurationDoesNotThrowException() {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mShortMockedInjector);
	Curve minimumBrightnessCurve = displayManager.getMinimumBrightnessCurveInternal();
	float[] lux = minimumBrightnessCurve.getX();
	float[] nits = minimumBrightnessCurve.getY();
	BrightnessConfiguration config = new BrightnessConfiguration.Builder(lux, nits).build();
	displayManager.validateBrightnessConfiguration(config);
	}

	/**
	* Tests that null brightness configurations are alright.
	*/
	@Test
	public void testNullBrightnessConfiguration() {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mShortMockedInjector);
	displayManager.validateBrightnessConfiguration(null);
	}

	/**
	* Tests that collection of display color sampling results are sensible.
	*/
	@Test
	public void testDisplayedContentSampling() {
	DisplayManagerService displayManager =
	new DisplayManagerService(mContext, mShortMockedInjector);
	registerDefaultDisplays(displayManager);

	DisplayDeviceInfo ddi = displayManager.getDisplayDeviceInfoInternal(0);
	assertNotNull(ddi);

	DisplayedContentSamplingAttributes attr =
	displayManager.getDisplayedContentSamplingAttributesInternal(0);
	if (attr == null) return; //sampling not supported on device, skip remainder of test.

	boolean enabled = displayManager.setDisplayedContentSamplingEnabledInternal(0, true, 0, 0);
	assertTrue(enabled);

	displayManager.setDisplayedContentSamplingEnabledInternal(0, false, 0, 0);
	DisplayedContentSample sample = displayManager.getDisplayedContentSampleInternal(0, 0, 0);
	assertNotNull(sample);

	long numPixels = ddi.width * ddi.height * sample.getNumFrames();
	long[] samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL0);
	assertTrue(samples.length == 0 \|\| LongStream.of(samples).sum() == numPixels);

	samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL1);
	assertTrue(samples.length == 0 \|\| LongStream.of(samples).sum() == numPixels);

	samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL2);
	assertTrue(samples.length == 0 \|\| LongStream.of(samples).sum() == numPixels);

	samples = sample.getSampleComponent(DisplayedContentSample.ColorComponent.CHANNEL3);
	assertTrue(samples.length == 0 \|\| LongStream.of(samples).sum() == numPixels);
	}

	private void registerDefaultDisplays(DisplayManagerService displayManager) {
	Handler handler = displayManager.getDisplayHandler();
	// Would prefer to call displayManager.onStart() directly here but it performs binderService
	// registration which triggers security exceptions when running from a test.
	handler.sendEmptyMessage(MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS);
	// flush the handler
	handler.runWithScissors(() -> {}, 0 /* now */);
	}
	}