org.eclipse.linuxtools.lttng.core.latency.analyzer,

 org.eclipse.linuxtools.lttng.core.tracecontrol,

/*******************************************************************************

 * Copyright (c) 2011 Ericsson

 * 

 * All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse

 * Public License v1.0 which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors: 

 *   Philippe Sawicki (INF4990.A2010@gmail.com)   - Initial API and implementation

 *   Mathieu Denis    (mathieu.denis55@gmail.com) - Refactored code

 *******************************************************************************/

package org.eclipse.linuxtools.lttng.core.latency.analyzer;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map.Entry;

import java.util.Set;

import java.util.Stack;

import java.util.Vector;

import org.eclipse.linuxtools.lttng.core.event.LttngEvent;

import org.eclipse.linuxtools.lttng.core.util.EventsPair;

/**

 * <b><u>EventMatcher</u></b>

 * <p>

 * Event matching class. Saves events in a list and returns the previously saved event if the currently processed one is

 * its response, so that the latency can be computed by subtracting their respective timestamps.

 * 

 * @author Philippe Sawicki

 */

public class EventMatcher {

    // ------------------------------------------------------------------------

    // Attributes

    // ------------------------------------------------------------------------

    /**

     * Class instance (Singleton pattern).

     */

    private static EventMatcher fInstance = null;

    /**

     * Stack abstraction, used to save the events in a list.

     */

    private StackWrapper fStack;

    /**

     * Match table, associates a request class to a response class.

     */

    private HashMap<String, String> fMatch;

    /**

     * Inverse match table, associates a response class to a request class.

     */

    private HashMap<String, String> fInverseMatch;

    /**

     * The number of events processed.

     */

    private int fProcessedEvents;

    /**

     * The number of events matched.

     */

    private int fMatchedEvents;

	/**

	 * Event types identification Strings.

	 */

	@SuppressWarnings("nls")

    public static String

		ADD_TO_PAGE_CACHE         = "add_to_page_cache",

		BIO_BACKMERGE             = "bio_backmerge",

		BIO_FRONTMERGE            = "bio_frontmerge",

		BIO_QUEUE                 = "bio_queue",

		BUFFER_WAIT_END           = "buffer_wait_end",

		BUFFER_WAIT_START         = "buffer_wait_start",

		CALL                      = "call",

		CLOSE                     = "close",

		CORE_MARKER_FORMAT        = "core_marker_format",

		CORE_MARKER_ID            = "core_marker_id",

		DEV_RECEIVE               = "dev_receive",

		DEV_XMIT                  = "dev_xmit",

		END_COMMIT                = "end_commit",

		EXEC                      = "exec",

		FILE_DESCRIPTOR           = "file_descriptor",

		GETRQ                     = "getrq",

		GETRQ_BIO                 = "getrq_bio",

		IDT_TABLE                 = "idt_table",

		INTERRUPT                 = "interrupt",

		IOCTL                     = "ioctl",

		IRQ_ENTRY                 = "irq_entry",

		IRQ_EXIT                  = "irq_exit",

		LIST_MODULE               = "list_module",

		LLSEEK                    = "llseek",

		LSEEK                     = "lseek",

		NAPI_COMPLETE             = "napi_complete",

		NAPI_POLL                 = "napi_poll",

		NAPI_SCHEDULE             = "napi_schedule",

		NETWORK_IPV4_INTERFACE    = "network_ipv4_interface",

		NETWORK_IP_INTERFACE      = "network_ip_interface",

		OPEN                      = "open",

		PAGE_FAULT_ENTRY          = "page_fault_entry",

		PAGE_FAULT_EXIT           = "page_fault_exit",

		PAGE_FAULT_GET_USER_ENTRY = "page_fault_get_user_entry",

		PAGE_FAULT_GET_USER_EXIT  = "page_fault_get_user_exit",

		PAGE_FREE                 = "page_free",

		PLUG                      = "plug",

		POLLFD                    = "pollfd",

		PREAD64                   = "pread64",

		PRINTF                    = "printf",

		PRINTK                    = "printk",

		PROCESS_EXIT              = "process_exit",

		PROCESS_FORK              = "process_fork",

		PROCESS_FREE              = "process_free",

		PROCESS_STATE             = "process_state",

		PROCESS_WAIT              = "process_wait",

		READ                      = "read",

		REMAP                     = "remap",

		REMOVE_FROM_PAGE_CACHE    = "remove_from_page_cache",

		RQ_COMPLETE_FS            = "rq_complete_fs",

		RQ_COMPLETE_PC            = "rq_complete_pc",

		RQ_INSERT_FS              = "rq_insert_fs",

		RQ_INSERT_PC              = "rq_insert_pc",

		RQ_ISSUE_FS               = "rq_issue_fs",

		RQ_ISSUE_PC               = "rq_issue_pc",

		RQ_REQUEUE_PC             = "rq_requeue_pc",

		SCHED_MIGRATE_TASK        = "sched_migrate_task",

		SCHED_SCHEDULE            = "sched_schedule",

		SCHED_TRY_WAKEUP          = "sched_try_wakeup",

		SCHED_WAKEUP_NEW_TASK     = "sched_wakeup_new_task",

		SELECT                    = "select",

		SEM_CREATE                = "sem_create",

		SEND_SIGNAL               = "send_signal",

		SHM_CREATE                = "shm_create",

		SLEEPRQ_BIO               = "sleeprq_bio",

		SOCKET_ACCEPT             = "socket_accept",

		SOCKET_BIND               = "socket_bind",

		SOCKET_CALL               = "socket_call",

		SOCKET_CONNECT            = "socket_connect",

		SOCKET_CREATE             = "socket_create",

		SOCKET_GETPEERNAME        = "socket_getpeername",

		SOCKET_GETSOCKNAME        = "socket_getsockname",

		SOCKET_GETSOCKOPT         = "socket_getsockopt",

		SOCKET_LISTEN             = "socket_listen",

		SOCKET_SETSOCKOPT         = "socket_setsockopt",

		SOCKET_SHUTDOWN           = "socket_shutdown",

		SOCKET_SOCKETPAIR         = "socket_socketpair",

		SOFTIRQ_ENTRY             = "softirq_entry",

		SOFTIRQ_EXIT              = "softirq_exit",

		SOFTIRQ_RAISE             = "softirq_raise",

		SOFTIRQ_VEC               = "softirq_vec",

		START_COMMIT              = "start_commit",

		STATEDUMP_END             = "statedump_end",

		SYS_CALL_TABLE            = "sys_call_table",

	    SYSCALL_ENTRY             = "syscall_entry",

	    SYSCALL_EXIT              = "syscall_exit",

