MrCoolK

This piece of code will delete the unused object in the object map.

Just replace the following variables:     workspacePath, scriptFolderName and  scriptName with appropriate data.

This code is tested but cant assure 100%.

Please use at your own risk.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * @author 
 * 
 */
public class DeleteUnusedObjectRFT {

    
    private static String workspacePath="Z:\\AQA_Projects\\NEGOTIATED_Bonds";//Give your RFT workspace path
    private static String scriptFolderName="eNegBonds_Trading.Submit_Termsheet.TestCases".replace(".", "\\");//Give your script package/folder name
    private static String scriptName="Submit_Termsheet_As_Underwriter_kishan.java";//Give your rft script name

    private static String rftdefFilePath = "";
    private static String helperFilePath = "";
    private static String scriptFilePath = "";

    
    public static void main(String[] args) throws IOException
    {
        DeleteUnusedObjectRFT obj = new DeleteUnusedObjectRFT();
        obj.initialize();
        obj.updateUnusedObjects(obj.getUnusedObjects());
        System.out.println(obj.refactorRFTDEF()+" and saved at "+rftdefFilePath);
    }

    
    public void  initialize()
    {
        if(scriptFolderName==null){
            rftdefFilePath = workspacePath+"\\resources\\"+scriptName.replace(".java", ".rftdef");
            helperFilePath = workspacePath + "\\resources\\" +  scriptName.replace(".", "Helper.");
            scriptFilePath = workspacePath + "\\" +  scriptName;
        
            
        }else{
            rftdefFilePath = workspacePath+"\\resources\\"+scriptFolderName+"\\"+scriptName.replace(".java", ".rftdef");
            helperFilePath = workspacePath + "\\resources\\" + scriptFolderName + "\\"+ scriptName.replace(".", "Helper.");
            scriptFilePath = workspacePath + "\\" + scriptFolderName + "\\" + scriptName;
        
        }
}

    
    @SuppressWarnings("resource")
    public ArrayList<String> getUnusedObjects() throws IOException

    {
        Reader readHelper;
        BufferedReader helperBufferReader;
        Reader readMainScript;
        BufferedReader mainScriptBufferReader;

        // Reading helper class
        readHelper = new FileReader(helperFilePath);
        helperBufferReader = new BufferedReader(readHelper);
        // Reading Script files
        readMainScript = new FileReader(scriptFilePath);
        mainScriptBufferReader = new BufferedReader(readMainScript);

        ArrayList<String> mainScriptArray = new ArrayList<String>();
        ArrayList<String> usedObjects = new ArrayList<String>();
        ArrayList<String> UnusedObjects = new ArrayList<String>();

        String tempLine = "";
        while ((tempLine = mainScriptBufferReader.readLine()) != null) {
            mainScriptArray.add(tempLine);
        }
        tempLine = "";
        int found =0;
        @SuppressWarnings("unused")
        int allObjectAreUsed=0;
        while ((tempLine = helperBufferReader.readLine()) != null) {
            if ((tempLine.contains("protected") && tempLine.contains("()"))
                    && (!tempLine.contains("Helper")) && (!tempLine.contains("IFtVerificationPoint"))) {
                String object = tempLine.split(" ")[2];
                found = 0;
                for (int i = 0; i < mainScriptArray.size(); i++) {
                    if (mainScriptArray.get(i).contains(object.replace(")", ""))) {
                        found++;
                    }

                }
                if (found == 0) {
                    UnusedObjects.add(object);
                    allObjectAreUsed++;                    
                }
                if (found != 0)
                {
                    usedObjects.add(object);
                }
            }
        }
        System.out.println("Script Name : "+scriptName);
        System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
        System.out.println("Total Objects exists in the given script : "+(UnusedObjects.size()+usedObjects.size()));
        System.out.println("Total Unused Objects in the given script : "+UnusedObjects.size());
        System.out.println("Total Used Objects in the given script   : " + usedObjects.size());
        /*
        //if you want to print object names uncomment following code
        System.out.println("\n==>Following are the names of Unused Objects in the given script i.e. "+scriptName+"\n");
        for ( int i = 0; i<UnusedObjects.size(); i++)
        {
            System.out.println(UnusedObjects.get(i));
        }

        System.out.println("\n==>Following are the names of Used Objects in the given script i.e. "+scriptName+"\n");
        for ( int i = 0; i<usedObjects.size(); i++)
        {
            System.out.println(usedObjects.get(i));
        }
        if (allObjectAreUsed == 0 ) {
            System.out.println("All objects are used in the given script i.e. "+scriptName+"\n");
        }*/

        return UnusedObjects;

    }

