| /* |
| * Copyright (C) 2016 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 android.print; |
| |
| import android.annotation.NonNull; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.os.Bundle; |
| import android.os.CancellationSignal; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.ParcelFileDescriptor; |
| import android.os.Process; |
| import android.os.ServiceManager; |
| import android.os.UserHandle; |
| import android.print.PrintAttributes.Margins; |
| import android.print.PrintAttributes.MediaSize; |
| import android.print.PrintAttributes.Resolution; |
| import android.printservice.PrintServiceInfo; |
| import android.printservice.recommendation.IRecommendationsChangeListener; |
| |
| import android.print.mockservice.MockPrintService; |
| import android.print.mockservice.PrintServiceCallbacks; |
| import android.print.mockservice.PrinterDiscoverySessionCallbacks; |
| import android.print.mockservice.StubbablePrinterDiscoverySession; |
| |
| import android.test.suitebuilder.annotation.LargeTest; |
| import android.test.suitebuilder.annotation.MediumTest; |
| import org.mockito.invocation.InvocationOnMock; |
| import org.mockito.stubbing.Answer; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * tests feeding all possible parameters to the IPrintManager Binder. |
| */ |
| public class IPrintManagerParametersTest extends BasePrintTest { |
| |
| private final int BAD_APP_ID = 0xffffffff; |
| |
| private final int mAppId; |
| private final int mUserId; |
| private final PrintJobId mBadPrintJobId; |
| |
| private PrintJob mGoodPrintJob; |
| private PrinterId mBadPrinterId; |
| private PrinterId mGoodPrinterId; |
| private ComponentName mGoodComponentName; |
| private ComponentName mBadComponentName; |
| |
| private IPrintManager mIPrintManager; |
| |
| /** |
| * Create a new IPrintManagerParametersTest and setup basic fields. |
| */ |
| public IPrintManagerParametersTest() { |
| super(); |
| |
| mAppId = UserHandle.getAppId(Process.myUid()); |
| mUserId = UserHandle.myUserId(); |
| mBadPrintJobId = new PrintJobId(); |
| mBadComponentName = new ComponentName("bad", "bad"); |
| } |
| |
| /** |
| * Create a mock PrintDocumentAdapter. |
| * |
| * @return The adapter |
| */ |
| private @NonNull PrintDocumentAdapter createMockAdapter() { |
| return new PrintDocumentAdapter() { |
| @Override |
| public void onStart() { |
| onStartCalled(); |
| } |
| |
| @Override |
| public void onLayout(PrintAttributes oldAttributes, PrintAttributes newAttributes, |
| CancellationSignal cancellationSignal, LayoutResultCallback callback, |
| Bundle extras) { |
| } |
| |
| @Override |
| public void onWrite(PageRange[] pages, ParcelFileDescriptor destination, |
| CancellationSignal cancellationSignal, WriteResultCallback callback) { |
| } |
| }; |
| } |
| |
| /** |
| * Create mock print service callbacks. |
| * |
| * @return the callbacks |
| */ |
| private PrintServiceCallbacks createMockCallbacks() { |
| return createMockPrintServiceCallbacks( |
| new Answer<PrinterDiscoverySessionCallbacks>() { |
| @Override |
| public PrinterDiscoverySessionCallbacks answer(InvocationOnMock invocation) { |
| return createMockPrinterDiscoverySessionCallbacks(new Answer<Void>() { |
| @Override |
| public Void answer(InvocationOnMock invocation) { |
| // Get the session. |
| StubbablePrinterDiscoverySession session = |
| ((PrinterDiscoverySessionCallbacks) invocation |
| .getMock()).getSession(); |
| |
| if (session.getPrinters().isEmpty()) { |
| final String PRINTER_NAME = "good printer"; |
| List<PrinterInfo> printers = new ArrayList<>(); |
| |
| // Add the printer. |
| mGoodPrinterId = session.getService() |
| .generatePrinterId(PRINTER_NAME); |
| |
| PrinterCapabilitiesInfo capabilities = |
| new PrinterCapabilitiesInfo.Builder(mGoodPrinterId) |
| .setMinMargins( |
| new Margins(200, 200, 200, 200)) |
| .addMediaSize(MediaSize.ISO_A4, true) |
| .addResolution(new Resolution("300x300", |
| "300x300", 300, 300), |
| true) |
| .setColorModes( |
| PrintAttributes.COLOR_MODE_COLOR, |
| PrintAttributes.COLOR_MODE_COLOR) |
| .build(); |
| |
| PrinterInfo printer = new PrinterInfo.Builder( |
| mGoodPrinterId, |
| PRINTER_NAME, |
| PrinterInfo.STATUS_IDLE) |
| .setCapabilities(capabilities) |
| .build(); |
| printers.add(printer); |
| |
| session.addPrinters(printers); |
| } |
| onPrinterDiscoverySessionStartCalled(); |
| return null; |
| } |
| }, null, null, null, null, null, null); |
| } |
| }, |
| null, null); |
| } |
| |
| /** |
| * Create a IPrintJobStateChangeListener object. |
| * |
| * @return the object |
| * @throws Exception if the object could not be created. |
| */ |
| private IPrintJobStateChangeListener createMockIPrintJobStateChangeListener() throws Exception { |
| return new PrintManager.PrintJobStateChangeListenerWrapper(null, |
| new Handler(Looper.getMainLooper())); |
| } |
| |
| /** |
| * Create a IPrintServicesChangeListener object. |
| * |
| * @return the object |
| * @throws Exception if the object could not be created. |
| */ |
| private IPrintServicesChangeListener createMockIPrintServicesChangeListener() throws Exception { |
| return new PrintManager.PrintServicesChangeListenerWrapper(null, |
| new Handler(Looper.getMainLooper())); |
| } |
| |
| /** |
| * Create a IPrintServiceRecommendationsChangeListener object. |
| * |
| * @return the object |
| * @throws Exception if the object could not be created. |
| */ |
| private IRecommendationsChangeListener |
| createMockIPrintServiceRecommendationsChangeListener() throws Exception { |
| return new PrintManager.PrintServiceRecommendationsChangeListenerWrapper(null, |
| new Handler(Looper.getMainLooper())); |
| } |
| |
| /** |
| * Create a IPrinterDiscoveryObserver object. |
| * |
| * @return the object |
| * @throws Exception if the object could not be created. |
| */ |
| private IPrinterDiscoveryObserver createMockIPrinterDiscoveryObserver() throws Exception { |
| return new PrinterDiscoverySession.PrinterDiscoveryObserver(null); |
| } |
| |
| private void startPrinting() { |
| mGoodPrintJob = print(createMockAdapter(), null); |
| |
| // Wait for PrintActivity to be ready |
| waitForStartAdapterCallbackCalled(); |
| |
| // Wait for printer discovery session to be ready |
| waitForPrinterDiscoverySessionStartCallbackCalled(); |
| } |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| |
| MockPrintService.setCallbacks(createMockCallbacks()); |
| |
| mGoodComponentName = getActivity().getComponentName(); |
| |
| mIPrintManager = IPrintManager.Stub |
| .asInterface(ServiceManager.getService(Context.PRINT_SERVICE)); |
| |
| // Generate dummy printerId which is a valid PrinterId object, but does not correspond to a |
| // printer |
| mBadPrinterId = new PrinterId(mGoodComponentName, "dummy printer"); |
| } |
| |
| /** |
| * {@link Runnable} that can throw and {@link Exception} |
| */ |
| private interface Invokable { |
| /** |
| * Execute the invokable |
| * |
| * @throws Exception |
| */ |
| void run() throws Exception; |
| } |
| |
| /** |
| * Assert that the invokable throws an expectedException |
| * |
| * @param invokable The {@link Invokable} to run |
| * @param expectedClass The {@link Exception} that is supposed to be thrown |
| */ |
| public void assertException(Invokable invokable, Class<? extends Exception> expectedClass) |
| throws Exception { |
| try { |
| invokable.run(); |
| } catch (Exception e) { |
| if (e.getClass().isAssignableFrom(expectedClass)) { |
| return; |
| } else { |
| throw new AssertionError("Expected: " + expectedClass.getName() + ", got: " |
| + e.getClass().getName()); |
| } |
| } |
| |
| throw new AssertionError("No exception thrown"); |
| } |
| |
| /** |
| * test IPrintManager.getPrintJobInfo |
| */ |
| @LargeTest |
| public void testGetPrintJobInfo() throws Exception { |
| startPrinting(); |
| |
| assertEquals(mGoodPrintJob.getId(), mIPrintManager.getPrintJobInfo(mGoodPrintJob.getId(), |
| mAppId, mUserId).getId()); |
| assertEquals(null, mIPrintManager.getPrintJobInfo(mBadPrintJobId, mAppId, mUserId)); |
| assertEquals(null, mIPrintManager.getPrintJobInfo(null, mAppId, mUserId)); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.getPrintJobInfo(mGoodPrintJob.getId(), BAD_APP_ID, mUserId); |
| } |
| }, SecurityException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.getPrintJobInfos |
| */ |
| @LargeTest |
| public void testGetPrintJobInfos() throws Exception { |
| startPrinting(); |
| |
| List<PrintJobInfo> infos = mIPrintManager.getPrintJobInfos(mAppId, mUserId); |
| |
| boolean foundPrintJob = false; |
| for (PrintJobInfo info : infos) { |
| if (info.getId().equals(mGoodPrintJob.getId())) { |
| assertEquals(PrintJobInfo.STATE_CREATED, info.getState()); |
| foundPrintJob = true; |
| } |
| } |
| assertTrue(foundPrintJob); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.getPrintJobInfos(BAD_APP_ID, mUserId); |
| } |
| }, SecurityException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.print |
| */ |
| @LargeTest |
| public void testPrint() throws Exception { |
| final String name = "dummy print job"; |
| |
| final IPrintDocumentAdapter adapter = new PrintManager |
| .PrintDocumentAdapterDelegate(getActivity(), createMockAdapter()); |
| |
| startPrinting(); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.print(null, adapter, null, mGoodComponentName.getPackageName(), |
| mAppId, mUserId); |
| } |
| }, IllegalArgumentException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.print(name, null, null, mGoodComponentName.getPackageName(), |
| mAppId, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.print(name, adapter, null, null, mAppId, mUserId); |
| } |
| }, IllegalArgumentException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.print(name, adapter, null, mBadComponentName.getPackageName(), |
| mAppId, mUserId); |
| } |
| }, IllegalArgumentException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.print(name, adapter, null, mGoodComponentName.getPackageName(), |
| BAD_APP_ID, mUserId); |
| } |
| }, SecurityException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.cancelPrintJob |
| */ |
| @LargeTest |
| public void testCancelPrintJob() throws Exception { |
| startPrinting(); |
| |
| // Invalid print jobs IDs do not produce an exception |
| mIPrintManager.cancelPrintJob(mBadPrintJobId, mAppId, mUserId); |
| mIPrintManager.cancelPrintJob(null, mAppId, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.cancelPrintJob(mGoodPrintJob.getId(), BAD_APP_ID, mUserId); |
| } |
| }, SecurityException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| |
| // Must be last as otherwise mGoodPrintJob will not be good anymore |
| mIPrintManager.cancelPrintJob(mGoodPrintJob.getId(), mAppId, mUserId); |
| } |
| |
| /** |
| * test IPrintManager.restartPrintJob |
| */ |
| @LargeTest |
| public void testRestartPrintJob() throws Exception { |
| startPrinting(); |
| |
| mIPrintManager.restartPrintJob(mGoodPrintJob.getId(), mAppId, mUserId); |
| |
| // Invalid print jobs IDs do not produce an exception |
| mIPrintManager.restartPrintJob(mBadPrintJobId, mAppId, mUserId); |
| mIPrintManager.restartPrintJob(null, mAppId, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.restartPrintJob(mGoodPrintJob.getId(), BAD_APP_ID, mUserId); |
| } |
| }, SecurityException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.addPrintJobStateChangeListener |
| */ |
| @MediumTest |
| public void testAddPrintJobStateChangeListener() throws Exception { |
| final IPrintJobStateChangeListener listener = createMockIPrintJobStateChangeListener(); |
| |
| mIPrintManager.addPrintJobStateChangeListener(listener, mAppId, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.addPrintJobStateChangeListener(null, mAppId, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.addPrintJobStateChangeListener(listener, BAD_APP_ID, mUserId); |
| } |
| }, SecurityException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.removePrintJobStateChangeListener |
| */ |
| @MediumTest |
| public void testRemovePrintJobStateChangeListener() throws Exception { |
| final IPrintJobStateChangeListener listener = createMockIPrintJobStateChangeListener(); |
| |
| mIPrintManager.addPrintJobStateChangeListener(listener, mAppId, mUserId); |
| mIPrintManager.removePrintJobStateChangeListener(listener, mUserId); |
| |
| // Removing unknown listeners is a no-op |
| mIPrintManager.removePrintJobStateChangeListener(listener, mUserId); |
| |
| mIPrintManager.addPrintJobStateChangeListener(listener, mAppId, mUserId); |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.removePrintJobStateChangeListener(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.addPrintServicesChangeListener |
| */ |
| @MediumTest |
| public void testAddPrintServicesChangeListener() throws Exception { |
| final IPrintServicesChangeListener listener = createMockIPrintServicesChangeListener(); |
| |
| mIPrintManager.addPrintServicesChangeListener(listener, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.addPrintServicesChangeListener(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.removePrintServicesChangeListener |
| */ |
| @MediumTest |
| public void testRemovePrintServicesChangeListener() throws Exception { |
| final IPrintServicesChangeListener listener = createMockIPrintServicesChangeListener(); |
| |
| mIPrintManager.addPrintServicesChangeListener(listener, mUserId); |
| mIPrintManager.removePrintServicesChangeListener(listener, mUserId); |
| |
| // Removing unknown listeners is a no-op |
| mIPrintManager.removePrintServicesChangeListener(listener, mUserId); |
| |
| mIPrintManager.addPrintServicesChangeListener(listener, mUserId); |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.removePrintServicesChangeListener(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.getPrintServices |
| */ |
| @MediumTest |
| public void testGetPrintServices() throws Exception { |
| List<PrintServiceInfo> printServices = mIPrintManager.getPrintServices( |
| PrintManager.ALL_SERVICES, mUserId); |
| assertTrue(printServices.size() >= 1); |
| |
| printServices = mIPrintManager.getPrintServices(0, mUserId); |
| assertEquals(printServices, null); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.getPrintServices(~PrintManager.ALL_SERVICES, mUserId); |
| } |
| }, IllegalArgumentException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.setPrintServiceEnabled |
| */ |
| @MediumTest |
| public void testSetPrintServiceEnabled() throws Exception { |
| final ComponentName printService = mIPrintManager.getPrintServices( |
| PrintManager.ALL_SERVICES, mUserId).get(0).getComponentName(); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.setPrintServiceEnabled(printService, false, mUserId); |
| } |
| }, SecurityException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.setPrintServiceEnabled(printService, true, mUserId); |
| } |
| }, SecurityException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.setPrintServiceEnabled(new ComponentName("bad", "name"), true, |
| mUserId); |
| } |
| }, SecurityException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.setPrintServiceEnabled(null, true, mUserId); |
| } |
| }, SecurityException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.addPrintServiceRecommendationsChangeListener |
| */ |
| @MediumTest |
| public void testAddPrintServiceRecommendationsChangeListener() throws Exception { |
| final IRecommendationsChangeListener listener = |
| createMockIPrintServiceRecommendationsChangeListener(); |
| |
| mIPrintManager.addPrintServiceRecommendationsChangeListener(listener, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.addPrintServiceRecommendationsChangeListener(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.removePrintServicesChangeListener |
| */ |
| @MediumTest |
| public void testRemovePrintServiceRecommendationsChangeListener() throws Exception { |
| final IRecommendationsChangeListener listener = |
| createMockIPrintServiceRecommendationsChangeListener(); |
| |
| mIPrintManager.addPrintServiceRecommendationsChangeListener(listener, mUserId); |
| mIPrintManager.removePrintServiceRecommendationsChangeListener(listener, mUserId); |
| |
| // Removing unknown listeners is a no-op |
| mIPrintManager.removePrintServiceRecommendationsChangeListener(listener, mUserId); |
| |
| mIPrintManager.addPrintServiceRecommendationsChangeListener(listener, mUserId); |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.removePrintServiceRecommendationsChangeListener(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.getPrintServiceRecommendations |
| */ |
| @MediumTest |
| public void testGetPrintServiceRecommendations() throws Exception { |
| mIPrintManager.getPrintServiceRecommendations(mUserId); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.createPrinterDiscoverySession |
| */ |
| @MediumTest |
| public void testCreatePrinterDiscoverySession() throws Exception { |
| final IPrinterDiscoveryObserver listener = createMockIPrinterDiscoveryObserver(); |
| |
| mIPrintManager.createPrinterDiscoverySession(listener, mUserId); |
| |
| try { |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.createPrinterDiscoverySession(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } finally { |
| // Remove discovery session so that the next test create a new one. Usually a leaked |
| // session is removed on the next call from the print service. But in this case we want |
| // to force a new call to onPrinterDiscoverySessionStart in the next test. |
| mIPrintManager.destroyPrinterDiscoverySession(listener, mUserId); |
| } |
| } |
| |
| /** |
| * test IPrintManager.startPrinterDiscovery |
| */ |
| @LargeTest |
| public void testStartPrinterDiscovery() throws Exception { |
| startPrinting(); |
| |
| final IPrinterDiscoveryObserver listener = createMockIPrinterDiscoveryObserver(); |
| final List<PrinterId> goodPrinters = new ArrayList<>(); |
| goodPrinters.add(mGoodPrinterId); |
| |
| final List<PrinterId> badPrinters = new ArrayList<>(); |
| badPrinters.add(mBadPrinterId); |
| |
| final List<PrinterId> emptyPrinters = new ArrayList<>(); |
| |
| final List<PrinterId> nullPrinters = new ArrayList<>(); |
| nullPrinters.add(null); |
| |
| mIPrintManager.startPrinterDiscovery(listener, goodPrinters, mUserId); |
| |
| // Bad or no printers do no cause exceptions |
| mIPrintManager.startPrinterDiscovery(listener, badPrinters, mUserId); |
| mIPrintManager.startPrinterDiscovery(listener, emptyPrinters, mUserId); |
| mIPrintManager.startPrinterDiscovery(listener, null, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.startPrinterDiscovery(listener, nullPrinters, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.startPrinterDiscovery(null, goodPrinters, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.stopPrinterDiscovery |
| */ |
| @MediumTest |
| public void testStopPrinterDiscovery() throws Exception { |
| final IPrinterDiscoveryObserver listener = createMockIPrinterDiscoveryObserver(); |
| |
| mIPrintManager.startPrinterDiscovery(listener, null, mUserId); |
| mIPrintManager.stopPrinterDiscovery(listener, mUserId); |
| |
| // Stopping an already stopped session is a no-op |
| mIPrintManager.stopPrinterDiscovery(listener, mUserId); |
| |
| mIPrintManager.startPrinterDiscovery(listener, null, mUserId); |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.stopPrinterDiscovery(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.validatePrinters |
| */ |
| @LargeTest |
| public void testValidatePrinters() throws Exception { |
| startPrinting(); |
| |
| final List<PrinterId> goodPrinters = new ArrayList<>(); |
| goodPrinters.add(mGoodPrinterId); |
| |
| final List<PrinterId> badPrinters = new ArrayList<>(); |
| badPrinters.add(mBadPrinterId); |
| |
| final List<PrinterId> emptyPrinters = new ArrayList<>(); |
| |
| final List<PrinterId> nullPrinters = new ArrayList<>(); |
| nullPrinters.add(null); |
| |
| mIPrintManager.validatePrinters(goodPrinters, mUserId); |
| |
| // Bad or empty list of printers do no cause exceptions |
| mIPrintManager.validatePrinters(badPrinters, mUserId); |
| mIPrintManager.validatePrinters(emptyPrinters, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.validatePrinters(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.validatePrinters(nullPrinters, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.startPrinterStateTracking |
| */ |
| @LargeTest |
| public void testStartPrinterStateTracking() throws Exception { |
| startPrinting(); |
| |
| mIPrintManager.startPrinterStateTracking(mGoodPrinterId, mUserId); |
| |
| // Bad printers do no cause exceptions |
| mIPrintManager.startPrinterStateTracking(mBadPrinterId, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.startPrinterStateTracking(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.getCustomPrinterIcon |
| */ |
| @LargeTest |
| public void testGetCustomPrinterIcon() throws Exception { |
| startPrinting(); |
| |
| mIPrintManager.getCustomPrinterIcon(mGoodPrinterId, mUserId); |
| |
| // Bad printers do no cause exceptions |
| mIPrintManager.getCustomPrinterIcon(mBadPrinterId, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.getCustomPrinterIcon(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.stopPrinterStateTracking |
| */ |
| @LargeTest |
| public void testStopPrinterStateTracking() throws Exception { |
| startPrinting(); |
| |
| mIPrintManager.startPrinterStateTracking(mGoodPrinterId, mUserId); |
| mIPrintManager.stopPrinterStateTracking(mGoodPrinterId, mUserId); |
| |
| // Stop to track a non-tracked printer is a no-op |
| mIPrintManager.stopPrinterStateTracking(mGoodPrinterId, mUserId); |
| |
| // Bad printers do no cause exceptions |
| mIPrintManager.startPrinterStateTracking(mBadPrinterId, mUserId); |
| mIPrintManager.stopPrinterStateTracking(mBadPrinterId, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.stopPrinterStateTracking(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| |
| /** |
| * test IPrintManager.destroyPrinterDiscoverySession |
| */ |
| @MediumTest |
| public void testDestroyPrinterDiscoverySession() throws Exception { |
| final IPrinterDiscoveryObserver listener = createMockIPrinterDiscoveryObserver(); |
| |
| mIPrintManager.createPrinterDiscoverySession(listener, mUserId); |
| mIPrintManager.destroyPrinterDiscoverySession(listener, mUserId); |
| |
| // Destroying already destroyed session is a no-op |
| mIPrintManager.destroyPrinterDiscoverySession(listener, mUserId); |
| |
| assertException(new Invokable() { |
| @Override |
| public void run() throws Exception { |
| mIPrintManager.destroyPrinterDiscoverySession(null, mUserId); |
| } |
| }, NullPointerException.class); |
| |
| // Cannot test bad user Id as these tests are allowed to call across users |
| } |
| } |