	    TASKLET_LOW_ENTRY         = "tasklet_low_entry",

	    TASKLET_LOW_EXIT          = "tasklet_low_exit",

	    TCPV4_RCV                 = "tcpv4_rcv",

	    TIMER_ITIMER_EXPIRED      = "timer_itimer_expired",

	    TIMER_ITIMER_SET          = "timer_itimer_set",

	    TIMER_SET                 = "timer_set",

	    TIMER_TIMEOUT             = "timer_timeout",

	    TIMER_UPDATE_TIME         = "timer_update_time",

	    UDPV4_RCV                 = "udpv4_rcv",

	    UNPLUG_IO                 = "unplug_io",

	    UNPLUG_TIMER              = "unplug_timer",

	    VM_MAP                    = "vm_map",

	    VPRINTK                   = "vprintk",

	    WAIT_ON_PAGE_END          = "wait_on_page_end",

	    WAIT_ON_PAGE_START        = "wait_on_page_start",

	    WRITE                     = "write",

	    WRITEV                    = "writev";

    // ------------------------------------------------------------------------

    // Constructor

    // ------------------------------------------------------------------------

    /**

     * Private constructor to defeat instantiation (Singleton pattern).

     */

    private EventMatcher() {

        fStack = new StackWrapper();

        fMatch = new HashMap<String, String>();

        fInverseMatch = new HashMap<String, String>();

        fProcessedEvents = 0;

        fMatchedEvents = 0;

        createMatchTable();

    }

    // ------------------------------------------------------------------------

    // Accessors

    // ------------------------------------------------------------------------

    /**

     * Returns an instance to the EventMatcher class (Singleton pattern).

     * @return An instance to the EventMatcher class (Singleton pattern).

     */

    public static EventMatcher getInstance() {

        if (fInstance == null)

            fInstance = new EventMatcher();

        return fInstance;

    }

    /**

     * Returns the number of events processed.

     * @return The number of events processed.

     */

    public int getNBProcessedEvents() {

        return fProcessedEvents;

    }

    /**

     * Returns the number of events matched.

     * @return The number of events matched.

     */

    public int getNBMatchedEvents() {

        return fMatchedEvents;

    }

    // ------------------------------------------------------------------------

    // Operations

    // ------------------------------------------------------------------------

    /**

     * Releases the instance to the EventMatcher class.

     */

    public static void releaseInstance() {

        fInstance = null;

    }

    /**

     * Creates the event matching table, linking a response class to a request class.

     */

    private void createMatchTable() {

        // Build the default matches

        fMatch.put(PAGE_FAULT_GET_USER_EXIT, PAGE_FAULT_GET_USER_ENTRY);

        fMatch.put(TASKLET_LOW_EXIT, TASKLET_LOW_ENTRY);

        fMatch.put(PAGE_FAULT_EXIT, PAGE_FAULT_ENTRY);

        fMatch.put(SYSCALL_EXIT, SYSCALL_ENTRY);

        fMatch.put(IRQ_EXIT, IRQ_ENTRY);

        fMatch.put(WRITE, READ);

        fMatch.put(CLOSE, OPEN);

        fMatch.put(BUFFER_WAIT_END, BUFFER_WAIT_START);

        fMatch.put(END_COMMIT, START_COMMIT);

        fMatch.put(WAIT_ON_PAGE_END, WAIT_ON_PAGE_START);

        // Build the inverse matches based on the matches

        Set<Entry<String, String>> pairs = fMatch.entrySet();

        Iterator<Entry<String, String>> it = pairs.iterator();

        while (it.hasNext()) {

            Entry<String, String> pair = it.next();

            fInverseMatch.put(pair.getValue(), pair.getKey());

        }

    }

    /**

     * Processes an event received: if it is identified as a response, try to get its request to remove it from the

     * list. If no request was saved, dismiss the current response. If it is a request, save it to the list of requests

     * waiting for a response.

     * @param event

     *            The event to identify, and maybe process if it is a response.

     * @return The request event associated with the current event (a response), or null if nothing was found (no

     *         request associated with this response, or the event to identify was a request that was added to the

     *         list).

     */

    public LttngEvent process(LttngEvent event) {

        fProcessedEvents++;

        String markerName = event.getMarkerName();

        if (fMatch.containsKey(markerName)) {

            String startEventType = fMatch.get(markerName);

            Stack<LttngEvent> events = fStack.getStackOf(startEventType);

            if (events != null) {

                for (int i = events.size() - 1; i >= 0; i--) {

                    LttngEvent request = events.get(i);

                    if (request.getCpuId() == event.getCpuId() && event.getTimestamp().getValue() > request.getTimestamp().getValue()) {

                        fStack.removeEvent(startEventType, request);

                        fMatchedEvents++;

                        return request;

                    }

                }

            }

            return null;

        } else {

            // Add only if there can later be a match for this request

            if (fMatch.containsValue(event.getMarkerName())) {

                fStack.put(event.clone());

            }

            return null;

        }

    }

    /**

     * Clears the stack content.

     */

    public void clearStack() {

        fStack.clear();

        // Reset the processed and matched events counter

        fProcessedEvents = 0;

        fMatchedEvents = 0;

    }

    /**

     * Resets all.

     */

    public void resetMatches() {

        fMatch.clear();

        fInverseMatch.clear();

        fStack.clear();

        // Reset the processed and matched events counter

        fProcessedEvents = 0;

        fMatchedEvents = 0;

    }

    /**

     * Returns the list of start events.

     * @return The list of start events.

     */

    public Collection<String> getStartEvents() {

        return fMatch.values();

    }

    /**

     * Returns the list of end events.

     * @return The list of end events.

     */

    public Set<String> getEndEvents() {

        return fMatch.keySet();

    }

    /**

     * Returns the alphabetically-sorted list of start/end events pairs.

     * @return The alphabetically-sorted list of start/end events pairs.

     */

    public EventsPair getEvents() {

        Vector<String> start = new Vector<String>(getStartEvents());

        Vector<String> end = new Vector<String>(fMatch.size());

        Collections.sort(start);

        for (int i = 0; i < start.size(); i++) {

            end.add(fInverseMatch.get(start.get(i)));

        }

        return new EventsPair(start, end);

    }

    /**

     * Adds a match to the list of events pairs.

     * @param startType

     *            The start event type.

     * @param endType

     *            The end event type.

     */

    public void addMatch(String startType, String endType) {

        fMatch.put(endType, startType);

        fInverseMatch.put(startType, endType);

    }

    /**

     * Removes a matched pair based on the their type.

     * 

     * <b>Note :</b> For now, only the pair's end type is used, since a type can only be either one start or one end.

     * This function takes both types to account for the future, if a pairing process ever becomes more complex.

     * 

     * @param startType

     *            The type of the pair's start type.

     * @param endType

     *            The type of the pair's end type.

     */

