xref: /trunk/test/testgui/source/bvt/gui/FileExport.java (revision 9c5183b9128ae5fa95a129746e5d9e3fc803f184)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/

/**
 *
 */
package bvt.gui;

import static org.openoffice.test.common.Testspace.*;
import static testlib.gui.AppTool.*;
import static testlib.gui.UIMap.*;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;
import java.util.concurrent.TimeoutException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import java.io.InputStreamReader;
import java.lang.RuntimeException;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.openoffice.test.common.Condition;
import org.openoffice.test.common.DataSheet;
import org.openoffice.test.common.FileUtil;
import org.openoffice.test.common.Logger;
import org.openoffice.test.common.Testspace;
import org.openoffice.test.vcl.widgets.VclDialog;


public class FileExport {
    private static class TestType {

        public TestType(boolean doc, boolean spread, boolean slide) {
            documentT = doc;
            spreadsheetT = spread;
            slideT = slide;
        }

        public boolean documentT;
        public boolean spreadsheetT;
        public boolean slideT;
    };

    private static class ContinuePoint {
        public String path;
        public int i;

        ContinuePoint() {
            path = "";
            i = 0;
        }
    }

    // for example
    // the path is "D:\\aoo\\utaoo\\testspace\\ooxmlsamples"
    String samplespath = "";// a dir
    String outpath = ""; // a dir
    static double timeout = 100;
    static double interval = 0.1;
    double sleeptime = 1;
    boolean bContinue = false;// if failed,next execute from the continue point
    TestType atest = new TestType(true, true, true);// doc,spreadsheet,slide
    ContinuePoint thepoint = null;
    BufferedWriter fwContinue = null;
    String testedlogfile = "";

    private static DataSheet result;
    private String scenario = null;
    private File sourceFile = null;

    public static final VclDialog passwdDlg = dialog("");

    public List<String> recursionfiles(File path, List<String> resultFileName) {
        File[] files = path.listFiles();
        if (files == null)
            return resultFileName;
        for (File f : files) {
            if (f.isDirectory()) {// a path
                if (!f.isHidden() && !f.getName().startsWith(".")) {
                    sampledirs.add(f.getPath());
                    recursionfiles(f, resultFileName);
                }
            } else {// a file
                if (!f.isHidden() && !f.getName().startsWith(".")) {
                    String apath = f.getPath();

                    int sepIndex = apath.indexOf(File.separatorChar);
                    String userpath = apath.substring(sepIndex);
                    String newpath = outpath + userpath;

                    File file = new File(newpath);
                    File parent = file.getParentFile();
                    if (parent != null && !parent.exists()) {
                        parent.mkdirs();
                    }
                    resultFileName.add(f.getPath());
                }
            }
        }
        return resultFileName;
    }

    private String getrealoutpath(String p) {
        String apath = p;

        int sepIndex = apath.indexOf(File.separatorChar);
        int sepIndexLast = apath.lastIndexOf(File.separatorChar);
        String userpath = apath.substring(sepIndex, sepIndexLast);
        String newpath = outpath + userpath;
        File tempFolderFile = new File(newpath);
        if (!tempFolderFile.exists()) {
            tempFolderFile.mkdirs();
        }
        return newpath;
    }

    private List<String> samplelist = null;
    private List<String> sampledirs = null;

    @Rule
    public Logger log = Logger.getLogger(this);

    @BeforeClass
    public static void beforeClass() {
        app.clean();
    }

    @AfterClass
    public static void afterClass() {
        app.stop();
    }

    @Before
    public void before() {

    }

    @After
    public void after() throws Exception {
        app.stop();
    }