    public String updateUnusedObjects(ArrayList<String> unusedObjectsList) throws IOException
    {
        File xmlFile = new File(rftdefFilePath);
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        dbFactory.setNamespaceAware(true);
        dbFactory.setIgnoringElementContentWhitespace(true);

        DocumentBuilder dBuilder;
        try {
            dBuilder = dbFactory.newDocumentBuilder();
            Document doc = dBuilder.parse(xmlFile);
            doc.getDocumentElement().normalize();
            NodeList employees = doc.getElementsByTagName("TestObject");
            Element emp = null;
            int noOfObjectsUpdatedToTrue=0;
            for(int i=0; i<employees.getLength();i++){
                emp = (Element) employees.item(i);
                String s=emp.getElementsByTagName("Name").item(0).getTextContent();

                for(int j=0;j<unusedObjectsList.size();j++)
                { 
                    if(s.equals(unusedObjectsList.get(j).replace("()", "")))
                    {
                        Node name = emp.getElementsByTagName("Deleted").item(0).getFirstChild();
                        name.setTextContent("true");
                        noOfObjectsUpdatedToTrue++;                         
                    }
                }

            }
            System.out.println("Total number of unused objects updated to TRUE are : "+noOfObjectsUpdatedToTrue);
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File(rftdefFilePath));
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.transform(source, result);
            
        }
        catch (SAXException | ParserConfigurationException | IOException | TransformerException e1) {
            e1.printStackTrace();
        }
        return "unused objects updated successfully";
    }
    

    /**
      *25th July 2015<br>
      *<B><U><FONT color="BLUE">Few notes about this method</FONT></U></B><br>
      * Following method[refactorRFTDEF()] is optional. I just created to make sure that before and after updating rftdef  file xml tags should be same.
        <br>actually while creating[updateUnusedObjects() method updates .rftdef file] updated rftdef file it is just converting and creating in standard xml format which is expected and it will not break any functionality.
        <br>So you can ignore calling of this method[refactorRFTDEF()]
        <br>if required you may need to change this method according to your rftdef file content and replace how you want your final rftdef file.
    <br>
      * @return
      * @throws IOException
    */
    public String refactorRFTDEF() throws IOException
    {
        //Refactor updated rftdef file
        File file = new File(rftdefFilePath);
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String tempStr = "", completeFilecontent = "";
        while((tempStr = reader.readLine()) != null)
        {
            completeFilecontent += tempStr + "\r\n";
        }
        reader.close();
        // replace a word in a file
        String temp1 = completeFilecontent.replaceAll("standalone=\"no\"", "");

        String temp2 = temp1.replaceAll("L=\".PropSet\"/>", " L=\".PropSet\"></Properties>");
        String temp3 = temp2.replaceAll("<KeywordName/>", "<KeywordName></KeywordName>");
        String updatedFileContent = temp3.replaceAll("<VisualScriptName/>", "<VisualScriptName></VisualScriptName>");
        FileWriter writer = new FileWriter(rftdefFilePath);
        writer.write(updatedFileContent);
        writer.close();

        return "RFTDEF file refactored successfully ";

    }

}