    public void removeMatch(String startType, String endType) {

        fMatch.remove(endType);

        fInverseMatch.remove(startType);

    }

    /**

     * Returns the list of all event possible types.

     * @return The list of all event possible types.

     */

    public Vector<String> getTypeList() {

        // Reserve some space for the 103 default event types.

        Vector<String> eventsList = new Vector<String>(103);

        eventsList.add(ADD_TO_PAGE_CACHE);

        eventsList.add(BIO_BACKMERGE);

        eventsList.add(BIO_FRONTMERGE);

        eventsList.add(BIO_QUEUE);

        eventsList.add(BUFFER_WAIT_END);

        eventsList.add(BUFFER_WAIT_START);

        eventsList.add(CALL);

        eventsList.add(CLOSE);

        eventsList.add(CORE_MARKER_FORMAT);

        eventsList.add(CORE_MARKER_ID);

        eventsList.add(DEV_RECEIVE);

        eventsList.add(DEV_XMIT);

        eventsList.add(END_COMMIT);

        eventsList.add(EXEC);

        eventsList.add(FILE_DESCRIPTOR);

        eventsList.add(GETRQ);

        eventsList.add(GETRQ_BIO);

        eventsList.add(IDT_TABLE);

        eventsList.add(INTERRUPT);

        eventsList.add(IOCTL);

        eventsList.add(IRQ_ENTRY);

        eventsList.add(IRQ_EXIT);

        eventsList.add(LIST_MODULE);

        eventsList.add(LLSEEK);

        eventsList.add(LSEEK);

        eventsList.add(NAPI_COMPLETE);

        eventsList.add(NAPI_POLL);

        eventsList.add(NAPI_SCHEDULE);

        eventsList.add(NETWORK_IPV4_INTERFACE);

        eventsList.add(NETWORK_IP_INTERFACE);

        eventsList.add(OPEN);

        eventsList.add(PAGE_FAULT_ENTRY);

        eventsList.add(PAGE_FAULT_EXIT);

        eventsList.add(PAGE_FAULT_GET_USER_ENTRY);

        eventsList.add(PAGE_FAULT_GET_USER_EXIT);

        eventsList.add(PAGE_FREE);

        eventsList.add(PLUG);

        eventsList.add(POLLFD);

        eventsList.add(PREAD64);

        eventsList.add(PRINTF);

        eventsList.add(PRINTK);

        eventsList.add(PROCESS_EXIT);

        eventsList.add(PROCESS_FORK);

        eventsList.add(PROCESS_FREE);

        eventsList.add(PROCESS_STATE);

        eventsList.add(PROCESS_WAIT);

        eventsList.add(READ);

        eventsList.add(REMAP);

        eventsList.add(REMOVE_FROM_PAGE_CACHE);

        eventsList.add(RQ_COMPLETE_FS);

        eventsList.add(RQ_COMPLETE_PC);

        eventsList.add(RQ_INSERT_FS);

        eventsList.add(RQ_INSERT_PC);

        eventsList.add(RQ_ISSUE_FS);

        eventsList.add(RQ_ISSUE_PC);

        eventsList.add(RQ_REQUEUE_PC);

        eventsList.add(SCHED_MIGRATE_TASK);

        eventsList.add(SCHED_SCHEDULE);

        eventsList.add(SCHED_TRY_WAKEUP);

        eventsList.add(SCHED_WAKEUP_NEW_TASK);

        eventsList.add(SELECT);

        eventsList.add(SEM_CREATE);

        eventsList.add(SEND_SIGNAL);

        eventsList.add(SHM_CREATE);

        eventsList.add(SLEEPRQ_BIO);

        eventsList.add(SOCKET_ACCEPT);

        eventsList.add(SOCKET_BIND);

        eventsList.add(SOCKET_CALL);

        eventsList.add(SOCKET_CONNECT);

        eventsList.add(SOCKET_CREATE);

        eventsList.add(SOCKET_GETPEERNAME);

        eventsList.add(SOCKET_GETSOCKNAME);

        eventsList.add(SOCKET_GETSOCKOPT);

        eventsList.add(SOCKET_LISTEN);

        eventsList.add(SOCKET_SETSOCKOPT);

        eventsList.add(SOCKET_SHUTDOWN);

        eventsList.add(SOCKET_SOCKETPAIR);

        eventsList.add(SOFTIRQ_ENTRY);

        eventsList.add(SOFTIRQ_EXIT);

        eventsList.add(SOFTIRQ_RAISE);

        eventsList.add(SOFTIRQ_VEC);

        eventsList.add(START_COMMIT);

        eventsList.add(STATEDUMP_END);

        eventsList.add(SYS_CALL_TABLE);

        eventsList.add(SYSCALL_ENTRY);

        eventsList.add(SYSCALL_EXIT);

        eventsList.add(TASKLET_LOW_ENTRY);

        eventsList.add(TASKLET_LOW_EXIT);

        eventsList.add(TCPV4_RCV);

        eventsList.add(TIMER_ITIMER_EXPIRED);

        eventsList.add(TIMER_ITIMER_SET);

        eventsList.add(TIMER_SET);

        eventsList.add(TIMER_TIMEOUT);

        eventsList.add(TIMER_UPDATE_TIME);

        eventsList.add(UDPV4_RCV);

        eventsList.add(UNPLUG_IO);

        eventsList.add(UNPLUG_TIMER);

        eventsList.add(VM_MAP);

        eventsList.add(VPRINTK);

        eventsList.add(WAIT_ON_PAGE_END);

        eventsList.add(WAIT_ON_PAGE_START);

        eventsList.add(WRITE);

        eventsList.add(WRITEV);

        return eventsList;

    }

    /**

     * Prints the stack content to the console.

     */

    public void print() {

        fStack.printContent();

    }

}

/*******************************************************************************

 * Copyright (c) 2011 Ericsson

 * 

 * All rights reserved. This program and the accompanying materials are

 * made available under the terms of the Eclipse Public License v1.0 which

 * accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *   Philippe Sawicki (INF4990.A2010@gmail.com)   - Initial API and implementation

 *   Mathieu Denis    (mathieu.denis55@gmail.com) - Refactored code

 *******************************************************************************/

package org.eclipse.linuxtools.lttng.core.latency.analyzer;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Set;

import java.util.Stack;

import org.eclipse.linuxtools.lttng.core.event.LttngEvent;

/**

 * <b><u>StackWrapper</u></b>

 * <p>

 * Stack pile.

 * 

 * TODO Change the types of the HashMaps from <String,String> to <Integer,Integer>, in order to take advantage of the

 * compilation-time String.hashCode() speedup over execution-time String hash computation.

 * 

 * @author Philippe Sawicki

 */