    void getcontinuepoint() {

        if (bContinue == false) {
            thepoint.path = "";
            thepoint.i = 0;
            return;
        }
        File ftestedlog = new File(testedlogfile);
        Reader reader = null;
        try {
            reader = new InputStreamReader(new FileInputStream(ftestedlog));
        } catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        BufferedReader br = new BufferedReader(reader);

        String line = null;
        int countline = 0;
        int m = 0;
        try {
            if ((line = br.readLine()) != null) {
                if (countline == 0) {
                    thepoint.path = line;
                } else {

                    m = Integer.parseInt(line);
                    if (m > 0)
                        thepoint.i = m;
                }
            }
        } catch (NumberFormatException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    }

    /**
     * Test Open/SaveAs ooxml file by Aoo
     *
     * @throws Exception
     */
    @Test
    public void testSaveAs() throws Exception {
        samplelist = new ArrayList<String>();
        sampledirs = new ArrayList<String>();
        thepoint = new ContinuePoint();
        File spacepath = new File(Testspace.getPath());
        File absspath = spacepath.getAbsoluteFile();
        String abspre = absspath.getParent();

        result = new DataSheet(getFile("outputlog" + File.separatorChar
                + FileExport.class.getName() + ".xml"));
        result.addRow("data", "File Path", "File Size", "Scenario",
                "Exported File Path", "Exported File Size", "Result", "Error");

        testedlogfile = abspre + "testgui" + File.separatorChar + "cases_tested.txt";
        samplespath = "samples";

        if (outpath.length() == 0) {
            File workspacepath = Testspace.getFile("output");// ..\\testspace\\output
            outpath = workspacepath.getAbsolutePath();

            // outpath = "D:\\AOOautomation\\Docs sample files\\out";
        }

        if (bContinue)
            getcontinuepoint();

        File samplesDir = Testspace.getFile(samplespath);
        recursionfiles(samplesDir, samplelist);
        ListIterator<String> it = sampledirs.listIterator();

        boolean bstartfromthis = false;
        while (it.hasNext()) {

            String str = (String) it.next();
            if (!bContinue) {
                File afiledir = new File(str);
                dotest(afiledir);
            } else {
                File file = new File(thepoint.path);
                File parent = file.getParentFile();
                if (parent != null) {
                    String pathbegin = parent.getAbsolutePath();
                    if (pathbegin.equalsIgnoreCase(str)) {
                        bstartfromthis = true;

                    }
                }
                if (bstartfromthis == true) {
                    File afiledir = new File(str);
                    dotest(afiledir);
                }
            }
        }
    }

    public void dotest(File samplesDir) throws Exception {
        FilenameFilter testFilter = new FilenameFilter() {
            public boolean accept(File file, String name) {
                if (name.endsWith(".doc") || name.endsWith(".docx")
                        || name.endsWith(".dot") || name.endsWith(".xls")
                        || name.endsWith(".xlsx") || name.endsWith(".ods")
                        || name.endsWith(".ppt") || name.endsWith(".pptx")
                        || name.endsWith(".odp")) {
                    // filters files
                    return true;
                } else {
                    return false;
                }
            }
        };
        File[] files = samplesDir.listFiles(testFilter);
        Arrays.sort(files);
        int nfiles = files.length;
        if (nfiles == 0)
            return;

        int i = thepoint.i;
        for (; i < nfiles; i++) {
            File afile = files[i];
            String path = afile.getAbsolutePath();

            String extName = FileUtil.getFileExtName(path).toLowerCase();
            boolean bShouldTest = false;
            if (extName.equals("doc") || extName.equals("docx")
                    || extName.equals("odt")) {
                bShouldTest = true;
                if (atest.documentT == false)
                    continue;
            }
            if (extName.equals("ppt") || extName.equals("pptx")
                    || extName.equals("odp")) {
                bShouldTest = true;
                if (atest.slideT == false)
                    continue;
            }
            if (extName.equals("xls") || extName.equals("xlsx")
                    || extName.equals("ods")) {
                bShouldTest = true;
                if (atest.spreadsheetT == false)
                    continue;
            }
            if (!bShouldTest)
                continue;
            String exportname = "aoo_" + afile.getName();

            sourceFile = new File(path);

            app.stop();
            app.start();

            if(!Open(path)){
                continue;
            }

            String newpath = getrealoutpath(path);

            // do testing
            if (!savetosameformat(exportname, newpath)) {
                continue;
            }

            if(!Open(path)) {
                continue;

            }
            if (!savetodiffformat(exportname, newpath)) {
                continue;
            }

            if(!Open(path)) {
                continue;

            }

            if (!savetopdfformat(exportname, newpath)) {
                continue;
            }
        }
    }

    private boolean Open(String path) throws Exception {
        try {
            open(path);
            if (!app.exists())
                throw new RuntimeException();
            HandleBlockers(false);
            if(statusBar.exists(timeout))
                statusBar.waitForEnabled(timeout, interval);
            else
                throw new TimeoutException("time out");
            HandleBlockers(false);
            if (!app.exists())
                throw new RuntimeException();
            return true;
        } catch (Exception e) {
            try {
                String reason = e.getMessage();
                if (reason == null || reason.isEmpty())
                    reason = "Opening";
                result.addRow("data", sourceFile.getCanonicalPath(),
                        sourceFile.length(), scenario, "", "", "Fail", reason);
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            return false;
        }
    }

    private boolean savetosameformat(String file, String outpath) {
        try {
            File reportDir = Testspace.getFile(outpath);

            String extName = FileUtil.getFileExtName(file).toLowerCase();

            boolean formatchanged = false;
            if (extName.equals("docx")) {
                extName = "doc";
                formatchanged = true;
            } else if (extName.equals("pptx")) {
                extName = "ppt";
                formatchanged = true;
            } else if (extName.equals("xlsx")) {
                extName = "xls";
                formatchanged = true;
            }

            scenario = FileUtil.getFileExtName(file).toLowerCase() + " to " + extName;

            int dotIndex = file.lastIndexOf(".");
            String pre = file.substring(0, dotIndex + 1);
            String newfile = pre + extName;

            String saveTo = reportDir + File.separator + file;
            if (formatchanged)
                saveTo = reportDir + File.separator + newfile;
            // Save the text document
            deleteFile(saveTo);
            SaveAs(saveTo);
            Close();
            if(!Open(saveTo))
                return false;

            String exception = "";
            String resultflag = "";
            try {
                Close();
                resultflag = "Pass";
            } catch (Exception e) {
                exception = e.getMessage();
                resultflag = "Fail";
            }

            File targetFile = new File(saveTo);
            result.addRow("data", sourceFile.getCanonicalPath(),
                    sourceFile.length(), scenario, saveTo, targetFile.length(),
                    resultflag, exception);

            return true;
        } catch (Exception e) {
            try {
                String exception = e.getMessage();
                if (exception == null || exception.isEmpty())
                    exception = "Saving to the same format";
                result.addRow("data", sourceFile.getCanonicalPath(),
                        sourceFile.length(), scenario, "", "", "Fail", exception);
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }

            return false;
        }
    }

    private boolean savetodiffformat(String file, String outpath) {
        try {
            File reportDir = Testspace.getFile(outpath);

            String extName = FileUtil.getFileExtName(file).toLowerCase();

            String targetExtName = null;

            if (extName.equals("doc") || extName.equals("docx"))
                targetExtName = "odt";
            else if (extName.equals("ppt") || extName.equals("pptx"))
                targetExtName = "odp";
            else if (extName.equals("xls") || extName.equals("xlsx"))
                targetExtName = "ods";
            else if (extName.equals("odt"))
                targetExtName = "doc";
            else if (extName.equals("odp"))
                targetExtName = "ppt";
            else if (extName.equals("ods"))
                targetExtName = "xls";

            scenario = extName + " to " + targetExtName;

            int dotIndex = file.lastIndexOf(".");
            String pre = file.substring(0, dotIndex + 1);
            String saveTo = reportDir + File.separator + pre + targetExtName;
            deleteFile(saveTo);
            // long base = System.currentTimeMillis();
            SaveAs(saveTo);
            Close();
            if(!Open(saveTo))
                return false;

            String exception = "";
            String resultflag = "";
            try {
                Close();
                resultflag = "Pass";
            } catch (Exception e) {
                exception = e.getMessage();
                resultflag = "Fail";
            }

            File targetFile = new File(saveTo);
            result.addRow("data", sourceFile.getCanonicalPath(),
                    sourceFile.length(), scenario, saveTo, targetFile.length(),
                    resultflag, exception);

            return true;
        } catch (Exception e) {
            try {
                String exception = e.getMessage();
                if (exception == null || exception.isEmpty())
                    exception = "Saving to a different format";
                result.addRow("data", sourceFile.getCanonicalPath(),
                        sourceFile.length(), scenario, "", "", "Fail", exception);
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }

            return false;
        }

    }

    private void Close() throws Exception {
        close();
        HandleBlockers(false);
    }

    public static void HandleBlockers(final boolean Positive) throws Exception {
        new Condition() {
            @Override
            public boolean value() {
                while (activeMsgBox.exists()) {

                    String context = activeMsgBox.getMessage();
                    if (context.toLowerCase().indexOf("has been modified") >= 0
                            && context.toLowerCase().indexOf(
                                    "do you want to save your changes") >= 0)
                        throw new RuntimeException("A wrong dirty flag");
                    if (context.toLowerCase().indexOf("read-error") >= 0)
                        throw new RuntimeException("Read Error");
                    if (context.toLowerCase().indexOf("does not exist") >= 0)
                        throw new RuntimeException("File not exist");

                    try {
                        if (Positive)
                            activeMsgBox.ok();
                        else
                            activeMsgBox.no();
                    } catch (Exception e) {
                        try {
                            if (Positive)
                                activeMsgBox.yes();
                            else
                                activeMsgBox.no();
                        } catch (Exception e1) {
                            try {
                                activeMsgBox.doDefault();
                            } catch (Exception e2) {
                                try {
                                    activeMsgBox.ok();
                                } catch (Exception e3) {
                                    activeMsgBox.yes();
                                }
                            }
                        }
                    }
                }
                if (passwdDlg.exists()) {
                    String caption = passwdDlg.getCaption();
                    if (caption.toLowerCase().indexOf(
                            "enter password to open file") >= 0)
                        throw new RuntimeException("A password protected file");
                    if (caption.toLowerCase().indexOf("properties") >= 0)
                        throw new RuntimeException("An unsupported format");
                    if (SupportedFormats(caption))
                        throw new RuntimeException("An unreadable file");
                }
                return true;
            }

        }.test(timeout, interval);
    }

    private static boolean SupportedFormats(String filename) {
        if (filename.endsWith(".doc") || filename.endsWith(".docx")
                || filename.endsWith(".dot") || filename.endsWith(".xls")
                || filename.endsWith(".xlsx") || filename.endsWith(".ods")
                || filename.endsWith(".ppt") || filename.endsWith(".pptx")
                || filename.endsWith(".odp")) {
            return true;
        } else {
            return false;
        }
    }

    private void SaveAs(String newfile) throws Exception {
        saveAs(newfile);
        HandleBlockers(true);
        if(statusBar.exists(timeout))
            statusBar.waitForEnabled(timeout, interval);
        else
            throw new TimeoutException("time out");
    }

    private boolean savetopdfformat(String file, String outpath) {
        try {
            File reportDir = Testspace.getFile(outpath);
            String extName = "pdf";

            int dotIndex = file.lastIndexOf(".");
            String pre = file.substring(0, dotIndex + 1);
            String newfile = pre + extName;

            scenario = FileUtil.getFileExtName(file).toLowerCase() + " to pdf";

            String saveTo = reportDir + File.separator + newfile;
            // Save the text document
            app.dispatch(".uno:ExportToPDF");
            pdfGeneralPage.ok();

            submitSaveDlg(saveTo);
            HandleBlockers(true);

            if(statusBar.exists(timeout))
                statusBar.waitForEnabled(timeout, interval);
            else
                throw new TimeoutException("time out");

            String outcome = "Pass";
            try {
                Close();
            } catch (Exception e) {
                if (!e.getMessage().matches("A wrong dirty flag"))
                    outcome = e.getMessage();
                else
                    throw e;
            }


            File targetFile = new File(saveTo);
            result.addRow("data", sourceFile.getCanonicalPath(),
                    sourceFile.length(), scenario, saveTo, targetFile.length(),
                    outcome);

            return true;
        } catch (Exception e) {
            try {
                String reason = e.getMessage();
                if (reason == null || reason.isEmpty())
                    reason = "Exporting to pdf format";
                result.addRow("data", sourceFile.getCanonicalPath(),
                        sourceFile.length(), scenario, "", "", "Fail", reason);
            } catch (IOException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }

            return false;
        }
    }

}