runner/helper/APIDescGetter.java

/*
 * 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 helper;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
import java.util.jar.JarEntry;

import share.DescEntry;
import share.DescGetter;

/**
 * This is the Office-API specific DescGetter<br>
 * <br>
 * Examples:<br><br>
 * -o sw.SwXBodyText<br>
 * runs the module test of <B>Sw.SwXBodyText</B><br>
 * <br>
 * -o sw.SwXBodyText::com::sun::star::text::Text<br>
 * runs only the interface test <B>com.sun.star.textText</B> of the module <B>Sw.SwXBodyText</B><br>
 * <br>
 * -o sw.SwXBodyText::com::sun::star::text::Text,com::sun::star::text::XSimpleText<br>
 * runs only the interfaces test <B>com.sun.star.textText</B> and <B>com.sun.star.text.XSimpleText</B> of the module <B>Sw.SwXBodyText</B><br>
 * <br>
 * -p sw<br>
 * runs all modules of the project <B>sw</B><br>
 * <br>
 * -p listall<br>
 * lists all known module tests<br>
 * <br>
 * -sce SCENARIO_FILE<br>
 * A scenario file is a property file which could contain <B>-o</B> and <B>-p</B> properties<br>
 * <br>
 * -sce sw.SwXBodyText,sw.SwXBookmark<br>
 * runs the module test of <B>Sw.SwXBodyText</B> and <B>sw.SwXBookmark</B><br>
 */
public class APIDescGetter extends DescGetter
{

    private static String fullJob = null;

    /*
     * gets the needed information about a StarOffice component
     * @param descPath Path to the ComponentDescription
     * @param entry contains the entry name, e.g. sw.SwXBodyText
     * @param debug if true some debug information is displayed on standard out
     */
    @Override
    public DescEntry[] getDescriptionFor(String job, String descPath,
            boolean debug)
    {

        if (job.startsWith("-o"))
        {
            job = job.substring(3, job.length()).trim();

            if (job.indexOf('.') < 0)
            {
                return null;
            }

            // special in case several Interfaces are given comma separated
            if (job.indexOf(',') < 0)
            {
                DescEntry entry = getDescriptionForSingleJob(job, descPath,
                        debug);

                if (entry != null)
                {
                    return new DescEntry[]
                            {
                                entry
                            };
                }
                else
                {
                    return null;
                }
            }
            else
            {
                ArrayList<String> subs = getSubInterfaces(job);
                String partjob = job.substring(0, job.indexOf(',')).trim();
                DescEntry entry = getDescriptionForSingleJob(partjob, descPath,
                        debug);

                if (entry != null)
                {
                    for (int i = 0; i < entry.SubEntryCount; i++)
                    {
                        String subEntry = entry.SubEntries[i].longName;
                        int cpLength = entry.longName.length();
                        subEntry = subEntry.substring(cpLength + 2,
                                subEntry.length());

                        if (subs.contains(subEntry))
                        {
                            entry.SubEntries[i].isToTest = true;
                        }
                    }

                    return new DescEntry[]
                            {
                                entry
                            };
                }
                else
                {
                    return null;
                }
            }
        }

        if (job.startsWith("-p"))
        {
            job = job.substring(3, job.length()).trim();

            String[] scenario = createScenario(descPath, job, debug);
            if (scenario == null)
            {
                return null;
            }
            DescEntry[] entries = new DescEntry[scenario.length];
            for (int i = 0; i < scenario.length; i++)
            {
                entries[i] = getDescriptionForSingleJob(
                        scenario[i].substring(3).trim(), descPath, debug);
            }
            if (job.equals("listall"))
            {
                util.dbg.printArray(scenario);
                System.exit(0);
            }
            return entries;
        }

        if (job.startsWith("-sce"))
        {
            job = job.substring(5, job.length()).trim();

            File sceFile = new File(job);
            if (sceFile.exists())
            {
                return getScenario(job, descPath, debug);
            }
            else
            {
                //look the scenario like this? :
                // sw.SwXBodyText,sw.SwXTextCursor
                ArrayList<String> subs = getSubObjects(job);
                DescEntry[] entries = new DescEntry[subs.size()];

                for (int i = 0; i < subs.size(); i++)
                {
                    entries[i] = getDescriptionForSingleJob(
                            subs.get(i), descPath, debug);
                }
                return entries;
            }
        }
        else
        {
            return null;
        }
    }

