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:	230		Methods:	14
	NCLOC:	105		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

StringEventData.java

100%

95.9%

92.9%

96.1%

 package junit.extensions.jfcunit.eventdata;
 
 import junit.extensions.jfcunit.JFCTestCase;
 import junit.extensions.jfcunit.TestHelper;
 import junit.extensions.jfcunit.keyboard.JFCKeyStroke;
 import junit.extensions.jfcunit.keyboard.KeyMapping;
 
 import org.w3c.dom.Element;
 
 import java.awt.AWTEvent;
 import java.awt.Component;
 import java.awt.event.KeyEvent;
 
 
 /**
  * Data container class that holds all the data necessary for jfcUnit to fire mouse events.
  *
  * @author <a href="mailto:vraravam@thoughtworks.com">Vijay Aravamudhan : ThoughtWorks Inc.</a>
  */
 public class StringEventData extends AbstractKeyEventData {
     /**
      * The string code to be fired.
      */
     private Component m_comp = null;
 
     /**
      * The string code to be fired.
      */
     private String m_string = "";
 
     /**
      * Default Constructor.
      */
     public StringEventData() {
         super();
         setValid(false);
     }
 
     /**
      * Constructor.
      *
      * @param testCase The JFCTestCase on whose thread <code>awtSleep()</code>
      * has to be invoked.
      * @param comp     The component on which to trigger the event.
      * @param string   The string to be sent to the component
      */
     public StringEventData(final JFCTestCase testCase, final Component comp,
         final String string) {
         this(testCase, comp, string, DEFAULT_KEY_MODIFIERS, DEFAULT_SLEEPTIME);
     }
 
     /**
      * Constructor.
      *
      * @param testCase  The JFCTestCase on whose thread <code>awtSleep()</code> has to be invoked.
      * @param comp      The component on which to trigger the event.
      * @param string    The string to be sent to the component
      * @param sleepTime The wait time in ms between each event.
      */
     public StringEventData(final JFCTestCase testCase, final Component comp,
         final String string, final long sleepTime) {
         this(testCase, comp, string, DEFAULT_KEY_MODIFIERS, sleepTime);
     }
 
     /**
      * Constructor.
      *
      * @param testCase  The JFCTestCase on whose thread <code>awtSleep()</code> has to be invoked.
      * @param comp      The component on which to trigger the event.
      * @param string    The string to be sent to the component
      * @param modifiers The modifier string values that need to be passed onto the event.
      * @param sleepTime
      *                   The wait time in ms between each event.
      */
     public StringEventData(final JFCTestCase testCase, final Component comp,
         final String string, final int modifiers, final long sleepTime) {
         setTestCase(testCase);
         setSource(comp);
         setString(string);
         setModifiers(modifiers);
         setSleepTime(sleepTime);
         setValid(true);
     }
 
     /**
      * Set the attribute value.
      *
      * @param comp   The new value of the attribute.
      */
     public final void setSource(final Component comp) {
         m_comp = comp;
     }
 
     /**
      * Get the attribute value.
      *
      * @return Component    The value of the attribute.
      */
     public final Component getSource() {
         return m_comp;
     }
 
     /**
      * Set the string to be sent.
      *
      * @param string Key code.
      */
     public final void setString(final String string) {
         m_string = string;
         setupKeyStrokes();
     }
 
     /**
      * The component on which the event has to be fired.
      *
      * @return The component
      */
     public Component getComponent() {
         // by default, the component is the same as the source
         return getSource();
     }
 
     /**
      * Get the string to be sent.
      *
      * @return String string to be sent.
      */
     public String getString() {
         return m_string;
     }
 
     /**
      * Check if this event can consume the AWTEvent.
      *
      * @param ae Event to be consumed.
      * @return boolean true if the event can be consumed.
      */
     public boolean canConsume(final AWTEvent ae) {
         if (!(ae instanceof KeyEvent)) {
             return false;
         }
 
         // If not a defined keystoke then cannot consume by the string.
         JFCKeyStroke[] stroke = getKeyMapping().getKeyStrokes(
                 ((KeyEvent) ae).getKeyChar());
         char           c = ((KeyEvent) ae).getKeyChar();
 
         if (Character.isISOControl(c)) {
             return false;
         }
 
         if (isValid()) {
             int mods = ((KeyEvent) ae).getModifiers();
 
             if (getModifiers() != mods) {
                 return false;
             }
         }
 
         return ((stroke != null) && (stroke.length > 0))
         && super.canConsume(ae)
         && (isMetaChar(((KeyEvent) ae).getKeyCode())
         || (((KeyEvent) ae).getKeyChar() != KeyEvent.CHAR_UNDEFINED));
     }
 
     /**
      * Consume the event.
      * @param ae Event to be consumed.
      * @return boolean true if the event was consumed.
      */
     public boolean consume(final AWTEvent ae) {
         if (super.consume(ae)) {
             return true;
         }
 
         setSource((Component) ae.getSource());
 
         StringBuffer buf = new StringBuffer();
 
         if (isValid()) {
             buf.append(getString());
         }
 
         buf.append(((KeyEvent) ae).getKeyChar());
         setSleepTime(getDefaultSleepTime());
 
         int mods = ((KeyEvent) ae).getModifiers();
 
         super.setModifiers(mods);
         setString(buf.toString());
         setValid(true);
 
         return true;
     }
 
     /**
      * Populate the element with the key code.
      * @param e Element to be populated with the data for this event.
      */
     public void populate(final Element e) {
         super.populate(e);
         e.setAttribute("string", m_string);
     }
 
     /**
      * Generate a description of the event.
      *
      * @return String description of the event.
      */
     public String toString() {
         return "StringEventData:" + getString() + " on " + getComponent() + " "
         + getModifiers() + " " + getSleepTime();
     }
 
     /**
      * Setup the keystrokes for the event.
      */
     protected void setupKeyStrokes() {
         KeyMapping km = TestHelper.getKeyMapping();
         clearKeyStrokes();
 
         for (int i = 0; i < m_string.length(); i++) {
             JFCKeyStroke[] strokes = km.getKeyStrokes(m_string.charAt(i));
             addKeyStrokes(strokes);
         }
 
         applyModifier(getModifiers());
     }
 }
 

