diff options
Diffstat (limited to 'framework/qa/complex/path_substitution/PathSubstitutionTest.java')
| -rw-r--r-- | framework/qa/complex/path_substitution/PathSubstitutionTest.java | 294 |
1 files changed, 294 insertions, 0 deletions
diff --git a/framework/qa/complex/path_substitution/PathSubstitutionTest.java b/framework/qa/complex/path_substitution/PathSubstitutionTest.java new file mode 100644 index 000000000..96d59287c --- /dev/null +++ b/framework/qa/complex/path_substitution/PathSubstitutionTest.java @@ -0,0 +1,294 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +package complex.path_substitution; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.util.ArrayList; + +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.openoffice.test.OfficeConnection; + +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.util.XStringSubstitution; + +/** + * + */ +public class PathSubstitutionTest +{ + + // all substitution variables + private VariableContainer substVars = null; + + /** + * Create an array with all substitution variables + */ + @Before public void initialize() + { + substVars = new VariableContainer(); + substVars.add("$(prog)", true, true); + substVars.add("$(inst)", true, true); + substVars.add("$(user)", true, true); + substVars.add("$(work)", true, true); + substVars.add("$(home)", true, true); + substVars.add("$(temp)", true, true); + substVars.add("$(lang)", false, false); + substVars.add("$(username)", false, false); + substVars.add("$(langid)", false, false); + substVars.add("$(vlang)", false, false); + // path won't resubstitute + substVars.add("$(path)", true, false); + } + + /** + * One actual test: as the method 'getTestMethodNames()' tells. + */ + @Test public void checkXStringSubstitution() + { + XMultiServiceFactory xMSF = getMSF(); + System.out.println("---- Testing the XStringSubstitution interface ----"); + System.out.println("Create instance of test object.\n"); + XStringSubstitution oObj = null; + try + { + Object x = xMSF.createInstance( + "com.sun.star.util.PathSubstitution"); + oObj = UnoRuntime.queryInterface(XStringSubstitution.class, x); + if (oObj == null) + { + throw new com.sun.star.uno.Exception(); + } + } + catch (com.sun.star.uno.Exception e) + { + System.out.println(e.getClass().getName()); + System.out.println("Message: " + e.getMessage()); + fail("Could not create an instance of the test object."); + return; + } + + for (int i = 0; i < substVars.size(); i++) + { + String var = substVars.getVariable(i); + System.out.println("Testing var '" + var + "'"); + try + { + String substVal = oObj.getSubstituteVariableValue(var); + System.out.println("\tvalue '" + substVal + "'"); + substVars.putValue(i, substVal); + + // simple check: let path in a string replace + String substString = var + "/additional/path"; + + System.out.println("Substitute '" + substString + "'"); + String newValue = oObj.substituteVariables(substString, true); + System.out.println("Return value '" + newValue + "'"); + // 2do: better check for correct substitution + assertTrue("Did not substitute '" + + substString + "' to '" + newValue + + "' correctly:", newValue.startsWith(substVal)); + + // simple check part two: + //make substitution backwards if possible + if (substVars.canReSubstitute(i)) + { + substString = substVal + "/additional/path"; + + System.out.println("Substitute backwards '" + substString + "'"); + newValue = oObj.reSubstituteVariables(substString); + System.out.println("Return value '" + newValue + "'"); + // 2do: better check for correct substitution + assertTrue("Did not reSubstitute '" + + substString + "' to '" + newValue + + "' correctly:", checkResubstitute(newValue, var)); + } + + // simple check part three: look if replace + //in middle of text works + substString = "file:///starting/" + var + "/path"; + + String sCanSubstAllPos; + if (substVars.onlySubstituteAtBegin(i)) + sCanSubstAllPos = "NO"; + else + sCanSubstAllPos = "YES"; + System.out.println("Variable can substitute within string: "+sCanSubstAllPos); + System.out.println("Substitute '" + substString + "'"); + newValue = oObj.substituteVariables(substString, false); + System.out.println("Return value '" + newValue + "'"); + boolean erg = true; + if (substVars.onlySubstituteAtBegin(i)) + { + // in this case it should not have worked + erg = newValue.indexOf(substVal) == -1; + } + else + { + erg = newValue.indexOf(substVal) != -1; + } + assertTrue("Did not substitute '" + + substString + "' to '" + newValue + + "' correctly:", erg); + + } + catch (com.sun.star.uno.Exception e) + { + System.out.println(e.getClass().getName()); + System.out.println("Message: " + e.getMessage()); + fail("Could not create an instance of the test object."); + return; + } + System.out.println("Finish testing '" + var + "'\n"); + } + + // check of greedy resubstitution + String prog = "$(prog)"; + String inst = "$(inst)"; + String instPth = substVars.getValue(inst); + String progPth = substVars.getValue(prog); + + if (progPth.startsWith(instPth) && instPth.startsWith(progPth)) + { + System.out.println("Greedy ReSubstitute"); + String substString = progPth + "/additional/path"; + String newVal = oObj.reSubstituteVariables(substString); + System.out.println("String '" + substString + + "' should be resubstituted with"); + System.out.println("Variable '" + prog + "' instead of Variable '" + + inst + "'"); + assertTrue("Did not reSubstitute '" + substString + + "' to '" + newVal + "' correctly:", + newVal.startsWith(prog)); + } + + System.out.println( + "---- Finish testing the XStringSubstitution interface ----"); + } + + /** + * test the resubstitution + * @return true, if resubstitution is correct. + */ + private boolean checkResubstitute(String subst, String original) + { + // simple: subst starts with original + if (subst.startsWith(original)) + { + return true; + } + else + { // hard: been resubstituted with a different variable. + for (int i = 0; i < substVars.size(); i++) + { + String var = substVars.getVariable(i); + if (subst.startsWith(var) && original.startsWith(original)) + { + return true; + } + } + } + return false; + } + + /** + * Class for containing the substitution variables with their + * values and some information. + */ + private static class VariableContainer + { + + public ArrayList<String> varName; + public ArrayList<String> varValue; + public ArrayList<Boolean> substAtBegin; + public ArrayList<Boolean> resubst; + + public VariableContainer() + { + varName = new ArrayList<String>(); + varValue = new ArrayList<String>(); + substAtBegin = new ArrayList<Boolean>(); + resubst = new ArrayList<Boolean>(); + } + + public void add(String var, boolean onlySubstAtBegin, + boolean canResubst) + { + varName.add(var); + this.substAtBegin.add(Boolean.valueOf(onlySubstAtBegin)); + this.resubst.add(Boolean.valueOf(canResubst)); + } + + public void putValue(int i, String val) + { + varValue.add(i, val); + } + + public int size() + { + return varName.size(); + } + + public String getVariable(int i) + { + return varName.get(i); + } + + public String getValue(String var) + { + return varValue.get(varName.indexOf(var)); + } + + public boolean onlySubstituteAtBegin(int i) + { + return substAtBegin.get(i).booleanValue(); + } + + public boolean canReSubstitute(int i) + { + return resubst.get(i).booleanValue(); + } + } + + private XMultiServiceFactory getMSF() + { + return UnoRuntime.queryInterface(XMultiServiceFactory.class, connection.getComponentContext().getServiceManager()); + } + + // setup and close connections + @BeforeClass + public static void setUpConnection() throws Exception + { + System.out.println("setUpConnection()"); + connection.setUp(); + } + + @AfterClass + public static void tearDownConnection() + throws InterruptedException, com.sun.star.uno.Exception + { + System.out.println("tearDownConnection()"); + connection.tearDown(); + } + private static final OfficeConnection connection = new OfficeConnection(); +} |