/enhanced/java/trunk/classlib/modules/print/src/test/api/java/common/javax/print/ValueTests.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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.
 */
/** 
 * @author Irina A. Arkhipets 
 */ 

/*
 * ValueTests.java 
 * 
 * JUnit not-interactive Value tests for "Hello, World!" version (javax.print
 * package only).
 * 
 */

package javax.print;

import java.io.ByteArrayOutputStream;
import java.io.FileReader;
import java.io.InputStream;
import java.util.Locale;
import java.util.Vector;

import javax.print.attribute.Attribute;
import javax.print.attribute.DocAttribute;
import javax.print.attribute.DocAttributeSet;
import javax.print.attribute.HashDocAttributeSet;
import javax.print.attribute.HashPrintJobAttributeSet;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.HashPrintServiceAttributeSet;
import javax.print.attribute.PrintJobAttribute;
import javax.print.attribute.PrintJobAttributeSet;
import javax.print.attribute.PrintRequestAttribute;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.print.attribute.PrintServiceAttribute;
import javax.print.attribute.PrintServiceAttributeSet;
import javax.print.attribute.standard.ColorSupported;
import javax.print.attribute.standard.Copies;
import javax.print.attribute.standard.MediaName;
import javax.print.attribute.standard.OrientationRequested;
import javax.print.attribute.standard.PrintQuality;
import javax.print.attribute.standard.PrinterLocation;

import junit.framework.TestCase;

