rev 9529 : 8034960: Serviceability tests using @library failing with java.lang.NoClassDefFoundError

   1 /*
   2  * Copyright (c) 2012, 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 import java.io.File;
  25 import java.io.IOException;
  26 import java.lang.reflect.Method;
  27 import java.net.ConnectException;
  28 import java.net.ServerSocket;
  29 import java.rmi.NoSuchObjectException;
  30 import java.rmi.registry.LocateRegistry;
  31 import java.rmi.registry.Registry;
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.HashMap;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Objects;
  39 import java.util.Set;
  40 import java.util.concurrent.TimeUnit;
  41 import java.util.concurrent.TimeoutException;
  42 import java.util.concurrent.atomic.AtomicBoolean;
  43 import java.util.concurrent.atomic.AtomicReference;
  44 import java.util.function.Consumer;
  45 
  46 import javax.management.*;
  47 import javax.management.remote.*;
  48 import javax.net.ssl.SSLHandshakeException;
  49 
  50 import jdk.testlibrary.ProcessTools;
  51 import jdk.testlibrary.JDKToolLauncher;
  52 
  53 /**
  54  * @test
  55  * @bug 7110104
  56  * @library /lib/testlibrary
  57  * @build jdk.testlibrary.ProcessTools
  58  * @build jdk.testlibrary.JDKToolLauncher
  59  * @build jdk.testlibrary.Utils
  60  * @build JMXStartStopTest JMXStartStopDoSomething
  61  * @run main/othervm JMXStartStopTest
  62  * @summary Makes sure that enabling/disabling the management agent through
  63  *          JCMD achieves the desired results
  64  */
  65 public class JMXStartStopTest {
  66     private static final String TEST_JDK = System.getProperty("test.jdk");
  67     private static final String TEST_SRC = System.getProperty("test.src");
  68 
  69     private static final boolean verbose = false;
  70 
  71     /**
  72      * Dynamically allocates two distinct ports using {@linkplain java.net.ServerSocket}
  73      * It keeps each of those ports blocked until it is first accessed by its getter
  74      */
  75     private static class PortAllocator {
  76         private final int port1, port2;
  77         private final ServerSocket ss1, ss2;
  78         PortAllocator() {
  79             try {
  80                 ss1 = new ServerSocket(0);
  81                 ss2 = new ServerSocket(0);
  82                 port1 = ss1.getLocalPort();
  83                 port2 = ss2.getLocalPort();
  84             } catch (IOException e) {
  85                 throw new Error("Error while obtaining free ports", e);
  86             }
  87         }
  88 
  89         public int getPort1() {
  90             if (!ss1.isClosed()) {
  91                 try {
  92                     ss1.close();
  93                 } catch (IOException e) {
  94                     // just ignore
  95                 }
  96             }
  97             return port1;
  98         }
  99 
 100         public int getPort2() {
 101             if (!ss2.isClosed()) {
 102                 try {
 103                     ss2.close();
 104                 } catch (IOException e) {
 105                     // just ignore
 106                 }
 107             }
 108             return port2;
 109         }
 110     }
 111 
 112     private static void dbg_print(String msg){
 113         if (verbose) {
 114             System.out.println("DBG: " +msg);
 115         }
 116     }
 117 
 118     private static int listMBeans(MBeanServerConnection server,
 119                                   ObjectName pattern,
 120                                   QueryExp query)
 121     throws Exception {
 122 
 123         Set names = server.queryNames(pattern,query);
 124         for (Iterator i=names.iterator(); i.hasNext(); ) {
 125             ObjectName name = (ObjectName)i.next();
 126             MBeanInfo info = server.getMBeanInfo(name);
 127             dbg_print("Got MBean: " + name);
 128 
 129             MBeanAttributeInfo[] attrs = info.getAttributes();
 130             if (attrs == null)
 131                 continue;
 132             for (MBeanAttributeInfo attr : attrs) {
 133                 if (attr.isReadable()) {
 134                     Object o = server.getAttribute(name, attr.getName());
 135                 }
 136             }
 137         }
 138         return names.size();
 139     }
 140 
 141 
 142     private static void testConnectLocal(int pid)
 143     throws Exception {
 144 
 145         String jmxUrlStr = null;
 146 
 147         try {
 148             jmxUrlStr = sun.management.ConnectorAddressLink.importFrom(pid);
 149             dbg_print("Local Service URL: " +jmxUrlStr);
 150             if ( jmxUrlStr == null ) {
 151                 throw new Exception("No Service URL. Local agent not started?");
 152             }
 153 
 154             JMXServiceURL url = new JMXServiceURL(jmxUrlStr);
 155             Map m = new HashMap();
 156 
 157             JMXConnector c = JMXConnectorFactory.connect(url,m);
 158 
 159             MBeanServerConnection conn = c.getMBeanServerConnection();
 160             ObjectName pattern = new ObjectName("java.lang:type=Memory,*");
 161 
 162             int count = listMBeans(conn,pattern,null);
 163             if (count == 0)
 164                 throw new Exception("Expected at least one matching "+
 165                                     "MBean for "+pattern);
 166 
 167         } catch (IOException e) {
 168             dbg_print("Cannot find process : " + pid);
 169             throw e;
 170         }
 171     }
 172 
 173     private static void testNoConnect(int port) throws Exception {
 174         testNoConnect(port, 0);
 175     }
 176 
 177     private static void testNoConnect(int port, int rmiPort) throws Exception {
 178         try {
 179             testConnect(port, rmiPort);
 180             throw new Exception("Didn't expect the management agent running");
 181         } catch (Exception e) {
 182             Throwable t = e;
 183             while (t != null) {
 184                 if (t instanceof NoSuchObjectException ||
 185                     t instanceof ConnectException ||
 186                     t instanceof SSLHandshakeException) {
 187                     break;
 188                 }
 189                 t = t.getCause();
 190             }
 191             if (t == null) {
 192                 throw new Exception("Unexpected exception", e);
 193             }
 194         }
 195     }
 196 
 197     private static void testConnect(int port) throws Exception {
 198         testConnect(port, 0);
 199     }
 200 
 201     private static void testConnect(int port, int rmiPort) throws Exception {
 202 
 203         dbg_print("RmiRegistry lookup...");
 204 
 205         dbg_print("Using port: " + port);
 206 
 207         dbg_print("Using rmi port: " + rmiPort);
 208 
 209         Registry registry = LocateRegistry.getRegistry(port);
 210 
 211         // "jmxrmi"
 212         String[] relist = registry.list();
 213         for (int i = 0; i < relist.length; ++i) {
 214             dbg_print("Got registry: " + relist[i]);
 215         }
 216 
 217         String jmxUrlStr = (rmiPort != 0) ?
 218             String.format(
 219                 "service:jmx:rmi://localhost:%d/jndi/rmi://localhost:%d/jmxrmi",
 220                 rmiPort,
 221                 port) :
 222             String.format(
 223                 "service:jmx:rmi:///jndi/rmi://localhost:%d/jmxrmi",
 224                 port);
 225 
 226         JMXServiceURL url = new JMXServiceURL(jmxUrlStr);
 227         Map m = new HashMap();
 228 
 229         JMXConnector c = JMXConnectorFactory.connect(url,m);
 230 
 231         MBeanServerConnection conn = c.getMBeanServerConnection();
 232         ObjectName pattern = new ObjectName("java.lang:type=Memory,*");
 233 
 234         int count = listMBeans(conn,pattern,null);
 235         if (count == 0)
 236             throw new Exception("Expected at least one matching " +
 237                                 "MBean for " + pattern);
 238     }
 239 
 240     private static class Failure {
 241         private final Throwable cause;
 242         private final String msg;
 243 
 244         public Failure(Throwable cause, String msg) {
 245             this.cause = cause;
 246             this.msg = msg;
 247         }
 248 
 249         public Failure(String msg) {
 250             this(null, msg);
 251         }
 252 
 253         public Throwable getCause() {
 254             return cause;
 255         }
 256 
 257         public String getMsg() {
 258             return msg;
 259         }
 260 
 261         @Override
 262         public int hashCode() {
 263             int hash = 7;
 264             hash = 97 * hash + Objects.hashCode(this.cause);
 265             hash = 97 * hash + Objects.hashCode(this.msg);
 266             return hash;
 267         }
 268 
 269         @Override
 270         public boolean equals(Object obj) {
 271             if (obj == null) {
 272                 return false;
 273             }
 274             if (getClass() != obj.getClass()) {
 275                 return false;
 276             }
 277             final Failure other = (Failure) obj;
 278             if (!Objects.equals(this.cause, other.cause)) {
 279                 return false;
 280             }
 281             if (!Objects.equals(this.msg, other.msg)) {
 282                 return false;
 283             }
 284             return true;
 285         }
 286 
 287         @Override
 288         public String toString() {
 289             if (cause != null) {
 290                 return msg + "\n" + cause;
 291             } else {
 292                 return msg;
 293             }
 294         }
 295     }
 296 
 297     private static List<Failure> failures = new ArrayList<>();
 298 
 299     public static void main(String args[]) throws Exception {
 300         for (Method m : JMXStartStopTest.class.getDeclaredMethods()) {
 301             if (m.getName().startsWith("test_")) {
 302                 try {
 303                     m.invoke(null);
 304                     System.out.println("=== PASSED\n");
 305                 } catch (Throwable e) {
 306                     failures.add(new Failure(e, m.getName() + " failed"));
 307                 }
 308             }
 309         }
 310 
 311         if (!failures.isEmpty()) {
 312             for(Failure f : failures) {
 313                 System.err.println(f.getMsg());
 314                 f.getCause().printStackTrace(System.err);
 315             }
 316             throw new Error();
 317         }
 318     }
 319 
 320     /**
 321      * Retrieves the PID of the test application using JCMD
 322      * @return The PID of the test application
 323      * @throws InterruptedException
 324      * @throws IOException
 325      */
 326     private static String getPID() throws InterruptedException, IOException {
 327         final AtomicReference<String> pid = new AtomicReference<>();
 328         jcmd(
 329             null,
 330             line -> {
 331                 if (line.endsWith("JMXStartStopDoSomething")) {
 332                     pid.set(line.split(" ")[0]);
 333                 }
 334             }
 335         );
 336         return pid.get();
 337     }
 338 
 339     private static class Something {
 340         private Process p;
 341         private final ProcessBuilder pb;
 342         private final String name;
 343         private final AtomicBoolean started = new AtomicBoolean(false);
 344         private volatile int pid = -1;
 345 
 346         public Something(ProcessBuilder pb, String name) {
 347             this.pb = pb;
 348             this.name = name;
 349         }
 350 
 351         public synchronized void start() throws InterruptedException, IOException, TimeoutException {
 352             if (started.compareAndSet(false, true)) {
 353                 try {
 354                     p = ProcessTools.startProcess(
 355                         "JMXStartStopDoSomething",
 356                         pb,
 357                         (line) -> {
 358                             if (line.toLowerCase().startsWith("pid:")) {
 359                                 pid = Integer.parseInt(line.split("\\:")[1]);
 360                             }
 361                             return line.equals("main enter");
 362                         },
 363                         5,
 364                         TimeUnit.SECONDS
 365                     );
 366                 } catch (TimeoutException e) {
 367                     p.destroy();
 368                     p.waitFor();
 369                     throw e;
 370                 }
 371             }
 372         }
 373 
 374         public int getPid() {
 375             return pid;
 376         }
 377 
 378         public synchronized void stop()
 379             throws IOException, InterruptedException {
 380             if (started.compareAndSet(true, false)) {
 381                 p.getOutputStream().write(0);
 382                 p.getOutputStream().flush();
 383                 int ec = p.waitFor();
 384                 if (ec != 0) {
 385                     StringBuilder msg = new StringBuilder();
 386                     msg.append("Test application '").append(name);
 387                     msg.append("' failed with exit code: ");
 388                     msg.append(ec);
 389 
 390                     failures.add(new Failure(msg.toString()));
 391                 }
 392             }
 393         }
 394     }
 395 
 396     /**
 397      * Runs the test application "JMXStartStopDoSomething"
 398      * @param name Test run name
 399      * @param args Additional arguments
 400      * @return Returns a {@linkplain Something} instance representing the run
 401      * @throws IOException
 402      * @throws InterruptedException
 403      * @throws TimeoutException
 404      */
 405     private static Something doSomething(String name, String ... args)
 406     throws Exception {
 407         List<String> pbArgs = new ArrayList<>(Arrays.asList(
 408             "-cp",
 409             System.getProperty("test.class.path")
 410         ));
 411         pbArgs.addAll(Arrays.asList(args));
 412         pbArgs.add("JMXStartStopDoSomething");
 413 
 414         ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
 415             pbArgs.toArray(new String[pbArgs.size()])
 416         );
 417         Something s = new Something(pb, name);
 418         s.start();
 419         return s;
 420     }
 421 
 422     /**
 423      * Run the "jcmd" command
 424      *
 425      * @param command Command with parameters; space separated string
 426      * @throws IOException
 427      * @throws InterruptedException
 428      */
 429     private static void jcmd(String ... command) throws IOException, InterruptedException {
 430         if (command.length == 0) {
 431             jcmd(null, (Consumer<String>)null);
 432         } else {
 433             jcmd(null, command);
 434         }
 435     }
 436 
 437     /**
 438      * Run the "jcmd" command
 439      *
 440      * @param c {@linkplain Consumer} instance; may be null
 441      * @param command Command with parameters; space separated string
 442      * @throws IOException
 443      * @throws InterruptedException
 444      */
 445     private static void jcmd(Consumer<String> c, String ... command) throws IOException, InterruptedException {
 446         jcmd("JMXStartStopDoSomething", c, command);
 447     }
 448 
 449     /**
 450      * Run the "jcmd" command
 451      * @param target The target application name (or PID)
 452      * @param c {@linkplain Consumer} instance; may be null
 453      * @param command Command with parameters; space separated string
 454      * @throws IOException
 455      * @throws InterruptedException
 456      */
 457     private static void jcmd(String target, final Consumer<String> c, String ... command) throws IOException, InterruptedException {
 458         dbg_print("[jcmd] " + (command.length > 0 ? command[0] : "list"));
 459 
 460         JDKToolLauncher l = JDKToolLauncher.createUsingTestJDK("jcmd");
 461         l.addToolArg(target);
 462         for(String cmd : command) {
 463             l.addToolArg(cmd);
 464         }
 465         Process p = ProcessTools.startProcess(
 466             "jcmd",
 467             new ProcessBuilder(l.getCommand()),
 468             c
 469         );
 470 
 471         p.waitFor();
 472         dbg_print("[jcmd] --------");
 473     }
 474 
 475     private static final String CMD_STOP = "ManagementAgent.stop";
 476     private static final String CMD_START= "ManagementAgent.start";
 477     private static final String CMD_START_LOCAL = "ManagementAgent.start_local";
 478 
 479     private static void test_01() throws Exception {
 480         // Run an app with JMX enabled stop it and
 481         // restart on other port
 482 
 483         System.out.println("**** Test one ****");
 484         PortAllocator pa = new PortAllocator();
 485 
 486         Something s = doSomething(
 487             "test_01",
 488             "-Dcom.sun.management.jmxremote.port=" + pa.getPort1(),
 489             "-Dcom.sun.management.jmxremote.authenticate=false",
 490             "-Dcom.sun.management.jmxremote.ssl=false");
 491 
 492         try {
 493             testConnect(pa.getPort1());
 494 
 495             jcmd(CMD_STOP);
 496             testNoConnect(pa.getPort1());
 497 
 498             jcmd(CMD_START, "jmxremote.port=" + pa.getPort2());
 499             testConnect(pa.getPort2());
 500         } finally {
 501             s.stop();
 502         }
 503     }
 504 
 505     private static void test_02() throws Exception {
 506         // Run an app without JMX enabled
 507         // start JMX by jcmd
 508 
 509         System.out.println("**** Test two ****");
 510 
 511         Something s = doSomething("test_02");
 512         PortAllocator pa = new PortAllocator();
 513         try {
 514             jcmd(CMD_START,
 515                 "jmxremote.port=" + pa.getPort1(),
 516                 "jmxremote.authenticate=false",
 517                 "jmxremote.ssl=false");
 518 
 519             testConnect(pa.getPort1());
 520         } finally {
 521 //            debugPortUsage(pa);
 522             s.stop();
 523         }
 524     }
 525 
 526     private static void test_03() throws Exception {
 527         // Run an app without JMX enabled
 528         // start JMX by jcmd on one port than on other one
 529 
 530         System.out.println("**** Test three ****");
 531 
 532         Something s = doSomething("test_03");
 533         PortAllocator pa = new PortAllocator();
 534         try {
 535             jcmd(CMD_START,
 536                 "jmxremote.port=" + pa.getPort1(),
 537                 "jmxremote.authenticate=false",
 538                 "jmxremote.ssl=false");
 539 
 540             // Second agent shouldn't start
 541             jcmd(CMD_START,
 542                 "jmxremote.port=" + pa.getPort2(),
 543                 "jmxremote.authenticate=false",
 544                 "jmxremote.ssl=false");
 545 
 546             // First agent should connect
 547             testConnect(pa.getPort1());
 548 
 549             // Second agent should not connect
 550             testNoConnect(pa.getPort2());
 551         } finally {
 552             s.stop();
 553         }
 554     }
 555 
 556     private static void test_04() throws Exception {
 557         // Run an app without JMX enabled
 558         // start JMX by jcmd on one port, specify rmi port explicitly
 559 
 560         System.out.println("**** Test four ****");
 561 
 562         Something s = doSomething("test_04");
 563         PortAllocator pa = new PortAllocator();
 564         try {
 565             jcmd(CMD_START,
 566                  "jmxremote.port=" + pa.getPort1(),
 567                  "jmxremote.rmi.port=" + pa.getPort2(),
 568                  "jmxremote.authenticate=false",
 569                  "jmxremote.ssl=false");
 570 
 571             testConnect(pa.getPort1(), pa.getPort2());
 572         } finally {
 573             s.stop();
 574         }
 575     }
 576 
 577     private static void test_05() throws Exception {
 578         // Run an app without JMX enabled, it will enable local server
 579         // but should leave remote server disabled
 580 
 581         System.out.println("**** Test five ****");
 582 
 583         Something s = doSomething("test_05");
 584         PortAllocator pa = new PortAllocator();
 585         try {
 586             jcmd(CMD_START_LOCAL);
 587 
 588             testNoConnect(pa.getPort1());
 589             testConnectLocal(s.getPid());
 590         } finally {
 591             s.stop();
 592         }
 593     }
 594 
 595     private static void test_06() throws Exception {
 596         // Run an app without JMX enabled
 597         // start JMX by jcmd on one port, specify rmi port explicitly
 598         // attempt to start it again
 599         // 1) with the same port
 600         // 2) with other port
 601         // 3) attempt to stop it twice
 602         // Check for valid messages in the output
 603 
 604         System.out.println("**** Test six ****");
 605 
 606         Something s = doSomething("test_06");
 607         PortAllocator pa = new PortAllocator();
 608         try {
 609             jcmd(CMD_START,
 610                  "jmxremote.port=" + pa.getPort1(),
 611                  "jmxremote.authenticate=false",
 612                  "jmxremote.ssl=false");
 613 
 614             testConnect(pa.getPort1(), pa.getPort2());
 615 
 616             final boolean[] checks = new boolean[3];
 617             jcmd(
 618                 line -> {
 619                     if (line.equals("java.lang.RuntimeException: Invalid agent state")) {
 620                         checks[0] = true;
 621                     }
 622                 },
 623                 CMD_START,
 624                  "jmxremote.port=" + pa.getPort1(),
 625                  "jmxremote.authenticate=false",
 626                  "jmxremote.ssl=false");
 627 
 628             jcmd(
 629                 line -> {
 630                     if (line.equals("java.lang.RuntimeException: Invalid agent state")) {
 631                         checks[1] = true;
 632                     }
 633                 },
 634                 CMD_START,
 635                 "jmxremote.port=" + pa.getPort2(),
 636                 "jmxremote.authenticate=false",
 637                 "jmxremote.ssl=false");
 638 
 639             jcmd(CMD_STOP);
 640             jcmd(CMD_STOP);
 641 
 642             ServerSocket ss = new ServerSocket(0);
 643 
 644             jcmd(
 645                 line -> {
 646                     if (line.contains("Port already in use: " + ss.getLocalPort())) {
 647                         checks[2] = true;
 648                     }
 649                 },
 650                 CMD_START,
 651                 "jmxremote.port=" + ss.getLocalPort(),
 652                 "jmxremote.rmi.port=" + pa.getPort2(),
 653                 "jmxremote.authenticate=false",
 654                 "jmxremote.ssl=false");
 655 
 656             if (!checks[0]) {
 657                 throw new Exception("Starting agent on port " + pa.getPort1() + " should " +
 658                                     "report an invalid agent state");
 659             }
 660             if (!checks[1]) {
 661                 throw new Exception("Starting agent on poprt " + pa.getPort2() + " should " +
 662                                     "report an invalid agent state");
 663             }
 664             if (!checks[2]) {
 665                 throw new Exception("Starting agent on port " + ss.getLocalPort() + " should " +
 666                                     "report port in use");
 667             }
 668         } finally {
 669             s.stop();
 670         }
 671     }
 672 
 673     private static void test_07() throws Exception {
 674         // Run an app without JMX enabled, but with some properties set
 675         // in command line.
 676         // make sure these properties overridden corectly
 677 
 678         System.out.println("**** Test seven ****");
 679 
 680         Something s = doSomething(
 681             "test_07",
 682             "-Dcom.sun.management.jmxremote.authenticate=false",
 683             "-Dcom.sun.management.jmxremote.ssl=true");
 684         PortAllocator pa = new PortAllocator();
 685 
 686         try {
 687             testNoConnect(pa.getPort1());
 688             jcmd(
 689                 CMD_START,
 690                 "jmxremote.port=" + pa.getPort2(),
 691                 "jmxremote.authenticate=false",
 692                 "jmxremote.ssl=false"
 693             );
 694             testConnect(pa.getPort2());
 695         } finally {
 696             s.stop();
 697         }
 698     }
 699 
 700     private static void test_08() throws Exception {
 701         // Run an app with JMX enabled and with some properties set
 702         // in command line.
 703         // stop JMX agent and then start it again with different property values
 704         // make sure these properties overridden corectly
 705 
 706         System.out.println("**** Test eight ****");
 707         PortAllocator pa = new PortAllocator();
 708 
 709         Something s = doSomething(
 710             "test_08",
 711             "-Dcom.sun.management.jmxremote.port=" + pa.getPort1(),
 712             "-Dcom.sun.management.jmxremote.authenticate=false",
 713             "-Dcom.sun.management.jmxremote.ssl=true");
 714 
 715         try {
 716             testNoConnect(pa.getPort1());
 717 
 718             jcmd(CMD_STOP);
 719 
 720             testNoConnect(pa.getPort1());
 721 
 722             jcmd(
 723                 CMD_START,
 724                 "jmxremote.port=" + pa.getPort2(),
 725                 "jmxremote.authenticate=false",
 726                 "jmxremote.ssl=false"
 727             );
 728 
 729             testConnect(pa.getPort2());
 730         } finally {
 731             s.stop();
 732         }
 733     }
 734 
 735     private static void test_09() throws Exception {
 736         // Run an app with JMX enabled and with some properties set
 737         // in command line.
 738         // stop JMX agent and then start it again with different property values
 739         // specifing some property in management config file and some of them
 740         // in command line
 741         // make sure these properties overridden corectly
 742 
 743         System.out.println("**** Test nine ****");
 744 
 745         Something s = doSomething("test_09",
 746             "-Dcom.sun.management.config.file=" +
 747                 TEST_SRC + File.separator + "management_cl.properties",
 748             "-Dcom.sun.management.jmxremote.authenticate=false"
 749         );
 750         PortAllocator pa = new PortAllocator();
 751 
 752         try {
 753             testNoConnect(pa.getPort1());
 754 
 755             jcmd(CMD_STOP);
 756 
 757             testNoConnect(pa.getPort1());
 758 
 759             jcmd(CMD_START,
 760                 "config.file=" + TEST_SRC + File.separator +
 761                     "management_jcmd.properties",
 762                 "jmxremote.authenticate=false",
 763                 "jmxremote.port=" + pa.getPort2()
 764             );
 765 
 766             testConnect(pa.getPort2());
 767         } finally {
 768             s.stop();
 769         }
 770     }
 771 
 772     private static void test_10() throws Exception {
 773         // Run an app with JMX enabled and with some properties set
 774         // in command line.
 775         // stop JMX agent and then start it again with different property values
 776         // stop JMX agent again and then start it without property value
 777         // make sure these properties overridden corectly
 778 
 779         System.out.println("**** Test ten ****");
 780         PortAllocator pa = new PortAllocator();
 781 
 782         Something s = doSomething(
 783             "test_10",
 784             "-Dcom.sun.management.jmxremote.port=" + pa.getPort1(),
 785             "-Dcom.sun.management.jmxremote.authenticate=false",
 786             "-Dcom.sun.management.jmxremote.ssl=true");
 787 
 788         try {
 789             testNoConnect(pa.getPort1());
 790 
 791             jcmd(CMD_STOP);
 792             jcmd(CMD_START,
 793                 "jmxremote.ssl=false",
 794                 "jmxremote.port=" + pa.getPort1()
 795             );
 796             testConnect(pa.getPort1());
 797 
 798             jcmd(CMD_STOP);
 799             jcmd(CMD_START,
 800                 "jmxremote.port=" + pa.getPort1()
 801             );
 802 
 803             testNoConnect(pa.getPort1());
 804         } finally {
 805             s.stop();
 806         }
 807     }
 808 
 809     private static void test_11() throws Exception {
 810         // Run an app with JMX enabled
 811         // stop remote agent
 812         // make sure local agent is not affected
 813 
 814         System.out.println("**** Test eleven ****");
 815         PortAllocator pa = new PortAllocator();
 816 
 817         Something s = doSomething(
 818             "test_11",
 819             "-Dcom.sun.management.jmxremote.port=" + pa.getPort1(),
 820             "-Dcom.sun.management.jmxremote.authenticate=false",
 821             "-Dcom.sun.management.jmxremote.ssl=false");
 822         try {
 823             testConnect(pa.getPort1());
 824             jcmd(CMD_STOP);
 825             testConnectLocal(s.getPid());
 826         } finally {
 827             s.stop();
 828         }
 829     }
 830 
 831     private static void test_12() throws Exception {
 832         // Run an app with JMX disabled
 833         // start local agent only
 834 
 835         System.out.println("**** Test twelve ****");
 836 
 837         Something s = doSomething("test_12");
 838         PortAllocator pa = new PortAllocator();
 839 
 840         try {
 841             testNoConnect(pa.getPort1());
 842             jcmd(CMD_START + "_local");
 843 
 844             testConnectLocal(s.getPid());
 845 
 846         } finally {
 847             s.stop();
 848         }
 849     }
 850 
 851     private static void test_13() throws Exception {
 852         // Run an app with -javaagent make sure it works as expected -
 853         // system properties are ignored
 854 
 855         System.out.println("**** Test thirteen ****");
 856         PortAllocator pa = new PortAllocator();
 857 
 858         String agent = TEST_JDK + "/jre/lib/management-agent.jar";
 859         if (!new File(agent).exists()) {
 860             agent = TEST_JDK + "/lib/management-agent.jar";
 861         }
 862 
 863         Something s = doSomething("test_14",
 864             "-javaagent:" + agent + "=com.sun.management.jmxremote.port=" +
 865                 pa.getPort1() + ",com.sun.management.jmxremote.authenticate=false",
 866             "-Dcom.sun.management.jmxremote.ssl=false"
 867         );
 868 
 869         try {
 870             testNoConnect(pa.port1);
 871         } finally {
 872             s.stop();
 873         }
 874     }
 875 }
--- EOF ---