| /* |
| * 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.cts; |
| |
| import static android.print.test.Utils.assertException; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertTrue; |
| |
| import android.os.ParcelFileDescriptor; |
| import android.print.PageRange; |
| import android.print.PrintAttributes; |
| import android.print.PrintAttributes.Margins; |
| import android.print.PrintAttributes.MediaSize; |
| import android.print.PrintAttributes.Resolution; |
| import android.print.PrintDocumentAdapter; |
| import android.print.PrintDocumentAdapter.LayoutResultCallback; |
| import android.print.PrintDocumentAdapter.WriteResultCallback; |
| import android.print.PrintDocumentInfo; |
| import android.print.PrinterCapabilitiesInfo; |
| import android.print.PrinterId; |
| import android.print.PrinterInfo; |
| import android.print.test.BasePrintTest; |
| import android.print.test.services.FirstPrintService; |
| import android.print.test.services.PrintServiceCallbacks; |
| import android.print.test.services.PrinterDiscoverySessionCallbacks; |
| import android.print.test.services.SecondPrintService; |
| import android.print.test.services.StubbablePrinterDiscoverySession; |
| |
| import androidx.test.runner.AndroidJUnit4; |
| |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| import java.util.ArrayList; |
| import java.util.function.Consumer; |
| import java.util.function.Function; |
| |
| /** |
| * This test verifies changes to the printer capabilities are applied correctly. |
| */ |
| @RunWith(AndroidJUnit4.class) |
| public class PrinterCapabilitiesTest extends BasePrintTest { |
| private static final String PRINTER_NAME = "Test printer"; |
| |
| private static final Margins DEFAULT_MARGINS = new Margins(0, 0, 0, 0); |
| private static final PrintAttributes.Resolution RESOLUTION_300 = |
| new PrintAttributes.Resolution("300", "300", 300, 300); |
| private static final PrintAttributes.Resolution RESOLUTION_600 = |
| new PrintAttributes.Resolution("600", "600", 600, 600); |
| private static boolean sDefaultPrinterBeenSet; |
| |
| /** |
| * That that you cannot create illegal PrinterCapabilityInfos. |
| * |
| * @throws Exception If anything is unexpected |
| */ |
| @Test |
| public void illegalPrinterCapabilityInfos() throws Exception { |
| final PrinterDiscoverySessionCallbacks firstSessionCallbacks = |
| createMockPrinterDiscoverySessionCallbacks(invocation -> { |
| StubbablePrinterDiscoverySession session = |
| ((PrinterDiscoverySessionCallbacks) |
| invocation.getMock()).getSession(); |
| |
| PrinterId printerId = session.getService().generatePrinterId(PRINTER_NAME); |
| |
| // printerId need to be set |
| assertException(() -> new PrinterCapabilitiesInfo.Builder(null), |
| IllegalArgumentException.class); |
| |
| // All capability fields (beside duplex) need to be initialized: |
| // Test no color |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .setMinMargins(DEFAULT_MARGINS) |
| .addMediaSize(MediaSize.ISO_A4, true) |
| .addResolution(RESOLUTION_300, true).build(), |
| IllegalStateException.class); |
| // Test bad colors |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .setColorModes(0xffff, |
| PrintAttributes.COLOR_MODE_MONOCHROME), |
| IllegalArgumentException.class); |
| // Test bad duplex mode |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .setDuplexModes(0xffff, |
| PrintAttributes.DUPLEX_MODE_NONE), |
| IllegalArgumentException.class); |
| // Test no mediasize |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .setColorModes(PrintAttributes.COLOR_MODE_COLOR, |
| PrintAttributes.COLOR_MODE_COLOR) |
| .setMinMargins(DEFAULT_MARGINS) |
| .addResolution(RESOLUTION_300, true).build(), |
| IllegalStateException.class); |
| // Test no default mediasize |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .setColorModes(PrintAttributes.COLOR_MODE_COLOR, |
| PrintAttributes.COLOR_MODE_COLOR) |
| .setMinMargins(DEFAULT_MARGINS) |
| .addMediaSize(MediaSize.ISO_A4, false) |
| .addResolution(RESOLUTION_300, true).build(), |
| IllegalStateException.class); |
| // Test two default mediasizes |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .addMediaSize(MediaSize.ISO_A4, true) |
| .addMediaSize(MediaSize.ISO_A5, true), |
| IllegalArgumentException.class); |
| // Test no resolution |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .setColorModes(PrintAttributes.COLOR_MODE_COLOR, |
| PrintAttributes.COLOR_MODE_COLOR) |
| .setMinMargins(DEFAULT_MARGINS) |
| .addMediaSize(MediaSize.ISO_A4, true).build(), |
| IllegalStateException.class); |
| // Test no default resolution |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .setColorModes(PrintAttributes.COLOR_MODE_COLOR, |
| PrintAttributes.COLOR_MODE_COLOR) |
| .setMinMargins(DEFAULT_MARGINS) |
| .addMediaSize(MediaSize.ISO_A4, true) |
| .addResolution(RESOLUTION_300, false).build(), |
| IllegalStateException.class); |
| // Test two default resolutions |
| assertException(() -> |
| (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .addResolution(RESOLUTION_300, true) |
| .addResolution(RESOLUTION_600, true), |
| IllegalArgumentException.class); |
| |
| onPrinterDiscoverySessionCreateCalled(); |
| return null; |
| }, null, null, null, null, null, invocation -> { |
| onPrinterDiscoverySessionDestroyCalled(); |
| return null; |
| }); |
| |
| // Create the service callbacks for the first print service. |
| PrintServiceCallbacks firstServiceCallbacks = createMockPrintServiceCallbacks( |
| invocation -> firstSessionCallbacks, null, null); |
| |
| // Configure the print services. |
| FirstPrintService.setCallbacks(firstServiceCallbacks); |
| SecondPrintService.setCallbacks(createMockPrintServiceCallbacks(null, null, null)); |
| |
| PrintDocumentAdapter adapter = createMockPrintDocumentAdapter(null, null, null); |
| |
| // Start printing. |
| print(adapter); |
| |
| waitForPrinterDiscoverySessionCreateCallbackCalled(); |
| |
| getActivity().finish(); |
| |
| waitForPrinterDiscoverySessionDestroyCallbackCalled(1); |
| } |
| |
| /** |
| * That that you can use all sane legal PrinterCapabilityInfos. |
| * |
| * @throws Exception If anything is unexpected |
| */ |
| @Test |
| public void sanePrinterCapabilityInfos() throws Exception { |
| final PrinterDiscoverySessionCallbacks firstSessionCallbacks = |
| createMockPrinterDiscoverySessionCallbacks(invocation -> { |
| StubbablePrinterDiscoverySession session = |
| ((PrinterDiscoverySessionCallbacks) |
| invocation.getMock()).getSession(); |
| |
| MediaSize[] mediaSizes = {MediaSize.ISO_A0, MediaSize.ISO_A0, |
| MediaSize.ISO_A1}; |
| Resolution[] resolutions = {RESOLUTION_300, RESOLUTION_300, |
| RESOLUTION_600}; |
| int[] colorModes = {PrintAttributes.COLOR_MODE_MONOCHROME, |
| PrintAttributes.COLOR_MODE_COLOR}; |
| int[] duplexModes = {PrintAttributes.DUPLEX_MODE_NONE, |
| PrintAttributes.DUPLEX_MODE_LONG_EDGE, |
| PrintAttributes.DUPLEX_MODE_SHORT_EDGE}; |
| |
| ArrayList<PrinterInfo> printers = new ArrayList<>(); |
| for (int mediaSizeIndex = 1; mediaSizeIndex < mediaSizes.length; |
| mediaSizeIndex++) { |
| for (int resolutionIndex = 1; resolutionIndex < mediaSizes.length; |
| resolutionIndex++) { |
| for (int colorIndex = 1; colorIndex < colorModes.length; |
| colorIndex++) { |
| for (int duplexIndex = 1; duplexIndex < duplexModes.length; |
| duplexIndex++) { |
| PrinterId printerId = session.getService() |
| .generatePrinterId(Integer.valueOf(printers.size()) |
| .toString()); |
| |
| // Setup capabilities |
| PrinterCapabilitiesInfo.Builder b = |
| new PrinterCapabilitiesInfo.Builder(printerId); |
| |
| for (int i = 0; i < mediaSizeIndex; i++) { |
| b.addMediaSize(mediaSizes[i], i == mediaSizeIndex - 1); |
| } |
| |
| for (int i = 0; i < resolutionIndex; i++) { |
| b.addResolution(resolutions[i], |
| i == resolutionIndex - 1); |
| } |
| |
| int allColors = 0; |
| for (int i = 0; i < colorIndex; i++) { |
| allColors |= colorModes[i]; |
| } |
| b.setColorModes(allColors, colorModes[colorIndex - 1]); |
| |
| int allDuplexModes = 0; |
| for (int i = 0; i < duplexIndex; i++) { |
| allDuplexModes |= duplexModes[i]; |
| } |
| b.setDuplexModes(allDuplexModes, |
| duplexModes[duplexIndex - 1]); |
| |
| b.setMinMargins(DEFAULT_MARGINS); |
| |
| // Create printer |
| PrinterInfo printer = (new PrinterInfo.Builder(printerId, |
| Integer.valueOf(printers.size()).toString(), |
| PrinterInfo.STATUS_IDLE)).setCapabilities(b.build()) |
| .build(); |
| |
| // Verify capabilities |
| PrinterCapabilitiesInfo cap = printer.getCapabilities(); |
| |
| assertEquals(mediaSizeIndex, cap.getMediaSizes().size()); |
| assertEquals(mediaSizes[mediaSizeIndex - 1], |
| cap.getDefaults().getMediaSize()); |
| for (int i = 0; i < mediaSizeIndex; i++) { |
| assertTrue(cap.getMediaSizes().contains(mediaSizes[i])); |
| } |
| |
| assertEquals(resolutionIndex, cap.getResolutions().size()); |
| assertEquals(resolutions[resolutionIndex - 1], |
| cap.getDefaults().getResolution()); |
| for (int i = 0; i < resolutionIndex; i++) { |
| assertTrue(cap.getResolutions().contains(resolutions[i])); |
| } |
| |
| assertEquals(allColors, cap.getColorModes()); |
| assertEquals(colorModes[colorIndex - 1], |
| cap.getDefaults().getColorMode()); |
| |
| assertEquals(allDuplexModes, cap.getDuplexModes()); |
| assertEquals(duplexModes[duplexIndex - 1], |
| cap.getDefaults().getDuplexMode()); |
| |
| assertEquals(DEFAULT_MARGINS, cap.getMinMargins()); |
| |
| // Add printer |
| printers.add(printer); |
| } |
| } |
| } |
| } |
| |
| session.addPrinters(printers); |
| |
| onPrinterDiscoverySessionCreateCalled(); |
| return null; |
| }, null, null, null, null, null, invocation -> { |
| onPrinterDiscoverySessionDestroyCalled(); |
| return null; |
| }); |
| |
| // Create the service callbacks for the first print service. |
| PrintServiceCallbacks firstServiceCallbacks = createMockPrintServiceCallbacks( |
| invocation -> firstSessionCallbacks, null, null); |
| |
| // Configure the print services. |
| FirstPrintService.setCallbacks(firstServiceCallbacks); |
| SecondPrintService.setCallbacks(createMockPrintServiceCallbacks(null, null, null)); |
| |
| PrintDocumentAdapter adapter = createMockPrintDocumentAdapter(null, null, null); |
| |
| // Start printing. |
| print(adapter); |
| |
| waitForPrinterDiscoverySessionCreateCallbackCalled(); |
| |
| getUiDevice().pressBack(); |
| |
| waitForPrinterDiscoverySessionDestroyCallbackCalled(1); |
| } |
| |
| /** |
| * Base test that performs a print operation with a give PrinterCapabilityInfo and run a test |
| * function before finishing. |
| * |
| * @throws Exception |
| */ |
| private void testPrinterCapabilityInfo(final Function<PrinterId, PrinterCapabilitiesInfo> |
| capBuilder, Consumer<PrintAttributes> test) throws Exception { |
| final PrinterDiscoverySessionCallbacks firstSessionCallbacks = |
| createMockPrinterDiscoverySessionCallbacks(invocation -> { |
| StubbablePrinterDiscoverySession session = |
| ((PrinterDiscoverySessionCallbacks) |
| invocation.getMock()).getSession(); |
| |
| PrinterId printerId = session.getService() |
| .generatePrinterId(PRINTER_NAME); |
| |
| ArrayList<PrinterInfo> printers = new ArrayList<>(); |
| printers.add((new PrinterInfo.Builder(printerId, PRINTER_NAME, |
| PrinterInfo.STATUS_IDLE)) |
| .setCapabilities(capBuilder.apply(printerId)).build()); |
| |
| session.addPrinters(printers); |
| |
| onPrinterDiscoverySessionCreateCalled(); |
| return null; |
| }, null, null, null, null, null, invocation -> { |
| onPrinterDiscoverySessionDestroyCalled(); |
| return null; |
| }); |
| |
| // Create the service callbacks for the first print service. |
| PrintServiceCallbacks firstServiceCallbacks = createMockPrintServiceCallbacks( |
| invocation -> firstSessionCallbacks, null, null); |
| |
| // Configure the print services. |
| FirstPrintService.setCallbacks(firstServiceCallbacks); |
| SecondPrintService.setCallbacks(createMockPrintServiceCallbacks(null, null, null)); |
| |
| final PrintAttributes[] layoutAttributes = new PrintAttributes[1]; |
| |
| PrintDocumentAdapter adapter = createMockPrintDocumentAdapter( |
| invocation -> { |
| LayoutResultCallback callback = (LayoutResultCallback) invocation |
| .getArguments()[3]; |
| PrintDocumentInfo info = new PrintDocumentInfo.Builder(PRINT_JOB_NAME) |
| .setPageCount(1) |
| .build(); |
| layoutAttributes[0] = (PrintAttributes) invocation.getArguments()[1]; |
| |
| callback.onLayoutFinished(info, true); |
| return null; |
| }, |
| invocation -> { |
| Object[] args = invocation.getArguments(); |
| PageRange[] pages = (PageRange[]) args[0]; |
| ParcelFileDescriptor fd = (ParcelFileDescriptor) args[1]; |
| WriteResultCallback callback = (WriteResultCallback) args[3]; |
| |
| writeBlankPages(layoutAttributes[0], fd, pages[0].getStart(), |
| pages[0].getEnd()); |
| fd.close(); |
| |
| callback.onWriteFinished(pages); |
| return null; |
| }, null); |
| |
| // Start printing. |
| print(adapter); |
| |
| // make sure that options does not crash |
| openPrintOptions(); |
| |
| if (!sDefaultPrinterBeenSet) { |
| // Select printer under test |
| selectPrinter(PRINTER_NAME); |
| } |
| |
| clickPrintButton(); |
| |
| if (!sDefaultPrinterBeenSet) { |
| answerPrintServicesWarning(true); |
| sDefaultPrinterBeenSet = true; |
| } |
| |
| test.accept(layoutAttributes[0]); |
| |
| waitForPrinterDiscoverySessionDestroyCallbackCalled(1); |
| } |
| |
| /** |
| * That that you use a default color that is not in the allowed colors. This is allowed because |
| * of historical reasons. |
| * |
| * @throws Exception If anything is unexpected |
| */ |
| @Test |
| public void invalidDefaultColor() throws Exception { |
| testPrinterCapabilityInfo( |
| (printerId) -> (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .addMediaSize(MediaSize.ISO_A4, true) |
| .addResolution(RESOLUTION_300, true) |
| .setColorModes(PrintAttributes.COLOR_MODE_MONOCHROME, |
| PrintAttributes.COLOR_MODE_COLOR).build(), |
| (layoutAttributes) -> assertEquals(layoutAttributes.getColorMode(), |
| PrintAttributes.COLOR_MODE_MONOCHROME)); |
| } |
| |
| /** |
| * That that you use a default duplex mode that is not in the allowed duplex modes. This is |
| * allowed because of historical reasons. |
| * |
| * @throws Exception If anything is unexpected |
| */ |
| @Test |
| public void invalidDefaultDuplexMode() throws Exception { |
| testPrinterCapabilityInfo( |
| (printerId) -> (new PrinterCapabilitiesInfo.Builder(printerId)) |
| .addMediaSize(MediaSize.ISO_A4, true) |
| .addResolution(RESOLUTION_300, true) |
| .setColorModes(PrintAttributes.COLOR_MODE_MONOCHROME, |
| PrintAttributes.COLOR_MODE_MONOCHROME) |
| .setDuplexModes(PrintAttributes.DUPLEX_MODE_LONG_EDGE |
| | PrintAttributes.DUPLEX_MODE_NONE, |
| PrintAttributes.DUPLEX_MODE_SHORT_EDGE).build(), |
| (layoutAttributes) -> assertTrue(layoutAttributes.getDuplexMode() == |
| PrintAttributes.DUPLEX_MODE_LONG_EDGE || layoutAttributes.getDuplexMode() == |
| PrintAttributes.DUPLEX_MODE_NONE)); |
| } |
| } |