public class ValueTests extends TestCase {

private static String OS = null;

static {
    try {
        OS = System.getProperty("os.name");
        if (OS.startsWith("Windows")) {
            System.loadLibrary("ValueTestsLibrary");
        }
    } catch (Exception e) {
        if (OS == null) {
            System.out.println("WARNING: Can not get Operation System name!");
        } else {
            if (OS.startsWith("Windows")) {
                System.out.println(
                        "WARNING! Can not load ValueTestsLibrary library!");
            }
        }
        System.out.println("Some testcases probably will not be started!");
   }
}

public void testDocFlavor() {
    startTest("DocFlavor class testing...");
    DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF;
    assertEquals(flavor, new DocFlavor.INPUT_STREAM("image/gif"));
    assertEquals(flavor.getMediaSubtype(), "gif");
    assertEquals(flavor.getMediaType(), "image");
    assertEquals(flavor.getMimeType(), "image/gif");
    assertEquals(flavor.getRepresentationClassName(), "java.io.InputStream");
    assertEquals(flavor.toString(), 
            "image/gif; class=\"java.io.InputStream\"");
}

public void testSimpleDoc() {
    startTest("SimpleDoc class testing...");
    
    DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF;
    InputStream reader =
            getClass().getResourceAsStream("/Resources/picture.gif");
    if (reader == null) {
        fail("/Resources/picture.gif resource is not found!");
    }
    
    DocAttributeSet aSet = new HashDocAttributeSet();
    Doc doc = new SimpleDoc(reader, flavor, aSet);
    
    assertEquals(doc.getAttributes(), aSet);
    aSet.add(OrientationRequested.LANDSCAPE);
    aSet.add(MediaName.NA_LETTER_WHITE);
    assertEquals(doc.getAttributes(), aSet);
    assertEquals(doc.getDocFlavor(), DocFlavor.INPUT_STREAM.GIF);
    try {
        assertTrue(doc.getPrintData() instanceof java.io.InputStream);
        assertNull(doc.getReaderForText());
        assertEquals(doc.getStreamForBytes(), reader);
    } catch(Exception e) {
        e.printStackTrace();
        fail("Exception found: "+e);
    }
}

public void testDefaultPrintService() {
    boolean flg = false;

    startTest("PrintService class testing...");
    DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF;
    PrintRequestAttributeSet printRequestSet =
            new HashPrintRequestAttributeSet();
    PrintService service = getPrintService(flavor, printRequestSet);
    DocFlavor [] flavors;
    String myName = getDefaultPrintService();
    
    System.out.println("OS is " + OS);
    if (service == null) {
        System.out.println(
        "WARNING: Can not get print service which supports INPUT_STREAM.GIF!");
    } else {
        assertTrue(service.isDocFlavorSupported(flavor));
        flavors = service.getSupportedDocFlavors();
        for (int i = 0; i < flavors.length; i++) {
            if (flavors[i].equals(flavor)) {
                flg = true;
                break;
            }
        }
        assertTrue(flg);
/*        if (myName != null) {
            assertEquals(service.getName(), myName);
        }
*/
    }
}

public void testPrintJob() {
    startTest("PrintJob class testing...");
    DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF;
    PrintRequestAttributeSet printRequestSet = 
            new HashPrintRequestAttributeSet();
    PrintService service = getPrintService(flavor, printRequestSet);
    if (service != null) { 
        DocPrintJob job = service.createPrintJob();
        assertEquals(job.getPrintService(), service);
    } else {
        System.out.println(
        "WARNING: Can not get print service which supports INPUT_STREAM.GIF!");
    }
}

public void testStreamServiceFactory() {
    startTest("StreamPrintServiceFactory class testing...");
    boolean flg = false;
    DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF;
    StreamPrintServiceFactory [] aFactory = StreamPrintServiceFactory
          .lookupStreamPrintServiceFactories(flavor, "application/postscript");
    StreamPrintServiceFactory streamFactory=null;
    StreamPrintService streamService;
    DocFlavor [] flavors;
    
    if ((aFactory == null) || (aFactory.length == 0)) {
        fail("Can not find stream print service factory!");
    } else {
        streamFactory = aFactory[0];
    }
    streamService = streamFactory.getPrintService(new ByteArrayOutputStream());
    assertEquals(streamFactory.getOutputFormat(), "application/postscript");
    assertEquals(streamFactory.getPrintService(new ByteArrayOutputStream()),
                 streamService);
    flavors = streamFactory.getSupportedDocFlavors();
    for (int i = 0; i < flavors.length; i++) {
        if (flavors[i].equals(flavor)) {
            flg = true;
            break;
        }
    }
    assertTrue(flg);
}

public void testStreamPrintService() {
    startTest("StreamPrintService class testing...");
    
    DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF;
    StreamPrintServiceFactory [] aFactory = StreamPrintServiceFactory
          .lookupStreamPrintServiceFactories(flavor, "application/postscript");
    StreamPrintServiceFactory streamFactory = null;
    StreamPrintService streamService; 
    DocFlavor [] flavors;
    boolean flg = false;
    
    if ((aFactory == null) || (aFactory.length == 0)) {
        fail("Can not find stream print service factory!");
    } else {
        streamFactory = aFactory[0];
    }
    streamService = streamFactory.getPrintService(new ByteArrayOutputStream());
    
    assertEquals(streamService.getOutputFormat(), "application/postscript");
    assertTrue(streamService.isDocFlavorSupported(flavor));
    flavors = streamService.getSupportedDocFlavors();
    for (int i = 0; i < flavors.length; i++) {
        if (flavors[i].equals(flavor)) {
            flg = true;
            break;
        }
    }
    assertTrue(flg);
    streamService.dispose();
    assertTrue(streamService.isDisposed());
}

public void testStreamServicePrinting() throws Exception {
    startTest("StreamPrintServiceFactory class testing...");
    
    byte [] forChecking = {'%', '!', 'P', 'S', '-', 'A', 'd', 'o', 'b', 'e'};
    DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF;
    StreamPrintServiceFactory [] aFactory = StreamPrintServiceFactory
          .lookupStreamPrintServiceFactories(flavor, "application/postscript");
    StreamPrintServiceFactory streamFactory = null;
    StreamPrintService streamService; 
    DocPrintJob aJob;
    InputStream aStream = 
        getClass().getResourceAsStream("/Resources/picture.gif");
    Doc doc;
    byte [] arr;
    boolean flg = true;
    
    if ((aFactory == null) || (aFactory.length == 0)) {
        fail("Can not find stream print service factory!");
    } else {
        streamFactory = aFactory[0];
    }
    if (aStream == null) {
        fail("/Resources/picture.gif resource is not found!");        
    }
    
    streamService = streamFactory.getPrintService(new ByteArrayOutputStream());
    aJob = streamService.createPrintJob();
    doc = new SimpleDoc(aStream, flavor, null);

    aJob.print(doc, null);

    arr = ((ByteArrayOutputStream) (streamService.getOutputStream()))
            .toByteArray();
    for (int i = 0; i < 10; i++) {
        if(arr[i] != forChecking[i]) {
            flg = false;
            break;
        }
    }
    assertTrue(flg);
}

public void testHashDocAttributeSet() {
    startTest("HashDocAttributeSet class testing...");

    DocAttributeSet set1 = new HashDocAttributeSet();
    DocAttributeSet set2 = 
        new HashDocAttributeSet(OrientationRequested.LANDSCAPE);
    DocAttributeSet set3 = new HashDocAttributeSet(set2);
    DocAttribute [] arr = {OrientationRequested.LANDSCAPE,
                           MediaName.NA_LETTER_WHITE};
    DocAttributeSet set4 = new HashDocAttributeSet(arr);
    Attribute [] attrArr;

    assertTrue(set1.isEmpty());
    assertFalse(set2.isEmpty());
    assertTrue(set3.equals(set2));
    assertFalse(set3.equals(set1));
    set3.clear();
    assertEquals(set3, set1);
    set3.add(OrientationRequested.LANDSCAPE);
    set3.add(MediaName.NA_LETTER_WHITE);
    assertTrue(set3.containsKey(OrientationRequested.LANDSCAPE.getClass()));
    assertFalse(set2.containsKey(MediaName.NA_LETTER_WHITE.getClass()));
    assertTrue(set3.containsValue(OrientationRequested.LANDSCAPE));
    assertFalse(set3.containsValue(OrientationRequested.PORTRAIT));
    assertFalse(set3.containsValue(PrintQuality.DRAFT));
    assertEquals(set1.size(), 0);
    assertEquals(set2.size(), 1);
    assertEquals(set3.size(), 2);
    assertTrue(set4.equals(set3));
    assertEquals(set3.get(OrientationRequested.PORTRAIT.getClass()),
                 OrientationRequested.LANDSCAPE);
    assertFalse((set3.get(OrientationRequested.PORTRAIT.getClass()))
            .equals(OrientationRequested.PORTRAIT));
    set1.addAll(set3);
    assertEquals(set3, set1);
    set1.remove(OrientationRequested.PORTRAIT.getClass());
    assertEquals(set1.size(), 1);
    attrArr = set1.toArray();
    assertEquals(attrArr.length, 1);
    assertEquals(attrArr[0], MediaName.NA_LETTER_WHITE);
}

public void testHashPrintJobAttributeSet() {
    startTest("HashPrintJobAttributeSet class testing...");

    PrintJobAttributeSet set1 = new HashPrintJobAttributeSet();
    PrintJobAttributeSet set2 = 
        new HashPrintJobAttributeSet(OrientationRequested.LANDSCAPE);
    PrintJobAttributeSet set3 = new HashPrintJobAttributeSet(set2);
    PrintJobAttribute [] arr = {OrientationRequested.LANDSCAPE,
                                MediaName.NA_LETTER_WHITE};
    PrintJobAttributeSet set4 = new HashPrintJobAttributeSet(arr);
    Attribute [] attrArr;
    
    assertTrue(set1.isEmpty());
    assertFalse(set2.isEmpty());
    assertTrue(set3.equals(set2));
    assertFalse(set3.equals(set1));
    set3.clear();
    assertEquals(set3, set1);
    set3.add(OrientationRequested.LANDSCAPE);
    set3.add(MediaName.NA_LETTER_WHITE);
    assertTrue(set3.containsKey(OrientationRequested.LANDSCAPE.getClass()));
    assertFalse(set2.containsKey(MediaName.NA_LETTER_WHITE.getClass()));
    assertTrue(set3.containsValue(OrientationRequested.LANDSCAPE));
    assertFalse(set3.containsValue(OrientationRequested.PORTRAIT));
    assertFalse(set3.containsValue(PrintQuality.DRAFT));
    assertEquals(set1.size(), 0);
    assertEquals(set2.size(), 1);
    assertEquals(set3.size(), 2);
    assertTrue(set4.equals(set3));
    assertEquals(set3.get(OrientationRequested.PORTRAIT.getClass()),
                 OrientationRequested.LANDSCAPE);
    assertFalse((set3.get(OrientationRequested.PORTRAIT.getClass()))
            .equals(OrientationRequested.PORTRAIT));
    set1.addAll(set3);
    assertEquals(set3, set1);
    set1.remove(OrientationRequested.PORTRAIT.getClass());
    assertEquals(set1.size(), 1);
    attrArr = set1.toArray();
    assertEquals(attrArr.length, 1);
    assertEquals(attrArr[0], MediaName.NA_LETTER_WHITE);
}

public void testHashPrintRequestAttributeSet() {
    startTest("HashPrintRequestAttributeSet class testing...");

    Copies copies = new Copies(2);
    PrintRequestAttributeSet set1 = new HashPrintRequestAttributeSet();
    PrintRequestAttributeSet set2 = new HashPrintRequestAttributeSet(copies);
    PrintRequestAttributeSet set3 = new HashPrintRequestAttributeSet(set2);
    PrintRequestAttribute [] arr = {copies, 
                                    MediaName.NA_LETTER_WHITE};
    PrintRequestAttributeSet set4 = new HashPrintRequestAttributeSet(arr);
    Attribute [] attrArr = set1.toArray();

    assertTrue(set1.isEmpty());
    assertFalse(set2.isEmpty());
    assertTrue(set3.equals(set2));
    assertFalse(set3.equals(set1));
    set3.clear();
    assertEquals(set3, set1);
    set3.add(copies);
    set3.add(MediaName.NA_LETTER_WHITE);
    assertTrue(set3.containsKey(copies.getClass()));
    assertFalse(set2.containsKey(MediaName.NA_LETTER_WHITE.getClass()));
    assertTrue(set3.containsValue(copies));
    assertFalse(set3.containsValue(OrientationRequested.PORTRAIT));
    assertFalse(set3.containsValue(PrintQuality.DRAFT));
    assertEquals(set1.size(), 0);
    assertEquals(set2.size(), 1);
    assertEquals(set3.size(), 2);
    assertTrue(set4.equals(set3));
    assertEquals(set3.get(copies.getClass()), copies);
    set1.addAll(set3);
    assertEquals(set3, set1);
    set1.remove(copies.getClass());
    assertEquals(set1.size(), 1);
    attrArr = set1.toArray();
    assertEquals(attrArr.length, 1);
    assertEquals(attrArr[0], MediaName.NA_LETTER_WHITE);
}

public void testHashPrintServiceAttributeSet() {
    startTest("HashPrintJobAttributeSet class testing...");

    PrintServiceAttributeSet set1 = new HashPrintServiceAttributeSet();
    PrintServiceAttributeSet set2 = new HashPrintServiceAttributeSet(
            ColorSupported.SUPPORTED);
    PrintServiceAttributeSet set3 = new HashPrintServiceAttributeSet(set2);
    PrinterLocation location = new PrinterLocation("room 222", Locale.ENGLISH);
    PrintServiceAttribute [] arr = { location, 
                                     ColorSupported.SUPPORTED };
    PrintServiceAttributeSet set4 = new HashPrintServiceAttributeSet(arr);
    
    assertTrue(set1.isEmpty());
    assertFalse(set2.isEmpty());
    assertTrue(set3.equals(set2));
    assertFalse(set3.equals(set1));
    set3.clear();
    assertEquals(set3, set1);
    set3.add(ColorSupported.SUPPORTED);
    set3.add(location);
    assertTrue(set3.containsKey(location.getClass()));
    assertFalse(set2.containsKey(MediaName.NA_LETTER_WHITE.getClass()));
    assertTrue(set4.equals(set3));
    assertEquals(set3.get(location.getClass()), location);
    set1.addAll(set3);
    assertEquals(set3, set1);
    set1.remove(location.getClass());
    assertEquals(set1.size(), 1);
}

// ---------------------------------------------------------------------------------
/* 
* This function search a PrintService which supports given 
* DocFlavor and PrintRequestAttributeSet.
* If default printer supports them, this function returns default printer.
* Overwise it returna first printer from all print services list.
*/
private PrintService getPrintService(DocFlavor aFlavor, 
                                     PrintRequestAttributeSet aSet)
{
    PrintService [] services = 
            PrintServiceLookup.lookupPrintServices(aFlavor, aSet);
    PrintService defaultService = 
            PrintServiceLookup.lookupDefaultPrintService();
    
    if (services.length <= 0) {
        System.out.println("Can not find default print service!");
        return null;
    }
    for (int i = 0; i < services.length; i++) {
        if (services[i].equals(defaultService)) {
            return services[i];
        }
    }
    System.out.println(
            "System Default PrintService does not support given attributes!");
    return services[0];
}

/*
 *  This functions returns a list of the available printers
*/
private String[] getPrintServices() {
    return (OS.startsWith("Windows")  
            ? getWindowsPrintServices() 
            : getLinuxPrintServices());
}

/*
 * This native function returns Windows printers list
 */
private native String [] getWindowsPrintServices();

/*
* This function returns Linus printers list.
* On Linux all CUPS printers are listed on /etc/printcap file
*/
private String [] getLinuxPrintServices() {
    Vector services = new Vector();
    String str = "";
    short state = 0;
    char c;
    String [] res;
    
    try {
        boolean flg = true;
        FileReader reader = new FileReader("/etc/printcap");
        while (flg) {
            c = (char) reader.read();
            if (( c <= 0) || (c == 65535)) {
                if (state == 2) {
                    services.add(str);
                }
                flg = false;
            }
            switch(state) {
                case 0:
                    if (c == '#') {
                        state = 1;
                    } else if (Character.isLetter(c)) {
                        str = str + c;
                        state = 2;
                    }
                    break;
                case 1:
                    if (c == '\n') {
                        state = 0;
                        str = "";
                    }
                    break;
                case 2:
                    if ((c == '|') || (c == '\n') || (c == ' ') || (c == 9)) {
                        services.add(str);
                        str = "";
                        state = (c == '\n') ? (short) 0 : (short) 1;
                    } else {
                        str = str + c;
                    }
                    break;
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }

    res = new String [services.size()];
    for (int i = 0; i < services.size(); i++) {
        res[i] = (String)services.get(i);
    }

    return res;
}

/*
 * This function returns system default printer
*/
private String getDefaultPrintService() {
    return OS.startsWith("Windows") 
           ? getDefaultWindowsPrintService() 
           : getDefaultLinuxPrintService();
}

/*
 * This function returns Windows default printer name
 */
private native String getDefaultWindowsPrintService();

/*
 * This function returns Linux default printer name
 * On Linux lpstat -d returns string like the following:
 * "system default destination: test"
 */
private String getDefaultLinuxPrintService() {
    try {
        Process process = Runtime.getRuntime().exec(
                "lpstat -d | grep \"system default destination\"");
        InputStream iStream;
        byte [] res;
        String resStr;
        
        process.waitFor();
        if (process.exitValue() != 0) {
            System.out.println("Can not exec \"lpstat -d\"");
            return null;
        }
        iStream = process.getInputStream();
        res = new byte [iStream.available()];
        iStream.read(res);
        resStr = new String(res);
        if (!resStr.startsWith("system default destination: ")) {
            System.out.println(
                    "WARNING: Can not recognize \"lpstat -d\" output:");
            System.out.println(resStr + "\n");
            return null;
        }
        // Last symbol in resStr is "\n"!
        return resStr.substring(28, resStr.length()-1);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

private void startTest(String s) {
    System.out.println("----------------------------------------");
    System.out.println(s);
}
}