    @Override
    protected DescEntry getDescriptionForSingleJob(String job, String descPath,
            boolean debug)
    {
        boolean isSingleInterface = job.indexOf("::") > 0;
        fullJob = job;

        if (isSingleInterface)
        {
            job = job.substring(0, job.indexOf("::"));
        }

        if (job.startsWith("bugs"))
        {
            DescEntry Entry = new DescEntry();
            Entry.entryName = job;
            Entry.longName = job;
            Entry.EntryType = "bugdoc";
            Entry.isOptional = false;
            Entry.isToTest = true;
            Entry.SubEntryCount = 0;
            Entry.hasErrorMsg = false;
            Entry.State = "non possible";

            return Entry;
        }

        DescEntry entry = null;

        if (descPath != null)
        {
            if (debug)
            {
                System.out.println("## reading from File " + descPath);
            }

            entry = getFromDirectory(descPath, job, debug);
        }
        else
        {
            if (debug)
            {
                System.out.println("## reading from jar");
            }

            entry = getFromClassPath(job);
        }

        boolean foundInterface = false;

        if (isSingleInterface && (entry != null))
        {
            for (int i = 0; i < entry.SubEntryCount; i++)
            {
                if (!(entry.SubEntries[i].longName).equals(fullJob))
                {
                    entry.SubEntries[i].isToTest = false;
                }
                else
                {
                    foundInterface = true;
                    entry.SubEntries[i].isToTest = true;
                }
            }
        }

        if (isSingleInterface && !foundInterface || entry == null)
        {
            return setErrorDescription(entry,
                    "couldn't find a description for test '" + fullJob + "'");
        }

        return entry;
    }

