JFCUnit Test Coverage

Clover coverage report - JFCUnit Test Coverage

Coverage timestamp: Mon Dec 20 2004 23:38:10 MST

FRAMES NO FRAMES

file stats:	LOC:	404		Methods:	21
	NCLOC:	194		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

DragEventData.java

55.8%

73.7%

71.4%

67.9%

 package junit.extensions.jfcunit.eventdata;
 
 import junit.extensions.jfcunit.JFCTestCase;
 
 import org.w3c.dom.Element;
 
 import java.awt.AWTEvent;
 import java.awt.Component;
 import java.awt.Point;
 import java.awt.event.MouseEvent;
 
 import java.util.List;
 import java.util.Vector;
 
 
 /**
  * DragEventSource is a wrapper for Drag Events.
  * The event encapsulates the source and destination
  * locations for the drag with xxxMouseEventData
  * types.
  *
  * @author <a href="mailto:vraravam@thoughtworks.com">Vijay Aravamudhan : ThoughtWorks Inc.</a>
  */
 public class DragEventData extends AbstractEventData {
     /**
      * Destination of the drag event.
      */
     private AbstractMouseEventData m_dest;
 
     /**
      * Source of the drag event.
      */
     private AbstractMouseEventData m_source;
 
     /**
      * List of points in the drag path.
      */
     private List m_points = new Vector();
 
     /**
      * Original reference location of component.
      */
     private Point m_origPoint = null;
 
     /**
      * Constructor: Assumes a null destination and default sleep time.
      *
      * @param testCase {@link JFCTestCase} to fire the sleeps upon.
      * @param source {@link AbstractMouseEventData} indicating the
      *                starting location of the drag event.
      */
     public DragEventData(final JFCTestCase testCase,
         final AbstractMouseEventData source) {
         this(testCase, source, null, DEFAULT_SLEEPTIME);
     }
 
     /**
      * Constructor for a drag event. Assumes the
      * default sleepTime.
      *
      * @param testCase {@link JFCTestCase} to fire the sleeps upon.
      * @param source {@link AbstractMouseEventData} indicating the
      *                starting location of the drag event.
      * @param dest {@link AbstractMouseEventData} indicating the
      *              ending location of the drag event.
      */
     public DragEventData(final JFCTestCase testCase,
         final AbstractMouseEventData source, final AbstractMouseEventData dest) {
         this(testCase, source, dest, DEFAULT_SLEEPTIME);
     }
 
     /**
      * Constructor for a drag event.
      *
      * @param testCase TestCase.
      * @param source {@link AbstractMouseEventData} indicating the
      *                starting location of the drag event.
      * @param dest {@link AbstractMouseEventData} indicating the
      *              ending location of the drag event.
      * @param delay sleepTime of the event.
      */
     public DragEventData(final JFCTestCase testCase,
         final AbstractMouseEventData source, final AbstractMouseEventData dest,
         final long delay) {
         setTestCase(testCase);
         setSource(source);
         setDest(dest);
         setSleepTime(delay);
 
         if ((getSource() != null) && getSource().isValid()) {
             setValid(true);
         }
     }
 
     /**
      * This method is provided here to close the
      * abstract base class.
      *
      * @return null This method always returns null.
      */
     public final Component getComponent() {
         return null;
     }
 
     /**
      * Get the default modifiers.
      * @return default modifiers for the drag event.
      */
     public final int getDefaultModifiers() {
         return m_source.getDefaultModifiers();
     }
 
     /**
      * Set the Destination of the drag event.
      *
      * @param dest destination {@link AbstractMouseEventData}.
      */
     public final void setDest(final AbstractMouseEventData dest) {
         m_dest = dest;
     }
 
     /**
      * Get the destination MouseEventData.
      *
      * @return The destination {@link AbstractMouseEventData}.
      */
     public final AbstractMouseEventData getDest() {
         return m_dest;
     }
 
     /**
      * Get the modifier text for the current.
      *
      * @return String modifier text.
      */
     public final String getModifierText() {
         return m_source.getModifierText();
     }
 
     /**
      * Set the points in the drag path.
      *
      * @param points Set of points to be hit in the
      *               drag path.
      */
     public final void setPoints(final Point[] points) {
         this.m_points.clear();
 
         for (int i = 0; i < points.length; i++) {
             this.m_points.add(points[i]);
         }
     }
 
     /**
      * Get the list of points in the drag path.
      *
      * @return {@link java.awt.Point}[] list of points.
      */
     public final Point[] getPoints() {
         return (Point[]) m_points.toArray(new Point[0]);
     }
 
     /**
      * Set the Source of the drag event.
      *
      * @param source {@link AbstractMouseEventData} indicating the
      *                starting location of the drag event.
      */
     public final void setSource(final AbstractMouseEventData source) {
         m_source = source;
 
         if ((m_source != null)
                 && (m_source.getComponent() != null)
                 && m_source.getComponent().isVisible()) {
             this.m_origPoint = m_source.getLocationOnScreen();
         }
     }
 
     /**
      * Get the Source of the drag event.
      *
      * @return The source {@link AbstractMouseEventData}.
      */
     public final AbstractMouseEventData getSource() {
         return m_source;
     }
 
     /**
      * Add a {@link java.awt.Point} to the drag path.
      *
      * @param p {@link java.awt.Point} to be hit along the drag path.
      */
     public final void addPoint(final Point p) {
         m_points.add(p);
     }
 
     /**
      * This prepares the source and dest components if set,
      * and inserts/appends the screen locations onto the list
      * of points.
      *
      * @return   boolean true if the source and destination events
      *           were able to "prepare" their components.
      */
     public final boolean prepareComponent() {
         boolean results = true;
         boolean resultd = true;
 
         if (m_source != null) {
             results = m_source.prepareComponent();
             m_points.add(
                 0,
                 m_source.getLocationOnScreen());
         }
 
         Point compLocation = m_source.getComponent().getLocationOnScreen();
 
         if (m_points.size() > 1) {
             for (int i = 1; i < m_points.size(); i++) {
                 Point p = (Point) m_points.get(i);
                 p.translate(compLocation.x, compLocation.y);
             }
         }
 
         if (m_dest != null) {
             resultd = m_dest.prepareComponent();
             m_points.add(m_dest.getLocationOnScreen());
         }
 
         return results & resultd;
     }
 
     /**
      * Check if this event can consume the {@link java.awt.AWTEvent}.
      *
      * @param ae {@link java.awt.AWTEvent} to be consumed.
      * @return boolean true if the event can be consumed.
      */
     public boolean canConsume(final AWTEvent ae) {
         if (!(ae instanceof MouseEvent)) {
             return false;
         }
 
         MouseEvent me = (MouseEvent) ae;
 
         if ((me.getID() == MouseEvent.MOUSE_DRAGGED)
                 || (me.getID() == MouseEvent.MOUSE_EXITED)
                 || (me.getID() == MouseEvent.MOUSE_ENTERED)) {
             return true;
         }
 
         if (isValid()) {
             return getSource().canConsume(ae);
         }
 
         return false;
     }
 
     /**
      * Consume the {@link java.awt.AWTEvent}.
      *
      * @param ae Event to be consumed.
      * @return boolean true if the event was consumed.
      */
     public boolean consume(final AWTEvent ae) {
         if (!(ae instanceof MouseEvent)) {
             return false;
         }
 
         MouseEvent me = (MouseEvent) ae;
 
         if ((me.getID() == MouseEvent.MOUSE_ENTERED)
                 || (me.getID() == MouseEvent.MOUSE_EXITED)) {
             return true;
         }
 
         if (me.getID() == MouseEvent.MOUSE_DRAGGED) {
             Point p = convertToSource(
                     me.getComponent(),
                     me.getPoint());
             addPoint(p);
         } else {
             return getSource().consume(ae);
         }
 
         return true;
     }
 
     /**
      * Equals comparison.
      *
      * @param o Object to be compared.
      * @return true if the objects are the same.
      */
     public boolean equals(final Object o) {
         if (!(o instanceof DragEventData)) {
             return false;
         }
 
         DragEventData ded = (DragEventData) o;
 
         if (m_source == null) {
             if (ded.getSource() != null) {
                 return false;
             }
         } else {
             if (!m_source.equals(ded.getSource())) {
                 return false;
             }
         }
 
         if (m_dest == null) {
             if (ded.getDest() != null) {
                 return false;
             }
         } else {
             if (!m_dest.equals(ded.getDest())) {
                 return false;
             }
         }
 
         return true;
     }
 
     /**
      * Calculate a hashcode based upon the source and the
      * dest of this class.
      * @return int hashcode.
      */
     public int hashCode() {
         int hc = super.hashCode();
 
         if (m_source != null) {
             hc += m_source.hashCode();
         }
 
         if (m_dest != null) {
             hc += m_dest.hashCode();
         }
 
         return hc;
     }
 
     /**
      * Populate the element wiht the data.
      *
      * @param e element to be populated.
      */
     public void populate(final Element e) {
     }
 
     /**
      * Return a string representing the eventdata.
      *
      * @return String description of the event data.
      */
     public String toString() {
         StringBuffer buf = new StringBuffer(1000);
         buf.append("DragEventData:");
 
         if (!isValid()) {
             buf.append(" invalid");
 
             return buf.toString();
         }
 
         buf.append("(Source:" + getSource().toString() + ")");
         buf.append("Points:");
 
         for (int i = 0; i < m_points.size(); i++) {
             if (i != 0) {
                 buf.append(",");
             }
 
             buf.append(m_points.get(i));
         }
 
         return buf.toString();
     }
 
     /**
      * Convert the point to the source coordinate system.
      * @param comp Souce component.
      * @param p Point to be converted.
      * @return point of p related to source coordinates.
      */
     private Point convertToSource(final Component comp, final Point p) {
         Point screen = comp.getLocationOnScreen();
         screen.translate(p.x, p.y);
 
         if (m_origPoint == null) {
             return p;
         }
 
         int   dx = screen.x - m_origPoint.x;
         int   dy = screen.y - m_origPoint.y;
 
         Point delta = new Point(p);
         delta.translate(dx, dy);
 
         return delta;
     }
 }
 