Below method makes your script wait until the browser is in ready state  

  public static boolean waitForAllBrowsers( int timeOut) {

Below mention code is just to find a web Browser and close it.

This will give you a hint how you can capture object dynamically and perform some action.

    public void closeBrowser(){
        // Get the RootTestObject
        RootTestObject root = RootTestObject.getRootTestObject();
        
        // Find all the windows on the system
        IWindow windows[] = root.getTopWindows();
        String className;
        
        for (int i=0;i<windows.length;i++)
        {
            // Get the class name of each window
            className = windows[i].getWindowClassName();
            System.out.println(className);
            // If the window is an instance of IE, close it
            if (className.equals("IEFrame"))
            {//if this matches your application you can use the find method to find the object .Find method has been listed in my other code...
                System.out.println("***************"+className);
                windows[i].close();
            }
        }
    }

Thanks

Cool K

    /**
     *Jan 24, 2017
     *@author kadhikari
     * @param matrix
     * @return
     */
    public static String[][] transposeArray(String[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        String[][] trasposedMatrix = new String[n][m];
        for (int x = 0; x < n; x++) {
            for (int y = 0; y < m; y++) {
                trasposedMatrix[x][y] = matrix[y][x];
            }
        }
        return trasposedMatrix;
    }

For String

s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", "");

String s = "10.1200";
DecimalFormat decimalFormat = new DecimalFormat("0.#####");
String result = decimalFormat.format(Double.valueOf(s));
System.out.println(result);

s.replaceFirst("\\.0*$|(\\.\\d*?)0+$", "$1");

Just type ma and press Ctrl + Space, you will get an option for it.

To get  or  update the excel file use below mention methods .Tab name will be schema name in sql query

public static List<List<String>>  executeQuery(String fileName,
            String query) throws FilloException{
        
                return executeExcelQuery(fileName, query);
            }
    
    public static String executeUpdateQuery(String fileName, String query)
            throws FilloException {

        Fillo fillo = new Fillo();
        Connection connection = fillo.getConnection(fileName);
        connection.executeUpdate(query);
        connection.close();

        return "Update was Successful";
    }
    
    /**
     * This method treats excel as a database.<BR>You can get data from the excel. 
     * file just using a basic query.<BR>
     * Dec 14, 2016
     * @author kadhikari
     * @param fileName
     * @param query
     * @return
     * @throws FilloException
     */
    public static List<List<String>> executeExcelQuery(String fileName,
            String query) throws FilloException {
        List<List<String>> listOfLists = new ArrayList<List<String>>();
        List<String> someList = new ArrayList<String>();

        Fillo fillo = new Fillo();
        Connection connection = fillo.getConnection(fileName);
        query = query.toUpperCase();
        logger.debug(query);
        Recordset recordset = connection.executeQuery(query);

        logger.debug("total number of row returned " + recordset.getCount());
        while (recordset.next()) {
            ArrayList<String> dataColl = recordset.getFieldNames();
            logger.debug("Total data column " + dataColl);
            Iterator<String> dataIterator = dataColl.iterator();

            String[] columns = columnsSplit(query);

            int width = 0;
            // Width size
            if (query.contains("*")) {
                width = dataColl.size();
                logger.debug(width);
            } else {
                width = columns.length;
                logger.debug(width);
            }

            String[] rowByRow = new String[width];
            int rowNo = 0;
            while (dataIterator.hasNext()) {
                for (int i = 0; i <= dataColl.size() - 1; i++) {
                    String data = dataIterator.next();

                    if (query.contains("*")) {

                        String dataVal = recordset.getField(data);
                        logger.debug(dataVal);
                        rowByRow[rowNo] = dataVal;
                        rowNo++;

                    } else {

                        logger.debug(columns.length);
                        for (String column : columns) {
                            if (column.length() > 0) {
                                if (data.equalsIgnoreCase(column)) {

                                    String dataVal = recordset.getField(column);
                                    rowByRow[rowNo] = dataVal;
                                    logger.debug(dataVal);
                                    rowNo++;

                                }

                            }
                        }

                    }

                }
                listOfLists.add(Arrays.asList(rowByRow));
                rowNo = 0;
                someList.iterator();
                break;
            }
        }

        recordset.close();
        connection.close();

        return listOfLists;
    }

    /**
     * Dec 14, 2016
     * @author kadhikari
     * @param query
     * @return
     */
    private static String[] columnsSplit(String query) {
        int start = 7;
        int end = query.indexOf(" FROM");
        String columnsWithComma = query.substring(start, end);
        return columnsWithComma.split(",");

    }

    public void clickInsideGuiSubitemTestObject(GuiSubitemTestObject guiSubitemTestObject, String text,String columnName) {
        ITestDataTable testTable = (ITestDataTable) guiSubitemTestObject
                .getTestData("alldata");
        int rowNumber = 0;
        int columnNumber = 0;
        for (int row = 0; row < testTable.getRowCount(); row++) {
            // Cycle through all columns
            for (int col = 0; col < testTable.getColumnCount(); col++) {
                if (text.equalsIgnoreCase((String) testTable.getCell(row, col))) {
                    columnNumber = col;
                    rowNumber = row;
                    break;
                }
            }
        }

        guiSubitemTestObject.click(atCell(atRow(atIndex(rowNumber + 1)),atColumn(atName(columnName))));

    }

Mouse Scroll

LowLevelEvent llEvents[] = new LowLevelEvent[1];

llEvents[0] = mouseWheel(-25);
getRootTestObject().emitLowLevelEvent(llEvents);

Just add    ANY,MAY_EXIT inside the parenthesis of your object.

 yesbutton(ANY,MAY_EXIT).click();

You can use any of the code depending upon your java type

java 7:

String[] unique = new HashSet<String>(Arrays.asList(array)).toArray(new String[0]);

 java 8:

String[] unique = Arrays.stream(array).distinct().toArray(new String[0]);

/**
     * This method will insert new column in the datapool
     *Feb 4, 2016
     *@author kadhikari
     * @param datapoolFile
     * @param columnName
     * @return
     */
    public static boolean insertNewDatapoolColumn(String datapoolFile, String columnName){
        logger.info(datapoolFile);
        logger.info(columnName);
        if(!datapoolFile.contains(System.getProperty("user.dir"))){
            datapoolFile = System.getProperty("user.dir") + "\\" + datapoolFile;    
        }
        DatapoolFactory dpFactory = DatapoolFactory.get();
        java.io.File TestData =new File(datapoolFile);
        IDatapool datapool = dpFactory.loadForEdit(TestData, true);

        //Get column index
        int columnToBeInserted = datapool.getVariableIndex(columnName);
        IDatapoolVariable newColumnVariable = (IDatapoolVariable) datapool.constructVariable(); 
        newColumnVariable.setName(columnName);    
 
        if(columnToBeInserted == -1)
        {
        logInfo("There is no pre existing Datapool Column with the name "+columnName+" in the datapool.");    
        datapool.appendVariable(newColumnVariable);    
        }

        else
        {
        datapool.removeVariable(columnToBeInserted);
        datapool.insertVariable(newColumnVariable, columnToBeInserted);
        }

        return true;
        } 

    public static void update(String datapoolFile, String datapoolColumnName[],
            String datapoolData[]) {
        
        if(!datapoolFile.contains(System.getProperty("user.dir"))){
            datapoolFile = System.getProperty("user.dir") + "\\" + datapoolFile;    
        }
        logger.debug(datapoolFile);
        DatapoolFactory dpFactory = DatapoolFactory.get();
        
        IDatapool dataPool = dpFactory
                .loadForEdit(new File(datapoolFile), true);
        
        int equivalenceClassIndex = dataPool.getDefaultEquivalenceClassIndex();
        IDatapoolEquivalenceClass equivalenceClass = (IDatapoolEquivalenceClass) dataPool
                .getEquivalenceClass(equivalenceClassIndex);
        IDatapoolRecord record = (IDatapoolRecord) equivalenceClass
                .getRecord(0);
        IDatapoolCell cell = null;
        for (int i = 0; i < datapoolColumnName.length; i++) {
            cell = (IDatapoolCell) record.getCell(datapoolColumnName[i]);
            cell.setCellValue(datapoolData[i]);
        }

        dpFactory.save(dataPool);
        dpFactory.unload(dataPool);
        logger.debug("Datapool Updated");

    }

public static ArrayList<String>  getAllData(String datapoolPath, String columnName) {

        return new Datapool().getLoopData(datapoolPath,
                new String[] { columnName });
    }
    private ArrayList<String> getLoopData(String datapoolPath, String[] columnNames) {
        logger.info(datapoolPath);
        java.io.File dpFile = new java.io.File(
                (String) getOption(IOptionName.DATASTORE), datapoolPath);
        IDatapool dp = (IDatapool) dpFactory().load(dpFile, true);
        // Use default iterator class
        IDatapoolIterator dpIter = dpFactory().open(dp, null);
        // Use default equivalence class
        dpIter.dpInitialize(dp);
        dpIter.dpReset();

        ArrayList<String> data = new ArrayList<String>();
        
    
        for (String columnName : columnNames) {
            while (!dpIter.dpDone()) {    
                data.add( dpIter.dpCurrent().getCell(columnName).getStringValue());
                dpIter.dpNext();
            }
        }
        dpIter.dpReset();
        dpFactory().close(dpIter);

        return data;
    }