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

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;
    }

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;
    }

    /**
     * This method will return data for the given datapool column name in the
     * file... Use this method if you just want 1 column. Jun 3, 2015
     * 
     * @author kadhikari
     * @param datapoolPath
     * @param columnName
     * @return
     */
    public static String getData(String datapoolPath, String columnName) {

        return new Datapool().getDPData(datapoolPath,
                new String[] { columnName })[0];
    }

    /**
     * This method will return data for the given datapool column names in the
     * file... Use this method if you just want to return value of multiple
     * columns Jun 3, 2015
     * 
     * @author kadhikari
     * @param datapoolPath
     * @param columnName
     * @return
     */
    public static String[] getData(String datapoolPath, String[] columnName) {

        return new Datapool().getDPData(datapoolPath, columnName);
    }

    private String[] getDPData(String datapoolPath, String[] columnNames) {
        if(!datapoolPath.contains(System.getProperty("user.dir"))){
            datapoolPath = System.getProperty("user.dir") + "\\" + datapoolPath;    
        }
        java.io.File dpFile =new File(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();
        String[] datapoolValue = new String[columnNames.length];
        int i = 0;
        for (String columnName : columnNames) {
            datapoolValue[i] = dpIter.dpCurrent().getCell(columnName)
                    .getStringValue();
            i++;
        }
        dpIter.dpReset();
        dpFactory().close(dpIter);

        return datapoolValue;
    }

    public static String getDataFromCSV(String csvFile, int lineNo) {
        return readCSV(csvFile, lineNo);
    }

    public static String getDataFromCSV(String csvFile) {
        return readCSV(csvFile, 0);
    }

    private static String readCSV(String csvFile, int lineNo) {

        IDatapool dataPool = DatapoolUtilities.loadCSV(new File(csvFile));
        IDatapoolEquivalenceClass equivalenceClass = (IDatapoolEquivalenceClass) dataPool
                .getEquivalenceClass(0);

        IDatapoolRecord record = (IDatapoolRecord) equivalenceClass
                .getRecord(lineNo);
        IDatapoolCell cell = (IDatapoolCell) record.getCell(0);
        String data = cell.getStringValue().trim();

        return data;

    }

/**
     *fileLocation=url or location of a file.<br>
     *name=Display name in the RFT HTML log file.<br>
     *Dec 11, 2015
     *@author kadhikari
     * @param fileLocation
     * @param name
     */
    public static void  addLinkToHTMLLog(String url,String name){
        logInfo("<a href=\""+url+"\">"+name+"</a>");
    }

/**
     * From is the array which you want to convert.Replace it with any array variable like String ,int.... <br> 
     * To is the array type you want to convert to.Replace it with any array variable like String ,int....<br>
     * 
     *Dec 11, 2015
     *@author kadhikari
     * @param objectArray
     * @return
     */

private To[ ] convertType(From[ ] objectArray){

        return Arrays.copyOf(objectArray, objectArray.length, To[ ].class);
        
        }