1 /*
   2  * Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25   @test %I% %E%
  26   @bug 6315717
  27   @summary verifies that modifiers are correct for extra buttons
  28   @author Andrei Dmitriev : area=awt.mouse
  29   @library ../../../../lib/testlibrary
  30   @build jdk.testlibrary.OSInfo
  31   @run main MouseModifiersUnitTest_Extra
  32  */
  33 
  34 import jdk.testlibrary.OSInfo;
  35 
  36 import java.awt.*;
  37 import java.awt.event.*;
  38 import java.util.Arrays;
  39 import java.util.HashMap;
  40 import java.util.StringTokenizer;
  41 import java.util.Vector;
  42 
  43 // will process extra buttons only
  44 // asking parameters from CMD: manual/automatic, modifier to test
  45 
  46 public class MouseModifiersUnitTest_Extra extends Frame {
  47     static final int NONE = 0;
  48     static final int SHIFT = 1;
  49     static final int CTRL = 2;
  50     static final int ALT = 3;
  51     static CheckingModifierAdapterExtra adapterTest1;
  52     static CheckingModifierAdapterExtra adapterTest2;
  53     static CheckingModifierAdapterExtra adapterTest3;
  54     static CheckingModifierAdapterExtra adapterTest4;
  55 
  56     static boolean debug = true; //dump all errors (debug) or throw first(under jtreg) exception
  57     static boolean autorun = false; //use robot or manual run
  58     static int testModifier = NONE;
  59 
  60     static int [] mouseButtonDownMasks;
  61 
  62     //an arrays representing a modifiersEx of extra mouse buttons while using ALT/CTRL/SHIFT or none of them
  63     static int [] modifiersExStandard;
  64     static int [] modifiersExStandardSHIFT;
  65     static int [] modifiersExStandardCTRL;
  66     static int [] modifiersExStandardALT;
  67 
  68     private final static String SHIFT_MODIFIER = OSInfo.getOSType().equals(OSInfo.OSType.MACOSX) ?
  69                                                 "\u21e7" : "Shift";
  70 
  71     private final static String ALT_MODIFIER = OSInfo.getOSType().equals(OSInfo.OSType.MACOSX) ?
  72                                                 "\u2325" : "Alt";
  73 
  74 
  75     private final static String CTRL_MODIFIER = OSInfo.getOSType().equals(OSInfo.OSType.MACOSX) ?
  76                                                 "\u2303" : "Ctrl";
  77 
  78 
  79     // BUTTON1, 2, 3 press-release.
  80     final static int  modifiersStandard = 0; //InputEvent.BUTTON_DOWN_MASK;
  81 
  82     public static void checkPressedModifiersTest(int testModifier, MouseEvent event){
  83         int [] curStandardExModifiers = getStandardExArray(testModifier);
  84         int button = event.getButton();
  85         int modifiers = event.getModifiers();
  86         int modifiersEx = event.getModifiersEx();
  87         int index = (button - 4)*3;
  88         dumpValues(button, modifiers, modifiersStandard, modifiersEx, curStandardExModifiers[index]);
  89         if (modifiers != modifiersStandard){
  90             MessageLogger.reportError("Test failed :  Pressed. modifiers != modifiersStandard");
  91         }
  92 
  93         if (modifiersEx != curStandardExModifiers[index]){
  94 //            System.out.println(">>>>>>>>>>>>>>> Pressed. modifiersEx "+modifiersEx +" : "+!= curStandardExModifiers");
  95             MessageLogger.reportError("Test failed :  Pressed. modifiersEx != curStandardExModifiers. Got: "
  96                     + modifiersEx + " , Expected: " + curStandardExModifiers[index]);
  97         }
  98 
  99      //check event.paramString() output
 100         HashMap <String, String> paramStringElements = tokenizeParamString(event.paramString());
 101         System.out.println(event.paramString());
 102         checkButton(paramStringElements, button);
 103         checkModifiers(testModifier, paramStringElements, button);
 104         checkExtModifiersOnPress(testModifier, paramStringElements, button);
 105     }
 106 
 107     public static void checkExtModifiersOnReleaseClick(int testModifier, HashMap<String, String> h, int button){
 108         String ethalon = "";
 109         switch (testModifier){
 110             case SHIFT:{
 111                 ethalon = SHIFT_MODIFIER;
 112                 break;
 113             }
 114             case ALT:{
 115                 ethalon = ALT_MODIFIER;
 116                 break;
 117             }
 118             case CTRL:{
 119                 ethalon = CTRL_MODIFIER;
 120                 break;
 121             }
 122         }
 123 
 124         if (h.get("extModifiers") == null){
 125             h.put("extModifiers", "");
 126         }
 127 
 128         if (!ethalon.equals(h.get("extModifiers"))) {
 129             MessageLogger.reportError("Test failed :  Released/Clicked. extModifiers = "
 130                     + h.get("extModifiers") + " instead of : " + ethalon);
 131         }
 132     }
 133 
 134     public static void checkExtModifiersOnPress(int testModifier, HashMap<String, String> h, int button){
 135         String ethalon = "";
 136         switch (testModifier){
 137             case SHIFT:{
 138                 ethalon = SHIFT_MODIFIER + "+";
 139                 break;
 140             }
 141             case ALT:{
 142                 ethalon = ALT_MODIFIER + "+";
 143                 break;
 144             }
 145             case CTRL:{
 146                 ethalon = CTRL_MODIFIER + "+";
 147                 break;
 148             }
 149         }
 150         ethalon = ethalon + "Button" +button;
 151 
 152         if (!h.get("extModifiers").equals(ethalon)) {
 153             MessageLogger.reportError("Test failed :  Pressed. extModifiers = " +h.get("extModifiers")+" instead of : "
 154                     + ethalon);
 155         }
 156     }
 157 
 158     public static void checkModifiers(int testModifier, HashMap<String, String> h, int button){
 159         // none of modifiers for extra button should be null
 160         if (h.get("modifiers") != null) {
 161             MessageLogger.reportError("Test failed : modifiers != null");
 162         }
 163     }
 164 
 165     public static void checkButton(HashMap<String, String> h, int button){
 166         if (h.get("button") == null) {
 167             MessageLogger.reportError("Test failed :  checkButton(). button is absent in paramString()");
 168         }
 169         if (Integer.parseInt(h.get("button")) != button) {
 170             MessageLogger.reportError("Test failed :  checkButton. button in paramString() doesn't equal to button being pressed.");
 171         }
 172     }
 173     public static HashMap<String, String> tokenizeParamString(String param){
 174         HashMap <String, String> params = new HashMap<>();
 175         StringTokenizer st = new StringTokenizer(param, ",=");
 176         while (st.hasMoreTokens()){
 177             String tmp = st.nextToken();
 178 //            System.out.println("PARSER : "+tmp);
 179             if (tmp.equals("button") ||
 180                     tmp.equals("modifiers") ||
 181                     tmp.equals("extModifiers")) {
 182                 params.put(tmp, st.nextToken());
 183             }
 184         }
 185         return params;
 186     }
 187 
 188     public static Vector<String> tokenizeModifiers(String modifierList){
 189         Vector<String> modifiers = new Vector<>();
 190         StringTokenizer st = new StringTokenizer(modifierList, "+");
 191         while (st.hasMoreTokens()){
 192             String tmp = st.nextToken();
 193             modifiers.addElement(tmp);
 194             System.out.println("MODIFIER PARSER : "+tmp);
 195         }
 196         return modifiers;
 197     }
 198 
 199     public static void checkReleasedModifiersTest(int testModifier, MouseEvent event){
 200         int [] curStandardExModifiers = getStandardExArray(testModifier);
 201         int button = event.getButton();
 202         int modifiers = event.getModifiers();
 203         int modifiersEx = event.getModifiersEx();
 204         int index = (button - 4)*3 + 1;
 205         dumpValues(button, modifiers, modifiersStandard, modifiersEx, curStandardExModifiers[index]);
 206         if (modifiers != modifiersStandard){
 207             MessageLogger.reportError("Test failed :  Released. modifiers != modifiersStandard");
 208         }
 209 
 210         if (modifiersEx != curStandardExModifiers[index]){
 211             MessageLogger.reportError("Test failed :  Released. modifiersEx != curStandardExModifiers. Got: "
 212                     + modifiersEx + " , Expected: " + curStandardExModifiers[index]);
 213         }
 214 
 215      //check event.paramString() output
 216         HashMap <String, String> paramStringElements = tokenizeParamString(event.paramString());
 217         checkButton(paramStringElements, button);
 218         checkModifiers(testModifier, paramStringElements, button);
 219         System.out.println("paramStringElements = "+paramStringElements);
 220         checkExtModifiersOnReleaseClick(testModifier, paramStringElements, button);
 221     }
 222 
 223     public static void checkClickedModifiersTest(int testModifier, MouseEvent event){
 224         int [] curStandardExModifiers = getStandardExArray(testModifier);
 225         int button = event.getButton();
 226         int modifiers = event.getModifiers();
 227         int modifiersEx = event.getModifiersEx();
 228         int index = (button - 4)*3 + 2;
 229         dumpValues(button, modifiers, modifiersStandard, modifiersEx, curStandardExModifiers[index]);
 230         if (modifiers != modifiersStandard){
 231             MessageLogger.reportError("Test failed :  Clicked. modifiers != modifiersStandard");
 232         }
 233 
 234         if (modifiersEx != curStandardExModifiers[index]){
 235             MessageLogger.reportError("Test failed :  Clicked. modifiersEx != curStandardExModifiers. Got: "
 236                     + modifiersEx + " , Expected: " + curStandardExModifiers[index]);
 237         }
 238 
 239      //check event.paramString() output
 240         HashMap <String, String> paramStringElements = tokenizeParamString(event.paramString());
 241         checkButton(paramStringElements, button);
 242         checkModifiers(testModifier, paramStringElements, button);
 243         checkExtModifiersOnReleaseClick(testModifier, paramStringElements, button);
 244     }
 245 
 246     private static int[] getStandardExArray(int testModifier) {
 247         int [] curStandardExModifiers;
 248         switch (testModifier){
 249             case SHIFT:
 250                 curStandardExModifiers = modifiersExStandardSHIFT;
 251                 break;
 252             case CTRL:
 253                 curStandardExModifiers = modifiersExStandardCTRL;
 254                 break;
 255             case ALT:
 256                 curStandardExModifiers = modifiersExStandardALT;
 257                 break;
 258             default: //NONE by default
 259                 curStandardExModifiers = modifiersExStandard;
 260         }
 261         return curStandardExModifiers;
 262     }
 263 
 264     static Robot robot;
 265     public void init() {
 266         this.setLayout(new BorderLayout());
 267         try {
 268             robot  = new Robot();
 269             robot.setAutoDelay(100);
 270             robot.setAutoWaitForIdle(true);
 271         } catch (Exception e) {
 272             MessageLogger.reportError("Test failed. "+e);
 273         }
 274     }//End  init()
 275 
 276     public void start() {
 277         //Get things going.  Request focus, set size, et cetera
 278         setSize(200,200);
 279         setVisible(true);
 280         validate();
 281         if (autorun) {
 282             testNONE();
 283             testSHIFT();
 284             testCTRL();
 285             testALT();
 286         } else {
 287             switch (testModifier){
 288                 case SHIFT:
 289                     this.addMouseListener(adapterTest2);
 290                     break;
 291                 case CTRL:
 292                     this.addMouseListener(adapterTest3);
 293                     break;
 294                 case ALT:
 295                     this.addMouseListener(adapterTest4);
 296                     break;
 297                 default:  //NONE by default
 298                     this.addMouseListener(adapterTest1);
 299             }
 300         }
 301     }// start()
 302 
 303     //000000000000000000000000000000000000000000000000000000000000000
 304     public void testNONE(){
 305         this.addMouseListener(adapterTest1);
 306         robot.delay(1000);
 307         robot.mouseMove(getLocationOnScreen().x + getWidth()/2, getLocationOnScreen().y + getHeight()/2);
 308         for (int i = 3; i< mouseButtonDownMasks.length; i++){
 309             System.out.println("testNONE() => " + mouseButtonDownMasks[i]);
 310             robot.mousePress(mouseButtonDownMasks[i]);
 311             robot.mouseRelease(mouseButtonDownMasks[i]);
 312         }
 313         robot.delay(1000);
 314         this.removeMouseListener(adapterTest1);
 315     }
 316 
 317     public void testSHIFT(){
 318         this.addMouseListener(adapterTest2);
 319         robot.delay(1000);
 320         robot.mouseMove(getLocationOnScreen().x + getWidth()/2, getLocationOnScreen().y + getHeight()/2);
 321         for (int i = 3; i< mouseButtonDownMasks.length; i++){
 322             robot.keyPress(KeyEvent.VK_SHIFT);
 323             System.out.println("testSHIFT() => " + mouseButtonDownMasks[i]);
 324             robot.mousePress(mouseButtonDownMasks[i]);
 325             robot.mouseRelease(mouseButtonDownMasks[i]);
 326             robot.keyRelease(KeyEvent.VK_SHIFT);
 327         }
 328         robot.delay(1000);
 329         this.removeMouseListener(adapterTest2);
 330     }
 331 
 332     public void testCTRL(){
 333         this.addMouseListener(adapterTest3);
 334         robot.delay(1000);
 335         robot.mouseMove(getLocationOnScreen().x + getWidth()/2, getLocationOnScreen().y + getHeight()/2);
 336         for (int i = 3; i< mouseButtonDownMasks.length; i++){
 337             robot.keyPress(KeyEvent.VK_CONTROL);
 338             System.out.println("testCTRL() => " + mouseButtonDownMasks[i]);
 339             robot.mousePress(mouseButtonDownMasks[i]);
 340             robot.mouseRelease(mouseButtonDownMasks[i]);
 341             robot.keyRelease(KeyEvent.VK_CONTROL);
 342         }
 343         robot.delay(1000);
 344         this.removeMouseListener(adapterTest3);
 345     }
 346 
 347     public void testALT(){
 348         this.addMouseListener(adapterTest4);
 349         robot.delay(1000);
 350         robot.mouseMove(getLocationOnScreen().x + getWidth()/2, getLocationOnScreen().y + getHeight()/2);
 351         for (int i = 3; i< mouseButtonDownMasks.length; i++){
 352             robot.keyPress(KeyEvent.VK_ALT);
 353             System.out.println("testALT() => " + mouseButtonDownMasks[i]);
 354             robot.mousePress(mouseButtonDownMasks[i]);
 355             robot.mouseRelease(mouseButtonDownMasks[i]);
 356             robot.keyRelease(KeyEvent.VK_ALT);
 357         }
 358         robot.delay(1000);
 359         this.removeMouseListener(adapterTest4);
 360     }
 361 
 362     //**************************************************************************************************
 363     public static void dumpValues(int button, int modifiers, int modifiersStandard, int modifiersEx, int modifiersExStandard){
 364         System.out.println("Button = "+button + "Modifiers = "+ modifiers + "standard = "+ modifiersStandard);
 365         System.out.println("Button = "+button + "ModifiersEx = "+ modifiersEx + "standardEx = "+ modifiersExStandard);
 366     }
 367 
 368     public static void initParams(String []s){
 369         if (s.length != 3){
 370             autorun = true;
 371             debug = false;
 372             testModifier = NONE;
 373         } else {
 374             autorun = Boolean.valueOf(s[0]);
 375             debug = Boolean.valueOf(s[1]);
 376 
 377             if (s[2].equals("NONE")){
 378                 testModifier = NONE;
 379             }
 380             if (s[2].equals("SHIFT")){
 381                 testModifier = SHIFT;
 382             }
 383             if (s[2].equals("CTRL")){
 384                 testModifier = CTRL;
 385             }
 386             if (s[2].equals("ALT")){
 387                 testModifier = ALT;
 388             }
 389         }
 390         MessageLogger.setDebug(debug);
 391         System.out.println("Autorun : " +autorun);
 392         System.out.println("Debug mode : " +debug);
 393         System.out.println("Modifier to verify : " + testModifier);
 394     }
 395 
 396     public static void initAdapters(){
 397         adapterTest1 = new CheckingModifierAdapterExtra(NONE);
 398         adapterTest2 = new CheckingModifierAdapterExtra(SHIFT);
 399         adapterTest3 = new CheckingModifierAdapterExtra(CTRL);
 400         adapterTest4 = new CheckingModifierAdapterExtra(ALT);
 401     }
 402 
 403     public static void initVars(){
 404         //Init the array of the mouse button masks. It will be used for generating mouse events.
 405         mouseButtonDownMasks = new int [MouseInfo.getNumberOfButtons()];
 406         for (int i = 0; i < mouseButtonDownMasks.length; i++){
 407             mouseButtonDownMasks[i] = InputEvent.getMaskForButton(i+1);
 408             System.out.println("MouseArray [i] == "+mouseButtonDownMasks[i]);
 409         }
 410 
 411         // So we need to get the number of extra buttons on the mouse:  "MouseInfo.getNumberOfButtons() - 3"
 412         // and multyply on 3 because each button will generate three events : PRESS, RELEASE and CLICK.
 413         int [] tmp = new int [(MouseInfo.getNumberOfButtons()-3)*3];
 414 
 415         //Fill array of expected results for the case when mouse buttons are only used (no-modifier keys)
 416         Arrays.fill(tmp, 0);
 417         for (int i = 0, j = 3; i < tmp.length; i = i + 3, j++){
 418             tmp[i] = mouseButtonDownMasks[j];
 419         }
 420         modifiersExStandard = Arrays.copyOf(tmp, tmp.length);
 421 
 422         //Fill array of expected results for the case when mouse buttons are only used with SHIFT modifier key
 423         Arrays.fill(tmp, InputEvent.SHIFT_DOWN_MASK);
 424         for (int i = 0, j = 3; i < tmp.length; i = i + 3, j++){
 425             System.out.println("modifiersExStandardSHIFT FILLING : " + tmp[i] + " + " + mouseButtonDownMasks[j]);
 426             tmp[i] = tmp[i] | mouseButtonDownMasks[j];
 427         }
 428         modifiersExStandardSHIFT = Arrays.copyOf(tmp, tmp.length);
 429 
 430         //Fill array of expected results for the case when mouse buttons are only used with CTRL modifier key
 431         Arrays.fill(tmp, InputEvent.CTRL_DOWN_MASK);
 432         for (int i = 0, j = 3; i < tmp.length; i = i + 3, j++){
 433             System.out.println("modifiersExStandardCTRL FILLING : " + tmp[i] + " + " + mouseButtonDownMasks[j]);
 434             tmp[i] = tmp[i] | mouseButtonDownMasks[j];
 435         }
 436         modifiersExStandardCTRL = Arrays.copyOf(tmp, tmp.length);
 437 
 438         //Fill array of expected results for the case when mouse buttons are only used with ALT modifier key
 439         Arrays.fill(tmp, InputEvent.ALT_DOWN_MASK);
 440         for (int i = 0, j = 3; i < tmp.length; i = i + 3, j++){
 441             System.out.println("modifiersExStandardALT FILLING : " + tmp[i] + " + " + mouseButtonDownMasks[j]);
 442             tmp[i] = tmp[i] | mouseButtonDownMasks[j];
 443         }
 444         modifiersExStandardALT = Arrays.copyOf(tmp, tmp.length);
 445     }
 446 
 447     public static void main(String []s){
 448         if (MouseInfo.getNumberOfButtons() < 4){
 449             System.out.println("There are less then 4 buttons on the mouse. The test may not be accomplished. Skipping.");
 450             return;
 451         }
 452         initVars();
 453         MouseModifiersUnitTest_Extra frame = new MouseModifiersUnitTest_Extra();
 454         frame.initParams(s);
 455         frame.init();
 456         initAdapters();
 457         frame.start();
 458     }
 459 
 460 }// class
 461 
 462 /* A class that invoke appropriate verification
 463  * routine with current modifier.
 464  */
 465 class CheckingModifierAdapterExtra extends MouseAdapter{
 466     int modifier;
 467     public CheckingModifierAdapterExtra(int modifier){
 468         this.modifier = modifier;
 469     }
 470 
 471     public void mousePressed(MouseEvent e) {
 472         System.out.println("PRESSED "+e);
 473         if (e.getButton() <= MouseEvent.BUTTON3) {
 474             System.out.println("Standard button affected. Skip.");
 475         } else {
 476             MouseModifiersUnitTest_Extra.checkPressedModifiersTest(modifier, e);
 477         }
 478     }
 479     public void mouseReleased(MouseEvent e) {
 480         System.out.println("RELEASED "+e);
 481         if (e.getButton() <= MouseEvent.BUTTON3) {
 482             System.out.println("Standard button affected. Skip.");
 483         } else {
 484             MouseModifiersUnitTest_Extra.checkReleasedModifiersTest(modifier, e);
 485         }
 486     }
 487     public void mouseClicked(MouseEvent e) {
 488         System.out.println("CLICKED "+e);
 489         if (e.getButton() <= MouseEvent.BUTTON3) {
 490             System.out.println("Standard button affected. Skip.");
 491         } else {
 492             MouseModifiersUnitTest_Extra.checkClickedModifiersTest(modifier, e);
 493         }
 494     }
 495 }
 496 //Utility class that could report a message depending on current purpose of the test run
 497 class MessageLogger{
 498     private static boolean debug;
 499 
 500     public static void setDebug(boolean d){
 501         debug = d;
 502         log("Switch to "+ ((debug)?"debug":"trial") +" mode");
 503     }
 504 
 505     public static void log(String message){
 506         System.out.println(message);
 507     }
 508 
 509     public static void reportError(String message){
 510         if (debug){
 511             System.out.println(message);
 512         } else {
 513             throw new RuntimeException(message);
 514         }
 515     }
 516 }
--- EOF ---