    private static DescEntry[] getSubEntries(BufferedReader cvsFile,
            DescEntry parent)
    {
        String line = "";
        String old_ifc_name = "";
        ArrayList<DescEntry> ifc_names = new ArrayList<DescEntry>();
        ArrayList<DescEntry> meth_names = new ArrayList<DescEntry>();
        DescEntry ifcDesc = null;

        while (line != null)
        {
            try
            {
                line = cvsFile.readLine();
                if (line == null)
                {
                    continue;
                }
                if (line.startsWith("#"))
                {
                    continue;
                }
                if (line.length() <= 0)
                {
                    continue;
                }
// TODO Problem here

                String ifc_name = ""; //  = line.substring(line.indexOf(";") + 2, line.lastIndexOf(";") - 1);
                String meth_name = ""; //  = line.substring(line.lastIndexOf(";") + 2, line.length() - 1);
                StringTokenizer aToken = new StringTokenizer(line, ";");
                if (aToken.countTokens() < 3)
                {
                    System.out.println("Wrong format: Line '" + line + "' is not supported.");
                    continue;
                }
                if (aToken.hasMoreTokens())
                {
                    aToken.nextToken();
                }
                if (aToken.hasMoreTokens())
                {
                    ifc_name = StringHelper.removeQuoteIfExists(aToken.nextToken());
                }
                if (aToken.hasMoreTokens())
                {
                    meth_name = StringHelper.removeQuoteIfExists(aToken.nextToken());
                }

                DescEntry methDesc = createDescEntry(meth_name, ifc_name, parent);

                if (!ifc_name.equals(old_ifc_name))
                {
                    if (ifcDesc != null)
                    {
                        ifcDesc.SubEntries = getDescArray(meth_names.toArray());
                        ifcDesc.SubEntryCount = meth_names.size();

                        //mark service/interface as optional if all methods/properties are optional
                        boolean allOptional = true;

                        for (int k = 0; k < ifcDesc.SubEntryCount; k++)
                        {
                            if (!ifcDesc.SubEntries[k].isOptional)
                            {
                                allOptional = false;
                            }
                        }

                        if (!ifcDesc.isOptional && allOptional)
                        {
                            ifcDesc.isOptional = allOptional;
                        }

                        meth_names.clear();
                        ifc_names.add(ifcDesc);
                    }

                    ifcDesc = new DescEntry();
                    ifcDesc.isToTest = true;
                    old_ifc_name = ifc_name;

                    if (ifc_name.indexOf("#optional") > 0)
                    {
                        ifcDesc.isOptional = true;
                        ifc_name = ifc_name.substring(0, ifc_name.indexOf('#'));
                    }

                    String className = createClassName(ifc_name);

                    ifcDesc.EntryType = entryType;
                    ifcDesc.entryName = "ifc" + className;
                    ifcDesc.longName = parent.entryName + "::" + ifc_name;
                }
                meth_names.add(methDesc);

            }
            catch (java.io.IOException ioe)
            {
                parent.hasErrorMsg = true;
                parent.ErrorMsg = "IOException while reading the description";
                break;
            }
        }

        if (ifcDesc == null) {
            return null;
        }

        ifcDesc.SubEntries = getDescArray(meth_names.toArray());
        ifcDesc.SubEntryCount = meth_names.size();

        //mark service/interface as optional if all methods/properties are optional
        boolean allOptional = true;

        for (int k = 0; k < ifcDesc.SubEntryCount; k++)
        {
            if (!ifcDesc.SubEntries[k].isOptional)
            {
                allOptional = false;
            }
        }

        if (!ifcDesc.isOptional && allOptional)
        {
            ifcDesc.isOptional = allOptional;
        }

        ifc_names.add(ifcDesc);

        return getDescArray(makeArray(ifc_names));
    }
    private static String createClassName(String _ifc_name)
    {
        StringTokenizer st = new StringTokenizer(_ifc_name, ":");

        int count = 3;

        if (_ifc_name.startsWith("drafts"))
        {
            count = 4;
        }

        StringBuilder className = new StringBuilder();

        for (int i = 0; st.hasMoreTokens(); i++)
        {
            String token = st.nextToken();

            // skipping (drafts.)com.sun.star
            if (i >= count)
            {
                if (!st.hasMoreTokens())
                {
                    // inserting '_' before the last token
                    token = "_" + token;
                }

                className.append(".").append(token);
            }
        }
        return className.toString();
    }

    private static String entryType;

    private static DescEntry createDescEntry(String meth_name, String ifc_name, DescEntry parent)
    {
        entryType = "service";
        DescEntry methDesc = new DescEntry();

        if (meth_name.indexOf("#optional") > 0)
        {
            methDesc.isOptional = true;
            meth_name = meth_name.substring(0, meth_name.indexOf('#'));
        }

        if (meth_name.endsWith("()"))
        {
            methDesc.EntryType = "method";
            entryType = "interface";
        }
        else
        {
            methDesc.EntryType = "property";
            entryType = "service";
        }

        methDesc.entryName = meth_name;
        methDesc.isToTest = true;


        String withoutHash = ifc_name;

        if (ifc_name.indexOf("#optional") > 0)
        {
            withoutHash = ifc_name.substring(0, ifc_name.indexOf('#'));
        }

        methDesc.longName = parent.entryName + "::" + withoutHash + "::" + meth_name;

        return methDesc;
    }

    /**
     * This method ensures that XComponent will be the last in the list of interfaces
     */
    private static Object[] makeArray(ArrayList<DescEntry> entries)
    {
        Object[] entriesArray = entries.toArray();
        ArrayList<Object> returnArray = new ArrayList<Object>();
        Object addAtEnd = null;

        for (int k = 0; k < entriesArray.length; k++)
        {
            DescEntry entry = (DescEntry) entriesArray[k];

            if (entry.entryName.equals("ifc.lang._XComponent"))
            {
                addAtEnd = entry;
            }
            else
            {
                returnArray.add(entry);
            }
        }

        if (addAtEnd != null)
        {
            returnArray.add(addAtEnd);
        }

        return returnArray.toArray();
    }

