1*b1cdbd2cSJim Jagielski /************************************************************** 2*b1cdbd2cSJim Jagielski * 3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one 4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file 5*b1cdbd2cSJim Jagielski * distributed with this work for additional information 6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file 7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the 8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance 9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at 10*b1cdbd2cSJim Jagielski * 11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0 12*b1cdbd2cSJim Jagielski * 13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing, 14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an 15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the 17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations 18*b1cdbd2cSJim Jagielski * under the License. 19*b1cdbd2cSJim Jagielski * 20*b1cdbd2cSJim Jagielski *************************************************************/ 21*b1cdbd2cSJim Jagielski 22*b1cdbd2cSJim Jagielski 23*b1cdbd2cSJim Jagielski package complex.memCheck; 24*b1cdbd2cSJim Jagielski 25*b1cdbd2cSJim Jagielski import com.sun.star.beans.PropertyValue; 26*b1cdbd2cSJim Jagielski import com.sun.star.frame.XStorable; 27*b1cdbd2cSJim Jagielski import com.sun.star.lang.XComponent; 28*b1cdbd2cSJim Jagielski import com.sun.star.lang.XMultiServiceFactory; 29*b1cdbd2cSJim Jagielski import com.sun.star.uno.UnoRuntime; 30*b1cdbd2cSJim Jagielski import com.sun.star.util.XCloseable; 31*b1cdbd2cSJim Jagielski // import complexlib.ComplexTestCase; 32*b1cdbd2cSJim Jagielski import helper.ProcessHandler; 33*b1cdbd2cSJim Jagielski import java.io.File; 34*b1cdbd2cSJim Jagielski // import java.io.FilePermission; 35*b1cdbd2cSJim Jagielski import java.io.FileWriter; 36*b1cdbd2cSJim Jagielski import java.io.FilenameFilter; 37*b1cdbd2cSJim Jagielski import java.io.PrintWriter; 38*b1cdbd2cSJim Jagielski import java.util.Enumeration; 39*b1cdbd2cSJim Jagielski import java.util.StringTokenizer; 40*b1cdbd2cSJim Jagielski import java.util.Vector; 41*b1cdbd2cSJim Jagielski import lib.*; 42*b1cdbd2cSJim Jagielski import util.DesktopTools; 43*b1cdbd2cSJim Jagielski // import util.WriterTools; 44*b1cdbd2cSJim Jagielski 45*b1cdbd2cSJim Jagielski import org.junit.After; 46*b1cdbd2cSJim Jagielski import org.junit.AfterClass; 47*b1cdbd2cSJim Jagielski import org.junit.Before; 48*b1cdbd2cSJim Jagielski import org.junit.BeforeClass; 49*b1cdbd2cSJim Jagielski import org.junit.Test; 50*b1cdbd2cSJim Jagielski import org.openoffice.test.OfficeConnection; 51*b1cdbd2cSJim Jagielski import static org.junit.Assert.*; 52*b1cdbd2cSJim Jagielski 53*b1cdbd2cSJim Jagielski /** 54*b1cdbd2cSJim Jagielski * Documents are opened and exported with StarOffice. The memory usage of 55*b1cdbd2cSJim Jagielski * StarOffice is monitored and if the usage exceeds the allowed kilobytes, 56*b1cdbd2cSJim Jagielski * the test is failed. Used for monitoring the StarOffice process is the 57*b1cdbd2cSJim Jagielski * command line tool 'pmap', available on Solaris or Linux. This test will not 58*b1cdbd2cSJim Jagielski * run on Windows.<br>Test procedure: every given document type is searched in 59*b1cdbd2cSJim Jagielski * the source directory 60*b1cdbd2cSJim Jagielski * Needed paramters: 61*b1cdbd2cSJim Jagielski * <ul> 62*b1cdbd2cSJim Jagielski * <li>"TestDocumentPath" - the path where test documents are located.</li> 63*b1cdbd2cSJim Jagielski * <li>"AllowMemoryIncrease" (optional) - the allowed memory increase measured in kByte per exported document. The default is 10 kByte.</li> 64*b1cdbd2cSJim Jagielski * <li>"ExportDocCount" (optional) - the amount of exports for each document that is loaded. Is defaulted to 25. 65*b1cdbd2cSJim Jagielski * <li>"FileExportFilter" (optional) - a relation between loaded document type and used export filter. Is defaulted to 66*b1cdbd2cSJim Jagielski * writer, calc and impress. This parameter can be set with a number to give more than one relation. Example:<br> 67*b1cdbd2cSJim Jagielski * "FileExportFilter1=sxw,writer_pdf_Export"<br> 68*b1cdbd2cSJim Jagielski * "FileExportFilter2=sxc,calc_pdf_Export"<br> 69*b1cdbd2cSJim Jagielski * "FileExportFilter3=sxi,impress_pdf_Export"<br></li> 70*b1cdbd2cSJim Jagielski * All parameters are used for iteration over the test document path. 71*b1cdbd2cSJim Jagielski * </ul> 72*b1cdbd2cSJim Jagielski */ 73*b1cdbd2cSJim Jagielski class TempDir 74*b1cdbd2cSJim Jagielski { 75*b1cdbd2cSJim Jagielski 76*b1cdbd2cSJim Jagielski private String m_sTempDir; 77*b1cdbd2cSJim Jagielski TempDir(String _sTempDir)78*b1cdbd2cSJim Jagielski public TempDir(String _sTempDir) 79*b1cdbd2cSJim Jagielski { 80*b1cdbd2cSJim Jagielski m_sTempDir = _sTempDir; 81*b1cdbd2cSJim Jagielski } 82*b1cdbd2cSJim Jagielski getOfficeTempDir()83*b1cdbd2cSJim Jagielski public String getOfficeTempDir() 84*b1cdbd2cSJim Jagielski { 85*b1cdbd2cSJim Jagielski return m_sTempDir; 86*b1cdbd2cSJim Jagielski } 87*b1cdbd2cSJim Jagielski getTempDir()88*b1cdbd2cSJim Jagielski public String getTempDir() 89*b1cdbd2cSJim Jagielski { 90*b1cdbd2cSJim Jagielski final String sTempDir = FileHelper.getJavaCompatibleFilename(m_sTempDir); 91*b1cdbd2cSJim Jagielski return sTempDir; 92*b1cdbd2cSJim Jagielski } 93*b1cdbd2cSJim Jagielski } 94*b1cdbd2cSJim Jagielski 95*b1cdbd2cSJim Jagielski public class CheckMemoryUsage /* extends ComplexTestCase */ 96*b1cdbd2cSJim Jagielski 97*b1cdbd2cSJim Jagielski { 98*b1cdbd2cSJim Jagielski 99*b1cdbd2cSJim Jagielski private final String sWriterDoc = "sxw,writer_pdf_Export"; 100*b1cdbd2cSJim Jagielski private final String sCalcDoc = "sxc,calc_pdf_Export"; 101*b1cdbd2cSJim Jagielski private final String sImpressDoc = "sxi,impress_pdf_Export"; 102*b1cdbd2cSJim Jagielski // private String sProcessIdCommand = null; 103*b1cdbd2cSJim Jagielski TempDir m_aTempDir; 104*b1cdbd2cSJim Jagielski // private String sFS = null; 105*b1cdbd2cSJim Jagielski // private String sMemoryMap1 = null; 106*b1cdbd2cSJim Jagielski // private String sMemoryMap2 = null; 107*b1cdbd2cSJim Jagielski // private String sDocumentPath = ""; 108*b1cdbd2cSJim Jagielski private String[][] sDocTypeExportFilter; 109*b1cdbd2cSJim Jagielski private String[][] sDocuments; 110*b1cdbd2cSJim Jagielski private int iAllowMemoryIncrease = 10; 111*b1cdbd2cSJim Jagielski private int iExportDocCount = 25; 112*b1cdbd2cSJim Jagielski /** 113*b1cdbd2cSJim Jagielski * The test parameters 114*b1cdbd2cSJim Jagielski */ 115*b1cdbd2cSJim Jagielski private static TestParameters param = null; 116*b1cdbd2cSJim Jagielski 117*b1cdbd2cSJim Jagielski /** 118*b1cdbd2cSJim Jagielski * Get all test methods 119*b1cdbd2cSJim Jagielski * @return The test methods. 120*b1cdbd2cSJim Jagielski // */ 121*b1cdbd2cSJim Jagielski // public String[] getTestMethodNames() { 122*b1cdbd2cSJim Jagielski // return new String[] {"loadAndSaveDocuments"}; 123*b1cdbd2cSJim Jagielski // } 124*b1cdbd2cSJim Jagielski /** 125*b1cdbd2cSJim Jagielski * Collect all documnets to load and all filters used for export. 126*b1cdbd2cSJim Jagielski */ 127*b1cdbd2cSJim Jagielski @Before before()128*b1cdbd2cSJim Jagielski public void before() 129*b1cdbd2cSJim Jagielski { 130*b1cdbd2cSJim Jagielski 131*b1cdbd2cSJim Jagielski final XMultiServiceFactory xMsf = getMSF(); 132*b1cdbd2cSJim Jagielski 133*b1cdbd2cSJim Jagielski // some Tests need the qadevOOo TestParameters, it is like a Hashmap for Properties. 134*b1cdbd2cSJim Jagielski param = new TestParameters(); 135*b1cdbd2cSJim Jagielski param.put("ServiceFactory", xMsf); // some qadevOOo functions need the ServiceFactory 136*b1cdbd2cSJim Jagielski 137*b1cdbd2cSJim Jagielski // test does definitely not run on Windows. 138*b1cdbd2cSJim Jagielski if (param.get("OperatingSystem").equals("wntmsci")) 139*b1cdbd2cSJim Jagielski { 140*b1cdbd2cSJim Jagielski System.out.println("Test can only reasonably be executed with a tool that " 141*b1cdbd2cSJim Jagielski + "displays the memory usage of StarOffice."); 142*b1cdbd2cSJim Jagielski System.out.println("Test does not run on Windows, only on Solaris or Linux."); 143*b1cdbd2cSJim Jagielski // in an automatic environment it is better to say, there is no error here. 144*b1cdbd2cSJim Jagielski // it is a limitation, but no error. 145*b1cdbd2cSJim Jagielski System.exit(0); 146*b1cdbd2cSJim Jagielski } 147*b1cdbd2cSJim Jagielski 148*b1cdbd2cSJim Jagielski 149*b1cdbd2cSJim Jagielski // how many times is every document exported. 150*b1cdbd2cSJim Jagielski int count = param.getInt("ExportDocCount"); 151*b1cdbd2cSJim Jagielski if (count != 0) 152*b1cdbd2cSJim Jagielski { 153*b1cdbd2cSJim Jagielski iExportDocCount = count; 154*b1cdbd2cSJim Jagielski } 155*b1cdbd2cSJim Jagielski 156*b1cdbd2cSJim Jagielski // get the temp dir for creating the command scripts. 157*b1cdbd2cSJim Jagielski // sTempDir = System.getProperty("java.io.tmpdir"); 158*b1cdbd2cSJim Jagielski m_aTempDir = new TempDir(util.utils.getOfficeTemp/*Dir*/(xMsf)); 159*b1cdbd2cSJim Jagielski 160*b1cdbd2cSJim Jagielski // get the file extension, export filter connection 161*b1cdbd2cSJim Jagielski Enumeration keys = param.keys(); 162*b1cdbd2cSJim Jagielski Vector<String> v = new Vector<String>(); 163*b1cdbd2cSJim Jagielski while (keys.hasMoreElements()) 164*b1cdbd2cSJim Jagielski { 165*b1cdbd2cSJim Jagielski String key = (String) keys.nextElement(); 166*b1cdbd2cSJim Jagielski if (key.startsWith("FileExportFilter")) 167*b1cdbd2cSJim Jagielski { 168*b1cdbd2cSJim Jagielski v.add((String) param.get(key)); 169*b1cdbd2cSJim Jagielski } 170*b1cdbd2cSJim Jagielski } 171*b1cdbd2cSJim Jagielski // if no param given, set defaults. 172*b1cdbd2cSJim Jagielski if (v.size() == 0) 173*b1cdbd2cSJim Jagielski { 174*b1cdbd2cSJim Jagielski v.add(sWriterDoc); 175*b1cdbd2cSJim Jagielski v.add(sCalcDoc); 176*b1cdbd2cSJim Jagielski v.add(sImpressDoc); 177*b1cdbd2cSJim Jagielski } 178*b1cdbd2cSJim Jagielski // store a file extension 179*b1cdbd2cSJim Jagielski sDocTypeExportFilter = new String[v.size()][2]; 180*b1cdbd2cSJim Jagielski for (int i = 0; i < v.size(); i++) 181*b1cdbd2cSJim Jagielski { 182*b1cdbd2cSJim Jagielski // 2do: error routine for wrong given params 183*b1cdbd2cSJim Jagielski final String sVContent = v.get(i); 184*b1cdbd2cSJim Jagielski StringTokenizer t = new StringTokenizer(sVContent, ","); 185*b1cdbd2cSJim Jagielski final String sExt = t.nextToken(); 186*b1cdbd2cSJim Jagielski final String sName = t.nextToken(); 187*b1cdbd2cSJim Jagielski sDocTypeExportFilter[i][0] = sExt; 188*b1cdbd2cSJim Jagielski sDocTypeExportFilter[i][1] = sName; 189*b1cdbd2cSJim Jagielski } 190*b1cdbd2cSJim Jagielski 191*b1cdbd2cSJim Jagielski // get files to load and export 192*b1cdbd2cSJim Jagielski // sDocumentPath = (String) param.get("TestDocumentPath"); 193*b1cdbd2cSJim Jagielski String sDocumentPath = TestDocument.getUrl(); 194*b1cdbd2cSJim Jagielski File f = new File(FileHelper.getJavaCompatibleFilename(sDocumentPath)); 195*b1cdbd2cSJim Jagielski // sDocumentPath = f.getAbsolutePath(); 196*b1cdbd2cSJim Jagielski // String sFS = System.getProperty("file.separator"); 197*b1cdbd2cSJim Jagielski sDocuments = new String[sDocTypeExportFilter.length][]; 198*b1cdbd2cSJim Jagielski for (int j = 0; j < sDocTypeExportFilter.length; j++) 199*b1cdbd2cSJim Jagielski { 200*b1cdbd2cSJim Jagielski FileFilter filter = new FileFilter(sDocTypeExportFilter[j][0]); 201*b1cdbd2cSJim Jagielski String[] doc = f.list(filter); 202*b1cdbd2cSJim Jagielski sDocuments[j] = new String[doc.length]; 203*b1cdbd2cSJim Jagielski for (int i = 0; i < doc.length; i++) 204*b1cdbd2cSJim Jagielski { 205*b1cdbd2cSJim Jagielski // final String sDocument = FileHelper.appendPath(sDocumentPath, doc[i]); 206*b1cdbd2cSJim Jagielski // sDocuments[j][i] = utils.getFullURL(sDocuments[j][i]); 207*b1cdbd2cSJim Jagielski sDocuments[j][i] = TestDocument.getUrl(doc[i]); 208*b1cdbd2cSJim Jagielski } 209*b1cdbd2cSJim Jagielski } 210*b1cdbd2cSJim Jagielski } 211*b1cdbd2cSJim Jagielski 212*b1cdbd2cSJim Jagielski /** 213*b1cdbd2cSJim Jagielski * delete all created files on disk 214*b1cdbd2cSJim Jagielski */ 215*b1cdbd2cSJim Jagielski @After after()216*b1cdbd2cSJim Jagielski public void after() 217*b1cdbd2cSJim Jagielski { 218*b1cdbd2cSJim Jagielski // delete the constructed files. 219*b1cdbd2cSJim Jagielski // we don't need to delete anything, all is stored in $USER_TREE 220*b1cdbd2cSJim Jagielski // for (int i = 0; i < iExportDocCount; i++) 221*b1cdbd2cSJim Jagielski // { 222*b1cdbd2cSJim Jagielski // final String sDocumentName = "DocExport" + i + ".pdf"; 223*b1cdbd2cSJim Jagielski // final String sFilename = FileHelper.appendPath(m_sTempDir, sDocumentName); 224*b1cdbd2cSJim Jagielski // File f = new File(FileHelper.getJavaCompatibleFilename(sFilename)); 225*b1cdbd2cSJim Jagielski // f.delete(); 226*b1cdbd2cSJim Jagielski // } 227*b1cdbd2cSJim Jagielski // File f = new File(sProcessIdCommand); 228*b1cdbd2cSJim Jagielski // f.delete(); 229*b1cdbd2cSJim Jagielski // f = new File(sOfficeMemoryCommand); 230*b1cdbd2cSJim Jagielski // f.delete(); 231*b1cdbd2cSJim Jagielski } 232*b1cdbd2cSJim Jagielski 233*b1cdbd2cSJim Jagielski /** 234*b1cdbd2cSJim Jagielski * The test function: load documents and save them using the given filters 235*b1cdbd2cSJim Jagielski * for each given document type. 236*b1cdbd2cSJim Jagielski */ 237*b1cdbd2cSJim Jagielski @Test loadAndSaveDocuments()238*b1cdbd2cSJim Jagielski public void loadAndSaveDocuments() 239*b1cdbd2cSJim Jagielski { 240*b1cdbd2cSJim Jagielski int nOk = 0; 241*b1cdbd2cSJim Jagielski int nRunThrough = 0; 242*b1cdbd2cSJim Jagielski 243*b1cdbd2cSJim Jagielski // At first: 244*b1cdbd2cSJim Jagielski // we load the document, there will be some post work in office like late initialisations 245*b1cdbd2cSJim Jagielski // we store exact one time the document 246*b1cdbd2cSJim Jagielski // so the memory footprint should be right 247*b1cdbd2cSJim Jagielski 248*b1cdbd2cSJim Jagielski // iterate over all document types 249*b1cdbd2cSJim Jagielski for (int k = 0; k < sDocTypeExportFilter.length; k++) 250*b1cdbd2cSJim Jagielski { 251*b1cdbd2cSJim Jagielski // iterate over all documents of this type 252*b1cdbd2cSJim Jagielski for (int i = 0; i < sDocuments[k].length; i++) 253*b1cdbd2cSJim Jagielski { 254*b1cdbd2cSJim Jagielski 255*b1cdbd2cSJim Jagielski final String sDocument = sDocuments[k][i]; 256*b1cdbd2cSJim Jagielski final String sExtension = sDocTypeExportFilter[k][1]; 257*b1cdbd2cSJim Jagielski 258*b1cdbd2cSJim Jagielski // OfficeMemchecker aChecker = new OfficeMemchecker(); 259*b1cdbd2cSJim Jagielski // aChecker.setDocumentName(FileHelper.getBasename(sDocument)); 260*b1cdbd2cSJim Jagielski // aChecker.setExtension(sExtension); 261*b1cdbd2cSJim Jagielski // aChecker.start(); 262*b1cdbd2cSJim Jagielski 263*b1cdbd2cSJim Jagielski loadAndSaveNTimesDocument(sDocument, 1, sExtension); 264*b1cdbd2cSJim Jagielski 265*b1cdbd2cSJim Jagielski // nOk += checkMemory(aChecker); 266*b1cdbd2cSJim Jagielski // nRunThrough ++; 267*b1cdbd2cSJim Jagielski } 268*b1cdbd2cSJim Jagielski System.out.println(); 269*b1cdbd2cSJim Jagielski System.out.println(); 270*b1cdbd2cSJim Jagielski } 271*b1cdbd2cSJim Jagielski 272*b1cdbd2cSJim Jagielski shortWait(10000); 273*b1cdbd2cSJim Jagielski 274*b1cdbd2cSJim Jagielski // Now the real test, load document and store 25 times 275*b1cdbd2cSJim Jagielski 276*b1cdbd2cSJim Jagielski // iterate over all document types 277*b1cdbd2cSJim Jagielski for (int k = 0; k < sDocTypeExportFilter.length; k++) 278*b1cdbd2cSJim Jagielski { 279*b1cdbd2cSJim Jagielski // iterate over all documents of this type 280*b1cdbd2cSJim Jagielski for (int i = 0; i < sDocuments[k].length; i++) 281*b1cdbd2cSJim Jagielski { 282*b1cdbd2cSJim Jagielski 283*b1cdbd2cSJim Jagielski final String sDocument = sDocuments[k][i]; 284*b1cdbd2cSJim Jagielski final String sExtension = sDocTypeExportFilter[k][1]; 285*b1cdbd2cSJim Jagielski 286*b1cdbd2cSJim Jagielski OfficeMemchecker aChecker = new OfficeMemchecker(); 287*b1cdbd2cSJim Jagielski aChecker.setDocumentName(FileHelper.getBasename(sDocument)); 288*b1cdbd2cSJim Jagielski aChecker.setExtension(sExtension); 289*b1cdbd2cSJim Jagielski aChecker.start(); 290*b1cdbd2cSJim Jagielski 291*b1cdbd2cSJim Jagielski loadAndSaveNTimesDocument(sDocument, iExportDocCount, sExtension); 292*b1cdbd2cSJim Jagielski 293*b1cdbd2cSJim Jagielski aChecker.stop(); 294*b1cdbd2cSJim Jagielski final int nConsumMore = aChecker.getConsumMore(); 295*b1cdbd2cSJim Jagielski 296*b1cdbd2cSJim Jagielski nOk += checkMemory(nConsumMore); 297*b1cdbd2cSJim Jagielski nRunThrough++; 298*b1cdbd2cSJim Jagielski } 299*b1cdbd2cSJim Jagielski System.out.println(); 300*b1cdbd2cSJim Jagielski System.out.println(); 301*b1cdbd2cSJim Jagielski } 302*b1cdbd2cSJim Jagielski System.out.println("Find the output of used 'pmap' here: " + m_aTempDir.getTempDir() + " if test failed."); 303*b1cdbd2cSJim Jagielski assertTrue("Office consumes too many memory.", nOk == nRunThrough); 304*b1cdbd2cSJim Jagielski } 305*b1cdbd2cSJim Jagielski 306*b1cdbd2cSJim Jagielski /** 307*b1cdbd2cSJim Jagielski * Checks how much memory should consum 308*b1cdbd2cSJim Jagielski * @param storageBefore 309*b1cdbd2cSJim Jagielski * @return 1 if consum is ok, else 0 310*b1cdbd2cSJim Jagielski */ checkMemory(int nConsumMore)311*b1cdbd2cSJim Jagielski private int checkMemory(int nConsumMore) 312*b1cdbd2cSJim Jagielski { 313*b1cdbd2cSJim Jagielski int nAllowed = iAllowMemoryIncrease * iExportDocCount; 314*b1cdbd2cSJim Jagielski System.out.println("The Office consumes now " + nConsumMore 315*b1cdbd2cSJim Jagielski + "K more memory than at the start of the test; allowed were " 316*b1cdbd2cSJim Jagielski + nAllowed + "K."); 317*b1cdbd2cSJim Jagielski if (nConsumMore > nAllowed) 318*b1cdbd2cSJim Jagielski { 319*b1cdbd2cSJim Jagielski System.out.println("ERROR: This is not allowed."); 320*b1cdbd2cSJim Jagielski return 0; 321*b1cdbd2cSJim Jagielski } 322*b1cdbd2cSJim Jagielski System.out.println("OK."); 323*b1cdbd2cSJim Jagielski return 1; 324*b1cdbd2cSJim Jagielski } 325*b1cdbd2cSJim Jagielski 326*b1cdbd2cSJim Jagielski /** 327*b1cdbd2cSJim Jagielski * load and save exact one document 328*b1cdbd2cSJim Jagielski */ loadAndSaveNTimesDocument(String _sDocument, int _nCount, String _sStoreExtension)329*b1cdbd2cSJim Jagielski private void loadAndSaveNTimesDocument(String _sDocument, int _nCount, String _sStoreExtension) 330*b1cdbd2cSJim Jagielski { 331*b1cdbd2cSJim Jagielski System.out.println("Document: " + _sDocument); 332*b1cdbd2cSJim Jagielski XComponent xComponent = DesktopTools.loadDoc(getMSF(), _sDocument, null); 333*b1cdbd2cSJim Jagielski XStorable xStorable = UnoRuntime.queryInterface(XStorable.class, xComponent); 334*b1cdbd2cSJim Jagielski if (xStorable != null) 335*b1cdbd2cSJim Jagielski { 336*b1cdbd2cSJim Jagielski // export each document iExportDocCount times 337*b1cdbd2cSJim Jagielski for (int j = 0; j < _nCount; j++) 338*b1cdbd2cSJim Jagielski { 339*b1cdbd2cSJim Jagielski final String sDocumentName = FileHelper.getBasename(_sDocument) + "_" + j + ".pdf"; 340*b1cdbd2cSJim Jagielski final String sFilename = FileHelper.appendPath(m_aTempDir.getOfficeTempDir(), sDocumentName); 341*b1cdbd2cSJim Jagielski // String url = utils.getFullURL(sFilename); 342*b1cdbd2cSJim Jagielski String url = sFilename; // graphical.FileHelper.getFileURLFromSystemPath(sFilename); 343*b1cdbd2cSJim Jagielski try 344*b1cdbd2cSJim Jagielski { 345*b1cdbd2cSJim Jagielski PropertyValue[] props = new PropertyValue[1]; 346*b1cdbd2cSJim Jagielski props[0] = new PropertyValue(); 347*b1cdbd2cSJim Jagielski props[0].Name = "FilterName"; 348*b1cdbd2cSJim Jagielski // use export filter for this doc type 349*b1cdbd2cSJim Jagielski props[0].Value = _sStoreExtension; 350*b1cdbd2cSJim Jagielski xStorable.storeToURL(url, props); 351*b1cdbd2cSJim Jagielski } 352*b1cdbd2cSJim Jagielski catch (com.sun.star.io.IOException e) 353*b1cdbd2cSJim Jagielski { 354*b1cdbd2cSJim Jagielski fail("Could not store to '" + url + "'"); 355*b1cdbd2cSJim Jagielski } 356*b1cdbd2cSJim Jagielski } 357*b1cdbd2cSJim Jagielski // close the doc 358*b1cdbd2cSJim Jagielski XCloseable xCloseable = UnoRuntime.queryInterface(XCloseable.class, xStorable); 359*b1cdbd2cSJim Jagielski try 360*b1cdbd2cSJim Jagielski { 361*b1cdbd2cSJim Jagielski xCloseable.close(true); 362*b1cdbd2cSJim Jagielski } 363*b1cdbd2cSJim Jagielski catch (com.sun.star.util.CloseVetoException e) 364*b1cdbd2cSJim Jagielski { 365*b1cdbd2cSJim Jagielski e.printStackTrace(); 366*b1cdbd2cSJim Jagielski fail("Cannot close document: test is futile, Office will surely use more space."); 367*b1cdbd2cSJim Jagielski } 368*b1cdbd2cSJim Jagielski } 369*b1cdbd2cSJim Jagielski else 370*b1cdbd2cSJim Jagielski { 371*b1cdbd2cSJim Jagielski System.out.println("Cannot query for XStorable interface on document '" + _sDocument + "'"); 372*b1cdbd2cSJim Jagielski System.out.println(" -> Skipping storage."); 373*b1cdbd2cSJim Jagielski } 374*b1cdbd2cSJim Jagielski 375*b1cdbd2cSJim Jagielski } 376*b1cdbd2cSJim Jagielski 377*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------------- 378*b1cdbd2cSJim Jagielski private class OfficeMemchecker 379*b1cdbd2cSJim Jagielski { 380*b1cdbd2cSJim Jagielski 381*b1cdbd2cSJim Jagielski /** 382*b1cdbd2cSJim Jagielski * After called start() it contains the memory need at startup 383*b1cdbd2cSJim Jagielski */ 384*b1cdbd2cSJim Jagielski private int m_nMemoryStart; 385*b1cdbd2cSJim Jagielski /** 386*b1cdbd2cSJim Jagielski * After called stop() it contains the memory usage 387*b1cdbd2cSJim Jagielski */ 388*b1cdbd2cSJim Jagielski private int m_nMemoryUsage; 389*b1cdbd2cSJim Jagielski private String m_sDocumentName; 390*b1cdbd2cSJim Jagielski private String m_sExtension; 391*b1cdbd2cSJim Jagielski OfficeMemchecker()392*b1cdbd2cSJim Jagielski public OfficeMemchecker() 393*b1cdbd2cSJim Jagielski { 394*b1cdbd2cSJim Jagielski m_nMemoryStart = 0; 395*b1cdbd2cSJim Jagielski } 396*b1cdbd2cSJim Jagielski setDocumentName(String _sDocName)397*b1cdbd2cSJim Jagielski public void setDocumentName(String _sDocName) 398*b1cdbd2cSJim Jagielski { 399*b1cdbd2cSJim Jagielski m_sDocumentName = _sDocName; 400*b1cdbd2cSJim Jagielski } 401*b1cdbd2cSJim Jagielski setExtension(String _sExt)402*b1cdbd2cSJim Jagielski public void setExtension(String _sExt) 403*b1cdbd2cSJim Jagielski { 404*b1cdbd2cSJim Jagielski m_sExtension = _sExt; 405*b1cdbd2cSJim Jagielski } 406*b1cdbd2cSJim Jagielski start()407*b1cdbd2cSJim Jagielski public void start() 408*b1cdbd2cSJim Jagielski { 409*b1cdbd2cSJim Jagielski m_nMemoryStart = getOfficeMemoryUsage(createModeName("start", 0)); 410*b1cdbd2cSJim Jagielski } 411*b1cdbd2cSJim Jagielski createModeName(String _sSub, int _nCount)412*b1cdbd2cSJim Jagielski private String createModeName(String _sSub, int _nCount) 413*b1cdbd2cSJim Jagielski { 414*b1cdbd2cSJim Jagielski StringBuffer aBuf = new StringBuffer(); 415*b1cdbd2cSJim Jagielski aBuf.append(_sSub); 416*b1cdbd2cSJim Jagielski aBuf.append('_').append(m_sDocumentName).append('_').append(m_sExtension); 417*b1cdbd2cSJim Jagielski aBuf.append('_').append(_nCount); 418*b1cdbd2cSJim Jagielski return aBuf.toString(); 419*b1cdbd2cSJim Jagielski } 420*b1cdbd2cSJim Jagielski stop()421*b1cdbd2cSJim Jagielski public void stop() 422*b1cdbd2cSJim Jagielski { 423*b1cdbd2cSJim Jagielski // short wait for the office to 'calm down' and free some memory 424*b1cdbd2cSJim Jagielski shortWait(20000); 425*b1cdbd2cSJim Jagielski // wait util memory is not freed anymore. 426*b1cdbd2cSJim Jagielski int storageAfter = getOfficeMemoryUsage(createModeName("stop", 0)); 427*b1cdbd2cSJim Jagielski int mem = 0; 428*b1cdbd2cSJim Jagielski int count = 0; 429*b1cdbd2cSJim Jagielski while (storageAfter != mem && count < 10) 430*b1cdbd2cSJim Jagielski { 431*b1cdbd2cSJim Jagielski count++; 432*b1cdbd2cSJim Jagielski mem = storageAfter; 433*b1cdbd2cSJim Jagielski storageAfter = getOfficeMemoryUsage(createModeName("stop", count)); 434*b1cdbd2cSJim Jagielski shortWait(1000); 435*b1cdbd2cSJim Jagielski } 436*b1cdbd2cSJim Jagielski m_nMemoryUsage = (storageAfter - m_nMemoryStart); 437*b1cdbd2cSJim Jagielski } 438*b1cdbd2cSJim Jagielski getConsumMore()439*b1cdbd2cSJim Jagielski public int getConsumMore() 440*b1cdbd2cSJim Jagielski { 441*b1cdbd2cSJim Jagielski return m_nMemoryUsage; 442*b1cdbd2cSJim Jagielski } 443*b1cdbd2cSJim Jagielski 444*b1cdbd2cSJim Jagielski /** 445*b1cdbd2cSJim Jagielski * Get the process ID from the Office 446*b1cdbd2cSJim Jagielski * @return the Id as String 447*b1cdbd2cSJim Jagielski */ getOfficeProcessID()448*b1cdbd2cSJim Jagielski private String getOfficeProcessID() 449*b1cdbd2cSJim Jagielski { 450*b1cdbd2cSJim Jagielski String sProcessIdCommand = FileHelper.appendPath(m_aTempDir.getTempDir(), "getPS"); 451*b1cdbd2cSJim Jagielski final String sofficeArg = org.openoffice.test.Argument.get("soffice"); 452*b1cdbd2cSJim Jagielski final String sPSGrep = "ps -ef | grep $USER | grep <soffice>.bin | grep -v grep"; 453*b1cdbd2cSJim Jagielski final String sProcessId = sPSGrep.replaceAll("<soffice>", FileHelper.getJavaCompatibleFilename(sofficeArg)); 454*b1cdbd2cSJim Jagielski 455*b1cdbd2cSJim Jagielski createExecutableFile(sProcessIdCommand, sProcessId); 456*b1cdbd2cSJim Jagielski ProcessHandler processID = new ProcessHandler(sProcessIdCommand); 457*b1cdbd2cSJim Jagielski processID.noOutput(); 458*b1cdbd2cSJim Jagielski processID.executeSynchronously(); 459*b1cdbd2cSJim Jagielski String text = processID.getOutputText(); 460*b1cdbd2cSJim Jagielski if (text == null || text.equals("") || text.indexOf(' ') == -1) 461*b1cdbd2cSJim Jagielski { 462*b1cdbd2cSJim Jagielski fail("Could not determine Office process ID. Check " + sProcessIdCommand); 463*b1cdbd2cSJim Jagielski } 464*b1cdbd2cSJim Jagielski StringTokenizer aToken = new StringTokenizer(text); 465*b1cdbd2cSJim Jagielski // this is not nice, but ps gives the same output on every machine 466*b1cdbd2cSJim Jagielski aToken.nextToken(); 467*b1cdbd2cSJim Jagielski String id = aToken.nextToken(); 468*b1cdbd2cSJim Jagielski return id; 469*b1cdbd2cSJim Jagielski } 470*b1cdbd2cSJim Jagielski 471*b1cdbd2cSJim Jagielski /** 472*b1cdbd2cSJim Jagielski * Get the memory usage of the Office in KByte. 473*b1cdbd2cSJim Jagielski * @return The memory used by the Office. 474*b1cdbd2cSJim Jagielski */ getOfficeMemoryUsage(String _sMode)475*b1cdbd2cSJim Jagielski private int getOfficeMemoryUsage(String _sMode) 476*b1cdbd2cSJim Jagielski { 477*b1cdbd2cSJim Jagielski final String sMemoryMonitor = "pmap <processID> |tee <pmapoutputfile> | grep total"; 478*b1cdbd2cSJim Jagielski String sOfficeMemoryCommand = null; 479*b1cdbd2cSJim Jagielski sOfficeMemoryCommand = FileHelper.appendPath(m_aTempDir.getTempDir(), "getPmap"); 480*b1cdbd2cSJim Jagielski // sOfficeMemoryCommand = FileHelper.getJavaCompatibleFilename(sOfficeMemoryCommand); 481*b1cdbd2cSJim Jagielski String command = sMemoryMonitor.replaceAll("<processID>", getOfficeProcessID()); 482*b1cdbd2cSJim Jagielski String sPmapOutputFile = FileHelper.appendPath(m_aTempDir.getTempDir(), "pmap_" + _sMode + ".txt"); 483*b1cdbd2cSJim Jagielski command = command.replaceAll("<pmapoutputfile>", sPmapOutputFile); 484*b1cdbd2cSJim Jagielski createExecutableFile(sOfficeMemoryCommand, command); 485*b1cdbd2cSJim Jagielski 486*b1cdbd2cSJim Jagielski ProcessHandler processID = new ProcessHandler(sOfficeMemoryCommand); 487*b1cdbd2cSJim Jagielski processID.noOutput(); 488*b1cdbd2cSJim Jagielski processID.executeSynchronously(); 489*b1cdbd2cSJim Jagielski int nError = processID.getExitCode(); 490*b1cdbd2cSJim Jagielski assertTrue("Execute of " + sOfficeMemoryCommand + " failed", nError == 0); 491*b1cdbd2cSJim Jagielski String text = processID.getOutputText(); 492*b1cdbd2cSJim Jagielski if (text == null || text.equals("") || text.indexOf(' ') == -1) 493*b1cdbd2cSJim Jagielski { 494*b1cdbd2cSJim Jagielski fail("Could not determine Office memory usage. Check " + sOfficeMemoryCommand); 495*b1cdbd2cSJim Jagielski } 496*b1cdbd2cSJim Jagielski StringTokenizer aToken = new StringTokenizer(text); 497*b1cdbd2cSJim Jagielski // this works, because the output of pmap is quite standardized. 498*b1cdbd2cSJim Jagielski aToken.nextToken(); 499*b1cdbd2cSJim Jagielski String mem = aToken.nextToken(); 500*b1cdbd2cSJim Jagielski mem = mem.substring(0, mem.indexOf('K')); 501*b1cdbd2cSJim Jagielski Integer memory = new Integer(mem); 502*b1cdbd2cSJim Jagielski return memory.intValue(); 503*b1cdbd2cSJim Jagielski } 504*b1cdbd2cSJim Jagielski 505*b1cdbd2cSJim Jagielski /** 506*b1cdbd2cSJim Jagielski * Write a script file and set its rights to rwxrwxrwx. 507*b1cdbd2cSJim Jagielski * @param fileName The name of the created file 508*b1cdbd2cSJim Jagielski * @param line The commandline that has to be written inside of the file. 509*b1cdbd2cSJim Jagielski */ createExecutableFile(String fileName, String line)510*b1cdbd2cSJim Jagielski private void createExecutableFile(String fileName, String line) 511*b1cdbd2cSJim Jagielski { 512*b1cdbd2cSJim Jagielski final String sChmod = "chmod a+x "; 513*b1cdbd2cSJim Jagielski final String bash = "#!/bin/bash"; 514*b1cdbd2cSJim Jagielski 515*b1cdbd2cSJim Jagielski try 516*b1cdbd2cSJim Jagielski { 517*b1cdbd2cSJim Jagielski String sFilename = FileHelper.getJavaCompatibleFilename(fileName); 518*b1cdbd2cSJim Jagielski PrintWriter fWriter = new PrintWriter(new FileWriter(sFilename)); 519*b1cdbd2cSJim Jagielski fWriter.println(bash); 520*b1cdbd2cSJim Jagielski fWriter.println(line); 521*b1cdbd2cSJim Jagielski fWriter.close(); 522*b1cdbd2cSJim Jagielski // change rights to rwxrwxrwx 523*b1cdbd2cSJim Jagielski ProcessHandler processID = new ProcessHandler(sChmod + sFilename); 524*b1cdbd2cSJim Jagielski processID.noOutput(); 525*b1cdbd2cSJim Jagielski processID.executeSynchronously(); 526*b1cdbd2cSJim Jagielski int nError = processID.getExitCode(); 527*b1cdbd2cSJim Jagielski assertTrue("chmod failed. ", nError == 0); 528*b1cdbd2cSJim Jagielski } 529*b1cdbd2cSJim Jagielski catch (java.io.IOException e) 530*b1cdbd2cSJim Jagielski { 531*b1cdbd2cSJim Jagielski } 532*b1cdbd2cSJim Jagielski } 533*b1cdbd2cSJim Jagielski } 534*b1cdbd2cSJim Jagielski 535*b1cdbd2cSJim Jagielski /** 536*b1cdbd2cSJim Jagielski * Let this thread sleep for some time 537*b1cdbd2cSJim Jagielski * @param milliSeconds time to wait in milliseconds. 538*b1cdbd2cSJim Jagielski */ shortWait(int milliSeconds)539*b1cdbd2cSJim Jagielski public static void shortWait(int milliSeconds) 540*b1cdbd2cSJim Jagielski { 541*b1cdbd2cSJim Jagielski System.out.println("Wait for: " + milliSeconds + "ms"); 542*b1cdbd2cSJim Jagielski try 543*b1cdbd2cSJim Jagielski { 544*b1cdbd2cSJim Jagielski Thread.sleep(milliSeconds); 545*b1cdbd2cSJim Jagielski } 546*b1cdbd2cSJim Jagielski catch (java.lang.InterruptedException e) 547*b1cdbd2cSJim Jagielski { // ignore 548*b1cdbd2cSJim Jagielski } 549*b1cdbd2cSJim Jagielski } 550*b1cdbd2cSJim Jagielski 551*b1cdbd2cSJim Jagielski /** 552*b1cdbd2cSJim Jagielski * Own file filter, will just return ok for all files that end with a given 553*b1cdbd2cSJim Jagielski * suffix 554*b1cdbd2cSJim Jagielski */ 555*b1cdbd2cSJim Jagielski private class FileFilter implements FilenameFilter 556*b1cdbd2cSJim Jagielski { 557*b1cdbd2cSJim Jagielski 558*b1cdbd2cSJim Jagielski private String suffix = null; 559*b1cdbd2cSJim Jagielski 560*b1cdbd2cSJim Jagielski /** 561*b1cdbd2cSJim Jagielski * C'tor. 562*b1cdbd2cSJim Jagielski * @param suffix The suffix each filename should end with. 563*b1cdbd2cSJim Jagielski */ FileFilter(String suffix)564*b1cdbd2cSJim Jagielski public FileFilter(String suffix) 565*b1cdbd2cSJim Jagielski { 566*b1cdbd2cSJim Jagielski this.suffix = suffix; 567*b1cdbd2cSJim Jagielski } 568*b1cdbd2cSJim Jagielski 569*b1cdbd2cSJim Jagielski /** 570*b1cdbd2cSJim Jagielski * Returns true, if the name of the file has the suffix given to the 571*b1cdbd2cSJim Jagielski * c'tor. 572*b1cdbd2cSJim Jagielski * @param name The filename that is tested. 573*b1cdbd2cSJim Jagielski * @param file Not used. 574*b1cdbd2cSJim Jagielski * @return True, if name ends with suffix. 575*b1cdbd2cSJim Jagielski */ accept(File file, String name)576*b1cdbd2cSJim Jagielski public boolean accept(File file, String name) 577*b1cdbd2cSJim Jagielski { 578*b1cdbd2cSJim Jagielski return name.endsWith(suffix); 579*b1cdbd2cSJim Jagielski } 580*b1cdbd2cSJim Jagielski } 581*b1cdbd2cSJim Jagielski getMSF()582*b1cdbd2cSJim Jagielski private XMultiServiceFactory getMSF() 583*b1cdbd2cSJim Jagielski { 584*b1cdbd2cSJim Jagielski final XMultiServiceFactory xMSF1 = UnoRuntime.queryInterface(XMultiServiceFactory.class, connection.getComponentContext().getServiceManager()); 585*b1cdbd2cSJim Jagielski return xMSF1; 586*b1cdbd2cSJim Jagielski } 587*b1cdbd2cSJim Jagielski 588*b1cdbd2cSJim Jagielski // setup and close connections 589*b1cdbd2cSJim Jagielski @BeforeClass setUpConnection()590*b1cdbd2cSJim Jagielski public static void setUpConnection() throws Exception 591*b1cdbd2cSJim Jagielski { 592*b1cdbd2cSJim Jagielski System.out.println("setUpConnection()"); 593*b1cdbd2cSJim Jagielski connection.setUp(); 594*b1cdbd2cSJim Jagielski } 595*b1cdbd2cSJim Jagielski 596*b1cdbd2cSJim Jagielski @AfterClass tearDownConnection()597*b1cdbd2cSJim Jagielski public static void tearDownConnection() 598*b1cdbd2cSJim Jagielski throws InterruptedException, com.sun.star.uno.Exception 599*b1cdbd2cSJim Jagielski { 600*b1cdbd2cSJim Jagielski System.out.println("tearDownConnection()"); 601*b1cdbd2cSJim Jagielski connection.tearDown(); 602*b1cdbd2cSJim Jagielski } 603*b1cdbd2cSJim Jagielski private static final OfficeConnection connection = new OfficeConnection(); 604*b1cdbd2cSJim Jagielski } 605