1 /*
   2   @test %I% %E%
   3   @bug 6315717
   4   @summary verifies that modifiers are correct for standard (1, 2, 3, wheel) mouse buttons
   5   @author Andrei Dmitriev : area=awt.mouse
   6   @run main MouseModifiersUnitTest_Standard
   7  */
   8 
   9 import java.awt.*;
  10 import java.awt.event.*;
  11 import java.util.HashMap;
  12 import java.util.StringTokenizer;
  13 import java.util.Vector;
  14 
  15 //the test verifies:
  16 // 1) verifies that modifiers are correct for standard (1, 2, 3) mouse buttons
  17 // TODO: 2) verifies that modifiers are correct for wheel
  18 // TODO: 3)
  19 // Case1. the test posts BUTTONx_MASK and verifies that paramString() contains correct modifiers and exModifiers
  20 // Case2. the test posts BUTTONx_DOWN_MASK and verifies that paramString() contains correct modifiers and exModifiers
  21 // Case3. the test posts getMaskForButton(n) and verifies that paramString() contains correct modifiers and exModifiers
  22 // repeat all cases with SHIFT/ALT/CTRL modifiers verify that paramString() contains correct modifiers and exModifiers
  23 // I'm verifying button, modifiers and extModifiers for now.
  24 
  25 public class MouseModifiersUnitTest_Standard {
  26     static final int NONE = 0;
  27     static final int SHIFT = 1;
  28     static final int CTRL = 2;
  29     static final int ALT = 3;
  30     static boolean debug = true; //dump all errors (debug) or throw first(under jtreg) exception
  31     static boolean autorun = false; //use robot or manual run
  32     static int testModifier = NONE;
  33     //    static String testModifier = "NONE";
  34     static CheckingModifierAdapter adapterTest1;
  35     static CheckingModifierAdapter adapterTest2;
  36     static CheckingModifierAdapter adapterTest3;
  37     static CheckingModifierAdapter adapterTest4;
  38     static Frame f;
  39     final static int [] mouseButtons = new int [] {MouseEvent.BUTTON1_MASK, MouseEvent.BUTTON2_MASK, MouseEvent.BUTTON3_MASK};
  40     // BUTTON1, 2, 3 press-release.
  41     final static int [] modifiersStandardTestNONE = new int[] {MouseEvent.BUTTON1_MASK, MouseEvent.BUTTON1_MASK, MouseEvent.BUTTON1_MASK,
  42     MouseEvent.BUTTON2_MASK, MouseEvent.BUTTON2_MASK, MouseEvent.BUTTON2_MASK,
  43     MouseEvent.BUTTON3_MASK, MouseEvent.BUTTON3_MASK, MouseEvent.BUTTON3_MASK };
  44     final static int [] modifiersExStandardTestNONE = new int[] {MouseEvent.BUTTON1_DOWN_MASK, 0, 0,
  45     MouseEvent.BUTTON2_DOWN_MASK, 0, 0,
  46     MouseEvent.BUTTON3_DOWN_MASK, 0, 0};
  47     // BUTTON1, 2, 3 press-release with shift modifier
  48     final static int [] modifiersStandardTestSHIFT = new int[] {MouseEvent.BUTTON1_MASK|InputEvent.SHIFT_MASK, MouseEvent.BUTTON1_MASK|InputEvent.SHIFT_MASK, MouseEvent.BUTTON1_MASK|InputEvent.SHIFT_MASK,
  49     MouseEvent.BUTTON2_MASK|InputEvent.SHIFT_MASK, MouseEvent.BUTTON2_MASK|InputEvent.SHIFT_MASK, MouseEvent.BUTTON2_MASK|InputEvent.SHIFT_MASK,
  50     MouseEvent.BUTTON3_MASK|InputEvent.SHIFT_MASK, MouseEvent.BUTTON3_MASK|InputEvent.SHIFT_MASK, MouseEvent.BUTTON3_MASK|InputEvent.SHIFT_MASK };
  51     final static int [] modifiersExStandardTestSHIFT = new int[] {MouseEvent.BUTTON1_DOWN_MASK|InputEvent.SHIFT_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK,
  52     MouseEvent.BUTTON2_DOWN_MASK|InputEvent.SHIFT_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK,
  53     MouseEvent.BUTTON3_DOWN_MASK|InputEvent.SHIFT_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK, InputEvent.SHIFT_DOWN_MASK};
  54     // BUTTON1, 2, 3 press-release with CTRL modifier
  55     final static int [] modifiersStandardTestCTRL = new int[] {MouseEvent.BUTTON1_MASK|InputEvent.CTRL_MASK, MouseEvent.BUTTON1_MASK|InputEvent.CTRL_MASK, MouseEvent.BUTTON1_MASK|InputEvent.CTRL_MASK,
  56     MouseEvent.BUTTON2_MASK|InputEvent.CTRL_MASK, MouseEvent.BUTTON2_MASK|InputEvent.CTRL_MASK, MouseEvent.BUTTON2_MASK|InputEvent.CTRL_MASK,
  57     MouseEvent.BUTTON3_MASK|InputEvent.CTRL_MASK, MouseEvent.BUTTON3_MASK|InputEvent.CTRL_MASK, MouseEvent.BUTTON3_MASK|InputEvent.CTRL_MASK };
  58     final static int [] modifiersExStandardTestCTRL = new int[] {MouseEvent.BUTTON1_DOWN_MASK|InputEvent.CTRL_DOWN_MASK, InputEvent.CTRL_DOWN_MASK, InputEvent.CTRL_DOWN_MASK,
  59     MouseEvent.BUTTON2_DOWN_MASK|InputEvent.CTRL_DOWN_MASK, InputEvent.CTRL_DOWN_MASK, InputEvent.CTRL_DOWN_MASK,
  60     MouseEvent.BUTTON3_DOWN_MASK|InputEvent.CTRL_DOWN_MASK, InputEvent.CTRL_DOWN_MASK, InputEvent.CTRL_DOWN_MASK};
  61 
  62     // BUTTON1, 2, 3 press-release with ALT modifier
  63     final static int [] modifiersStandardTestALT = new int[] {MouseEvent.BUTTON1_MASK|InputEvent.ALT_MASK, MouseEvent.BUTTON1_MASK|InputEvent.ALT_MASK, MouseEvent.BUTTON1_MASK|InputEvent.ALT_MASK,
  64     MouseEvent.BUTTON2_MASK|InputEvent.ALT_MASK, MouseEvent.BUTTON2_MASK|InputEvent.ALT_MASK, MouseEvent.BUTTON2_MASK|InputEvent.ALT_MASK,
  65     MouseEvent.BUTTON3_MASK|InputEvent.ALT_MASK, MouseEvent.BUTTON3_MASK|InputEvent.ALT_MASK, MouseEvent.BUTTON3_MASK|InputEvent.ALT_MASK };
  66     final static int [] modifiersExStandardTestALT = new int[] {MouseEvent.BUTTON1_DOWN_MASK|InputEvent.ALT_DOWN_MASK, InputEvent.ALT_DOWN_MASK, InputEvent.ALT_DOWN_MASK,
  67     MouseEvent.BUTTON2_DOWN_MASK|InputEvent.ALT_DOWN_MASK, InputEvent.ALT_DOWN_MASK, InputEvent.ALT_DOWN_MASK,
  68     MouseEvent.BUTTON3_DOWN_MASK|InputEvent.ALT_DOWN_MASK, InputEvent.ALT_DOWN_MASK, InputEvent.ALT_DOWN_MASK};
  69 
  70     static Robot robot;
  71 
  72     public static void main(String s[]){
  73         initParams(s);
  74         initAdapters();
  75         f = new Frame();
  76         final int [] modifiers = {InputEvent.SHIFT_MASK, InputEvent.CTRL_MASK};
  77         final String [] modifierNames = {"InputEvent.SHIFT_MASK", "InputEvent.CTRL_MASK"};
  78         f.setLayout(new FlowLayout());
  79         f.addMouseWheelListener(new MouseWheelListener() {
  80             public void mouseWheelMoved(MouseWheelEvent e) {
  81                 System.out.println("WHEEL "+e);
  82             }
  83         });
  84         f.setSize(300, 300);
  85         f.setVisible(true);
  86 
  87         try {
  88             robot = new Robot();
  89             robot.delay(500);
  90             robot.mouseMove(f.getLocationOnScreen().x + f.getWidth()/2, f.getLocationOnScreen().y + f.getHeight()/2);
  91             if (autorun) {
  92                 //testing buttons 1, 2, 3 only
  93                 testPlainButtons();
  94                 robot.delay(500);
  95 
  96                 //testing buttons 1, 2, 3 with SHIFT, CTRL, ALT keyboard modifiers
  97                 testButtonsWithShift();
  98                 robot.delay(500);
  99 
 100                 testButtonsWithControl();
 101                 robot.delay(500);
 102 
 103                 testButtonsWithAlt();
 104                 robot.delay(500);
 105             } else {
 106                 switch (testModifier){
 107                     case SHIFT:
 108                         f.addMouseListener(adapterTest2);
 109                         break;
 110                     case CTRL:
 111                         f.addMouseListener(adapterTest3);
 112                         break;
 113                     case ALT:
 114                         f.addMouseListener(adapterTest4);
 115                         break;
 116                     default:  //NONE inclusive
 117                         f.addMouseListener(adapterTest1);
 118                 }
 119             }
 120         } catch (Exception e){
 121             throw new RuntimeException("Test failed.");
 122         }
 123 
 124     }
 125 
 126     public static void initAdapters(){
 127         adapterTest1 = new CheckingModifierAdapter(NONE);
 128         adapterTest2 = new CheckingModifierAdapter(SHIFT);
 129         adapterTest3 = new CheckingModifierAdapter(CTRL);
 130         adapterTest4 = new CheckingModifierAdapter(ALT);
 131     }
 132 
 133     /*======================================================================*/
 134     public static void checkPressedModifiersTest(int testModifier, MouseEvent event){
 135         int [] curStandardModifiers = getStandardArray(testModifier);
 136         int [] curStandardExModifiers = getStandardExArray(testModifier);
 137         int button = event.getButton();
 138         int modifiers = event.getModifiers();
 139         int modifiersEx = event.getModifiersEx();
 140         int index = (button - 1)*3;
 141         //        int index = (button - 4)*3;
 142         dumpValues(button, modifiers, curStandardModifiers[index], modifiersEx, curStandardExModifiers[index]);
 143         if (modifiers != curStandardModifiers[index]){
 144             if (debug){
 145                 System.out.println("Test failed :  Pressed. modifiers != modifiersStandard");
 146             } else {
 147                 throw new RuntimeException("Test failed :  Pressed. modifiers != modifiersStandard");
 148             }
 149         }
 150 
 151         if (modifiersEx != curStandardExModifiers[index]){
 152 //            System.out.println(">>>>>>>>>>>>>>> Pressed. modifiersEx "+modifiersEx +" : "+!= curStandardExModifiers");
 153             if (debug){
 154                 System.out.println("Test failed :  Pressed. modifiersEx != curStandardExModifiers");
 155             } else {
 156                 throw new RuntimeException("Test failed :  Pressed. modifiersEx != curStandardExModifiers");
 157             }
 158         }
 159         HashMap <String, String> paramStringElements = tokenizeParamString(event.paramString());
 160         System.out.println(event.paramString());
 161         checkButton(paramStringElements, button);
 162         checkModifiers(testModifier, paramStringElements, button);
 163         checkExtModifiersOnPress(testModifier, paramStringElements, button);
 164     }
 165 
 166     public static void checkButton(HashMap<String, String> h, int button){
 167         if (h.get("button") == null) {
 168             throw new RuntimeException("Test failed :  Clicked. button is absent in paramString()");
 169         }
 170         if (Integer.parseInt(h.get("button")) != button) {
 171             throw new RuntimeException("Test failed :  Clicked. button in paramString() doesn't equal to button being pressed.");
 172         }
 173     }
 174 
 175     public static void checkExtModifiersOnPress(int testModifier, HashMap h, int button){
 176         String ethalon = "";
 177         if (h.get("extModifiers") == null) {
 178             System.out.println("Test failed :  Pressed. extModifiers == null");
 179             throw new RuntimeException("Test failed :  Pressed. extModifiers == null");
 180         }
 181         switch (testModifier){
 182             case SHIFT:{
 183                 ethalon = "Shift+";
 184                 break;
 185             }
 186             case ALT:{
 187                 ethalon = "Alt+";
 188                 break;
 189             }
 190             case CTRL:{
 191                 ethalon = "Ctrl+";
 192                 break;
 193             }
 194             default: {
 195                 ethalon = "";
 196             }
 197             ethalon = ethalon + "Button" +button;
 198 
 199             if (!h.get("extModifiers").equals(ethalon)) {
 200                 System.out.println("Test failed :  Pressed. extModifiers = " +h.get("extModifiers")+" instead of : "+ethalon);
 201                 throw new RuntimeException("Test failed :  Pressed. extModifiers = " +h.get("extModifiers")+" instead of : "+ethalon);
 202             }
 203         }
 204     }
 205 
 206 
 207 
 208     public static void checkModifiers(int testModifier, HashMap<String, String> h, int button){
 209         // none of modifiers should be null
 210         if (h.get("modifiers") == null) {
 211             System.out.println("Test failed : modifiers == null");
 212             throw new RuntimeException("Test failed :  modifiers == null");
 213         }
 214         Vector <String> modifierElements = tokenizeModifiers(h.get("modifiers"));
 215         //check that ButtonX is there
 216         String buttonEthalon = "Button" + button;
 217         if (modifierElements.contains(buttonEthalon)){
 218             modifierElements.remove(buttonEthalon);
 219         } else {
 220             System.out.println("Test failed :  modifiers doesn't contain Button "+h.get("modifiers"));
 221             throw new RuntimeException("Test failed :  modifiers doesn't contain Button "+h.get("modifiers"));
 222         }
 223 
 224 
 225         //Check all explicitly pressed modifires
 226 //        boolean altIncluded = false; //don't duplicate Alt when ALT is pressed and BUTTON2_MASK.
 227         String excplicitModifier = "";
 228         boolean altIncluded = false;
 229         switch (testModifier){
 230             case SHIFT:{
 231                 excplicitModifier = "Shift";
 232                 break;
 233             }
 234             case ALT:{
 235                 excplicitModifier = "Alt";
 236                 altIncluded = true; //there should be only on "Alt" for two modifiers. So check it.
 237                 break;
 238             }
 239             case CTRL:{
 240                 excplicitModifier = "Ctrl";
 241                 break;
 242             }
 243         }
 244         if (!excplicitModifier.equals("")){
 245             if (modifierElements.contains(excplicitModifier)){
 246                 modifierElements.remove(excplicitModifier);
 247             } else {
 248                 System.out.println("Test failed :  modifiers doesn't contain explicit modifier "+excplicitModifier + " in "+ h.get("modifiers"));
 249                 throw new RuntimeException("Test failed :  modifiers doesn't contain explicit modifier "+excplicitModifier + " in "+ h.get("modifiers"));
 250             }
 251         }
 252 
 253         //Button 2 and 3 reports about Alt+Button2 and Meta+Button3 respectively.
 254         //Check these values too
 255         String extraModifiers = "";
 256         String extraModifiersButton3 = "";
 257         switch (button){
 258             //BUTTON1 with ALT reports about Alt+Button1+Button2.
 259             //We should fix this but I would not change this.
 260             case 1: {
 261                 //Alt+Button1+Button2:
 262                 // 1) we already handled "Alt" in excplicitModifier
 263                 // 2) we already took "Button1" in buttonEthalon
 264                 // 3) so "Button2" is only remained.
 265                 // This should only happen when ALT+Button1 is pressed
 266                 if (altIncluded){
 267                     extraModifiers = "Button2";
 268                 }
 269                 break;
 270             }
 271             case 2: {
 272                 //Alt+Button2 report about "Alt+Button2".
 273                 extraModifiers = "Alt";
 274                 break;
 275             }
 276             case 3: {
 277                 //ALT+BUTTON3 reports about "Alt+Meta+Button2+Button3"
 278                 // This should only happen when ALT+Button3 is pressed
 279                 extraModifiers = "Meta";
 280                 if (altIncluded){
 281                     extraModifiersButton3 = "Button2";
 282                 }
 283                 break;
 284             }
 285         }//switch
 286 
 287         if (!extraModifiers.equals("")){
 288             if (modifierElements.contains(extraModifiers)){
 289                 modifierElements.remove(extraModifiers);
 290             } else {
 291                 //we may already removed "Alt" when filtered explicit modifiers.
 292                 //Here is no failure in this case.
 293                 if (!altIncluded) {
 294                     System.out.println("Test failed :  modifiers doesn't contain a modifier from BUTTON2 or BUTTON3 "+extraModifiers + " in "+ h.get("modifiers"));
 295                     throw new RuntimeException("Test failed :  modifiers doesn't contain a modifier from BUTTON2 or BUTTON3 "+extraModifiers + " in "+ h.get("modifiers"));
 296                 }
 297             }
 298         }
 299 
 300         if (!extraModifiersButton3.equals("")){
 301             if (modifierElements.contains(extraModifiersButton3)){
 302                 modifierElements.remove(extraModifiersButton3);
 303             } else {
 304                 System.out.println("Test failed :  modifiers doesn't contain a modifier from BUTTON2 or BUTTON3 "+extraModifiersButton3 + " in "+ h.get("modifiers"));
 305                 throw new RuntimeException("Test failed :  modifiers doesn't contain a modifier from BUTTON2 or BUTTON3 "+extraModifiersButton3 + " in "+ h.get("modifiers"));
 306             }
 307         }
 308 
 309         //the length of vector should now be zero
 310         if (!modifierElements.isEmpty()){
 311             System.out.println("Test failed :  there is some more elements in modifiers that shouldn't be there: "+h.get("modifiers"));
 312             throw new RuntimeException("Test failed :  there is some more elements in modifiers that shouldn't be there: "+h.get("modifiers"));
 313         }
 314     }
 315 
 316     public static void checkExtModifiersOnReleaseClick(int testModifier, HashMap h, int button){
 317         String ethalon = "";
 318         switch (testModifier){
 319             case SHIFT:{
 320                 ethalon = "Shift+";
 321                 break;
 322             }
 323             case ALT:{
 324                 ethalon = "Alt+";
 325                 break;
 326             }
 327             case CTRL:{
 328                 ethalon = "Ctrl+";
 329                 break;
 330             }
 331             default: {
 332                 if (h.get("extModifiers") != null) {
 333                     System.out.println("Test failed :  Released. extModifiers != null but no modifiers keys are pressed");
 334                     throw new RuntimeException("Test failed :  Released. extModifiers != null but no modifiers keys are pressed");
 335                 } else {
 336                     //no modifiers
 337                     return;
 338                 }
 339             }
 340         }
 341         if (h.get("extModifiers").equals(ethalon)) {
 342             System.out.println("Test failed :  Released. extModifiers = "+ h.get("extModifiers") +" instead of : "+ethalon);
 343             throw new RuntimeException("Test failed :  Released. extModifiers = "+ h.get("extModifiers") +" instead of : "+ethalon);
 344         }
 345     }
 346 
 347     public static void checkReleasedModifiersTest(int testModifier, MouseEvent event){
 348         int [] curStandardModifiers = getStandardArray(testModifier);
 349         int [] curStandardExModifiers = getStandardExArray(testModifier);
 350         //        int index = (button - 4)*3 + 1;
 351         int button = event.getButton();
 352         int modifiers = event.getModifiers();
 353         int modifiersEx = event.getModifiersEx();
 354         int index = (button - 1)*3 + 1;
 355         dumpValues(button, modifiers, curStandardModifiers[index], modifiersEx, curStandardExModifiers[index]);
 356         if (modifiers != curStandardModifiers[index]){
 357             if (debug){
 358                 System.out.println("Test failed :  Released. modifiers != modifiersStandard");
 359             } else {
 360                 throw new RuntimeException("Test failed :  Released. modifiers != modifiersStandard");
 361             }
 362         }
 363         if (modifiersEx != curStandardExModifiers[index]){
 364             if (debug){
 365                 System.out.println("Test failed :  Released. modifiersEx != curStandardExModifiers");
 366             } else {
 367                 throw new RuntimeException("Test failed :  Released. modifiersEx != curStandardExModifiers");
 368             }
 369         }
 370         HashMap <String, String> paramStringElements = tokenizeParamString(event.paramString());
 371         System.out.println(event.paramString());
 372         checkButton(paramStringElements, button);
 373         checkModifiers(testModifier, paramStringElements, button);
 374         checkExtModifiersOnReleaseClick(testModifier, paramStringElements, button);
 375     }
 376 
 377     public static void checkClickedModifiersTest(int testModifier, MouseEvent event){
 378         int [] curStandardModifiers = getStandardArray(testModifier);
 379         int [] curStandardExModifiers = getStandardExArray(testModifier);
 380         //        int index = (button - 4)*3 + 2;
 381         int button = event.getButton();
 382         int modifiers = event.getModifiers();
 383         int modifiersEx = event.getModifiersEx();
 384         int index = (button - 1)*3 + 2;
 385         dumpValues(button, modifiers, curStandardModifiers[index], modifiersEx, curStandardExModifiers[index]);
 386         if (modifiers != curStandardModifiers[index]){
 387             if (debug){
 388                 System.out.println("Test failed :  Clicked. modifiers != modifiersStandard");
 389             } else {
 390                 throw new RuntimeException("Test failed :  Clicked. modifiers != modifiersStandard");
 391             }
 392         }
 393         if (modifiersEx != curStandardExModifiers[index]){
 394             if (debug){
 395                 System.out.println("Test failed :  Clicked. modifiersEx != curStandardExModifiers");
 396             } else {
 397                 throw new RuntimeException("Test failed :  Clicked. modifiersEx != curStandardExModifiers");
 398             }
 399         }
 400         HashMap <String, String> paramStringElements = tokenizeParamString(event.paramString());
 401         checkButton(paramStringElements, button);
 402         checkModifiers(testModifier, paramStringElements, button);
 403         checkExtModifiersOnReleaseClick(testModifier, paramStringElements, button);
 404     }
 405     /*======================================================================*/
 406 
 407     public static HashMap<String, String> tokenizeParamString(String param){
 408         HashMap <String, String> params = new HashMap<String, String>();
 409         StringTokenizer st = new StringTokenizer(param, ",=");
 410         while (st.hasMoreTokens()){
 411             String tmp = st.nextToken();
 412 //            System.out.println("PARSER : "+tmp);
 413             if (tmp.equals("button") ||
 414                     tmp.equals("modifiers") ||
 415                     tmp.equals("extModifiers")) {
 416                 params.put(tmp, st.nextToken());
 417             }
 418         }
 419         return params;
 420     }
 421 
 422     public static Vector<String> tokenizeModifiers(String modifierList){
 423         Vector<String> modifiers = new Vector<String>();
 424         StringTokenizer st = new StringTokenizer(modifierList, "+");
 425         while (st.hasMoreTokens()){
 426             String tmp = st.nextToken();
 427             modifiers.addElement(tmp);
 428             System.out.println("MODIFIER PARSER : "+tmp);
 429         }
 430         return modifiers;
 431     }
 432 
 433 
 434     //test BUTTON1, 2 and 3 without any modifiers keys
 435     public static void  testPlainButtons(){
 436         System.out.println("Testing buttons without modifiers.");
 437         f.addMouseListener(adapterTest1);
 438         for (int button : mouseButtons){
 439             robot.mousePress(button);
 440             robot.delay(100);
 441             robot.mouseRelease(button);
 442         }
 443         robot.delay(1000);
 444         f.removeMouseListener(adapterTest1);
 445     }
 446 
 447     //test BUTTON1, 2 and 3 with SHIFT key
 448     public static void  testButtonsWithShift(){
 449         System.out.println("Testing buttons with SHIFT modifier.");
 450         f.addMouseListener(adapterTest2);
 451 
 452         for (int button : mouseButtons){
 453             robot.keyPress(KeyEvent.VK_SHIFT);
 454             robot.mousePress(button);
 455             robot.delay(100);
 456             robot.mouseRelease(button);
 457             robot.keyRelease(KeyEvent.VK_SHIFT);
 458         }
 459         robot.delay(1000);
 460         f.removeMouseListener(adapterTest2);
 461     }
 462 
 463     //test BUTTON1, 2 and 3 with CTRL key
 464     public static void  testButtonsWithControl(){
 465         System.out.println("Testing buttons with CONTROL modifier.");
 466         f.addMouseListener(adapterTest3);
 467         for (int button : mouseButtons){
 468             robot.keyPress(KeyEvent.VK_CONTROL);
 469             robot.mousePress(button);
 470             robot.delay(100);
 471             robot.mouseRelease(button);
 472             robot.keyRelease(KeyEvent.VK_CONTROL);
 473         }
 474         robot.delay(1000);
 475         f.removeMouseListener(adapterTest3);
 476     }
 477 
 478     //test BUTTON1, 2 and 3 with ALT key
 479     public static void  testButtonsWithAlt(){
 480         System.out.println("Testing buttons with ALT modifier.");
 481         f.addMouseListener(adapterTest4);
 482         for (int button : mouseButtons){
 483             robot.keyPress(KeyEvent.VK_ALT);
 484             robot.mousePress(button);
 485             robot.delay(100);
 486             robot.mouseRelease(button);
 487             robot.keyRelease(KeyEvent.VK_ALT);
 488         }
 489         robot.delay(1000);
 490         f.removeMouseListener(adapterTest4);
 491     }
 492 
 493     public static void initParams(String []s){
 494         if (s.length != 3){
 495             autorun = true;
 496             debug = false;
 497             testModifier = NONE;
 498         } else {
 499             autorun = Boolean.valueOf(s[0]);
 500             debug = Boolean.valueOf(s[1]);
 501 
 502             if (s[2].equals("NONE")){
 503                 testModifier = NONE;
 504             }
 505             if (s[2].equals("SHIFT")){
 506                 testModifier = SHIFT;
 507             }
 508             if (s[2].equals("CTRL")){
 509                 testModifier = CTRL;
 510             }
 511             if (s[2].equals("ALT")){
 512                 testModifier = ALT;
 513             }
 514         }
 515         System.out.println("Autorun : " +autorun);
 516         System.out.println("Debug mode : " +debug);
 517         System.out.println("Modifier to verify : " + testModifier);
 518     }
 519 
 520     public static void dumpValues(int button, int modifiers, int modifiersStandard, int modifiersEx, int modifiersExStandard){
 521         System.out.println("Button = "+button + "Modifiers = "+ modifiers + " standard = "+ modifiersStandard);
 522         System.out.println("                   ModifiersEx = "+ modifiersEx + " standardEx = "+ modifiersExStandard);
 523     }
 524 
 525     private static int[] getStandardExArray(int testModifier) {
 526         int [] curStandardExModifiers;
 527         switch (testModifier){
 528             case SHIFT:
 529                 curStandardExModifiers = modifiersExStandardTestSHIFT;
 530                 break;
 531             case CTRL:
 532                 curStandardExModifiers = modifiersExStandardTestCTRL;
 533                 break;
 534             case ALT:
 535                 curStandardExModifiers = modifiersExStandardTestALT;
 536                 break;
 537             default: //NONE by default
 538                 curStandardExModifiers = modifiersExStandardTestNONE;
 539         }
 540         return curStandardExModifiers;
 541     }
 542 
 543     private static int[] getStandardArray(int testModifier) {
 544         int [] curStandardModifiers;
 545         switch (testModifier){
 546             case SHIFT:
 547                 curStandardModifiers = modifiersStandardTestSHIFT;
 548                 break;
 549             case CTRL:
 550                 curStandardModifiers = modifiersStandardTestCTRL;
 551                 break;
 552             case ALT:
 553                 curStandardModifiers = modifiersStandardTestALT;
 554                 break;
 555             default: //NONE by default
 556                 curStandardModifiers = modifiersStandardTestNONE;
 557         }
 558         return curStandardModifiers;
 559     }
 560 
 561 }
 562 
 563 
 564 /* A class that invoke appropriate verification
 565  * routine with current modifier.
 566  */
 567 class CheckingModifierAdapter extends MouseAdapter{
 568     int modifier;
 569     public CheckingModifierAdapter(int modifier){
 570         this.modifier = modifier;
 571     }
 572 
 573     public void mousePressed(MouseEvent e) {
 574         System.out.println("PRESSED "+e);
 575         if (e.getButton() > MouseEvent.BUTTON3) {
 576             System.out.println("Extra button affected. Skip.");
 577         } else {
 578             MouseModifiersUnitTest_Standard.checkPressedModifiersTest(modifier, e); // e.getButton(), e.getModifiers(), e.getModifiersEx(),
 579         }
 580     }
 581     public void mouseReleased(MouseEvent e) {
 582         System.out.println("RELEASED "+e);
 583         if (e.getButton() > MouseEvent.BUTTON3) {
 584             System.out.println("Extra button affected. Skip.");
 585         } else {
 586             MouseModifiersUnitTest_Standard.checkReleasedModifiersTest(modifier, e); // e.getButton(), e.getModifiers(), e.getModifiersEx()
 587         }
 588     }
 589     public void mouseClicked(MouseEvent e) {
 590         System.out.println("CLICKED "+e);
 591         if (e.getButton() > MouseEvent.BUTTON3) {
 592             System.out.println("Extra button affected. Skip.");
 593         } else {
 594             MouseModifiersUnitTest_Standard.checkClickedModifiersTest(modifier, e); //e.getButton(), e.getModifiers(), e.getModifiersEx()
 595         }
 596     }
 597 }
 598