    private static DescEntry setErrorDescription(DescEntry entry,
            String ErrorMsg)
    {
        if (entry == null)
        {
            entry = new DescEntry();
        }
        entry.hasErrorMsg = true;
        entry.ErrorMsg = "Error while getting description for test '" +
                fullJob + "' as an API test: " + ErrorMsg;

        return entry;
    }

    private static DescEntry[] getDescArray(Object[] list)
    {
        DescEntry[] entries = new DescEntry[list.length];

        for (int i = 0; i < list.length; i++)
        {
            entries[i] = (DescEntry) list[i];
        }

        return entries;
    }

    private DescEntry getFromClassPath(String aEntry)
    {
        int dotindex = aEntry.indexOf('.');

        if (dotindex == -1)
        {
            return null;
        }

        String module = null;
        String shortName = null;

        if (aEntry.indexOf(".uno") == -1)
        {
            module = aEntry.substring(0, aEntry.indexOf('.'));
            shortName = aEntry.substring(aEntry.indexOf('.') + 1);
        }
        else
        {
            module = aEntry.substring(0, aEntry.lastIndexOf('.'));
            shortName = aEntry.substring(aEntry.lastIndexOf('.') + 1);
        }

        DescEntry theEntry = new DescEntry();
        theEntry.entryName = aEntry;
        theEntry.longName = aEntry;
        theEntry.isOptional = false;
        theEntry.EntryType = "component";
        theEntry.isToTest = true;

        BufferedReader csvFile = null;

        java.net.URL url = this.getClass().getResource("/objdsc/" + module);

        if (url == null)
        {
            return setErrorDescription(theEntry,
                    "couldn't find module '" + module + "'");
        }

        try
        {
            java.net.URLConnection con = url.openConnection();

            String sEndsWithCSVName = "." + shortName.trim() + ".csv";
            if (con instanceof java.net.JarURLConnection)
            {
                // get Jar file from connection
                java.util.jar.JarFile f = ((java.net.JarURLConnection) con).getJarFile();

                // Enumerate over all entries
                java.util.Enumeration<JarEntry> e = f.entries();

                String sStartModule = "/" + module + "/";
                while (e.hasMoreElements())
                {

                    String entry = e.nextElement().toString();

                    if ((entry.lastIndexOf(sStartModule) != -1) &&
                            entry.endsWith(sEndsWithCSVName))
                    {
                        InputStream input = this.getClass().getResourceAsStream("/" + entry);
                        csvFile = new BufferedReader(new InputStreamReader(input, "UTF-8"));
                        break;
                    }
                }
            }
            else
            {
                InputStream in = con.getInputStream();
                java.io.BufferedReader buf = new java.io.BufferedReader(new InputStreamReader(in, "UTF-8"));
                while (true)
                {
                    String entry = buf.readLine();
                    if (entry == null)
                        break;
                    if (entry.endsWith(sEndsWithCSVName))
                    {
                        System.out.println("FOUND  ####");
                        InputStream input =
                            this.getClass().getResourceAsStream("/objdsc/" +
                                module +
                                "/" +
                                entry);
                        csvFile = new BufferedReader(new InputStreamReader(input, "UTF-8"));
                        break;
                    }
                }

                buf.close();
            }
        }
        catch (java.io.IOException e)
        {
            e.printStackTrace();
        }

        if (csvFile == null)
        {
            return setErrorDescription(theEntry,
                    "couldn't find component '" +
                    theEntry.entryName + "'");
        }

        DescEntry[] subEntries = getSubEntries(csvFile, theEntry);

        theEntry.SubEntryCount = subEntries != null ? subEntries.length : 0;
        theEntry.SubEntries = subEntries;

        try
        {
            csvFile.close();
        }
        catch (java.io.IOException ioe)
        {
            System.out.println("Exception while closing csvFile");
        }

        return theEntry;
    }