1		package junit.extensions.jfcunit.eventdata;
2
3		import junit.extensions.jfcunit.JFCTestCase;
4
5		import org.w3c.dom.Element;
6
7		import java.awt.AWTEvent;
8		import java.awt.Component;
9		import java.awt.Point;
10		import java.awt.event.MouseEvent;
11
12		import java.util.List;
13		import java.util.Vector;
14
15
16		/**
17		* DragEventSource is a wrapper for Drag Events.
18		* The event encapsulates the source and destination
19		* locations for the drag with xxxMouseEventData
20		* types.
21		*
22		* @author <a href="mailto:vraravam@thoughtworks.com">Vijay Aravamudhan : ThoughtWorks Inc.</a>
23		*/
24		public class DragEventData extends AbstractEventData {
25		/**
26		* Destination of the drag event.
27		*/
28		private AbstractMouseEventData m_dest;
29
30		/**
31		* Source of the drag event.
32		*/
33		private AbstractMouseEventData m_source;
34
35		/**
36		* List of points in the drag path.
37		*/
38		private List m_points = new Vector();
39
40		/**
41		* Original reference location of component.
42		*/
43		private Point m_origPoint = null;
44
45		/**
46		* Constructor: Assumes a null destination and default sleep time.
47		*
48		* @param testCase {@link JFCTestCase} to fire the sleeps upon.
49		* @param source {@link AbstractMouseEventData} indicating the
50		* starting location of the drag event.
51		*/
52	29	public DragEventData(final JFCTestCase testCase,
53		final AbstractMouseEventData source) {
54	29	this(testCase, source, null, DEFAULT_SLEEPTIME);
55		}
56
57		/**
58		* Constructor for a drag event. Assumes the
59		* default sleepTime.
60		*
61		* @param testCase {@link JFCTestCase} to fire the sleeps upon.
62		* @param source {@link AbstractMouseEventData} indicating the
63		* starting location of the drag event.
64		* @param dest {@link AbstractMouseEventData} indicating the
65		* ending location of the drag event.
66		*/
67	86	public DragEventData(final JFCTestCase testCase,
68		final AbstractMouseEventData source, final AbstractMouseEventData dest) {
69	86	this(testCase, source, dest, DEFAULT_SLEEPTIME);
70		}
71
72		/**
73		* Constructor for a drag event.
74		*
75		* @param testCase TestCase.
76		* @param source {@link AbstractMouseEventData} indicating the
77		* starting location of the drag event.
78		* @param dest {@link AbstractMouseEventData} indicating the
79		* ending location of the drag event.
80		* @param delay sleepTime of the event.
81		*/
82	122	public DragEventData(final JFCTestCase testCase,
83		final AbstractMouseEventData source, final AbstractMouseEventData dest,
84		final long delay) {
85	122	setTestCase(testCase);
86	122	setSource(source);
87	122	setDest(dest);
88	122	setSleepTime(delay);
89
90	122	if ((getSource() != null) && getSource().isValid()) {
91	122	setValid(true);
92		}
93		}
94
95		/**
96		* This method is provided here to close the
97		* abstract base class.
98		*
99		* @return null This method always returns null.
100		*/
101	0	public final Component getComponent() {
102	0	return null;
103		}
104
105		/**
106		* Get the default modifiers.
107		* @return default modifiers for the drag event.
108		*/
109	0	public final int getDefaultModifiers() {
110	0	return m_source.getDefaultModifiers();
111		}
112
113		/**
114		* Set the Destination of the drag event.
115		*
116		* @param dest destination {@link AbstractMouseEventData}.
117		*/
118	122	public final void setDest(final AbstractMouseEventData dest) {
119	122	m_dest = dest;
120		}
121
122		/**
123		* Get the destination MouseEventData.
124		*
125		* @return The destination {@link AbstractMouseEventData}.
126		*/
127	8	public final AbstractMouseEventData getDest() {
128	8	return m_dest;
129		}
130
131		/**
132		* Get the modifier text for the current.
133		*
134		* @return String modifier text.
135		*/
136	0	public final String getModifierText() {
137	0	return m_source.getModifierText();
138		}
139
140		/**
141		* Set the points in the drag path.
142		*
143		* @param points Set of points to be hit in the
144		* drag path.
145		*/
146	0	public final void setPoints(final Point[] points) {
147	0	this.m_points.clear();
148
149	0	for (int i = 0; i < points.length; i++) {
150	0	this.m_points.add(points[i]);
151		}
152		}
153
154		/**
155		* Get the list of points in the drag path.
156		*
157		* @return {@link java.awt.Point}[] list of points.
158		*/
159	84	public final Point[] getPoints() {
160	84	return (Point[]) m_points.toArray(new Point[0]);
161		}
162
163		/**
164		* Set the Source of the drag event.
165		*
166		* @param source {@link AbstractMouseEventData} indicating the
167		* starting location of the drag event.
168		*/
169	122	public final void setSource(final AbstractMouseEventData source) {
170	122	m_source = source;
171
172	122	if ((m_source != null)
173		&& (m_source.getComponent() != null)
174		&& m_source.getComponent().isVisible()) {
175	119	this.m_origPoint = m_source.getLocationOnScreen();
176		}
177		}
178
179		/**
180		* Get the Source of the drag event.
181		*
182		* @return The source {@link AbstractMouseEventData}.
183		*/
184	739	public final AbstractMouseEventData getSource() {
185	739	return m_source;
186		}
187
188		/**
189		* Add a {@link java.awt.Point} to the drag path.
190		*
191		* @param p {@link java.awt.Point} to be hit along the drag path.
192		*/
193	193	public final void addPoint(final Point p) {
194	193	m_points.add(p);
195		}
196
197		/**
198		* This prepares the source and dest components if set,
199		* and inserts/appends the screen locations onto the list
200		* of points.
201		*
202		* @return boolean true if the source and destination events
203		* were able to "prepare" their components.
204		*/
205	84	public final boolean prepareComponent() {
206	84	boolean results = true;
207	84	boolean resultd = true;
208
209	84	if (m_source != null) {
210	84	results = m_source.prepareComponent();
211	84	m_points.add(
212		0,
213		m_source.getLocationOnScreen());
214		}
215
216	84	Point compLocation = m_source.getComponent().getLocationOnScreen();
217
218	84	if (m_points.size() > 1) {
219	0	for (int i = 1; i < m_points.size(); i++) {
220	0	Point p = (Point) m_points.get(i);
221	0	p.translate(compLocation.x, compLocation.y);
222		}
223		}
224
225	84	if (m_dest != null) {
226	84	resultd = m_dest.prepareComponent();
227	84	m_points.add(m_dest.getLocationOnScreen());
228		}
229
230	84	return results & resultd;
231		}
232
233		/**
234		* Check if this event can consume the {@link java.awt.AWTEvent}.
235		*
236		* @param ae {@link java.awt.AWTEvent} to be consumed.
237		* @return boolean true if the event can be consumed.
238		*/
239	195	public boolean canConsume(final AWTEvent ae) {
240	195	if (!(ae instanceof MouseEvent)) {
241	0	return false;
242		}
243
244	195	MouseEvent me = (MouseEvent) ae;
245
246	195	if ((me.getID() == MouseEvent.MOUSE_DRAGGED)
247		\|\| (me.getID() == MouseEvent.MOUSE_EXITED)
248		\|\| (me.getID() == MouseEvent.MOUSE_ENTERED)) {
249	168	return true;
250		}
251
252	27	if (isValid()) {
253	27	return getSource().canConsume(ae);
254		}
255
256	0	return false;
257		}
258
259		/**
260		* Consume the {@link java.awt.AWTEvent}.
261		*
262		* @param ae Event to be consumed.
263		* @return boolean true if the event was consumed.
264		*/
265	222	public boolean consume(final AWTEvent ae) {
266	222	if (!(ae instanceof MouseEvent)) {
267	0	return false;
268		}
269
270	222	MouseEvent me = (MouseEvent) ae;
271
272	222	if ((me.getID() == MouseEvent.MOUSE_ENTERED)
273		\|\| (me.getID() == MouseEvent.MOUSE_EXITED)) {
274	2	return true;
275		}
276
277	220	if (me.getID() == MouseEvent.MOUSE_DRAGGED) {
278	193	Point p = convertToSource(
279		me.getComponent(),
280		me.getPoint());
281	193	addPoint(p);
282		} else {
283	27	return getSource().consume(ae);
284		}
285
286	193	return true;
287		}
288
289		/**
290		* Equals comparison.
291		*
292		* @param o Object to be compared.
293		* @return true if the objects are the same.
294		*/
295	6	public boolean equals(final Object o) {
296	6	if (!(o instanceof DragEventData)) {
297	2	return false;
298		}
299
300	4	DragEventData ded = (DragEventData) o;
301
302	4	if (m_source == null) {
303	0	if (ded.getSource() != null) {
304	0	return false;
305		}
306		} else {
307	4	if (!m_source.equals(ded.getSource())) {
308	2	return false;
309		}
310		}
311
312	2	if (m_dest == null) {
313	0	if (ded.getDest() != null) {
314	0	return false;
315		}
316		} else {
317	2	if (!m_dest.equals(ded.getDest())) {
318	1	return false;
319		}
320		}
321
322	1	return true;
323		}
324
325		/**
326		* Calculate a hashcode based upon the source and the
327		* dest of this class.
328		* @return int hashcode.
329		*/
330	0	public int hashCode() {
331	0	int hc = super.hashCode();
332
333	0	if (m_source != null) {
334	0	hc += m_source.hashCode();
335		}
336
337	0	if (m_dest != null) {
338	0	hc += m_dest.hashCode();
339		}
340
341	0	return hc;
342		}
343
344		/**
345		* Populate the element wiht the data.
346		*
347		* @param e element to be populated.
348		*/
349	0	public void populate(final Element e) {
350		}
351
352		/**
353		* Return a string representing the eventdata.
354		*
355		* @return String description of the event data.
356		*/
357	11	public String toString() {
358	11	StringBuffer buf = new StringBuffer(1000);
359	11	buf.append("DragEventData:");
360
361	11	if (!isValid()) {
362	0	buf.append(" invalid");
363
364	0	return buf.toString();
365		}
366
367	11	buf.append("(Source:" + getSource().toString() + ")");
368	11	buf.append("Points:");
369
370	11	for (int i = 0; i < m_points.size(); i++) {
371	81	if (i != 0) {
372	70	buf.append(",");
373		}
374
375	81	buf.append(m_points.get(i));
376		}
377
378	11	return buf.toString();
379		}
380
381		/**
382		* Convert the point to the source coordinate system.
383		* @param comp Souce component.
384		* @param p Point to be converted.
385		* @return point of p related to source coordinates.
386		*/
387	193	private Point convertToSource(final Component comp, final Point p) {
388	193	Point screen = comp.getLocationOnScreen();
389	193	screen.translate(p.x, p.y);
390
391	193	if (m_origPoint == null) {
392	0	return p;
393		}
394
395	193	int dx = screen.x - m_origPoint.x;
396	193	int dy = screen.y - m_origPoint.y;
397
398	193	Point delta = new Point(p);
399	193	delta.translate(dx, dy);
400
401	193	return delta;
402		}
403		}
404