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