public class StackWrapper {

    // ------------------------------------------------------------------------

    // Attributes

    // ------------------------------------------------------------------------

    /**

     * Hash map of event stacks.

     */

    private HashMap<String, Stack<LttngEvent>> fStacks = null;

    // ------------------------------------------------------------------------

    // Constructors

    // ------------------------------------------------------------------------

    /**

     * Constructor.

     */

    public StackWrapper() {

        fStacks = new HashMap<String, Stack<LttngEvent>>();

    }

    // ------------------------------------------------------------------------

    // Operations

    // ------------------------------------------------------------------------

    /**

     * Adds an event to the list of events of the same type.

     * @param event

     *            The event to add to the list.

     */

    public void put(LttngEvent event) {

        String key = event.getMarkerName();

        if (fStacks.containsKey(key)) {

            fStacks.get(key).add(event);

        } else {

            Stack<LttngEvent> newStack = new Stack<LttngEvent>();

            newStack.add(event);

            fStacks.put(key, newStack);

        }

    }

    /**

     * Checks if the stack contains a list of events of the given type.

     * @param key

     *            The type of events to check for.

     * @return "true" if the stack contains events of the given type, "false" otherwise.

     */

    public boolean containsKey(String key) {

        return fStacks.containsKey(key);

    }

    /**

     * Returns the list of events of the given type.

     * @param key

     *            The type of events to return.

     * @return The list of events of the given type, or null.

     */

    public Stack<LttngEvent> getStackOf(String key) {

        return fStacks.get(key);

    }

    /**

     * Removes the given event from the given stack list.

     * @param key

     *            The given stack type.

     * @param event

     *            The event to remove from the given stack type.

     * @return "true" if the event was removed, "false" otherwise.

     */

    public boolean removeEvent(String key, LttngEvent event) {

        Stack<LttngEvent> stack = fStacks.get(key);

        boolean removed = false;

        try {

            /**

             * TODO Correct this... Here, no matter what CPU or other content field, we always remove the last event

             * added to the stack. Should be something like : return stack.remove(event);

             */

            stack.pop();

            removed = true;

        } catch (Exception e) {

            e.printStackTrace();

        }

        // Remove the stack from the stack list if it is empty

        if (stack.isEmpty()) {

            fStacks.remove(key);

        }

        return removed;

    }

    /**

     * Clears the stack content.

     */

    public void clear() {

        fStacks.clear();

    }

    /**

     * Prints the content of the stack to the console.

     */

    @SuppressWarnings("nls")

    public void printContent() {

        Collection<Stack<LttngEvent>> values = fStacks.values();

        Iterator<Stack<LttngEvent>> valueIt = values.iterator();

        Set<String> keys = fStacks.keySet();

        Iterator<String> keyIt = keys.iterator();

        while (valueIt.hasNext() && keyIt.hasNext()) {

            Stack<LttngEvent> stack = valueIt.next();

            System.out.println("   " + keyIt.next() + " [" + stack.size() + "] : " + stack);

        }

    }

}

/*******************************************************************************

 * Copyright (c) 2011 Ericsson

 * 

 * All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse

 * Public License v1.0 which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors: 

 *   Mathieu Denis    (mathieu.denis55@gmail.com) - Initial API and implementation

 *******************************************************************************/

package org.eclipse.linuxtools.lttng.core.util;

import java.util.Vector;

/**

 * Contains two lists of events name. The first list contains the events identified as starting request and the second list

 * contains the events identified as ending request

 */

public class EventsPair extends Pair<Vector<String>, Vector<String>> {

    public EventsPair() {

        super();

    }

    public EventsPair(Vector<String> startingEvents, Vector<String> endingEvents) {

        super(startingEvents, endingEvents);

    }

}

/*******************************************************************************

 * Copyright (c) 2011 Ericsson

 * 

 * All rights reserved. This program and the accompanying materials are

 * made available under the terms of the Eclipse Public License v1.0 which

 * accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *   Philippe Sawicki (INF4990.A2010@gmail.com)   - Initial API and implementation

 *   Mathieu Denis    (mathieu.denis55@gmail.com) - Refactored code

 *******************************************************************************/

package org.eclipse.linuxtools.lttng.core.util;

/**

 * Pair utility class, encapsulates a pair of objects.

 * 

 * @author Philippe Sawicki

 * 

 * @param <A>

 *            The type of the first object.

 * @param <B>

 *            The type of the second object.

 */

public abstract class Pair<A, B> {

    /**

     * A reference to the first object.

     */

    protected A fFirst;

    /**

     * A reference to the second object.

     */

    protected B fSecond;

    /**

     * Constructor.

     * @param first

     *            The pair's first object.

     * @param second

     *            The pair's second object.

     */

    public Pair(A first, B second) {

        fFirst = first;

        fSecond = second;

    }

    /**

     * Constructor.

     */

    public Pair() {

        this(null, null);

    }

    /**

     * Pair hash code.

     */

    @Override

    public int hashCode() {

        int hashFirst = fFirst != null ? fFirst.hashCode() : 0;

        int hashSecond = fSecond != null ? fSecond.hashCode() : 0;

        return (hashFirst + hashSecond) * hashSecond + hashFirst;

    }

    /**

     * Object comparison.

     */

    @Override

    @SuppressWarnings("unchecked")

    public boolean equals(Object other) {

        if (other instanceof Pair) {

            Pair<A, B> otherPair = (Pair<A, B>) other;

            return ((fFirst == otherPair.fFirst || (fFirst != null && otherPair.fFirst != null && fFirst.equals(otherPair.fFirst))) && (fSecond == otherPair.fSecond || (fSecond != null

                    && otherPair.fSecond != null && fSecond.equals(otherPair.fSecond))));

        }

        return false;

    }

    /**

     * Object to string.

     */

    @Override

    public String toString() {

        return "(" + fFirst + ", " + fSecond + ")";  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

    }

    /**

     * Returns a reference to the pair's first object.

     * @return A reference to the pair's first object.

     */

    public A getFirst() {

        return fFirst;

    }

    /**

     * Sets the pair's first object.

     * @param first

     *            The pair's first object.

     */

    public void setFirst(A first) {

        fFirst = first;

    }

    /**

     * Returns a reference to the pair's second object.

     * @return A reference to the pair's second object.

     */

    public B getSecond() {

        return fSecond;

    }

    /**

     * Sets the pair's second object.

     * @param second

     *            The pair's second object.

     */

