gfxcmp02: #159601# add graphical compare test

1 files changed, 718 insertions, 0 deletions

diff --git a/testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java b/testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java
new file mode 100644
index 000000000000..2b49ffa760a0
--- /dev/null
+++ b/testgraphical/ui/java/ConvwatchGUIProject/src/IniFile.java
@@ -0,0 +1,718 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+import java.io.File;
+import java.io.RandomAccessFile;
+import java.util.ArrayList;
+import java.util.Enumeration;
+
+
+/**
+ * Simple implementation of a inifile manager
+ */
+class GlobalLogWriter
+{
+    public static void println(String _s)
+    {
+        System.out.println(_s);
+    }
+}
+
+/**
+   Helper class to give a simple API to read/write windows like ini files
+*/
+
+/* public */ // is only need, if we need this class outside package convwatch
+public class IniFile implements Enumeration
+{
+
+    /**
+     * internal representation of the ini file content.
+     * Problem, if ini file changed why other write something difference, we don't realise this.
+     */
+    private String m_sFilename;
+    // private File m_aFile;
+    private ArrayList<String> m_aList;
+    boolean m_bListContainUnsavedChanges = false;
+    private int m_aEnumerationPos = 0;
+
+    /**
+       open a ini file by it's name
+       @param _sFilename string a filename, if the file doesn't exist, a new empty ini file will create.
+       write back to disk only if there are really changes.
+    */
+    public IniFile(String _sFilename)
+        {
+            m_sFilename = _sFilename;
+            // m_aFile = new File(_sFilename);
+            m_aList = loadLines();
+            m_aEnumerationPos = findNextSection(0);
+        }
+
+    /**
+       open a ini file by it's name
+       @param _aFile a java.io.File object, if the file doesn't exist, a new empty ini file will create.
+       write back to disk only if there are really changes.
+    */
+    public IniFile(File _aFile)
+    {
+        m_sFilename = _aFile.getAbsolutePath();
+        m_aList = loadLines();
+        m_aEnumerationPos = findNextSection(0);
+    }
+
+    public void insertFirstComment(String[] _aList)
+        {
+            if (m_aList.size() == 0)
+            {
+                // can only insert if there is nothing else already in the ini file
+                for (int i = 0; i < _aList.length; i++)
+                {
+                    m_aList.add(_aList[i]);
+                }
+            }
+        }
+
+    private ArrayList<String> loadLines()
+        {
+            ArrayList<String> aLines = new ArrayList<String>();
+            File aFile = new File(m_sFilename);
+            if (!aFile.exists())
+            {
+                // GlobalLogWriter.println("couldn't find file '" + m_sFilename + "', will be created.");
+                // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, "");
+                // m_bListContainUnsavedChanges = false;
+                return aLines;
+            }
+            RandomAccessFile aReader = null;
+            // BufferedReader aReader;
+            try
+            {
+                aReader = new RandomAccessFile(aFile, "r");
+                String aLine = "";
+                while (aLine != null)
+                {
+                    aLine = aReader.readLine();
+                    if (aLine != null && aLine.length() > 0)
+                    {
+                        aLines.add(aLine);
+                    }
+                }
+            }
+            catch (java.io.FileNotFoundException fne)
+            {
+                GlobalLogWriter.println("couldn't open file " + m_sFilename);
+                GlobalLogWriter.println("Message: " + fne.getMessage());
+                // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, "");
+            }
+            catch (java.io.IOException ie)
+            {
+                GlobalLogWriter.println("Exception occurs while reading from file " + m_sFilename);
+                GlobalLogWriter.println("Message: " + ie.getMessage());
+                // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage());
+            }
+            try
+            {
+                aReader.close();
+            }
+            catch (java.io.IOException ie)
+            {
+                GlobalLogWriter.println("Couldn't close file " + m_sFilename);
+                GlobalLogWriter.println("Message: " + ie.getMessage());
+                // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage());
+            }
+            return aLines;
+        }
+
+    /**
+     * @return true, if the ini file contain some readable data
+     */
+    public boolean is()
+        {
+            return m_aList.size() > 1 ? true : false;
+        }
+
+    /**
+     * Check if a given Section and Key exists in the ini file
+     * @param _sSectionName
+     * @param _sKey
+     * @return true if the given Section, Key exists, now you can get the value
+     */
+    public boolean hasValue(String _sSectionName, String _sKey)
+        {
+            int n = findKey(_sSectionName, _sKey);
+            if (n > 0)
+            {
+                return true;
+            }
+            return false;
+        }
+    // -----------------------------------------------------------------------------
+
+    private boolean isRemark(String _sLine)
+        {
+            if (((_sLine.length() < 2)) ||
+                (_sLine.startsWith("#")) ||
+                (_sLine.startsWith(";")))
+            {
+                return true;
+            }
+            return false;
+        }
+
+    private String getItem(int i)
+        {
+            return m_aList.get(i);
+        }
+
+    private String buildSectionName(String _sSectionName)
+        {
+            String sFindSection = "[" + _sSectionName + "]";
+            return sFindSection;
+        }
+
+    private String sectionToString(String _sSectionName)
+        {
+            String sKeyName = _sSectionName;
+            if (sKeyName.startsWith("[") &&
+                sKeyName.endsWith("]"))
+            {
+                sKeyName = sKeyName.substring(1, sKeyName.length() - 1);
+            }
+            return sKeyName;
+        }
+
+    private String toLowerIfNeed(String _sName)
+        {
+            return _sName.toLowerCase();
+        }
+
+    // return the number where this section starts
+    private int findSection(String _sSection)
+        {
+            String sFindSection = toLowerIfNeed(buildSectionName(_sSection));
+            // ----------- find _sSection ---------------
+            int i;
+            for (i = 0; i < m_aList.size(); i++)
+            {
+                String sLine = toLowerIfNeed(getItem(i).trim());
+                if (isRemark(sLine))
+                {
+                    continue;
+                }
+                if (sFindSection.equals("[]"))
+                {
+                    // special case, empty Section.
+                    return i - 1;
+                }
+                if (sLine.startsWith(sFindSection))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+    /**
+     * Checks if a given section exists in the ini file
+     * @param _sSection
+     * @return true if the given _sSection was found
+     */
+    public boolean hasSection(String _sSection)
+        {
+            int i = findSection(_sSection);
+            if (i == -1)
+            {
+                return false;
+            }
+            return true;
+        }
+
+    // return the line number, where the key is found.
+    private int findKey(String _sSection, String _sKey)
+        {
+            int i = findSection(_sSection);
+            if (i == -1)
+            {
+                // Section not found, therefore the value can't exist
+                return -1;
+            }
+            return findKeyFromKnownSection(i, _sKey);
+        }
+
+    // i must be the index in the list, where the well known section starts
+    private int findKeyFromKnownSection(int _nSectionIndex, String _sKey)
+        {
+            _sKey = toLowerIfNeed(_sKey);
+            for (int j = _nSectionIndex + 1; j < m_aList.size(); j++)
+            {
+                String sLine = getItem(j).trim();
+
+                if (isRemark(sLine))
+                {
+                    continue;
+                }
+                if (sLine.startsWith("[") /* && sLine.endsWith("]") */)
+                {
+                    // TODO: due to the fact we would like to insert an empty line before new sections
+                    // TODO: we should check if we are in an empty line and if, go back one line.
+
+                    // found end.
+                    break;
+                }
+
+                int nEqual = sLine.indexOf("=");
+                if (nEqual >= 0)
+                {
+                    String sKey = toLowerIfNeed(sLine.substring(0, nEqual).trim());
+                    if (sKey.equals(_sKey))
+                    {
+                        return j;
+                    }
+                }
+            }
+            return -1;
+        }
+
+    // i must be the index in the list, where the well known section starts
+    private int findLastKnownKeyIndex(int _nSectionIndex, String _sKey)
+        {
+            _sKey = toLowerIfNeed(_sKey);
+            int i = _nSectionIndex + 1;
+            for (int j = i; j < m_aList.size(); j++)
+            {
+                String sLine = getItem(j).trim();
+
+                if (isRemark(sLine))
+                {
+                    continue;
+                }
+
+                if (sLine.startsWith("[") /* && sLine.endsWith("]") */)
+                {
+                    // found end.
+                    return j;
+                }
+
+                int nEqual = sLine.indexOf("=");
+                if (nEqual >= 0)
+                {
+                    String sKey = toLowerIfNeed(sLine.substring(0, nEqual).trim());
+                    if (sKey.equals(_sKey))
+                    {
+                        return j;
+                    }
+                }
+            }
+            return i;
+        }
+
+    private String getValue(int _nIndex)
+        {
+            String sLine = getItem(_nIndex).trim();
+            if (isRemark(sLine))
+            {
+                return "";
+            }
+            int nEqual = sLine.indexOf("=");
+            if (nEqual >= 0)
+            {
+                String sKey = sLine.substring(0, nEqual).trim();
+                String sValue = sLine.substring(nEqual + 1).trim();
+                return sValue;
+            }
+            return "";
+        }
+
+    /**
+       @param _sSection string
+       @param _sKey string
+       @return the value found in the inifile which is given by the section and key parameter
+    */
+    // private int m_nCurrentPosition;
+    // private String m_sOldKey;
+    public String getValue(String _sSection, String _sKey)
+        {
+            String sValue = "";
+            int m_nCurrentPosition = findKey(_sSection, _sKey);
+            if (m_nCurrentPosition == -1)
+            {
+                // Section not found, therefore the value can't exist
+                return "";
+            }
+
+            // m_sOldKey = _sKey;
+            sValue = getValue(m_nCurrentPosition);
+
+            return sValue;
+        }
+
+//    private String getNextValue()
+//    {
+//        if (m_nCurrentPosition >= 0)
+//        {
+//            ++m_nCurrentPosition;
+//            String sValue = getValue(m_nCurrentPosition);
+//            return sValue;
+//        }
+//        return "";
+//    }
+    /**
+     * Returns the value at Section, Key converted to an integer
+     * Check with hasValue(Section, Key) to check before you get into trouble.
+     * @param _sSection
+     * @param _sKey
+     * @param _nDefault if there is a problem, key not found... this value will return
+     * @return
+     */
+    public int getIntValue(String _sSection, String _sKey, int _nDefault)
+        {
+            String sValue = getValue(_sSection, _sKey);
+            int nValue = _nDefault;
+            if (sValue.length() > 0)
+            {
+                try
+                {
+                    nValue = Integer.valueOf(sValue).intValue();
+                }
+                catch (java.lang.NumberFormatException e)
+                {
+                    GlobalLogWriter.println("IniFile.getIntValue(): Caught a number format exception, return the default value.");
+                }
+            }
+            return nValue;
+        }
+
+/**
+ * close a open inifile.
+ * If there are changes, all changes will store back to disk.
+ */
+    public void close()
+        {
+            store();
+        }
+
+    /**
+       write back the ini file to the disk, only if there exist changes
+       * @deprecated use close() instead!
+       */
+
+    // TODO: make private
+    private void store()
+        {
+            if (m_bListContainUnsavedChanges == false)
+            {
+                // nothing has changed, so no need to store
+                return;
+            }
+
+            File aFile = new File(m_sFilename);
+            if (aFile.exists())
+            {
+                // System.out.println("couldn't find file " + m_sFilename);
+                // TODO: little bit unsafe here, first rename, after write is complete, delete the old.
+                aFile.delete();
+                if (aFile.exists())
+                {
+                    GlobalLogWriter.println("Couldn't delete the file " + m_sFilename);
+                    return;
+                    // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, "Couldn't delete the file " + m_sFilename);
+                }
+            }
+            // if (! aFile.canWrite())
+            // {
+            //    System.out.println("Couldn't write to file " + m_sFilename);
+            //    DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, "");
+            // }
+            try
+            {
+                RandomAccessFile aWriter = new RandomAccessFile(aFile, "rw");
+                for (int i = 0; i < m_aList.size(); i++)
+                {
+                    String sLine = getItem(i);
+                    if (sLine.startsWith("["))
+                    {
+                        // write an extra empty line before next section.
+                        aWriter.writeByte((int) '\n');
+                    }
+                    aWriter.writeBytes(sLine);
+                    aWriter.writeByte((int) '\n');
+                }
+                aWriter.close();
+            }
+            catch (java.io.FileNotFoundException fne)
+            {
+                GlobalLogWriter.println("couldn't open file for writing " + m_sFilename);
+                GlobalLogWriter.println("Message: " + fne.getMessage());
+                // DebugHelper.exception(BasicErrorCode.SbERR_FILE_NOT_FOUND, "");
+            }
+            catch (java.io.IOException ie)
+            {
+                GlobalLogWriter.println("Exception occurs while writing to file " + m_sFilename);
+                GlobalLogWriter.println("Message: " + ie.getMessage());
+                // DebugHelper.exception(BasicErrorCode.SbERR_INTERNAL_ERROR, ie.getMessage());
+            }
+        }
+
+    public void insertValue(String _sSection, String _sKey, int _nValue)
+        {
+            insertValue(_sSection, _sKey, String.valueOf(_nValue));
+        }
+
+    public void insertValue(String _sSection, String _sKey, long _nValue)
+        {
+            insertValue(_sSection, _sKey, String.valueOf(_nValue));
+        }
+
+    /**
+       insert a value
+       there are 3 cases
+       1. section doesn't exist, goto end and insert a new section, insert a new key value pair
+       2. section exist but key not, search section, search key, if key is -1 get last known key position and insert new key value pair there
+       3. section exist and key exist, remove the old key and insert the key value pair at the same position
+     * @param _sSection
+     * @param _sKey
+     * @param _sValue
+     */
+    public void insertValue(String _sSection, String _sKey, String _sValue)
+        {
+            int i = findSection(_sSection);
+            if (i == -1)
+            {
+                // case 1: section doesn't exist
+                String sFindSection = buildSectionName(_sSection);
+
+                // TODO: before create a new Section, insert a empty line
+                m_aList.add(sFindSection);
+                if (_sKey.length() > 0)
+                {
+                    String sKeyValuePair = _sKey + "=" + _sValue;
+                    m_aList.add(sKeyValuePair);
+                }
+                m_bListContainUnsavedChanges = true;
+                return;
+            }
+            int j = findKeyFromKnownSection(i, _sKey);
+            if (j == -1)
+            {
+                // case 2: section exist, but not the key
+                j = findLastKnownKeyIndex(i, _sKey);
+                if (_sKey.length() > 0)
+                {
+                    String sKeyValuePair = _sKey + "=" + _sValue;
+                    m_aList.add(j, sKeyValuePair);
+                    m_bListContainUnsavedChanges = true;
+                }
+                return;
+            }
+            else
+            {
+                // case 3: section exist, and also the key
+                String sKeyValuePair = _sKey + "=" + _sValue;
+                m_aList.set(j, sKeyValuePair);
+                m_bListContainUnsavedChanges = true;
+            }
+        }
+    // -----------------------------------------------------------------------------
+    // String replaceEvaluatedValue(String _sSection, String _sValue)
+    //     {
+    //         String sValue = _sValue;
+    //         int nIndex = 0;
+    //         while (( nIndex = sValue.indexOf("$(", nIndex)) >= 0)
+    //         {
+    //             int nNextIndex = sValue.indexOf(")", nIndex);
+    //             if (nNextIndex >= 0)
+    //             {
+    //                 String sKey = sValue.substring(nIndex + 2, nNextIndex);
+    //                 String sNewValue = getValue(_sSection, sKey);
+    //                 if (sNewValue != null && sNewValue.length() > 0)
+    //                 {
+    //                     String sRegexpKey = "\\$\\(" + sKey + "\\)";
+    //                     sValue = sValue.replaceAll(sRegexpKey, sNewValue);
+    //                 }
+    //                 nIndex = nNextIndex;
+    //             }
+    //             else
+    //             {
+    //                 nIndex += 2;
+    //             }
+    //         }
+    //         return sValue;
+    //     }
+    // -----------------------------------------------------------------------------
+
+    // public String getLocalEvaluatedValue(String _sSection, String _sKey)
+    //     {
+    //         String sValue = getValue(_sSection, _sKey);
+    //         sValue = replaceEvaluatedValue(_sSection, sValue);
+    //         return sValue;
+    //     }
+
+    // -----------------------------------------------------------------------------
+
+    // this is a special behaviour.
+    // public String getGlobalLocalEvaluatedValue(String _sSection, String _sKey)
+    //     {
+    //         String sGlobalValue = getKey("global", _sKey);
+    //         String sLocalValue = getKey(_sSection, _sKey);
+    //         if (sLocalValue.length() == 0)
+    //         {
+    //             sGlobalValue = replaceEvaluatedKey(_sSection, sGlobalValue);
+    //             sGlobalValue = replaceEvaluatedKey("global", sGlobalValue);
+    //             return sGlobalValue;
+    //         }
+    //         sLocalValue = replaceEvaluatedKey(_sSection, sLocalValue);
+    //         sLocalValue = replaceEvaluatedKey("global", sLocalValue);
+    //
+    //         return sLocalValue;
+    //     }
+    public void removeSection(String _sSectionToRemove)
+        {
+            // first, search for the name
+            int i = findSection(_sSectionToRemove);
+            if (i == -1)
+            {
+                // Section to remove not found, do nothing.
+                return;
+            }
+            // second, find the next section
+            int j = findNextSection(i + 1);
+            if (j == -1)
+            {
+                // if we are at the end, use size() as second section
+                j = m_aList.size();
+            }
+            // remove all between first and second section
+            for (int k = i; k < j; k++)
+            {
+                m_aList.remove(i);
+            }
+            // mark the list as changed
+            m_bListContainUnsavedChanges = true;
+        }
+
+    /**
+     * some tests for this class
+     */
+//    public static void main(String[] args)
+//        {
+//            String sTempFile = System.getProperty("java.io.tmpdir");
+//            sTempFile += "inifile";
+//
+//
+//            IniFile aIniFile = new IniFile(sTempFile);
+//            String sValue = aIniFile.getValue("Section", "Key");
+//            // insert a new value to a already exist section
+//            aIniFile.insertValue("Section", "Key2", "a new value in a existing section");
+//            // replace a value
+//            aIniFile.insertValue("Section", "Key", "replaced value");
+//            // create a new value
+//            aIniFile.insertValue("New Section", "Key", "a new key value pair");
+//            aIniFile.insertValue("New Section", "Key2", "a new second key value pair");
+//
+//            String sValue2 = aIniFile.getValue("Section2", "Key");
+//
+//            aIniFile.removeSection("Section");
+//            aIniFile.removeSection("New Section");
+//
+//            aIniFile.close();
+//        }
+
+    /**
+     * Enumeration Interface
+     * @return true, if there are more Key values
+     */
+    public boolean hasMoreElements()
+        {
+            if (m_aEnumerationPos >= 0 &&
+                m_aEnumerationPos < m_aList.size())
+            {
+                return true;
+            }
+            return false;
+        }
+
+    /**
+     * Find the next line, which starts with '['
+     * @param i start position
+     * @return the line where '[' found or -1
+     */
+    private int findNextSection(int i)
+        {
+            if (i >= 0)
+            {
+                while (i < m_aList.size())
+                {
+                    String sLine =  m_aList.get(i);
+                    if (sLine.startsWith("["))
+                    {
+                        return i;
+                    }
+                    i++;
+                }
+            }
+            return -1;
+        }
+
+    /**
+     * Enumeration Interface
+     * @return a key without the enveloped '[' ']'
+     */
+    public Object nextElement()
+        {
+            int nLineWithSection = findNextSection(m_aEnumerationPos);
+            if (nLineWithSection != -1)
+            {
+                String sSection =  m_aList.get(nLineWithSection);
+                m_aEnumerationPos = findNextSection(nLineWithSection + 1);
+                sSection = sectionToString(sSection);
+                return sSection;
+            }
+            else
+            {
+                m_aEnumerationPos = m_aList.size();
+            }
+            return null;
+        }
+
+    /**
+     * Helper to count the occurence of Sections
+     * @return returns the count of '^['.*']$' Elements
+     */
+    public int getElementCount()
+        {
+            int nCount = 0;
+            int nPosition = 0;
+            while ((nPosition = findNextSection(nPosition)) != -1)
+            {
+                nCount++;
+                nPosition++;
+            }
+            return nCount;
+        }
+}
+