1		package junit.extensions.jfcunit.eventdata;
2
3		import junit.extensions.jfcunit.JFCTestCase;
4		import junit.extensions.jfcunit.TestHelper;
5		import junit.extensions.jfcunit.keyboard.JFCKeyStroke;
6		import junit.extensions.jfcunit.keyboard.KeyMapping;
7
8		import org.w3c.dom.Element;
9
10		import java.awt.AWTEvent;
11		import java.awt.Component;
12		import java.awt.event.KeyEvent;
13
14
15		/**
16		* Data container class that holds all the data necessary for jfcUnit to fire mouse events.
17		*
18		* @author <a href="mailto:vraravam@thoughtworks.com">Vijay Aravamudhan : ThoughtWorks Inc.</a>
19		*/
20		public class StringEventData extends AbstractKeyEventData {
21		/**
22		* The string code to be fired.
23		*/
24		private Component m_comp = null;
25
26		/**
27		* The string code to be fired.
28		*/
29		private String m_string = "";
30
31		/**
32		* Default Constructor.
33		*/
34	233	public StringEventData() {
35	233	super();
36	233	setValid(false);
37		}
38
39		/**
40		* Constructor.
41		*
42		* @param testCase The JFCTestCase on whose thread <code>awtSleep()</code>
43		* has to be invoked.
44		* @param comp The component on which to trigger the event.
45		* @param string The string to be sent to the component
46		*/
47	31	public StringEventData(final JFCTestCase testCase, final Component comp,
48		final String string) {
49	31	this(testCase, comp, string, DEFAULT_KEY_MODIFIERS, DEFAULT_SLEEPTIME);
50		}
51
52		/**
53		* Constructor.
54		*
55		* @param testCase The JFCTestCase on whose thread <code>awtSleep()</code> has to be invoked.
56		* @param comp The component on which to trigger the event.
57		* @param string The string to be sent to the component
58		* @param sleepTime The wait time in ms between each event.
59		*/
60	2	public StringEventData(final JFCTestCase testCase, final Component comp,
61		final String string, final long sleepTime) {
62	2	this(testCase, comp, string, DEFAULT_KEY_MODIFIERS, sleepTime);
63		}
64
65		/**
66		* Constructor.
67		*
68		* @param testCase The JFCTestCase on whose thread <code>awtSleep()</code> has to be invoked.
69		* @param comp The component on which to trigger the event.
70		* @param string The string to be sent to the component
71		* @param modifiers The modifier string values that need to be passed onto the event.
72		* @param sleepTime
73		* The wait time in ms between each event.
74		*/
75	42	public StringEventData(final JFCTestCase testCase, final Component comp,
76		final String string, final int modifiers, final long sleepTime) {
77	42	setTestCase(testCase);
78	42	setSource(comp);
79	42	setString(string);
80	42	setModifiers(modifiers);
81	42	setSleepTime(sleepTime);
82	42	setValid(true);
83		}
84
85		/**
86		* Set the attribute value.
87		*
88		* @param comp The new value of the attribute.
89		*/
90	337	public final void setSource(final Component comp) {
91	337	m_comp = comp;
92		}
93
94		/**
95		* Get the attribute value.
96		*
97		* @return Component The value of the attribute.
98		*/
99	1343	public final Component getSource() {
100	1343	return m_comp;
101		}
102
103		/**
104		* Set the string to be sent.
105		*
106		* @param string Key code.
107		*/
108	337	public final void setString(final String string) {
109	337	m_string = string;
110	337	setupKeyStrokes();
111		}
112
113		/**
114		* The component on which the event has to be fired.
115		*
116		* @return The component
117		*/
118	1337	public Component getComponent() {
119		// by default, the component is the same as the source
120	1337	return getSource();
121		}
122
123		/**
124		* Get the string to be sent.
125		*
126		* @return String string to be sent.
127		*/
128	290	public String getString() {
129	290	return m_string;
130		}
131
132		/**
133		* Check if this event can consume the AWTEvent.
134		*
135		* @param ae Event to be consumed.
136		* @return boolean true if the event can be consumed.
137		*/
138	1111	public boolean canConsume(final AWTEvent ae) {
139	1111	if (!(ae instanceof KeyEvent)) {
140	100	return false;
141		}
142
143		// If not a defined keystoke then cannot consume by the string.
144	1011	JFCKeyStroke[] stroke = getKeyMapping().getKeyStrokes(
145		((KeyEvent) ae).getKeyChar());
146	1011	char c = ((KeyEvent) ae).getKeyChar();
147
148	1011	if (Character.isISOControl(c)) {
149	3	return false;
150		}
151
152	1008	if (isValid()) {
153	878	int mods = ((KeyEvent) ae).getModifiers();
154
155	878	if (getModifiers() != mods) {
156	49	return false;
157		}
158		}
159
160	959	return ((stroke != null) && (stroke.length > 0))
161		&& super.canConsume(ae)
162		&& (isMetaChar(((KeyEvent) ae).getKeyCode())
163		\|\| (((KeyEvent) ae).getKeyChar() != KeyEvent.CHAR_UNDEFINED));
164		}
165
166		/**
167		* Consume the event.
168		* @param ae Event to be consumed.
169		* @return boolean true if the event was consumed.
170		*/
171	885	public boolean consume(final AWTEvent ae) {
172	885	if (super.consume(ae)) {
173	590	return true;
174		}
175
176	295	setSource((Component) ae.getSource());
177
178	295	StringBuffer buf = new StringBuffer();
179
180	295	if (isValid()) {
181	239	buf.append(getString());
182		}
183
184	295	buf.append(((KeyEvent) ae).getKeyChar());
185	295	setSleepTime(getDefaultSleepTime());
186
187	295	int mods = ((KeyEvent) ae).getModifiers();
188
189	295	super.setModifiers(mods);
190	295	setString(buf.toString());
191	295	setValid(true);
192
193	295	return true;
194		}
195
196		/**
197		* Populate the element with the key code.
198		* @param e Element to be populated with the data for this event.
199		*/
200	0	public void populate(final Element e) {
201	0	super.populate(e);
202	0	e.setAttribute("string", m_string);
203		}
204
205		/**
206		* Generate a description of the event.
207		*
208		* @return String description of the event.
209		*/
210	6	public String toString() {
211	6	return "StringEventData:" + getString() + " on " + getComponent() + " "
212		+ getModifiers() + " " + getSleepTime();
213		}
214
215		/**
216		* Setup the keystrokes for the event.
217		*/
218	674	protected void setupKeyStrokes() {
219	674	KeyMapping km = TestHelper.getKeyMapping();
220	674	clearKeyStrokes();
221
222	674	for (int i = 0; i < m_string.length(); i++) {
223	7473	JFCKeyStroke[] strokes = km.getKeyStrokes(m_string.charAt(i));
224	7473	addKeyStrokes(strokes);
225		}
226
227	674	applyModifier(getModifiers());
228		}
229		}
230