Clover coverage report - JFCUnit Test Coverage
Coverage timestamp: Mon Dec 20 2004 23:38:10 MST
file stats: LOC: 731   Methods: 29
NCLOC: 458   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
JFCEventManagerT.java 68% 88.2% 96.6% 83.9%
coverage coverage
 1   
 package junit.extensions.jfcunit;
 2   
 
 3   
 import java.text.MessageFormat;
 4   
 import java.text.ParseException;
 5   
 import java.util.ArrayList;
 6   
 
 7   
 import java.awt.AWTException;
 8   
 import java.awt.event.KeyEvent;
 9   
 
 10   
 import junit.extensions.jfcunit.eventdata.AbstractEventData;
 11   
 import junit.extensions.jfcunit.eventdata.DragEventData;
 12   
 import junit.extensions.jfcunit.eventdata.JComboBoxMouseEventData;
 13   
 import junit.extensions.jfcunit.eventdata.JFCEventDataListener;
 14   
 import junit.extensions.jfcunit.eventdata.JFCEventManager;
 15   
 import junit.extensions.jfcunit.eventdata.JListMouseEventData;
 16   
 import junit.extensions.jfcunit.eventdata.JTabbedPaneMouseEventData;
 17   
 import junit.extensions.jfcunit.eventdata.JTableHeaderMouseEventData;
 18   
 import junit.extensions.jfcunit.eventdata.JTableMouseEventData;
 19   
 import junit.extensions.jfcunit.eventdata.JTextComponentMouseEventData;
 20   
 import junit.extensions.jfcunit.eventdata.JTreeMouseEventData;
 21   
 import junit.extensions.jfcunit.eventdata.KeyEventData;
 22   
 import junit.extensions.jfcunit.eventdata.MouseEventData;
 23   
 import junit.extensions.jfcunit.eventdata.StringEventData;
 24   
 import junit.swingui.TestRunner;
 25   
 
 26   
 /**
 27   
  * Title:        RobotTestHelperT
 28   
  * Description:  Unit tests for the {@link RobotTestHelper} class and it's methods.
 29   
  *               Designed to work with JUnit v3.7 or later.
 30   
  *
 31   
  * @author <a href="mailto:vraravam@thoughtworks.com">Vijay Aravamudhan : ThoughtWorks Inc.</a>
 32   
  */
 33   
 public class JFCEventManagerT
 34   
     extends AbstractTestHelperBase {
 35   
 
 36   
   /**
 37   
    * Time to wait for events to be flushed from the JFCEventManager.
 38   
    */
 39   
   private long m_eventFlushTime = JFCEventManager.getEventManager().getHoldTime()
 40   
       + 25;
 41   
   /** This array holds all of the events. */
 42   
   private ArrayList m_eventDataList = new ArrayList();
 43   
 
 44   
   /** Listener which adds the events to the eventDataList list. */
 45   
   private JFCEventDataListener m_listener = new JFCEventDataListener() {
 46  237
     public void handleEvent(final AbstractEventData aed) {
 47  237
       m_eventDataList.add(aed);
 48   
     }
 49   
   };
 50   
 
 51   
   /**
 52   
    * Constructor.
 53   
    *
 54   
    * @param name Test case name.
 55   
    */
 56  40
   public JFCEventManagerT(final String name) {
 57  40
     super(name);
 58   
   }
 59   
 
 60   
   /**
 61   
    * Setup the test case.
 62   
    *
 63   
    * @exception  Exception   An instance of java.lang.Exception can be thrown
 64   
    */
 65  40
   public void setUp() throws Exception {
 66  40
     super.setUp();
 67  40
     if (getHelper() == null) {
 68  40
       try {
 69  40
         setHelper(new RobotTestHelper());
 70   
       } catch (AWTException ex) {
 71  0
         throw new RuntimeException("Could not create the robot" + ex);
 72   
       }
 73   
     }
 74  40
     setSleepTimer(300);
 75   
 
 76  40
     m_eventDataList.clear();
 77  40
     JFCEventManager.getEventManager().setRecording(true);
 78  40
     JFCEventManager.getEventManager().addJFCEventDataListener(m_listener);
 79   
   }
 80   
 
 81   
   /**
 82   
    * Cleanup the subtest and before validation of the
 83   
    * eventDataList.
 84   
    */
 85  23
   private void postTest() {
 86  23
     sleep(m_eventFlushTime);
 87  23
     JFCEventManager.getEventManager().setRecording(false);
 88  23
     JFCEventManager.getEventManager().removeJFCEventDataListener(m_listener);
 89   
   }
 90   
 
 91   
   /**
 92   
    * Run the test case.
 93   
    *
 94   
    * @param args Command line arguments.
 95   
    */
 96  0
   public static void main(final String[] args) {
 97  0
     TestRunner.run(RobotTestHelperT.class);
 98   
   }
 99   
 
 100   
   /**
 101   
    * Test the creation of events.
 102   
    */
 103  1
   public void testSendStringLowerCaseLetters() {
 104  1
     if (!validPlatform()) {
 105  0
       return;
 106   
     }
 107   
 
 108   
 
 109  1
     super.testSendStringLowerCaseLetters();
 110   
 
 111  1
     postTest();
 112   
 
 113   
     // Verify the event data list
 114  1
     int size = m_eventDataList.size();
 115  1
     StringBuffer result = new StringBuffer();
 116  1
     for (int i = 0; i < size; i++) {
 117  1
       Object obj = m_eventDataList.get(i);
 118  1
       if (!(obj instanceof StringEventData)) {
 119  0
         fail("Inncorrect event type");
 120   
       }
 121  1
       result.append(((StringEventData) obj).getString());
 122   
     }
 123  1
     assertEquals("string compare", "testing all lower case letters",
 124   
                  result.toString());
 125   
   }
 126   
 
 127   
   /**
 128   
    * Test the creation of events.
 129   
    */
 130  1
   public void testSendStringUpperCaseLetters() {
 131  1
     if (!validPlatform()) {
 132  0
       return;
 133   
     }
 134   
 
 135   
 
 136  1
     super.testSendStringUpperCaseLetters();
 137   
 
 138  1
     postTest();
 139   
 
 140   
     // Verify the event data list
 141  1
     int size = m_eventDataList.size();
 142  1
     StringBuffer result = new StringBuffer();
 143  1
     for (int i = 0; i < size; i++) {
 144  9
       Object obj = m_eventDataList.get(i);
 145  9
       if (!(obj instanceof StringEventData)) {
 146  0
         fail("Inncorrect event type");
 147   
       }
 148  9
       result.append(((StringEventData) obj).getString());
 149   
     }
 150  1
     assertEquals("string compare", "TESTING ALL UPPER CASE LETTERS",
 151   
                  result.toString());
 152   
   }
 153   
 
 154   
   /**
 155   
    * Test the creation of events.
 156   
    */
 157  1
   public void testSendStringLowerAndUpperCaseLetters() {
 158  1
     if (!validPlatform()) {
 159  0
       return;
 160   
     }
 161   
 
 162   
 
 163  1
     super.testSendStringLowerAndUpperCaseLetters();
 164   
 
 165  1
     postTest();
 166   
 
 167   
     // Verify the event data list
 168  1
     int size = m_eventDataList.size();
 169  1
     StringBuffer result = new StringBuffer();
 170  1
     for (int i = 0; i < size; i++) {
 171  13
       Object obj = m_eventDataList.get(i);
 172  13
       if (!(obj instanceof StringEventData)) {
 173  0
         fail("Inncorrect event type");
 174   
       }
 175  13
       result.append(((StringEventData) obj).getString());
 176   
     }
 177  1
     assertEquals("string compare", "Testing both UPPER AnD lower caSE leTTerS",
 178   
                  result.toString());
 179   
   }
 180   
 
 181   
   /**
 182   
    * Test the creation of events.
 183   
    */
 184  1
   public void testSendStringAllUppercaseCharacters() {
 185  1
     if (!validPlatform()) {
 186  0
       return;
 187   
     }
 188   
 
 189  1
     super.testSendStringAllUppercaseCharacters();
 190   
 
 191  1
     postTest();
 192   
 
 193   
     // Verify the event data list
 194  1
     int size = m_eventDataList.size();
 195  1
     StringBuffer result = new StringBuffer();
 196  1
     for (int i = 0; i < size; i++) {
 197  2
       Object obj = m_eventDataList.get(i);
 198  2
       if (!(obj instanceof StringEventData)) {
 199  0
         fail("Inncorrect event type");
 200   
       }
 201  2
       result.append(((StringEventData) obj).getString());
 202   
     }
 203  1
     assertEquals("string compare", "ABCDEFGHIJKLMNOPQRSTUVWXYZ 12345678901",
 204   
                  result.toString());
 205   
   }
 206   
 
 207   
   /**
 208   
    * Test the creation of events.
 209   
    */
 210  1
   public void testSendStringAllLowercaseCharacters() {
 211  1
     if (!validPlatform()) {
 212  0
       return;
 213   
     }
 214   
 
 215  1
     super.testSendStringAllLowercaseCharacters();
 216   
 
 217  1
     postTest();
 218   
 
 219   
     // Verify the event data list
 220  1
     int size = m_eventDataList.size();
 221  1
     StringBuffer result = new StringBuffer();
 222  1
     for (int i = 0; i < size; i++) {
 223  1
       Object obj = m_eventDataList.get(i);
 224  1
       if (!(obj instanceof StringEventData)) {
 225  0
         fail("Inncorrect event type");
 226   
       }
 227  1
       result.append(((StringEventData) obj).getString());
 228   
     }
 229  1
     assertEquals("string compare", "abcdefghijklmnopqrstuvwxyz 12345678901",
 230   
                  result.toString());
 231   
   }
 232   
 
 233   
   /**
 234   
    * Test the creation of events.
 235   
    */
 236  1
   public void testSendStringSpecialCharacters() {
 237  1
     if (!validPlatform()) {
 238  0
       return;
 239   
     }
 240   
 
 241  1
     super.testSendStringSpecialCharacters();
 242   
 
 243  1
     postTest();
 244   
 
 245   
     // Verify the event data list
 246  1
     int size = m_eventDataList.size();
 247  1
     StringBuffer result = new StringBuffer();
 248  1
     for (int i = 0; i < size; i++) {
 249  13
       Object obj = m_eventDataList.get(i);
 250  13
       if (!(obj instanceof StringEventData)) {
 251  0
         fail("Inncorrect event type");
 252   
       }
 253  13
       result.append(((StringEventData) obj).getString());
 254   
     }
 255  1
     assertEquals("string compare", "!@#$%^&*()_-+={}|[]:;'<>?,./~`\\\"",
 256   
                  result.toString());
 257   
   }
 258   
 
 259   
   /**
 260   
    * Test the creation of events.
 261   
    */
 262  1
   public void testSendKeyActionJTextField() {
 263  1
     if (!validPlatform()) {
 264  0
       return;
 265   
     }
 266   
 
 267  1
     super.testSendKeyActionJTextField();
 268   
 
 269  1
     postTest();
 270   
 
 271   
     // Verify the event data list
 272  1
     assertEquals("One event expected", 1, m_eventDataList.size());
 273  1
     Object obj = m_eventDataList.get(0);
 274  1
     assertTrue("KeyEventData" + obj, obj instanceof KeyEventData);
 275  1
     assertEquals("string compare", KeyEvent.VK_F2,
 276   
                  ((KeyEventData) obj).getKeyCode());
 277   
   }
 278   
 
 279   
   /**
 280   
    * Test the creation of events.
 281   
    */
 282  1
   public void testEnterJTreeClickAndLeave() {
 283  1
     if (!validPlatform()) {
 284  0
       return;
 285   
     }
 286   
 
 287  1
     super.testEnterJTreeClickAndLeave();
 288   
 
 289  1
     postTest();
 290   
 
 291   
     // Verify the event data list
 292  1
     assertEquals("Incorrect number of events", 2, m_eventDataList.size());
 293   
 
 294  1
     Object obj;
 295  1
     obj = m_eventDataList.get(0);
 296  1
     assertTrue("JTreeMouseEventData" + obj, obj instanceof JTreeMouseEventData);
 297  1
     assertEquals("ClickCount:", 1,
 298   
                  ((JTreeMouseEventData) obj).getNumberOfClicks());
 299   
 
 300  1
     obj = m_eventDataList.get(1);
 301  1
     assertTrue("JTreeMouseEventData" + obj, obj instanceof JTreeMouseEventData);
 302  1
     assertEquals("ClickCount:", 2,
 303   
                  ((JTreeMouseEventData) obj).getNumberOfClicks());
 304   
     // Need to validate the cell.
 305   
   }
 306   
 
 307   
   /**
 308   
    * Test the creation of events.
 309   
    */
 310  1
   public void testEnterDropDownClickAndLeaveByIndex() {
 311  1
     if (!validPlatform()) {
 312  0
       return;
 313   
     }
 314   
 
 315  1
     super.testEnterDropDownClickAndLeaveByIndex();
 316   
 
 317  1
     postTest();
 318   
 
 319   
     // Verify the event data list
 320  1
     assertEquals("Incorrect number of events", 4, m_eventDataList.size());
 321  1
     Object obj;
 322  1
     obj = m_eventDataList.get(0);
 323  1
     assertTrue("JComboBoxMouseEventData " + obj,
 324   
                obj instanceof JComboBoxMouseEventData);
 325  1
     assertEquals("ClickCount:", 1,
 326   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 327   
 
 328  1
     obj = m_eventDataList.get(1);
 329  1
     assertTrue("JComboBoxMouseEventData" + obj,
 330   
                obj instanceof JComboBoxMouseEventData);
 331  1
     assertEquals("ClickCount:", 1,
 332   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 333   
 
 334  1
     obj = m_eventDataList.get(2);
 335  1
     assertTrue("JComboBoxMouseEventData" + obj,
 336   
                obj instanceof JComboBoxMouseEventData);
 337  1
     assertEquals("ClickCount:", 1,
 338   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 339   
 
 340  1
     obj = m_eventDataList.get(3);
 341  1
     assertTrue("JComboBoxMouseEventData" + obj,
 342   
                obj instanceof JComboBoxMouseEventData);
 343  1
     assertEquals("ClickCount:", 1,
 344   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 345   
     // Need to validate the cell.
 346   
   }
 347   
 
 348   
   /**
 349   
    * Test the creation of events.
 350   
    */
 351  1
   public void testEnterDropDownClickAndLeaveByElement() {
 352  1
     if (!validPlatform()) {
 353  0
       return;
 354   
     }
 355   
 
 356  1
     super.testEnterDropDownClickAndLeaveByElement();
 357   
 
 358  1
     postTest();
 359   
 
 360   
     // Verify the event data list
 361  1
     assertEquals("Incorrect number of events", 4, m_eventDataList.size());
 362  1
     Object obj;
 363  1
     obj = m_eventDataList.get(0);
 364  1
     assertTrue("JComboBoxMouseEventData " + obj,
 365   
                obj instanceof JComboBoxMouseEventData);
 366  1
     assertEquals("ClickCount:", 1,
 367   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 368   
 
 369  1
     obj = m_eventDataList.get(1);
 370  1
     assertTrue("JComboBoxMouseEventData" + obj,
 371   
                obj instanceof JComboBoxMouseEventData);
 372  1
     assertEquals("ClickCount:", 1,
 373   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 374   
 
 375  1
     obj = m_eventDataList.get(2);
 376  1
     assertTrue("JComboBoxMouseEventData" + obj,
 377   
                obj instanceof JComboBoxMouseEventData);
 378  1
     assertEquals("ClickCount:", 1,
 379   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 380   
 
 381  1
     obj = m_eventDataList.get(3);
 382  1
     assertTrue("JComboBoxMouseEventData" + obj,
 383   
                obj instanceof JComboBoxMouseEventData);
 384  1
     assertEquals("ClickCount:", 1,
 385   
                  ((JComboBoxMouseEventData) obj).getNumberOfClicks());
 386   
     // Need to validate the cell.
 387   
   }
 388   
 
 389   
   /**
 390   
    * Test the creation of events.
 391   
    */
 392  1
   public void testEnterJListClickAndLeaveByIndex() {
 393  1
     if (!validPlatform()) {
 394  0
       return;
 395   
     }
 396   
 
 397  1
     super.testEnterJListClickAndLeaveByIndex();
 398   
 
 399  1
     postTest();
 400   
 
 401   
     // Verify the event data list
 402  1
     assertEquals("Incorrect number of events", 2, m_eventDataList.size());
 403  1
     Object obj;
 404  1
     obj = m_eventDataList.get(0);
 405  1
     assertTrue("JListMouseEventData" + obj, obj instanceof JListMouseEventData);
 406  1
     assertEquals("ClickCount:", 1,
 407   
                  ((JListMouseEventData) obj).getNumberOfClicks());
 408   
 
 409  1
     obj = m_eventDataList.get(1);
 410  1
     assertTrue("JListMouseEventData" + obj, obj instanceof JListMouseEventData);
 411  1
     assertEquals("ClickCount:", 2,
 412   
                  ((JListMouseEventData) obj).getNumberOfClicks());
 413   
   }
 414   
 
 415   
   /**
 416   
    * Test the creation of events.
 417   
    */
 418  1
   public void testEnterJListClickAndLeaveByElement() {
 419  1
     if (!validPlatform()) {
 420  0
       return;
 421   
     }
 422   
 
 423  1
     super.testEnterJListClickAndLeaveByElement();
 424   
 
 425  1
     postTest();
 426   
 
 427   
     // Verify the event data list
 428  1
     assertEquals("Incorrect number of events", 2, m_eventDataList.size());
 429  1
     Object obj;
 430  1
     obj = m_eventDataList.get(0);
 431  1
     assertTrue("JListMouseEventData" + obj, obj instanceof JListMouseEventData);
 432  1
     assertEquals("ClickCount:", 1,
 433   
                  ((JListMouseEventData) obj).getNumberOfClicks());
 434   
 
 435  1
     obj = m_eventDataList.get(1);
 436  1
     assertTrue("JListMouseEventData" + obj, obj instanceof JListMouseEventData);
 437  1
     assertEquals("ClickCount:", 2,
 438   
                  ((JListMouseEventData) obj).getNumberOfClicks());
 439   
   }
 440   
 
 441   
   /**
 442   
    * Test the creation of events.
 443   
    */
 444  1
   public void testEnterJTableClickAndLeave() {
 445  1
     if (!validPlatform()) {
 446  0
       return;
 447   
     }
 448   
 
 449  1
     super.testEnterJTableClickAndLeave();
 450   
 
 451  1
     postTest();
 452   
 
 453   
     // Verify the event data list
 454  1
     assertEquals("Incorrect number of events", 20, m_eventDataList.size());
 455  1
     Object obj;
 456   
 
 457  1
     for (int t = 0; t < 5; t++) {
 458  5
       for (int c = 1; c < 5; c++) {
 459   
 
 460  20
         obj = m_eventDataList.get(t * 4 + c - 1);
 461  20
         assertTrue("JTableMouseEventData" + obj,
 462   
                    obj instanceof JTableMouseEventData);
 463  20
         assertEquals("ClickCount:", c,
 464   
                      ((JTableMouseEventData) obj).getNumberOfClicks());
 465   
       }
 466   
     }
 467   
   }
 468   
 
 469   
   /**
 470   
    * Test the creation of events.
 471   
    */
 472  1
   public void testEnterInvalidJTableClickAndLeave() {
 473   
     /** @todo */
 474  1
     if (!validPlatform()) {
 475  0
       return;
 476   
     }
 477   
 
 478  1
     super.testEnterInvalidJTableClickAndLeave();
 479   
 
 480  1
     postTest();
 481   
 
 482   
     // Verify the event data list
 483   
 //    assertEquals("Incorrect number of events", 20, m_eventDataList.size());
 484   
 //    Object obj;
 485   
 //
 486   
 //    for (int t = 0; t < 5; t++) {
 487   
 //      for (int c = 1; c < 5; c++) {
 488   
 //
 489   
 //        obj = m_eventDataList.get(t * 4 + c - 1);
 490   
 //        assertTrue("JTableMouseEventData" + obj,
 491   
 //                   obj instanceof JTableMouseEventData);
 492   
 //        assertEquals("ClickCount:", c,
 493   
 //                     ((JTableMouseEventData) obj).getNumberOfClicks());
 494   
 //      }
 495   
 //    }
 496   
   }
 497   
 
 498   
   /**
 499   
    * Test the creation of events.
 500   
    */
 501  1
   public void testEnterJTableHeaderClickAndLeave() {
 502  1
     if (!validPlatform()) {
 503  0
       return;
 504   
     }
 505   
 
 506  1
     super.testEnterJTableHeaderClickAndLeave();
 507   
 
 508  1
     postTest();
 509   
 
 510   
     // Verify the event data list
 511  1
     assertEquals("Incorrect number of events", 20, m_eventDataList.size());
 512  1
     Object obj;
 513   
 
 514  1
     for (int t = 0; t < 5; t++) {
 515  5
       for (int c = 1; c < 5; c++) {
 516  20
         obj = m_eventDataList.get(t * 4 + c - 1);
 517  20
         assertTrue("JTableHeaderMouseEventData" + obj,
 518   
                    obj instanceof JTableHeaderMouseEventData);
 519  20
         assertEquals("ClickCount:", c,
 520   
                      ((JTableHeaderMouseEventData) obj).getNumberOfClicks());
 521   
       }
 522   
     }
 523   
   }
 524   
 
 525   
   /**
 526   
    * Test the creation of events.
 527   
    */
 528  1
   public void testEnterJTabbedPaneClickAndLeave() {
 529  1
     if (!validPlatform()) {
 530  0
       return;
 531   
     }
 532   
 
 533  1
     super.testEnterJTabbedPaneClickAndLeave();
 534   
 
 535  1
     postTest();
 536   
 
 537   
     // Verify the event data list
 538  1
     assertEquals("Incorrect number of events", 30, m_eventDataList.size());
 539  1
     Object obj;
 540   
 
 541  1
     for (int t = 0; t < 10; t++) {
 542  10
       for (int c = 1; c < 3; c++) {
 543  20
         obj = m_eventDataList.get(t * 3 + c - 1);
 544  20
         assertTrue("JTabbedPaneMouseEventData" + obj,
 545   
                    obj instanceof JTabbedPaneMouseEventData);
 546  20
         assertEquals("ClickCount:", c,
 547   
                      ((JTabbedPaneMouseEventData) obj).getNumberOfClicks());
 548   
       }
 549   
     }
 550   
   }
 551   
 
 552   
   /**
 553   
    * Test the creation of events.
 554   
    */
 555  1
   public void testEnterClickAndLeaveJToggleButton() {
 556  1
     if (!validPlatform()) {
 557  0
       return;
 558   
     }
 559   
 
 560  1
     super.testEnterClickAndLeaveJToggleButton();
 561   
 
 562  1
     postTest();
 563   
 
 564   
     // Verify the event data list
 565  1
     assertEquals("Incorrect number of events", 10, m_eventDataList.size());
 566  1
     Object obj;
 567   
 
 568  1
     for (int t = 0; t < 10; t++) {
 569  10
       obj = m_eventDataList.get(t);
 570  10
       assertTrue("MouseEventData" + obj, obj instanceof MouseEventData);
 571  10
       assertEquals("ClickCount:", 1, ((MouseEventData) obj).getNumberOfClicks());
 572   
     }
 573   
   }
 574   
 
 575   
   /**
 576   
    * Test the creation of events.
 577   
    */
 578  1
   public void testEnterClickAndLeaveJRadioButton() {
 579  1
     if (!validPlatform()) {
 580  0
       return;
 581   
     }
 582   
 
 583  1
     super.testEnterClickAndLeaveJRadioButton();
 584   
 
 585  1
     postTest();
 586   
 
 587   
     // Verify the event data list
 588  1
     assertEquals("Incorrect number of events", 10, m_eventDataList.size());
 589  1
     Object obj;
 590   
 
 591  1
     for (int t = 0; t < 10; t++) {
 592  10
       obj = m_eventDataList.get(t);
 593  10
       assertTrue("MouseEventData" + obj, obj instanceof MouseEventData);
 594  10
       assertEquals("ClickCount:", 1, ((MouseEventData) obj).getNumberOfClicks());
 595   
     }
 596   
   }
 597   
 
 598   
   /**
 599   
    * Test the creation of events.
 600   
    */
 601  1
   public void testEnterClickAndLeaveJCheckBox() {
 602  1
     if (!validPlatform()) {
 603  0
       return;
 604   
     }
 605   
 
 606  1
     super.testEnterClickAndLeaveJCheckBox();
 607   
 
 608  1
     postTest();
 609   
 
 610   
     // Verify the event data list
 611  1
     assertEquals("Incorrect number of events", 10, m_eventDataList.size());
 612  1
     Object obj;
 613   
 
 614  1
     for (int t = 0; t < 10; t++) {
 615  10
       obj = m_eventDataList.get(t);
 616  10
       assertTrue("MouseEventData" + obj, obj instanceof MouseEventData);
 617  10
       assertEquals("ClickCount:", 1, ((MouseEventData) obj).getNumberOfClicks());
 618   
     }
 619   
   }
 620   
 
 621   
   /**
 622   
    * Test the creation of events.
 623   
    */
 624  1
   public void testJTextComponentEnterClickAndLeave() {
 625  1
     if (!validPlatform()) {
 626  0
       return;
 627   
     }
 628   
 
 629  1
     super.testJTextComponentEnterClickAndLeave();
 630   
 
 631  1
     postTest();
 632   
 
 633   
     // Verify the event data list
 634  1
     assertEquals("Incorrect number of events", 22, m_eventDataList.size());
 635  1
     Object obj;
 636   
 
 637  1
     for (int t = 0; t < 22; t++) {
 638  22
       obj = m_eventDataList.get(t);
 639  22
       assertTrue("MouseEventData" + obj,
 640   
                  obj instanceof JTextComponentMouseEventData);
 641  22
       assertEquals("ClickCount:", 1,
 642   
                    ((JTextComponentMouseEventData) obj).getNumberOfClicks());
 643   
     }
 644   
   }
 645   
 
 646   
   /**
 647   
    * Test the creation of events.
 648   
    */
 649  1
   public void testJTextComponentDrag() {
 650  1
     if (!validPlatform()) {
 651  0
       return;
 652   
     }
 653   
 
 654  1
     super.testJTextComponentDrag();
 655   
 
 656  1
     postTest();
 657   
 
 658   
     // Verify the event data list
 659  1
     assertEquals("Incorrect number of events", 1, m_eventDataList.size());
 660  1
     Object obj = m_eventDataList.get(0);
 661  1
     assertTrue("DragEventData:" + obj, obj instanceof DragEventData);
 662   
   }
 663   
 
 664   
   /**
 665   
    * Test the creation of events.
 666   
    */
 667  1
   public void testEnterJTableHeaderMoveDragAndLeave() {
 668  1
     if (!validPlatform()) {
 669  0
       return;
 670   
     }
 671   
 
 672  1
     super.testEnterJTableHeaderMoveDragAndLeave();
 673   
 
 674  1
     postTest();
 675   
 
 676   
     // Verify the event data list
 677  1
     assertEquals("Incorrect number of events", 5, m_eventDataList.size());
 678  1
     Object obj;
 679  1
     for (int t = 0; t < 5; t++) {
 680  5
       obj = m_eventDataList.get(t);
 681  5
       assertTrue("DragEventData:" + obj, obj instanceof DragEventData);
 682   
     }
 683   
   }
 684   
 
 685   
   /**
 686   
    * Test the creation of events.
 687   
    */
 688  1
   public void testEnterJTableHeaderResizeDragAndLeave() {
 689  1
     if (!validPlatform()) {
 690  0
       return;
 691   
     }
 692   
 
 693  1
     super.testEnterJTableHeaderResizeDragAndLeave();
 694   
 
 695  1
     postTest();
 696   
 
 697   
     // Verify the event data list
 698  1
     assertEquals("Incorrect number of events", 5, m_eventDataList.size());
 699   
 
 700  1
     Object obj;
 701  1
     for (int t = 0; t < 5; t++) {
 702  5
       obj = m_eventDataList.get(t);
 703  5
       assertTrue("DragEventData:" + obj, obj instanceof DragEventData);
 704   
     }
 705   
   }
 706   
 
 707   
   /**
 708   
    * This procedure is used to force the 1.2.2, 1.3 on XP to return without testing
 709   
    * On this platform the robot does not operate properly.
 710   
    * @return false if 1.2.2 or 1.3 running on XP.
 711   
    */
 712  64
   protected boolean validPlatform() {
 713  64
     String version = System.getProperty("java.version");
 714  64
     String platform = System.getProperty("os.name");
 715  64
     if ("Windows XP".equals(platform)) {
 716  64
       MessageFormat mf = new MessageFormat("{0}.{1}.{2}");
 717  64
       try {
 718  64
         Object[] args = mf.parse(version);
 719  64
         int ver = Integer.parseInt((String) args[1]);
 720  64
         if (ver < 4) {
 721  0
           return false;
 722   
         }
 723   
       } catch (ParseException ex) {
 724  0
         return true;
 725   
       }
 726   
 
 727   
     }
 728  64
     return true;
 729   
   }
 730   
 }
 731