    public void setSecond(B second) {

        fSecond = second;

    }

}

        suite.addTest(org.eclipse.linuxtools.lttng.ui.tests.distribution.AllTests.suite());

/*******************************************************************************

 * Copyright (c) 2011 Ericsson

 * 

 * All rights reserved. This program and the accompanying materials are

 * made available under the terms of the Eclipse Public License v1.0 which

 * accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *   Bernd Hufmann - Initial API and implementation

 *******************************************************************************/

package org.eclipse.linuxtools.lttng.ui.tests.distribution;

import junit.framework.Test;

import junit.framework.TestSuite;

public class AllTests {

    public static Test suite() {

        TestSuite suite = new TestSuite(AllTests.class.getName());

        //$JUnit-BEGIN$

        suite.addTestSuite(LatencyGraphModelTest.class);

        //$JUnit-END$

        return suite;

    }

}

package org.eclipse.linuxtools.lttng.ui.tests.distribution;

import junit.framework.TestCase;

import org.eclipse.linuxtools.lttng.ui.views.latency.model.Config;

import org.eclipse.linuxtools.lttng.ui.views.latency.model.GraphScaledData;

import org.eclipse.linuxtools.lttng.ui.views.latency.model.IGraphModelListener;

import org.eclipse.linuxtools.lttng.ui.views.latency.model.LatencyGraphModel;

@SuppressWarnings("nls")

public class LatencyGraphModelTest extends TestCase {

    // ------------------------------------------------------------------------

    // Test data

    // ------------------------------------------------------------------------

    // ------------------------------------------------------------------------

    // Housekeeping

    // ------------------------------------------------------------------------

    @Override

    public void setUp() throws Exception {

    }

    @Override

    public void tearDown() throws Exception {

    }

    // ------------------------------------------------------------------------

    // Tests

    // ------------------------------------------------------------------------

    public void testLatencyGraphModel() {

        LatencyGraphModel model = new LatencyGraphModel();

        assertEquals("nbBuckets", Config.DEFAULT_NUMBER_OF_BUCKETS, model.getNbBuckets());

        assertEquals("currentTime", Config.INVALID_EVENT_TIME, model.getCurrentEventTime());

    }

    public void testLatencyGraphModelInt() {

        LatencyGraphModel model = new LatencyGraphModel(100);

        assertEquals("nbBuckets", 100, model.getNbBuckets());

        assertEquals("currentTime", Config.INVALID_EVENT_TIME, model.getCurrentEventTime());

    }

    public void testGraphModelListener() {

        final int nbBuckets = 2000;

        final int nbEvents = 10 * nbBuckets + 256;

        final int[] count = new int[2];

        count [0] = 0;

        count [1] = 0;

        // Test add listener and call of listener

        IGraphModelListener listener = new IGraphModelListener() {

            @Override

            public void graphModelUpdated() {

                count[0]++;

            }

            @Override

            public void currentEventUpdated(long currentEventTime) {

                count[1]++;

            }

        };

        // Test that the listener interface is called every 10000 events.

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        model.addGraphModelListener(listener);

        for (int i = 0; i < nbEvents; i++) {

            model.countEvent(i+1, i, i);

        }

        assertEquals("listener", 2, count[0]);

        // Test that the listener interface is called when complete is called.

        model.complete();

        assertEquals("listener", 3, count[0]);

        // Test that clear triggers call of listener interface

        model.clear();

        assertEquals("listener", 4, count[0]);

        // Test that clear triggers call of listener interface

        model.setCurrentEventNotifyListeners(100);

        assertEquals("listener", 1, count[1]);

        // Test remove listener

        count[0] = 0;

        count[1] = 0;

        model.removeGraphModelListener(listener);

        for (int i = 0; i < nbEvents; i++) {

            model.countEvent(i, i, i);

        }

        model.complete();

        assertEquals("listener", 0, count[1]);

        // Test that clear triggers call of listener interface

        model.setCurrentEventNotifyListeners(100);

        assertEquals("listener", 0, count[1]);

    }

    public void testConstructor() {

        final int nbBuckets = 2000;

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        GraphScaledData scaledData = model.scaleTo(100, 100, 1);

        // Verify model parameters

        assertEquals("Horizontal bucket duration", 1, model.getHorBucketDuration());

        assertEquals("Vertical bucket duration", 1, model.getVerBucketDuration());

        assertEquals("Horizontal first bucket time", 0, model.getHorFirstBucketTime());

        assertEquals("Vertical first bucket time", 0, model.getVerFirstBucketTime());

        assertEquals("Horizontal last bucket ", 0, model.getHorLastBucket());

        assertEquals("Vertical last bucket ", 0, model.getVerLastBucket());

        assertEquals("Horizontal first time", 0, model.getHorFirstEventTime());

        assertEquals("Vertical first time", 0, model.getVerFirstEventTime());

        assertEquals("Horizontal last time", 0, model.getHorLastEventTime());

        assertEquals("Vertical last time", 0, model.getVerLastEventTime());

        assertEquals("Horizontal time limit", 2000, model.getHorTimeLimit());

        assertEquals("Vertical time limit", 2000, model.getVerTimeLimit());

        // Verify scaled data parameters

        scaledData = model.scaleTo(101, 100, 1);

        assertEquals("barWidth", 1, scaledData.getBarWidth());

        assertEquals("height", 100, scaledData.getHeight());

        assertEquals("width", 101, scaledData.getWidth());

        assertEquals(Config.INVALID_EVENT_TIME, scaledData.getCurrentEventTime());

        assertEquals("Horizontal bucket duration", 1, scaledData.getHorBucketDuration());

        assertEquals("Vertical bucket duration", 1, scaledData.getVerBucketDuration());

        assertEquals("Horizontal bucket end time", 1, scaledData.getHorBucketEndTime(0));

        assertEquals("Vertical bucket end time", 1, scaledData.getVerBucketEndTime(0));

        assertEquals("Horizontal bucket start time", 0, scaledData.getHorBucketStartTime(0));

        assertEquals("Vertical bucket start time", 0, scaledData.getVerBucketStartTime(0));

        assertEquals("Horizontal first time", 0, scaledData.getHorFirstEventTime());

        assertEquals("Vertical first time", 0, scaledData.getVerFirstEventTime());

        assertEquals("Horizontal first bucket time", 0, scaledData.getHorFirstBucketTime());

        assertEquals("Vertical first bucket time", 0, scaledData.getVerFirstBucketTime());

        assertEquals("Horizontal last bucket time", 0, scaledData.getHorLastBucketTime());

        assertEquals("Vertical last bucket time", 0, scaledData.getVerLastBucketTime());

        assertEquals("Horizontal number of buckets", 101, scaledData.getHorNbBuckets());

        assertEquals("Vertical nubmer of buckets", 100, scaledData.getVerNbBuckets());

        assertEquals("Horizontal getIndex", 100, scaledData.getHorBucketIndex(100));

        assertEquals("Vertical getIndex", 124, scaledData.getVerBucketIndex(124));

        assertEquals("Horizontal last bucket", 0, scaledData.getHorLastBucket());

        assertEquals("Vertical last bucket", 0, scaledData.getVerLastBucket());

        assertEquals("Horizontal last event time", 0, scaledData.getHorLastEventTime());

        assertEquals("Vertical last event time", 0, scaledData.getVerLastEventTime());

    }

