source: trunk/gli/src/org/greenstone/gatherer/util/TreeModelTest.java@ 5170

package org.greenstone.gatherer.util;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.util.DefaultSynchronizedTreeNode;
import org.greenstone.gatherer.util.SynchronizedTreeModel;
import org.greenstone.gatherer.util.SynchronizedTreeNode;

public class TreeModelTest
    extends JFrame {

    /** Testing - test frame size. */
    static final private Dimension SIZE = new Dimension(400,400);

    /** Testing - should a debug file be written. */
    static private boolean debug = false;

    /** Testing - debug output stream. */
    static private FileOutputStream output = null;

    /** Testing - write a message to the debug file. */
    static void debug(String message) {
        if(debug) {
            try {
                if(output == null) {
                    output = new FileOutputStream(new File("debug.txt"));
                }
                output.write(message.getBytes());
                output.flush();

            }
            catch (Exception error) {
                error.printStackTrace();
            }
        }
    }

    /** Testing - usage message. */
    static void printUsage() {
        System.out.println("Usage: java Test3 [-safe] [-debug]");
        System.out.println(" safe  - use SynchronizedTreeModel");
        System.out.println(" debug - write debug messages to debug.txt file\n");
        System.out.println("Actions:");
        System.out.println(" 'Add Node' - Adds a new node to the selected node. Since this happens on the AWTEvent Thread it should always be safe.");
        System.out.println(" 'Remove Node' - Removes the selected node. Since this happens on the AWTEvent Thread it should always be safe.");
        System.out.println(" 'Preset Structure' - Generates a small preset structure on a seperate (dangerous) thread.");
        System.out.println(" 'Dangerous' - The ultimate test. Hammers the model with incessant random mutations from a separate thread.");
        System.exit(0);
    }
    /** Testing - creates a frame containing a JTree backed by either a normal DefaultTreeModel or a SynchronizedTreeModel depending on arguments. There are also several actions you can perform by clicking on buttons. */
    static public void main(String[] args) {
        boolean safe = false;
        if(args.length <= 2) {
            for(int i = 0; i < args.length; i++) {
                String arg = args[i];
                if(arg.equalsIgnoreCase("-safe")) {
                    safe = true;
                }
                else if(arg.equalsIgnoreCase("-debug")) {
                    debug = true;
                }
                else {
                    printUsage();
                }
            }
        }
        else {
            printUsage();
        }
        new TreeModelTest(safe);
    }

    /** Testing - a dangerous thread which hammers the mutable tree model. */
    private DangerousTask task;

    /** Testing - a dangerous thread which builds a preset structure. */
    private DangerousTask preset_task;

    /** Testing - the tree model, which may be a SynchronizedTreeModel. */
    private DefaultTreeModel model;

    /** Testing - a button for toggling the dangerous thread on and off. */
    private JToggleButton dangerous_button;

    /** Testing - the tree used during testing. */
    private JTree tree;

    TreeModelTest(boolean safe) {
        super("Testing");
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(SIZE);
        JPanel content_panel = (JPanel) getContentPane();
        // Creation

        task = new DangerousTask(false);
        preset_task = new DangerousTask(true);

        if(safe) {
            model = new SynchronizedTreeModel(new DefaultSynchronizedTreeNode("Root"));
        }
        else {
            model = new DefaultTreeModel(new DefaultMutableTreeNode("Root"));
        }

        tree = new JTree(model);

        JPanel button_panel = new JPanel();
        JButton add_button = new JButton("Add Node");
        dangerous_button = new JToggleButton("Dangerous!");
        dangerous_button.setSelected(false);
        JButton remove_button = new JButton("Remove Node");
        JButton preset_button = new JButton("Preset Structure");

        // Connection
        add_button.addActionListener(new AddListener());
        dangerous_button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                if(dangerous_button.isSelected()) {
                    task.start();
                }
                else {
                    task.exit = true;
                }
            }
        });
        remove_button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                ///ystem.err.println("*** Start Remove ***");
                // Get the selected node
                TreePath selected_path = tree.getSelectionPath();
                if(selected_path != null) {
                    DefaultMutableTreeNode old_child = (DefaultMutableTreeNode)     selected_path.getLastPathComponent();
                    if(!old_child.isRoot()) {
                        // Remove node.
                        model.removeNodeFromParent(old_child);
                    }
                }
                ///ystem.err.println("*** End Remove ***\n");
            }
        });
        preset_button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                preset_task.start();
            }
        });

        // Layout
        button_panel.setLayout(new GridLayout(2,2));
        button_panel.add(add_button);
        button_panel.add(remove_button);
        button_panel.add(preset_button);
        button_panel.add(dangerous_button);

        content_panel.setLayout(new BorderLayout());
        content_panel.add(new JScrollPane(tree), BorderLayout.CENTER);
        content_panel.add(button_panel, BorderLayout.SOUTH);

        // Display
        Dimension screen_size = Toolkit.getDefaultToolkit().getScreenSize();
        setLocation((screen_size.width - SIZE.width) / 2, (screen_size.height - SIZE.height) / 2);
        show();
    }

    private class AddListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            ///ystem.err.println("*** Start Add ***");
            // Get the selected node
            TreePath selected_path = tree.getSelectionPath();
            if(selected_path != null) {
                DefaultMutableTreeNode parent = (DefaultMutableTreeNode)    selected_path.getLastPathComponent();
                // Create a new node
                MutableTreeNode new_child = new DefaultSynchronizedTreeNode(    String.valueOf(System.currentTimeMillis()));
                // Insert node.
                model.insertNodeInto(new_child, parent, parent.getChildCount());
            }
            ///ystem.err.println("*** End Add ***\n");
        }
    }

    private class DangerousTask
        extends Thread {

        private boolean exit = false;
        private boolean preset = false;

        DangerousTask(boolean preset) {
            this.preset = preset;
        }

        public void run() {
            if(preset) {
                DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
                MutableTreeNode alpha = new DefaultSynchronizedTreeNode("Alpha");
                MutableTreeNode beta = new DefaultSynchronizedTreeNode("Beta");
                MutableTreeNode delta = new DefaultSynchronizedTreeNode("Delta");
                MutableTreeNode gamma = new DefaultSynchronizedTreeNode("Gamma");
                MutableTreeNode epsilon = new DefaultSynchronizedTreeNode("Epsilon");
                MutableTreeNode rho = new DefaultSynchronizedTreeNode("Rho");
                MutableTreeNode pi = new DefaultSynchronizedTreeNode("Pi");
                MutableTreeNode xhi = new DefaultSynchronizedTreeNode("Xhi");
                MutableTreeNode kappa = new DefaultSynchronizedTreeNode("Kappa");
                MutableTreeNode lambda = new DefaultSynchronizedTreeNode("Lambda");
                MutableTreeNode omega = new DefaultSynchronizedTreeNode("Omega");MutableTreeNode tau = new DefaultSynchronizedTreeNode("Tau");

                model.insertNodeInto(alpha, root, 0);
                model.insertNodeInto(omega, root, 1);
                model.insertNodeInto(pi, root, 1);

                model.insertNodeInto(beta, alpha, 0);
                model.insertNodeInto(delta, beta, 0);
                model.insertNodeInto(epsilon, delta, 0);
                model.insertNodeInto(gamma, delta, 0);
                model.insertNodeInto(rho, pi, 0);
                model.insertNodeInto(xhi, alpha, 0);
                model.insertNodeInto(kappa, root, 1);


                debug("Root has: " + model.getChildCount(model.getRoot()));
            }
            else {
                exit = false;
                while(!exit) {
                    // Find a random node
                    DefaultMutableTreeNode current = (DefaultMutableTreeNode) model.getRoot();
                    while(Math.random() > 0.3 && model.getChildCount(current) > 0) {
                        int index = (int)(Math.random() * (model.getChildCount(current) - 1));
                        current = (DefaultMutableTreeNode) model.getChild(current, index);
                    }
                    // Either add or remove a random node.
                    if(Math.random() > 0.9) {
                        ///ystem.err.println("<< Expand >>");
                        TreePath path = new TreePath(model.getPathToRoot(current));
                        tree.expandPath(path);
                    }
                    else if(Math.random() > 0.4 || current.isRoot()) {
                        if(model.getChildCount(current) < 25) {
                            ///ystem.err.println("<<< Add >>>");
                            // Add a new node
                            MutableTreeNode new_child = new DefaultSynchronizedTreeNode(String.valueOf(System.currentTimeMillis()));
                            // Insert node.
                            model.insertNodeInto(new_child, current, model. getChildCount(current));
                            ///ystem.err.println("<<<     >>>\n");
                        }
                    }
                    else {
                        ///ystem.err.println("<<< Remove >>>");
                        // Remove node.
                        model.removeNodeFromParent(current);
                        ///ystem.err.println("<<<        >>>\n");

                    }
                    // Wait some random minute amount of time
                    try {
                        synchronized(this) {
                            wait((int)(5 * Math.random()) + 1);
                        }
                    } catch (Exception exception) {
                        exception.printStackTrace();
                    }
                }
            }
        }
    }
}