/************************************************************** | |
* | |
* 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 fvt.uno.ffc; | |
import java.io.File; | |
import java.io.FilenameFilter; | |
import java.util.HashMap; | |
import java.util.List; | |
import java.util.Map; | |
import java.util.logging.Level; | |
import junit.framework.Assert; | |
import org.junit.After; | |
import org.junit.Before; | |
import org.junit.BeforeClass; | |
import org.junit.Ignore; | |
import org.junit.Rule; | |
import org.junit.Test; | |
import org.junit.runner.RunWith; | |
import org.openoffice.test.OpenOffice; | |
import org.openoffice.test.common.FileProvider; | |
import org.openoffice.test.common.FileProvider.FileRepos; | |
import org.openoffice.test.common.FileUtil; | |
import org.openoffice.test.common.Logger; | |
import org.openoffice.test.common.SystemUtil; | |
import org.openoffice.test.common.Testspace; | |
import org.openoffice.test.uno.UnoApp; | |
import com.sun.star.beans.PropertyValue; | |
import com.sun.star.document.MacroExecMode; | |
import com.sun.star.frame.XComponentLoader; | |
import com.sun.star.frame.XStorable; | |
import com.sun.star.io.IOException; | |
import com.sun.star.lang.IllegalArgumentException; | |
import com.sun.star.lang.XComponent; | |
import com.sun.star.uno.UnoRuntime; | |
/** | |
* Pls place a suite file in directory "suite" which is same level with test uno. like bewlow | |
* -suite | |
* -testuno | |
* The suite file content is like this format | |
* ftp://user:password@192.168.0.1/public/sample/testsample.doc | |
* .. | |
* .. | |
* ftp://user:password@192.168.0.1/public/sample/testsample2.doc | |
*This script is used to test FFC by UNO API | |
*It cover below scenario: | |
*MS2003/2010 format->ODF format | |
*New Saved ODF Format file -> MS 2003 Format | |
*New Saved ODF Format file -> PDF | |
* | |
*/ | |
@RunWith(FileProvider.class) | |
public class FFCTest { | |
@Rule | |
public Logger log = Logger.getLogger(this, false); | |
private static UnoApp app = null; | |
private static Map<String, String> filterMap = new HashMap<String, String>(); | |
@FileRepos | |
public static String suiteDir = "../suite/"; | |
private String fileURL = ""; | |
private String operateFilePath = ""; | |
private static Map<String, String> formatMap = new HashMap<String, String>(); | |
private static File testSpaceFile = Testspace.getFile(); | |
private boolean isSucceed = false; | |
private static String tempFolder = testSpaceFile.getAbsolutePath() + File.separator + "temp"; | |
private static String failedFilesDir = "output/failedSampleFiles/"; | |
private String runedScenarios = ""; | |
public FFCTest(String url) { | |
this.fileURL = url; | |
} | |
@BeforeClass | |
public static void init() { | |
initMap(); | |
File failedDirec = Testspace.getFile(failedFilesDir); | |
FileUtil.deleteFile(failedDirec); | |
//Disable automation | |
OpenOffice defaultOpenOffice = new OpenOffice(); | |
defaultOpenOffice.addArgs("-nofirststartwizard", "-norestore", "-quickstart=no"); | |
defaultOpenOffice.setUnoUrl(OpenOffice.DEFAULT_UNO_URL); | |
defaultOpenOffice.addArgs("-invisible", "-conversionmode", "-headless", "-hidemenu"); | |
app = new UnoApp(defaultOpenOffice); | |
failedDirec.mkdirs(); | |
} | |
@Before | |
public void setUp() throws Exception { | |
operateFilePath = Testspace.prepareData(fileURL); | |
runedScenarios = ""; | |
app.start(); | |
} | |
@After | |
public void tearDown() throws Exception { | |
if (!isSucceed) { | |
FileUtil.copyFile(operateFilePath, Testspace.getFile(failedFilesDir).getAbsolutePath()); | |
FileUtil.appendStringToFile( Testspace.getFile(failedFilesDir + File.separator + "failedFiles.files").getAbsolutePath(), fileURL +"\r\n"); | |
String failedMessage = fileURL +"\r\n" + runedScenarios; | |
FileUtil.appendStringToFile( Testspace.getFile(failedFilesDir + File.separator + "failedFiles_scenarios.files").getAbsolutePath(), failedMessage); | |
app.close(); | |
SystemUtil.killProcess("WerFault.*"); | |
SystemUtil.sleep(2); | |
SystemUtil.killProcess("EQNEDT32.*"); | |
//WerFault.exe | |
//EQNEDT32.EXE | |
} | |
} | |
@Test(timeout=1000*60*10) | |
@Ignore | |
public void exportTest() throws Exception { | |
//MS Office Format ->ODF | |
boolean flag = false; | |
String saveAsODF = exportAsODF(operateFilePath); | |
System.out.println("MS ->ODF finished"); | |
runedScenarios = "MS ->ODF finished" + "\r\n"; | |
//ODF->MS | |
String savedMSFilePath = exportAsODF(saveAsODF); | |
File savedMSFile = new File(savedMSFilePath); | |
Assert.assertTrue("FFC Test for file : "+ savedMSFilePath, savedMSFile.exists()); | |
System.out.println("ODF->MS Finished"); | |
runedScenarios = runedScenarios + "ODF->MS Finished" + "\r\n"; | |
//Export ODF->PDF | |
exportAsPDF(saveAsODF); | |
System.out.println("ODF->PDF Finished"); | |
runedScenarios = runedScenarios + "ODF->PDF Finished" + "\r\n"; | |
flag = true; | |
Assert.assertTrue("FFC Test for file : "+ operateFilePath, flag); | |
isSucceed = true; | |
} | |
private String getSuffix(String file) { | |
String lowerCaseName = file.toLowerCase(); | |
String suffix = lowerCaseName.substring(lowerCaseName.lastIndexOf(".")); | |
return suffix; | |
} | |
/** | |
* return the Export ODF file path | |
* @throws IOException | |
* @throws IllegalArgumentException | |
*/ | |
private String exportAsODF(String testFile) throws IOException, IllegalArgumentException { | |
XComponent document = loadSampleFile(testFile); | |
try { | |
Thread.sleep(2000); | |
} catch (InterruptedException e) { | |
e.printStackTrace(); | |
} | |
String suffix = getSuffix(testFile); | |
String filterName = filterMap.get(suffix); | |
PropertyValue[] lProperties = null; | |
lProperties = new PropertyValue[3]; | |
lProperties[0] = new PropertyValue(); | |
lProperties[0].Name = "FilterName"; | |
lProperties[0].Value = filterName; | |
lProperties[1] = new PropertyValue(); | |
lProperties[1].Name = "Overwrite"; | |
lProperties[1].Value = Boolean.TRUE; | |
lProperties[2] = new PropertyValue(); | |
lProperties[2].Name = "AsyncMode"; | |
lProperties[2].Value = new Boolean(false); | |
XStorable store = (XStorable) UnoRuntime.queryInterface(XStorable.class, document); | |
File file = new File(testFile); | |
String fileName = file.getName(); | |
String saveAsFilePath = file.getParentFile().getAbsolutePath() + File.separator + fileName + "." + formatMap.get(suffix);//TODO | |
store.storeAsURL(Testspace.getUrl(saveAsFilePath), lProperties); | |
try { | |
Thread.sleep(3000); | |
} catch (InterruptedException e) { | |
e.printStackTrace(); | |
} | |
app.closeDocument(document); | |
try { | |
Thread.sleep(2000); | |
} catch (InterruptedException e) { | |
e.printStackTrace(); | |
} | |
return saveAsFilePath; | |
} | |
private void exportAsPDF(String testFilePath) throws Exception { | |
XComponent xComponent = loadSampleFile(testFilePath); | |
XStorable xStorable = (XStorable) UnoRuntime.queryInterface( | |
XStorable.class, xComponent); | |
PropertyValue[] aMediaDescriptor = new PropertyValue[1]; | |
aMediaDescriptor[0] = new PropertyValue(); | |
aMediaDescriptor[0].Name = "FilterName"; | |
aMediaDescriptor[0].Value = "writer_pdf_Export"; | |
File file = new File(testFilePath); | |
String fileName = file.getName(); | |
String saveAsFilePath = file.getParentFile().getAbsolutePath() + File.separator + fileName + ".pdf" ; | |
// export to pdf | |
xStorable.storeToURL(Testspace.getUrl(saveAsFilePath), aMediaDescriptor); | |
try { | |
Thread.sleep(5000); | |
} catch (InterruptedException e) { | |
e.printStackTrace(); | |
} | |
// close this document | |
app.closeDocument(xComponent); | |
File pdfFile = new File(saveAsFilePath); | |
Assert.assertTrue("Verify sampe file " + testFilePath + " exprot to pdf!", pdfFile.exists()); | |
} | |
public static void initMap() { | |
filterMap.put(".doc", "writer8"); | |
filterMap.put(".docx", "writer8"); | |
filterMap.put(".odt", "MS Word 97"); | |
filterMap.put(".ppt", "impress8"); | |
filterMap.put(".pptx", "impress8"); | |
filterMap.put(".odp", "MS PowerPoint 97"); | |
filterMap.put(".xls", "calc8"); | |
filterMap.put(".xlsx", "calc8"); | |
filterMap.put(".ods", "MS Excel 97"); | |
formatMap.put(".doc", "odt"); | |
formatMap.put(".docx", "odt"); | |
formatMap.put(".odt", "doc"); | |
formatMap.put(".ppt", "odp"); | |
formatMap.put(".pptx", "odp"); | |
formatMap.put(".odp", "ppt"); | |
formatMap.put(".xls", "ods"); | |
formatMap.put(".xlsx", "ods"); | |
formatMap.put(".ods", "xls"); | |
} | |
private XComponent loadSampleFile(String filePath) throws IOException, IllegalArgumentException { | |
if (!"".equals(filePath)) { | |
PropertyValue[] loadProps = null; | |
if (filePath.endsWith("x")) {//ooxml sample file | |
loadProps = new PropertyValue[4]; | |
loadProps[0] = new PropertyValue(); | |
loadProps[0].Name = "Hidden"; | |
loadProps[0].Value = Boolean.TRUE; | |
loadProps[1] = new PropertyValue(); | |
loadProps[1].Name = "FilterName"; | |
String filePathLowCase = filePath.toLowerCase(); | |
if(filePathLowCase.endsWith("docx")) { | |
loadProps[1].Value = "MS Word 2007 XML"; | |
} | |
if(filePathLowCase.endsWith("pptx")){ | |
loadProps[1].Value = "MS PowerPoint 2007 XML"; | |
} | |
if(filePathLowCase.endsWith("xlsx")) { | |
loadProps[1].Value = "MS Excel 2007 XML"; | |
} | |
loadProps[2] = new PropertyValue(); | |
loadProps[2].Name = "ReadOnly"; | |
loadProps[2].Value = true; | |
loadProps[3] = new PropertyValue(); | |
loadProps[3].Name = "MacroExecutionMode"; | |
loadProps[3].Value = MacroExecMode.NEVER_EXECUTE; | |
} else { | |
loadProps = new PropertyValue[3]; | |
loadProps[0] = new PropertyValue(); | |
loadProps[0].Name = "Hidden"; | |
loadProps[0].Value = Boolean.TRUE; | |
loadProps[1] = new PropertyValue(); | |
loadProps[1].Name = "ReadOnly"; | |
loadProps[1].Value = Boolean.TRUE; | |
loadProps[2] = new PropertyValue(); | |
loadProps[2].Name = "AsyncMode"; | |
loadProps[2].Value = new Boolean(false); | |
} | |
String urlPath = Testspace.getUrl(filePath); | |
XComponentLoader componentLoader = (XComponentLoader) UnoRuntime.queryInterface(XComponentLoader.class, app.getDesktop()); | |
return componentLoader.loadComponentFromURL(urlPath, "_blank", 0, loadProps); | |
} | |
return null; | |
} | |
/** | |
* the url is like this format: | |
* ftp://user:password@192.168.0.1/public/sample/testsample.doc | |
* @param url | |
* @return | |
*/ | |
public String downloadFile(String url) { | |
File urlFile = new File( new File(url.replaceAll("%20", " ")).getName()); | |
File tempFolderFile = new File(tempFolder); | |
if (!tempFolderFile.exists()) { | |
tempFolderFile.mkdir(); | |
} | |
String testFile = testSpaceFile.getAbsolutePath() + File.separator + "temp" + File.separator + urlFile.getName(); | |
FileUtil.download(url, new File(testFile)); | |
return testFile; | |
} | |
} |