    public void testClear() {

        final int nbBuckets = 2000;

        final int nbEvents = 10 * nbBuckets + 256;

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        for (int i = 0; i < nbEvents; i++) {

            model.countEvent(i+1, i, i);

        }

        // make sure that we actually counted something.

        GraphScaledData scaledData = model.scaleTo(100, 100, 1);

        assertTrue(scaledData.getHorLastBucket() > 0);

        model.clear();

        // Verify model parameters

        assertEquals("Horizontal bucket duration", 1, model.getHorBucketDuration());

        assertEquals("Vertical bucket duration", 1, model.getVerBucketDuration());

        assertEquals("Horizontal first bucket time", 0, model.getHorFirstBucketTime());

        assertEquals("Vertical first bucket time", 0, model.getVerFirstBucketTime());

        assertEquals("Horizontal last bucket ", 0, model.getHorLastBucket());

        assertEquals("Vertical last bucket ", 0, model.getVerLastBucket());

        assertEquals("Horizontal first time", 0, model.getHorFirstEventTime());

        assertEquals("Vertical first time", 0, model.getVerFirstEventTime());

        assertEquals("Horizontal last time", 0, model.getHorLastEventTime());

        assertEquals("Vertical last time", 0, model.getVerLastEventTime());

        assertEquals("Horizontal time limit", 2000, model.getHorTimeLimit());

        assertEquals("Vertical time limit", 2000, model.getVerTimeLimit());

        // Verify scaled data parameters

        scaledData = model.scaleTo(101, 100, 1);

        assertEquals("barWidth", 1, scaledData.getBarWidth());

        assertEquals("height", 100, scaledData.getHeight());

        assertEquals("width", 101, scaledData.getWidth());

        assertEquals(Config.INVALID_EVENT_TIME, scaledData.getCurrentEventTime());

        assertEquals("Horizontal bucket duration", 1, scaledData.getHorBucketDuration());

        assertEquals("Vertical bucket duration", 1, scaledData.getVerBucketDuration());

        assertEquals("Horizontal bucket end time", 1, scaledData.getHorBucketEndTime(0));

        assertEquals("Vertical bucket end time", 1, scaledData.getVerBucketEndTime(0));

        assertEquals("Horizontal bucket start time", 0, scaledData.getHorBucketStartTime(0));

        assertEquals("Vertical bucket start time", 0, scaledData.getVerBucketStartTime(0));

        assertEquals("Horizontal first time", 0, scaledData.getHorFirstEventTime());

        assertEquals("Vertical first time", 0, scaledData.getVerFirstEventTime());

        assertEquals("Horizontal first bucket time", 0, scaledData.getHorFirstBucketTime());

        assertEquals("Vertical first bucket time", 0, scaledData.getVerFirstBucketTime());

        assertEquals("Horizontal last bucket time", 0, scaledData.getHorLastBucketTime());

        assertEquals("Vertical last bucket time", 0, scaledData.getVerLastBucketTime());

        assertEquals("Horizontal getIndex", 100, scaledData.getHorBucketIndex(100));

        assertEquals("Vertical getIndex", 124, scaledData.getVerBucketIndex(124));

        assertEquals("Horizontal number of buckets", 101, scaledData.getHorNbBuckets());

        assertEquals("Vertical nubmer of buckets", 100, scaledData.getVerNbBuckets());

        assertEquals("Horizontal last bucket", 0, scaledData.getHorLastBucket());

        assertEquals("Vertical last bucket", 0, scaledData.getVerLastBucket());

        assertEquals("Horizontal last event time", 0, scaledData.getHorLastEventTime());

        assertEquals("Vertical last event time", 0, scaledData.getVerLastEventTime());

    }

    public void testCountEvent() {

        final int nbBuckets = 2000;

        final int nbEvents = 10 * nbBuckets + 256;

        final long hOffset = 100;

        final long vOffset = 55;

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        for (int i = 0; i < nbEvents; i++) {

            model.countEvent(i + 1, hOffset + i, vOffset + i);

        }

        // Verify model parameters

        assertEquals("Horizontal bucket duration", 16, model.getHorBucketDuration());

        assertEquals("Vertical bucket duration", 16, model.getVerBucketDuration());

        assertEquals("Horizontal first bucket time", hOffset, model.getHorFirstBucketTime());

        assertEquals("Vertical first bucket time", vOffset, model.getVerFirstBucketTime());

        assertEquals("Horizontal last bucket ", (nbEvents - 1)/16, model.getHorLastBucket());

        assertEquals("Vertical last bucket ", (nbEvents - 1)/16, model.getVerLastBucket());

        assertEquals("Horizontal first time", hOffset, model.getHorFirstEventTime());

        assertEquals("Vertical first time", vOffset, model.getVerFirstEventTime());

        assertEquals("Horizontal last time", nbEvents + hOffset - 1, model.getHorLastEventTime());

        assertEquals("Vertical last time", nbEvents + vOffset - 1, model.getVerLastEventTime());

        assertEquals("Horizontal time limit", 16 * nbBuckets + hOffset, model.getHorTimeLimit());

        assertEquals("Vertical time limit", 16 * nbBuckets + vOffset, model.getVerTimeLimit());

        // Verify scaled data parameters

        GraphScaledData scaledData = model.scaleTo(50, 100, 1);

        assertEquals("barWidth", 1, scaledData.getBarWidth());

        assertEquals("height", 100, scaledData.getHeight());

        assertEquals("width", 50, scaledData.getWidth());

        assertEquals(Config.INVALID_EVENT_TIME, scaledData.getCurrentEventTime());

        // nbBars = width / barWidth

        // bucketsPerBar = lastBucket/nbBars + 1

        // scaled bucket duration = bucketsPerBar * model.bucketDuration

        // for nbBuckets=2000 and nbEvents=20256 (means 20256 ns + offset) -> model.bucketDuration = 16

        assertEquals("Horizontal bucket duration", 416, scaledData.getHorBucketDuration());

        assertEquals("Vertical bucket duration", 208, scaledData.getVerBucketDuration());

        // startTime + scaledData.bucketDuration

        assertEquals("Horizontal bucket end time", hOffset + 416, scaledData.getHorBucketEndTime(0));

        assertEquals("Vertical bucket end time", 55 + 208, scaledData.getVerBucketEndTime(0));

        assertEquals("Horizontal bucket start time", 100, scaledData.getHorBucketStartTime(0));

        assertEquals("Vertical bucket start time", 55, scaledData.getVerBucketStartTime(0));

        assertEquals("Horizontal first time", 100, scaledData.getHorFirstEventTime());

        assertEquals("Vertical first time", 55, scaledData.getVerFirstEventTime());

        assertEquals("Horizontal first bucket time", hOffset, scaledData.getHorFirstBucketTime());

        assertEquals("Vertical first bucket time", 55, scaledData.getVerFirstBucketTime());

        assertEquals("Horizontal last bucket time", hOffset + 48 * 416, scaledData.getHorLastBucketTime());

        assertEquals("Vertical last bucket time", vOffset + 97 * 208, scaledData.getVerLastBucketTime());

        assertEquals("Horizontal getIndex", 47, scaledData.getHorBucketIndex(20000));

        assertEquals("Vertical getIndex", 47, scaledData.getVerBucketIndex(10000));

        // nb Buckets = nbBars

        assertEquals("Horizontal number of buckets", 50, scaledData.getHorNbBuckets());

        assertEquals("Vertical nubmer of buckets", 100, scaledData.getVerNbBuckets());

        assertEquals("Horizontal last bucket", 48, scaledData.getHorLastBucket());

        assertEquals("Vertical last bucket", 97, scaledData.getVerLastBucket());

        // start time of last bucket

        assertEquals("Horizontal last event time", hOffset + nbEvents - 1, scaledData.getHorLastEventTime());

        assertEquals("Vertical last event time", vOffset + nbEvents - 1 , scaledData.getVerLastEventTime());

    }

