1 /*
   2  * Copyright (c) 2003, 2013, 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
  26  * @bug 4915825 4921009 4934965 4977469 8019584
  27  * @summary Tests behavior when client or server gets object of unknown class
  28  * @author Eamonn McManus
  29  * @run clean MissingClassTest SingleClassLoader
  30  * @run build MissingClassTest SingleClassLoader
  31  * @run main MissingClassTest
  32  * @key randomness
  33  */
  34 
  35 /*
  36   Tests that clients and servers react correctly when they receive
  37   objects of unknown classes.  This can happen easily due to version
  38   skew or missing jar files on one end or the other.  The default
  39   behaviour of causing a connection to die because of the resultant
  40   IOException is not acceptable!  We try sending attributes and invoke
  41   parameters to the server of classes it doesn't know, and we try
  42   sending attributes, exceptions and notifications to the client of
  43   classes it doesn't know.
  44 
  45   We also test objects that are of known class but not serializable.
  46   The test cases are similar.
  47  */
  48 
  49 import java.io.ByteArrayOutputStream;
  50 import java.io.IOException;
  51 import java.io.NotSerializableException;
  52 import java.io.ObjectOutputStream;
  53 import java.net.MalformedURLException;
  54 import java.util.HashMap;
  55 import java.util.Map;
  56 import java.util.Random;
  57 import java.util.Set;
  58 import javax.management.Attribute;
  59 import javax.management.MBeanServer;
  60 import javax.management.MBeanServerConnection;
  61 import javax.management.MBeanServerFactory;
  62 import javax.management.Notification;
  63 import javax.management.NotificationBroadcasterSupport;
  64 import javax.management.NotificationFilter;
  65 import javax.management.NotificationListener;
  66 import javax.management.ObjectName;
  67 import javax.management.remote.JMXConnectionNotification;
  68 import javax.management.remote.JMXConnector;
  69 import javax.management.remote.JMXConnectorFactory;
  70 import javax.management.remote.JMXConnectorServer;
  71 import javax.management.remote.JMXConnectorServerFactory;
  72 import javax.management.remote.JMXServiceURL;
  73 import javax.management.remote.rmi.RMIConnectorServer;
  74 
  75 public class MissingClassTest {
  76     private static final int NNOTIFS = 50;
  77 
  78     private static ClassLoader clientLoader, serverLoader;
  79     private static Object serverUnknown;
  80     private static Exception clientUnknown;
  81     private static ObjectName on;
  82     private static final Object[] NO_OBJECTS = new Object[0];
  83     private static final String[] NO_STRINGS = new String[0];
  84 
  85     private static final Object unserializableObject = Thread.currentThread();
  86 
  87     private static boolean isInstance(Object o, String cn) {
  88         try {
  89             Class<?> c = Class.forName(cn);
  90             return c.isInstance(o);
  91         } catch (ClassNotFoundException x) {
  92             return false;
  93         }
  94     }
  95 
  96     public static void main(String[] args) throws Exception {
  97         System.out.println("Test that the client or server end of a " +
  98                            "connection does not fail if sent an object " +
  99                            "it cannot deserialize");
 100 
 101         on = new ObjectName("test:type=Test");
 102 
 103         ClassLoader testLoader = MissingClassTest.class.getClassLoader();
 104         clientLoader =
 105             new SingleClassLoader("$ServerUnknown$", HashMap.class,
 106                                   testLoader);
 107         serverLoader =
 108             new SingleClassLoader("$ClientUnknown$", Exception.class,
 109                                   testLoader);
 110         serverUnknown =
 111             clientLoader.loadClass("$ServerUnknown$").newInstance();
 112         clientUnknown = (Exception)
 113             serverLoader.loadClass("$ClientUnknown$").newInstance();
 114 
 115         final String[] protos = {"rmi", /*"iiop",*/ "jmxmp"};
 116         boolean ok = true;
 117         for (int i = 0; i < protos.length; i++) {
 118             try {
 119                 ok &= test(protos[i]);
 120             } catch (Exception e) {
 121                 System.out.println("TEST FAILED WITH EXCEPTION:");
 122                 e.printStackTrace(System.out);
 123                 ok = false;
 124             }
 125         }
 126 
 127         if (ok)
 128             System.out.println("Test passed");
 129         else {
 130             throw new RuntimeException("TEST FAILED");
 131         }
 132     }
 133 
 134     private static boolean test(String proto) throws Exception {
 135         System.out.println("Testing for proto " + proto);
 136 
 137         boolean ok = true;
 138 
 139         MBeanServer mbs = MBeanServerFactory.newMBeanServer();
 140         mbs.createMBean(Test.class.getName(), on);
 141 
 142         JMXConnectorServer cs;
 143         JMXServiceURL url = new JMXServiceURL(proto, null, 0);
 144         Map<String,Object> serverMap = new HashMap<>();
 145         serverMap.put(JMXConnectorServerFactory.DEFAULT_CLASS_LOADER,
 146                       serverLoader);
 147 
 148         // make sure no auto-close at server side
 149         serverMap.put("jmx.remote.x.server.connection.timeout", "888888888");
 150 
 151         try {
 152             cs = JMXConnectorServerFactory.newJMXConnectorServer(url,
 153                                                                  serverMap,
 154                                                                  mbs);
 155         } catch (MalformedURLException e) {
 156             System.out.println("System does not recognize URL: " + url +
 157                                "; ignoring");
 158             return true;
 159         }
 160         cs.start();
 161         JMXServiceURL addr = cs.getAddress();
 162         Map<String,Object> clientMap = new HashMap<>();
 163         clientMap.put(JMXConnectorFactory.DEFAULT_CLASS_LOADER,
 164                       clientLoader);
 165 
 166         System.out.println("Connecting for client-unknown test");
 167 
 168         JMXConnector client = JMXConnectorFactory.connect(addr, clientMap);
 169 
 170         // add a listener to verify no failed notif
 171         CNListener cnListener = new CNListener();
 172         client.addConnectionNotificationListener(cnListener, null, null);
 173 
 174         MBeanServerConnection mbsc = client.getMBeanServerConnection();
 175 
 176         System.out.println("Getting attribute with class unknown to client");
 177         try {
 178             Object result = mbsc.getAttribute(on, "ClientUnknown");
 179             System.out.println("TEST FAILS: getAttribute for class " +
 180                                "unknown to client should fail, returned: " +
 181                                result);
 182             ok = false;
 183         } catch (IOException e) {
 184             Throwable cause = e.getCause();
 185             if (isInstance(cause, "org.omg.CORBA.MARSHAL"))  // see CR 4935098
 186                 cause = cause.getCause();
 187             if (cause instanceof ClassNotFoundException) {
 188                 System.out.println("Success: got an IOException wrapping " +
 189                                    "a ClassNotFoundException");
 190             } else {
 191                 System.out.println("TEST FAILS: Caught IOException (" + e +
 192                                    ") but cause should be " +
 193                                    "ClassNotFoundException: " + cause);
 194                 ok = false;
 195             }
 196         }
 197 
 198         System.out.println("Doing queryNames to ensure connection alive");
 199         Set<ObjectName> names = mbsc.queryNames(null, null);
 200         System.out.println("queryNames returned " + names);
 201 
 202         System.out.println("Provoke exception of unknown class");
 203         try {
 204             mbsc.invoke(on, "throwClientUnknown", NO_OBJECTS, NO_STRINGS);
 205             System.out.println("TEST FAILS: did not get exception");
 206             ok = false;
 207         } catch (IOException e) {
 208             Throwable wrapped = e.getCause();
 209             if (isInstance(wrapped, "org.omg.CORBA.MARSHAL"))  // see CR 4935098
 210                 wrapped = wrapped.getCause();
 211             if (wrapped instanceof ClassNotFoundException) {
 212                 System.out.println("Success: got an IOException wrapping " +
 213                                    "a ClassNotFoundException: " +
 214                                    wrapped);
 215             } else {
 216                 System.out.println("TEST FAILS: Got IOException but cause " +
 217                                    "should be ClassNotFoundException: ");
 218                 if (wrapped == null)
 219                     System.out.println("(null)");
 220                 else
 221                     wrapped.printStackTrace(System.out);
 222                 ok = false;
 223             }
 224         } catch (Exception e) {
 225             System.out.println("TEST FAILS: Got wrong exception: " +
 226                                "should be IOException with cause " +
 227                                "ClassNotFoundException:");
 228             e.printStackTrace(System.out);
 229             ok = false;
 230         }
 231 
 232         System.out.println("Doing queryNames to ensure connection alive");
 233         names = mbsc.queryNames(null, null);
 234         System.out.println("queryNames returned " + names);
 235 
 236         ok &= notifyTest(client, mbsc);
 237 
 238         System.out.println("Doing queryNames to ensure connection alive");
 239         names = mbsc.queryNames(null, null);
 240         System.out.println("queryNames returned " + names);
 241 
 242         for (int i = 0; i < 2; i++) {
 243             boolean setAttribute = (i == 0); // else invoke
 244             String what = setAttribute ? "setAttribute" : "invoke";
 245             System.out.println("Trying " + what +
 246                                " with class unknown to server");
 247             try {
 248                 if (setAttribute) {
 249                     mbsc.setAttribute(on, new Attribute("ServerUnknown",
 250                                                         serverUnknown));
 251                 } else {
 252                     mbsc.invoke(on, "useServerUnknown",
 253                                 new Object[] {serverUnknown},
 254                                 new String[] {"java.lang.Object"});
 255                 }
 256                 System.out.println("TEST FAILS: " + what + " with " +
 257                                    "class unknown to server should fail " +
 258                                    "but did not");
 259                 ok = false;
 260             } catch (IOException e) {
 261                 Throwable cause = e.getCause();
 262                 if (isInstance(cause, "org.omg.CORBA.MARSHAL"))  // see CR 4935098
 263                     cause = cause.getCause();
 264                 if (cause instanceof ClassNotFoundException) {
 265                     System.out.println("Success: got an IOException " +
 266                                        "wrapping a ClassNotFoundException");
 267                 } else {
 268                     System.out.println("TEST FAILS: Caught IOException (" + e +
 269                                        ") but cause should be " +
 270                                        "ClassNotFoundException: " + cause);
 271                     e.printStackTrace(System.out); // XXX
 272                     ok = false;
 273                 }
 274             }
 275         }
 276 
 277         System.out.println("Doing queryNames to ensure connection alive");
 278         names = mbsc.queryNames(null, null);
 279         System.out.println("queryNames returned " + names);
 280 
 281         System.out.println("Trying to get unserializable attribute");
 282         try {
 283             mbsc.getAttribute(on, "Unserializable");
 284             System.out.println("TEST FAILS: get unserializable worked " +
 285                                "but should not");
 286             ok = false;
 287         } catch (IOException e) {
 288             System.out.println("Success: got an IOException: " + e +
 289                                " (cause: " + e.getCause() + ")");
 290         }
 291 
 292         System.out.println("Doing queryNames to ensure connection alive");
 293         names = mbsc.queryNames(null, null);
 294         System.out.println("queryNames returned " + names);
 295 
 296         System.out.println("Trying to set unserializable attribute");
 297         try {
 298             Attribute attr =
 299                 new Attribute("Unserializable", unserializableObject);
 300             mbsc.setAttribute(on, attr);
 301             System.out.println("TEST FAILS: set unserializable worked " +
 302                                "but should not");
 303             ok = false;
 304         } catch (IOException e) {
 305             System.out.println("Success: got an IOException: " + e +
 306                                " (cause: " + e.getCause() + ")");
 307         }
 308 
 309         System.out.println("Doing queryNames to ensure connection alive");
 310         names = mbsc.queryNames(null, null);
 311         System.out.println("queryNames returned " + names);
 312 
 313         System.out.println("Trying to throw unserializable exception");
 314         try {
 315             mbsc.invoke(on, "throwUnserializable", NO_OBJECTS, NO_STRINGS);
 316             System.out.println("TEST FAILS: throw unserializable worked " +
 317                                "but should not");
 318             ok = false;
 319         } catch (IOException e) {
 320             System.out.println("Success: got an IOException: " + e +
 321                                " (cause: " + e.getCause() + ")");
 322         }
 323 
 324         client.removeConnectionNotificationListener(cnListener);
 325         ok = ok && !cnListener.failed;
 326 
 327         client.close();
 328         cs.stop();
 329 
 330         if (ok)
 331             System.out.println("Test passed for protocol " + proto);
 332 
 333         System.out.println();
 334         return ok;
 335     }
 336 
 337     private static class TestListener implements NotificationListener {
 338         TestListener(LostListener ll) {
 339             this.lostListener = ll;
 340         }
 341 
 342         public void handleNotification(Notification n, Object h) {
 343             /* Connectors can handle unserializable notifications in
 344                one of two ways.  Either they can arrange for the
 345                client to get a NotSerializableException from its
 346                fetchNotifications call (RMI connector), or they can
 347                replace the unserializable notification by a
 348                JMXConnectionNotification.NOTIFS_LOST (JMXMP
 349                connector).  The former case is handled by code within
 350                the connector client which will end up sending a
 351                NOTIFS_LOST to our LostListener.  The logic here
 352                handles the latter case by converting it into the
 353                former.
 354              */
 355             if (n instanceof JMXConnectionNotification
 356                 && n.getType().equals(JMXConnectionNotification.NOTIFS_LOST)) {
 357                 lostListener.handleNotification(n, h);
 358                 return;
 359             }
 360 
 361             synchronized (result) {
 362                 if (!n.getType().equals("interesting")
 363                     || !n.getUserData().equals("known")) {
 364                     System.out.println("TestListener received strange notif: "
 365                                        + notificationString(n));
 366                     result.failed = true;
 367                     result.notifyAll();
 368                 } else {
 369                     result.knownCount++;
 370                     if (result.knownCount == NNOTIFS)
 371                         result.notifyAll();
 372                 }
 373             }
 374         }
 375 
 376         private LostListener lostListener;
 377     }
 378 
 379     private static class LostListener implements NotificationListener {
 380         public void handleNotification(Notification n, Object h) {
 381             synchronized (result) {
 382                 handle(n, h);
 383             }
 384         }
 385 
 386         private void handle(Notification n, Object h) {
 387             if (!(n instanceof JMXConnectionNotification)) {
 388                 System.out.println("LostListener received strange notif: " +
 389                                    notificationString(n));
 390                 result.failed = true;
 391                 result.notifyAll();
 392                 return;
 393             }
 394 
 395             JMXConnectionNotification jn = (JMXConnectionNotification) n;
 396             if (!jn.getType().equals(jn.NOTIFS_LOST)) {
 397                 System.out.println("Ignoring JMXConnectionNotification: " +
 398                                    notificationString(jn));
 399                 return;
 400             }
 401             final String msg = jn.getMessage();
 402             if ((!msg.startsWith("Dropped ")
 403                  || !msg.endsWith("classes were missing locally"))
 404                 && (!msg.startsWith("Not serializable: "))) {
 405                 System.out.println("Surprising NOTIFS_LOST getMessage: " +
 406                                    msg);
 407             }
 408             if (!(jn.getUserData() instanceof Long)) {
 409                 System.out.println("JMXConnectionNotification userData " +
 410                                    "not a Long: " + jn.getUserData());
 411                 result.failed = true;
 412             } else {
 413                 int lost = ((Long) jn.getUserData()).intValue();
 414                 result.lostCount += lost;
 415                 if (result.lostCount == NNOTIFS*2)
 416                     result.notifyAll();
 417             }
 418         }
 419     }
 420 
 421     private static class TestFilter implements NotificationFilter {
 422         public boolean isNotificationEnabled(Notification n) {
 423             return (n.getType().equals("interesting"));
 424         }
 425     }
 426 
 427     private static class Result {
 428         int knownCount, lostCount;
 429         boolean failed;
 430     }
 431     private static Result result;
 432 
 433     /* Send a bunch of notifications to exercise the logic to recover
 434        from unknown notification classes.  We have four kinds of
 435        notifications: "known" ones are of a class known to the client
 436        and which match its filters; "unknown" ones are of a class that
 437        match the client's filters but that the client can't load;
 438        "tricky" ones are unserializable; and "boring" notifications
 439        are of a class that the client knows but that doesn't match its
 440        filters.  We emit NNOTIFS notifications of each kind.  We do a
 441        random shuffle on these 4*NNOTIFS notifications so it is likely
 442        that we will cover the various different cases in the logic.
 443 
 444        Specifically, what we are testing here is the logic that
 445        recovers from a fetchNotifications request that gets a
 446        ClassNotFoundException.  Because the request can contain
 447        several notifications, the client doesn't know which of them
 448        generated the exception.  So it redoes a request that asks for
 449        just one notification.  We need to be sure that this works when
 450        that one notification is of an unknown class and when it is of
 451        a known class, and in both cases when there are filtered
 452        notifications that are skipped.
 453 
 454        We are also testing the behaviour in the server when it tries
 455        to include an unserializable notification in the response to a
 456        fetchNotifications, and in the client when that happens.
 457 
 458        If the test succeeds, the listener should receive the NNOTIFS
 459        "known" notifications, and the connection listener should
 460        receive an indication of NNOTIFS lost notifications
 461        representing the "unknown" notifications.
 462 
 463        We depend on some implementation-specific features here:
 464 
 465        1. The buffer size is sufficient to contain the 4*NNOTIFS
 466        notifications which are all sent at once, before the client
 467        gets a chance to start receiving them.
 468 
 469        2. When one or more notifications are dropped because they are
 470        of unknown classes, the NOTIFS_LOST notification contains a
 471        userData that is a Long with a count of the number dropped.
 472 
 473        3. If a notification is not serializable on the server, the
 474        client gets told about it somehow, rather than having it just
 475        dropped on the floor.  The somehow might be through an RMI
 476        exception, or it might be by the server replacing the
 477        unserializable notif by a JMXConnectionNotification.NOTIFS_LOST.
 478     */
 479     private static boolean notifyTest(JMXConnector client,
 480                                       MBeanServerConnection mbsc)
 481             throws Exception {
 482         System.out.println("Send notifications including unknown ones");
 483         result = new Result();
 484         LostListener ll = new LostListener();
 485         client.addConnectionNotificationListener(ll, null, null);
 486         TestListener nl = new TestListener(ll);
 487         mbsc.addNotificationListener(on, nl, new TestFilter(), null);
 488         mbsc.invoke(on, "sendNotifs", NO_OBJECTS, NO_STRINGS);
 489 
 490         // wait for the listeners to receive all their notifs
 491         // or to fail
 492         long deadline = System.currentTimeMillis() + 60000;
 493         long remain;
 494         while ((remain = deadline - System.currentTimeMillis()) >= 0) {
 495             synchronized (result) {
 496                 if (result.failed
 497                     || (result.knownCount >= NNOTIFS
 498                         && result.lostCount >= NNOTIFS*2))
 499                     break;
 500                 result.wait(remain);
 501             }
 502         }
 503         Thread.sleep(2);  // allow any spurious extra notifs to arrive
 504         if (result.failed) {
 505             System.out.println("TEST FAILS: Notification strangeness");
 506             return false;
 507         } else if (result.knownCount == NNOTIFS
 508                    && result.lostCount == NNOTIFS*2) {
 509             System.out.println("Success: received known notifications and " +
 510                                "got NOTIFS_LOST for unknown and " +
 511                                "unserializable ones");
 512             return true;
 513         } else if (result.knownCount >= NNOTIFS
 514                 || result.lostCount >= NNOTIFS*2) {
 515             System.out.println("TEST FAILS: Received too many notifs: " +
 516                     "known=" + result.knownCount + "; lost=" + result.lostCount);
 517             return false;
 518         } else {
 519             System.out.println("TEST FAILS: Timed out without receiving " +
 520                                "all notifs: known=" + result.knownCount +
 521                                "; lost=" + result.lostCount);
 522             return false;
 523         }
 524     }
 525 
 526     public static interface TestMBean {
 527         public Object getClientUnknown() throws Exception;
 528         public void throwClientUnknown() throws Exception;
 529         public void setServerUnknown(Object o) throws Exception;
 530         public void useServerUnknown(Object o) throws Exception;
 531         public Object getUnserializable() throws Exception;
 532         public void setUnserializable(Object un) throws Exception;
 533         public void throwUnserializable() throws Exception;
 534         public void sendNotifs() throws Exception;
 535     }
 536 
 537     public static class Test extends NotificationBroadcasterSupport
 538             implements TestMBean {
 539 
 540         public Object getClientUnknown() {
 541             return clientUnknown;
 542         }
 543 
 544         public void throwClientUnknown() throws Exception {
 545             throw clientUnknown;
 546         }
 547 
 548         public void setServerUnknown(Object o) {
 549             throw new IllegalArgumentException("setServerUnknown succeeded "+
 550                                                "but should not have");
 551         }
 552 
 553         public void useServerUnknown(Object o) {
 554             throw new IllegalArgumentException("useServerUnknown succeeded "+
 555                                                "but should not have");
 556         }
 557 
 558         public Object getUnserializable() {
 559             return unserializableObject;
 560         }
 561 
 562         public void setUnserializable(Object un) {
 563             throw new IllegalArgumentException("setUnserializable succeeded " +
 564                                                "but should not have");
 565         }
 566 
 567         public void throwUnserializable() throws Exception {
 568             throw new Exception() {
 569                 private Object unserializable = unserializableObject;
 570             };
 571         }
 572 
 573         public void sendNotifs() {
 574             /* We actually send the same four notification objects
 575                NNOTIFS times each.  This doesn't particularly matter,
 576                but note that the MBeanServer will replace "this" by
 577                the sender's ObjectName the first time.  Since that's
 578                always the same, no problem.  */
 579             Notification known =
 580                 new Notification("interesting", this, 1L, 1L, "known");
 581             known.setUserData("known");
 582             Notification unknown =
 583                 new Notification("interesting", this, 1L, 1L, "unknown");
 584             unknown.setUserData(clientUnknown);
 585             Notification boring =
 586                 new Notification("boring", this, 1L, 1L, "boring");
 587             Notification tricky =
 588                 new Notification("interesting", this, 1L, 1L, "tricky");
 589             tricky.setUserData(unserializableObject);
 590 
 591             // check that the tricky notif is indeed unserializable
 592             try {
 593                 new ObjectOutputStream(new ByteArrayOutputStream())
 594                     .writeObject(tricky);
 595                 throw new RuntimeException("TEST INCORRECT: tricky notif is " +
 596                                            "serializable");
 597             } catch (NotSerializableException e) {
 598                 // OK: tricky notif is not serializable
 599             } catch (IOException e) {
 600                 throw new RuntimeException("TEST INCORRECT: tricky notif " +
 601                                             "serialization check failed");
 602             }
 603 
 604             /* Now shuffle an imaginary deck of cards where K, U, T, and
 605                B (known, unknown, tricky, boring) each appear NNOTIFS times.
 606                We explicitly seed the random number generator so we
 607                can reproduce rare test failures if necessary.  We only
 608                use a StringBuffer so we can print the shuffled deck --
 609                otherwise we could just emit the notifications as the
 610                cards are placed.  */
 611             long seed = System.currentTimeMillis();
 612             System.out.println("Random number seed is " + seed);
 613             Random r = new Random(seed);
 614             int knownCount = NNOTIFS;   // remaining K cards
 615             int unknownCount = NNOTIFS; // remaining U cards
 616             int trickyCount = NNOTIFS;  // remaining T cards
 617             int boringCount = NNOTIFS;  // remaining B cards
 618             StringBuffer notifList = new StringBuffer();
 619             for (int i = NNOTIFS * 4; i > 0; i--) {
 620                 int rand = r.nextInt(i);
 621                 // use rand to pick a card from the remaining ones
 622                 if ((rand -= knownCount) < 0) {
 623                     notifList.append('k');
 624                     knownCount--;
 625                 } else if ((rand -= unknownCount) < 0) {
 626                     notifList.append('u');
 627                     unknownCount--;
 628                 } else if ((rand -= trickyCount) < 0) {
 629                     notifList.append('t');
 630                     trickyCount--;
 631                 } else {
 632                     notifList.append('b');
 633                     boringCount--;
 634                 }
 635             }
 636             if (knownCount != 0 || unknownCount != 0
 637                 || trickyCount != 0 || boringCount != 0) {
 638                 throw new RuntimeException("TEST INCORRECT: Shuffle failed: " +
 639                                    "known=" + knownCount +" unknown=" +
 640                                    unknownCount + " tricky=" + trickyCount +
 641                                    " boring=" + boringCount +
 642                                    " deal=" + notifList);
 643             }
 644             String notifs = notifList.toString();
 645             System.out.println("Shuffle: " + notifs);
 646             for (int i = 0; i < NNOTIFS * 4; i++) {
 647                 Notification n;
 648                 switch (notifs.charAt(i)) {
 649                 case 'k': n = known; break;
 650                 case 'u': n = unknown; break;
 651                 case 't': n = tricky; break;
 652                 case 'b': n = boring; break;
 653                 default:
 654                     throw new RuntimeException("TEST INCORRECT: Bad shuffle char: " +
 655                                                notifs.charAt(i));
 656                 }
 657                 sendNotification(n);
 658             }
 659         }
 660     }
 661 
 662     private static String notificationString(Notification n) {
 663         return n.getClass().getName() + "/" + n.getType() + " \"" +
 664             n.getMessage() + "\" <" + n.getUserData() + ">";
 665     }
 666 
 667     //
 668     private static class CNListener implements NotificationListener {
 669         public void handleNotification(Notification n, Object o) {
 670             if (n instanceof JMXConnectionNotification) {
 671                 JMXConnectionNotification jn = (JMXConnectionNotification)n;
 672                 if (JMXConnectionNotification.FAILED.equals(jn.getType())) {
 673                     failed = true;
 674                 }
 675             }
 676         }
 677 
 678         public boolean failed = false;
 679     }
 680 }
--- EOF ---