gt:         display("OK--> " + className);
context: /*
   * Copyright (c) 2002, 2019, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package nsk.jdi.ClassUnloadRequest.addClassExclusionFilter;
  
  import jdk.test.lib.Utils;
  import nsk.share.*;
  import nsk.share.jdi.*;
  
  import com.sun.jdi.*;
  import com.sun.jdi.event.*;
  import com.sun.jdi.request.*;
  
  import java.io.*;
  
  /**
   * Debugger requests <code>ClassUnloadEvent</code> and sets class filter by calling
   * <code>addClassExclusionFilter</code> with pattern that begins with '*' and ends
   * with '*'.
   *
   * <p>
   * To excite a class loading/unloading onto debugee, debugeer uses
   * <code>nsk.share.ClassUnloader</code> and performs it twice : <br>
   *      1. for pattern that ends with '*'   <br>
   *      2. for pattern that begins with '*' <br>
   * It is expected:  <br>
   *  - in case no events occured, test is considered as passed     <br>
   *  - in case classunload event occurs, debugger checks class name to do not match to
   * pattern.
   */
  public class exclfilter001 {
  
      final static String prefix = "nsk.jdi.ClassUnloadRequest.addClassExclusionFilter.";
      private final static String className = "exclfilter001";
      private final static String debuggerName = prefix + className;
      private final static String debugeeName = debuggerName + "a";
  
      // signals to control working of debugee
      public final static String SGNL_LOAD = "load";
      public final static String SGNL_UNLOAD = "unload";
      public final static String SGNL_BREAK = "break";
      public final static String SGNL_READY = "ready";
      public final static String SGNL_QUIT = "quit";
  
      private static int exitStatus;
      private static Log log;
      private static Debugee debugee;
      private static long waitTime;
  
      String[] patterns = {
                      prefix + "Sub*",
                      "*.Superexclfilter002b"
      };
  
      private static void display(String msg) {
          log.display("debugger> " + msg);
      }
  
      private static void complain(String msg) {
          log.complain("debugger> " + msg + "\n");
      }
  
      public static void main(String argv[]) {
          System.exit(Consts.JCK_STATUS_BASE + run(argv, System.out));
      }
  
      public static int run(String argv[], PrintStream out) {
  
          exclfilter001 tstObj = new exclfilter001();
  
          ArgumentHandler argHandler = new ArgumentHandler(argv);
          waitTime = argHandler.getWaitTime();
          log = new Log(out, argHandler);
  
          debugee = Debugee.prepareDebugee(argHandler, log, debugeeName);
          tstObj.execTest();
  
          display("execTest finished. exitStatus = " + exitStatus);
  
          return exitStatus;
      }
  
      private void execTest() {
  
          ClassUnloadRequest request;
  
          // when there are no class unload events, test should be considered as PASSED
          exitStatus = Consts.TEST_PASSED;
  
          for (int i = 0; i < patterns.length; i++) {
              // loading of tested classes
              display("sending " + SGNL_LOAD);
              debugee.sendSignal(SGNL_LOAD);
              debugee.receiveExpectedSignal(SGNL_READY);
  
              // unloading of tested classes
              display("------------------------------------------------");
              request = requestClassUnload(patterns[i]);
              display("================================================");
  
              display("sending " + SGNL_UNLOAD);
              debugee.sendSignal(SGNL_UNLOAD);
              debugee.receiveExpectedSignal(SGNL_READY);
  
              receiveEvents(patterns[i]);
  
              display("");
              debugee.getEventRequestManager().deleteEventRequest(request);
          }
  
          display("sending " + SGNL_BREAK);
          debugee.sendSignal(SGNL_BREAK);
          debugee.quit();
  
      }
  
      private ClassUnloadRequest requestClassUnload(String filter) {
          display(">>>creating ClassUnloadRequest");
          ClassUnloadRequest request =
                  debugee.getEventRequestManager().createClassUnloadRequest();
          display("adding exclusion filter :");
          display("  <" + filter + ">");
  
          request.addClassExclusionFilter(filter);
          request.enable();
  
          return request;
      }
  
      private void receiveEvents(String pattern) {
          EventSet eventSet = null;
          Event event;
          long totalWaitTime = Utils.adjustTimeout(waitTime * 10000);
          long waitTimeout = Utils.adjustTimeout(waitTime * 1000);
          long begin, delta;
          int count = 0;
          boolean exit = false;
  
          try {
              begin = System.currentTimeMillis();
              eventSet = debugee.VM().eventQueue().remove(waitTimeout);
              delta = System.currentTimeMillis() - begin;
              totalWaitTime -= delta;
              while (eventSet != null) {
                  EventIterator eventIterator = eventSet.eventIterator();
                  while (eventIterator.hasNext()) {
                      event = eventIterator.nextEvent();
                      if (event instanceof ClassUnloadEvent) {
                          if (!analyzeEvents((ClassUnloadEvent )event, pattern)) {
                              display("exiting...");
                              exit = true;
                              break;
                          }
                          count++;
                      } else if (event instanceof VMDisconnectEvent) {
                          throw new Failure("Unexpected VMDisconnectEvent received");
                      }
                  }
                  if (totalWaitTime <= 0 || exit) {
                      break;
                  }
                  debugee.resume();
                  begin = System.currentTimeMillis();
                  eventSet = debugee.VM().eventQueue().remove(waitTimeout);
                  delta = System.currentTimeMillis() - begin;
                  totalWaitTime -= delta;
              }
          } catch(InterruptedException e) {
              throw new Failure(e);
          } catch(VMDisconnectedException e) {
              throw new Failure(e);
          }
  
          if (count==0) {
              display("");
              display("WARNING: No events were arrived");
              display("");
          }
  
          debugee.resume();
      }
  
      private boolean analyzeEvents(ClassUnloadEvent event, String pattern) {
          String className;
  
          className = event.className();
  
          if (checkMatching(className, pattern)) {
              complain("***class was excluded***\n " + className);
              display("");
              exitStatus = Consts.TEST_FAILED;
              return false;
          }
  
  