    public void testCountEvent2() {

        final int nbBuckets = 2000;

        final int nbEvents = 10 * nbBuckets + 256;

        final long offset = 100;

        final int height = 100;

        final int width = 100;

        final int barWidth = 1;

        int[][] expectedResults = new int[width/barWidth][height/barWidth];

        int total = 0;

        // Horizontally and vertically the same data is used

        // for nbBuckets=2000 and nbEvents=20256 (means 20256 ns + offset) -> model.bucketDuration = 16

        // nbBars = width / barWidth = 100

        // bucketsPerBar = lastBucket/nbBars + 1 = 13

        // scaled bucket duration = bucketsPerBar * model.bucketDuration =  13 * 16

        boolean isFinished = false;

        for (int i = 0; i < width/barWidth; i++) {

            if (isFinished) {

                break;

            }

            for (int j = 0; j < height/barWidth; j++) {

                if (i == j) {

                    int value = 13 * 16;

                    if (total + value > nbEvents) {

                        expectedResults[i][j] = nbEvents - total;

                        isFinished = true;

                        break;

                    }

                    else {

                        expectedResults[i][j] = value;

                        total += value;

                    }

                }

            }

        }

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        for (int i = 0; i < nbEvents; i++) {

            model.countEvent(i+1, offset + i, offset + i);

        }

        GraphScaledData scaledData = model.scaleTo(height, width, barWidth);

        for (int i = 0; i < scaledData.getHorLastBucket(); i++) {

            for (int j = 0; j < scaledData.getVerLastBucket(); j++) {

                assertEquals(expectedResults[i][j], scaledData.getEventCount(i, j));

            }

        }

    }

    public void testCountEvent3() {

        // Test with barWidth > 1

        final int nbBuckets = 2000;

        final int nbEvents = 10 * nbBuckets + 256;

        final long offset = 100;

        final int height = 100;

        final int width = 100;

        final int barWidth = 4;

        int[][] expectedResults = new int[width/barWidth][height/barWidth];

        int total = 0;

        // Horizontally and vertically the same data is used

        // for nbBuckets=2000 and nbEvents=20256 (means 20256 ns + offset) -> model.bucketDuration = 16

        // nbBars = width / barWidth = 25

        // bucketsPerBar = lastBucket/nbBars + 1 = 51

        // scaled bucket duration = bucketsPerBar * model.bucketDuration =  51 * 16

        boolean isFinished = false;

        for (int i = 0; i < width/barWidth; i++) {

            if (isFinished) {

                break;

            }

            for (int j = 0; j < height/barWidth; j++) {

                if (i == j) {

                    int value = 51 * 16;

                    if (total + value > nbEvents) {

                        expectedResults[i][j] = nbEvents - total;

                        isFinished = true;

                        break;

                    }

                    else {

                        expectedResults[i][j] = value;

                        total += value;

                    }

                }

            }

        }

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        for (int i = 0; i < nbEvents; i++) {

            model.countEvent(i+1, offset + i, offset + i);

        }

        GraphScaledData scaledData = model.scaleTo(height, width, barWidth);

        for (int i = 0; i < scaledData.getHorLastBucket(); i++) {

            for (int j = 0; j < scaledData.getVerLastBucket(); j++) {

                assertEquals(expectedResults[i][j], scaledData.getEventCount(i, j));

            }

        }

    }