    private static DescEntry getFromDirectory(String descPath, String entry,
            boolean debug)
    {
        int dotindex = entry.indexOf('.');

        if (dotindex == -1)
        {
            return null;
        }

        String fs = System.getProperty("file.separator");
        String module = null;
        String shortName = null;

        if (entry.indexOf(".uno") == -1)
        {
            module = entry.substring(0, entry.indexOf('.'));
            shortName = entry.substring(entry.indexOf('.') + 1);
        }
        else
        {
            module = entry.substring(0, entry.lastIndexOf('.'));
            shortName = entry.substring(entry.lastIndexOf('.') + 1);
        }

        DescEntry aEntry = new DescEntry();
        aEntry.entryName = entry;
        aEntry.longName = entry;
        aEntry.isOptional = false;
        aEntry.EntryType = "component";
        aEntry.isToTest = true;

        if (debug)
        {
            System.out.println("Parsing Description Path: " + descPath);
            System.out.println("Searching module: " + module);
            System.out.println("For the Component " + shortName);
        }

        File modPath = new File(descPath + fs + module);

        if (!modPath.exists())
        {
            return setErrorDescription(aEntry,
                    "couldn't find module '" + module + "'");
        }

        String[] files = modPath.list();
        String found = "none";

        for (int i = 0; i < files.length; i++)
        {
            if (files[i].endsWith("." + shortName + ".csv"))
            {
                found = files[i];
                System.out.println("found " + found);
                break;
            }
        }

        if (found.equals("none"))
        {
            return setErrorDescription(aEntry,
                    "couldn't find component '" + entry + "'");
        }

        String aUrl = descPath + fs + module + fs + found;

        BufferedReader csvFile = null;

        try
        {
            csvFile = new BufferedReader(new FileReader(aUrl));
        }
        catch (java.io.FileNotFoundException fnfe)
        {
            return setErrorDescription(aEntry, "couldn't find file '" + aUrl + "'");
        }

        DescEntry[] subEntries = getSubEntries(csvFile, aEntry);

        try
        {
            csvFile.close();
        }
        catch (java.io.IOException ioe)
        {
            System.out.println("Exception while closing csvFile");
        }

        aEntry.SubEntryCount = subEntries != null ? subEntries.length : 0;
        aEntry.SubEntries = subEntries;

        return aEntry;
    }

    @Override
    protected ArrayList<String> getSubInterfaces(String job)
    {
        ArrayList<String> namesList = new ArrayList<String>();
        StringTokenizer st = new StringTokenizer(job, ",");

        while (st.hasMoreTokens())
        {
            String token = st.nextToken();

            if (token.indexOf('.') < 0)
            {
                namesList.add(token);
            }
        }

        return namesList;
    }

    private ArrayList<String> getSubObjects(String job)
    {
        ArrayList<String> namesList = new ArrayList<String>();
        StringTokenizer st = new StringTokenizer(job, ",");

        while (st.hasMoreTokens())
        {
            namesList.add(st.nextToken());
        }

        return namesList;
    }

    @Override
    protected String[] createScenario(String descPath, String job,
            boolean debug)
    {
        String[] scenario = null;

        if (descPath != null)
        {
            if (debug)
            {
                System.out.println("## reading from File " + descPath);
            }

            scenario = getScenarioFromDirectory(descPath, job);
        }
        else
        {
            if (debug)
            {
                System.out.println("## reading from jar");
            }

            scenario = getScenarioFromClassPath(job);
        }

        return scenario;
    }