    public void testCountEventReverse1() {

        // Depending on the number of buckets and events the start buckets can be different

        // between forward and reserve times. However, the content is correct.

        final int nbBuckets = 100;

        final int nbEvents = 256;

        final long hOffset = 100;

        final long vOffset = 55;

        final int height = 100;

        final int width = 50;

        final int barWidth = 1;

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        for (int i = 0; i < nbEvents; i++) {

            model.countEvent(i + 1, hOffset + i, vOffset + i);

        }

        GraphScaledData scaledData = model.scaleTo(width, height, barWidth);

        model.clear();

        for (int i = nbEvents - 1; i >= 0; i--) {

            model.countEvent(nbEvents - i, hOffset + i, vOffset + i);

        }

        GraphScaledData scaledDataReverse = model.scaleTo(50, 100, 1);

        long count = 0;

        for (int i = 0; i <= scaledData.getHorLastBucket(); i++) {

            for (int j = 0; j <= scaledData.getVerLastBucket(); j++) {

                count += scaledData.getEventCount(i, j);

            }

        }

        long revCount = 0;

        for (int i = 0; i <= scaledDataReverse.getHorLastBucket(); i++) {

            for (int j = 0; j <= scaledDataReverse.getVerLastBucket(); j++) {

                revCount += scaledDataReverse.getEventCount(i, j);

            }

        }

        assertEquals(count, revCount);

        // Make sure that both scaledData have the same content

        assertTrue("barWidth", scaledData.getBarWidth() == scaledDataReverse.getBarWidth());

        assertTrue("height", scaledData.getHeight() == scaledDataReverse.getHeight());

        assertTrue("width", scaledData.getWidth() == scaledDataReverse.getWidth());

        assertTrue(scaledData.getCurrentEventTime() == scaledDataReverse.getCurrentEventTime());

        assertTrue("Horizontal bucket duration", scaledData.getHorBucketDuration() == scaledDataReverse.getHorBucketDuration());

        assertTrue("Vertical bucket duration", scaledData.getVerBucketDuration() == scaledDataReverse.getVerBucketDuration());

        // startTime + scaledData.bucketDuration

        assertTrue("Horizontal bucket end time", scaledData.getHorBucketEndTime(0) == scaledDataReverse.getHorBucketEndTime(0));

        assertTrue("Vertical bucket end time", scaledData.getVerBucketEndTime(0) == scaledDataReverse.getVerBucketEndTime(0));

        assertTrue("Horizontal bucket start time", scaledData.getHorBucketStartTime(0) == scaledDataReverse.getHorBucketStartTime(0));

        assertTrue("Vertical bucket start time", scaledData.getVerBucketStartTime(0) == scaledDataReverse.getVerBucketStartTime(0));

        assertTrue("Horizontal first time", scaledData.getHorFirstEventTime() == scaledDataReverse.getHorFirstEventTime());

        assertTrue("Vertical first time",  scaledData.getVerFirstEventTime() == scaledDataReverse.getVerFirstEventTime());

        assertTrue("Horizontal getIndex", scaledData.getHorBucketIndex(200) == scaledDataReverse.getHorBucketIndex(200));

        assertTrue("Vertical getIndex", scaledData.getVerBucketIndex(100) == scaledDataReverse.getVerBucketIndex(100));

        assertTrue("Horizontal last bucket", scaledData.getHorNbBuckets() == scaledDataReverse.getHorNbBuckets());

        assertTrue("Vertical last bucket", scaledData.getVerNbBuckets() == scaledDataReverse.getVerNbBuckets());

        assertTrue("Horizontal nubmer of buckets", scaledData.getHorLastBucket() == scaledDataReverse.getHorLastBucket());

        assertTrue("Vertical nubmer of buckets", scaledData.getVerLastBucket() == scaledDataReverse.getVerLastBucket());

        // start time of last bucket

        assertTrue("Horizontal last event time", scaledData.getHorLastEventTime() == scaledDataReverse.getHorLastEventTime());

        assertTrue("Vertical last event time", scaledData.getVerLastEventTime() == scaledDataReverse.getVerLastEventTime());

    }

    public void testCountEventReverse2() {

        // Depending on the number of buckets and events the start buckets can be different

        // between forward and reserve times. However, the content is correct.

        final int nbBuckets = 100;

        final int nbEvents = 256;

        final long hOffset = 100;

        final long vOffset = 55;

        final int height = 100;

        final int width = 50;

        final int barWidth = 1;

        LatencyGraphModel model = new LatencyGraphModel(nbBuckets);

        for (int i = nbEvents - 1; i >= 0; i--) {

            model.countEvent(nbEvents - i, hOffset + i, vOffset + i);

        }

        // Verify model parameters

        int expectedBucketDuration = 4;

        assertEquals("Horizontal bucket duration", expectedBucketDuration, model.getHorBucketDuration());

        assertEquals("Vertical bucket duration", expectedBucketDuration, model.getVerBucketDuration());

        assertEquals("Horizontal first bucket time", hOffset, model.getHorFirstBucketTime());

        assertEquals("Vertical first bucket time", vOffset, model.getVerFirstBucketTime());

        assertEquals("Horizontal last bucket", (nbEvents -1)/expectedBucketDuration, model.getHorLastBucket());

        assertEquals("Vertical last bucket", (nbEvents -1)/expectedBucketDuration, model.getVerLastBucket());

        assertEquals("Horizontal first time", hOffset, model.getHorFirstEventTime());

        assertEquals("Vertical first time", vOffset, model.getVerFirstEventTime());

        assertEquals("Horizontal last time", nbEvents + hOffset - 1, model.getHorLastEventTime());

        assertEquals("Vertical last time", nbEvents + vOffset - 1, model.getVerLastEventTime());

        assertEquals("Horizontal time limit", expectedBucketDuration * nbBuckets + hOffset, model.getHorTimeLimit());

        assertEquals("Vertical time limit", expectedBucketDuration * nbBuckets + vOffset, model.getVerTimeLimit());

        GraphScaledData scaledData = model.scaleTo(50, 100, 1);

        // Make sure that both scaledData have the same content

        assertEquals("barWidth", barWidth, scaledData.getBarWidth());

        assertEquals("height", height, scaledData.getHeight());

        assertEquals("width", width, scaledData.getWidth());

        assertEquals(-1, scaledData.getCurrentEventTime()); 

        assertEquals("Horizontal bucket duration", 8, scaledData.getHorBucketDuration());

        assertEquals("Vertical bucket duration", 4, scaledData.getVerBucketDuration());

        // startTime + scaledData.bucketDuration

        assertEquals("Horizontal bucket end time", hOffset + 8, scaledData.getHorBucketEndTime(0));

        assertEquals("Vertical bucket end time", vOffset + 4, scaledData.getVerBucketEndTime(0));

        assertEquals("Horizontal bucket start time", hOffset, scaledData.getHorBucketStartTime(0));

        assertEquals("Vertical bucket start time", vOffset, scaledData.getVerBucketStartTime(0));

        assertEquals("Horizontal first time", hOffset, scaledData.getHorFirstEventTime());

        assertEquals("Vertical first time",  vOffset, scaledData.getVerFirstEventTime());

        assertEquals("Horizontal getIndex", 12, scaledData.getHorBucketIndex(200));

        assertEquals("Vertical getIndex", 11, scaledData.getVerBucketIndex(100));

        // nb Buckets = nbBars

        assertEquals("Horizontal number of buckets", 50, scaledData.getHorNbBuckets());

        assertEquals("Vertical number of buckets", 100, scaledData.getVerNbBuckets());

        assertEquals("Horizontal last bucket", 31, scaledData.getHorLastBucket());

        assertEquals("Vertical last bucket", 63, scaledData.getVerLastBucket());

        // start time of last bucket

        assertEquals("Horizontal last event time", 355, scaledData.getHorLastEventTime());

        assertEquals("Vertical last event time", 310, scaledData.getVerLastEventTime());

    }

}

import org.eclipse.linuxtools.lttng.ui.views.histogram.IHistogramModelListener;

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 1);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == startTime);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);

        assertTrue(model.getFirstBucketTime() == 0);