    private String[] getScenarioFromDirectory(String descPath, String job)
    {
        String[] modules = null;
        ArrayList<String> componentList = new ArrayList<String>();

        if (!job.equals("unknown") && !job.equals("listall"))
        {
            modules = new String[]
                    {
                        job
                    };
        }
        else
        {
            File dirs = new File(descPath);

            if (dirs.exists()) {
                modules = dirs.list();
            }
        }

        int moduleLength = modules != null ? modules.length : 0;

        for (int i = 0; i < moduleLength; ++i)
        {
            if (!isUnusedModule(modules[i]))
            {
                File moduleDir = new File(descPath + System.getProperty("file.separator") + modules[i]);
                if (moduleDir.exists())
                {
                    String[] components = moduleDir.list();
                    for (int j = 0; j < components.length; j++)
                    {
                        if (components[j].endsWith(".csv"))
                        {
                            String toAdd = getComponentForString(components[j], modules[i]);
                            toAdd = "-o " + modules[i] + "." + toAdd;
                            componentList.add(toAdd);
                        }
                    }
                }
            }
        }

        Collections.sort(componentList);
        String[] scenario = componentList.toArray(new String[componentList.size()]);
        return scenario;
    }

    private String[] getScenarioFromClassPath(String job)
    {
        String subdir = "/";

        if (!job.equals("unknown") && !job.equals("listall"))
        {
            subdir += job;
        }

        java.net.URL url = this.getClass().getResource("/objdsc" + subdir);

        if (url == null)
        {
            return null;
        }

        ArrayList<String> scenarioList = new ArrayList<String>();

        try
        {
            java.net.URLConnection con = url.openConnection();

            if (con instanceof java.net.JarURLConnection)
            {
                // get Jar file from connection
                java.util.jar.JarFile f = ((java.net.JarURLConnection) con).getJarFile();

                // Enumerate over all entries
                java.util.Enumeration<JarEntry> e = f.entries();

                while (e.hasMoreElements())
                {
                    String entry = e.nextElement().toString();

                    if (entry.startsWith("objdsc" + subdir) &&
                            (entry.indexOf("CVS") < 0) &&
                            !entry.endsWith("/"))
                    {
                        int startMod = entry.indexOf('/');
                        int endMod = entry.lastIndexOf('/');
                        String module = entry.substring(startMod + 1, endMod);
                        String component = getComponentForString(
                                entry.substring(endMod + 1,
                                entry.length()),
                                module);

                        if (!isUnusedModule(module))
                        {
                            scenarioList.add("-o " + module + "." +
                                    component);
                        }
                    }
                }
            }
        }
        catch (java.io.IOException e)
        {
            e.printStackTrace();
        }

        Collections.sort(scenarioList);
        String[] scenario = scenarioList.toArray(new String[scenarioList.size()]);
        return scenario;
    }

    private String getComponentForString(String full, String module)
    {
        String component = "";


        //cutting .csv
        full = full.substring(0, full.length() - 4);

        //cutting component
        int lastdot = full.lastIndexOf('.');
        component = full.substring(lastdot + 1, full.length());

        if (module.equals("file") || module.equals("xmloff"))
        {
            String withoutComponent = full.substring(0, lastdot);
            int preLastDot = withoutComponent.lastIndexOf('.');
            component = withoutComponent.substring(preLastDot + 1,
                    withoutComponent.length()) +
                    "." + component;
        }

        return component;
    }

    private boolean isUnusedModule(String moduleName)
    {
        ArrayList<String> removed = new ArrayList<String>();
        removed.add("acceptor");
        removed.add("brdgfctr");
        removed.add("connector");
        removed.add("corefl");
        removed.add("cpld");
        removed.add("defreg");
        removed.add("dynamicloader");
        removed.add("impreg");
        removed.add("insp");
        removed.add("inv");
        removed.add("invadp");
        removed.add("javaloader");
        removed.add("jen");
        removed.add("namingservice");
        removed.add("proxyfac");
        removed.add("rdbtdp");
        removed.add("remotebridge");
        removed.add("simreg");
        removed.add("smgr");
        removed.add("stm");
        removed.add("tcv");
        removed.add("tdmgr");
        removed.add("ucprmt");
        removed.add("uuresolver");

        return removed.contains(moduleName);
    }
}