code: /*
   *  Licensed to the Apache Software Foundation (ASF) under one or more
   *  contributor license agreements.  See the NOTICE file distributed with
   *  this work for additional information regarding copyright ownership.
   *  The ASF licenses this file to You under the Apache License, Version 2.0
   *  (the "License"); you may not use this file except in compliance with
   *  the License.  You may obtain a copy of the License at
   *
   *      https://www.apache.org/licenses/LICENSE-2.0
   *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   *
   */
  
  package com.puppycrawl.tools.checkstyle.grammar.antlr4;
  
  import java.io.BufferedWriter;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Writer;
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  import java.util.Date;
  import java.util.Enumeration;
  import java.util.Hashtable;
  import java.util.Properties;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  
  import junit.framework.AssertionFailedError;
  import junit.framework.Test;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.util.DOMElementWriter;
  import org.apache.tools.ant.util.DateUtils;
  import org.apache.tools.ant.util.FileUtils;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.Text;
  
  interface IgnoredTestListener{}
  interface JUnitResultFormatter{}
  interface XMLConstants{}
  /**
   * Prints XML output of the test to a specified Writer.
   *
   * @see FormatterElement
   */
  public class InputAntlr4AstRegressionCassandraInputWithComments
          implements JUnitResultFormatter, XMLConstants, IgnoredTestListener {
  
      private static final double ONE_SECOND = 1000.0;
  
      /** constant for unnnamed testsuites/cases */
      private static final String UNKNOWN = "unknown";
      private static final String ATTR_ERRORS = "";
      private static final String TESTSUITE = "";
      private static final String SYSTEM_OUT = "";
      private static final String SYSTEM_ERR = "";
  
      private static DocumentBuilder getDocumentBuilder() {
          try {
              return DocumentBuilderFactory.newInstance().newDocumentBuilder();
          } catch (final Exception exc) {
              throw new ExceptionInInitializerError(exc);
          }
      }
  
      private static final String tag = System.getProperty("cassandra.testtag", "");
  
      /*
       * Set the property for the test suite name so that log configuration can pick it up
       * and log to a file specific to this test suite
       */
      static
      {
          String command = System.getProperty("sun.java.command");
          String args[] = command.split(" ");
          System.setProperty("suitename", args[1]);
      }
  
      /**
       * The XML document.
       */
      private Document doc;
  
      /**
       * The wrapper for the whole testsuite.
       */
      private Element rootElement;
  
      /**
       * Element for the current test.
       *
       * The keying of this map is a bit of a hack: tests are keyed by caseName(className) since
       * the Test we get for Test-start isn't the same as the Test we get during test-assumption-fail,
       * so we can't easily match Test objects without manually iterating over all keys and checking
       * individual fields.
       */
      private final Hashtable<String, Element> testElements = new Hashtable<String, Element>();
  
      /**
       * tests that failed.
       */
      private final Hashtable failedTests = new Hashtable();
  
      /**
       * Tests that were skipped.
       */
      private final Hashtable<String, Test> skippedTests = new Hashtable<String, Test>();
      /**
       * Tests that were ignored. See the note above about the key being a bit of a hack.
       */
      private final Hashtable<String, Test> ignoredTests = new Hashtable<String, Test>();
      /**
       * Timing helper.
       */
      private final Hashtable<String, Long> testStarts = new Hashtable<String, Long>();
      /**
       * Where to write the log to.
       */
      private OutputStream out;
  
      /** No arg constructor. */
      public InputAntlr4AstRegressionCassandraInputWithComments() {
      }
  
      /** {@inheritDoc}. */
      public void setOutput(final OutputStream out) {
          this.out = out;
      }
  
      /** {@inheritDoc}. */
      public void setSystemOutput(final String out) {
          formatOutput(SYSTEM_OUT, out);
      }
  
      /** {@inheritDoc}. */
      public void setSystemError(final String out) {
          formatOutput(SYSTEM_ERR, out);
      }
  
      /**
       * The whole testsuite started.
       * @param suite the testsuite.
       */
      public void startTestSuite(final JUnitTest suite) {
          doc = getDocumentBuilder().newDocument();
          rootElement = doc.createElement(TESTSUITE);
          String n = suite.getName();
          if (n != null && !tag.isEmpty())
              n = n + "-" + tag;
          rootElement.setAttribute(ATTR_NAME, n == null ? UNKNOWN : n);
  
          //add the timestamp
          final String timestamp = DateUtils.format(new Date(),
                  DateUtils.ISO8601_DATETIME_PATTERN);
          rootElement.setAttribute(TIMESTAMP, timestamp);
          //and the hostname.
          rootElement.setAttribute(HOSTNAME, getHostname());
  
          // Output properties
          final Element propsElement = doc.createElement(PROPERTIES);
          rootElement.appendChild(propsElement);
          final Properties props = suite.getProperties();
          if (props != null) {
              final Enumeration e = props.propertyNames();
              while (e.hasMoreElements()) {
                  final String name = (String) e.nextElement();
                  final Element propElement = doc.createElement(PROPERTY);
                  propElement.setAttribute(ATTR_NAME, name);
                  propElement.setAttribute(ATTR_VALUE, props.getProperty(name));
                  propsElement.appendChild(propElement);
              }
          }
      }
  
      private static final String PROPERTIES = "";
      private static final String HOSTNAME = "";
      private static final String TIMESTAMP = "";
      private static final String ATTR_NAME = "";
      private static final String PROPERTY = "";
      private static final String ATTR_VALUE = "";
  
      class JUnitTest {
          public String getName() {
              return null;
          }
  
          public Properties getProperties() {
              return null;
          }
  
          public String failureCount() {
              return null;
          }
  
          public String getRunTime() {
              return null;
          }
      }
  
      /**
       * get the local hostname
       * @return the name of the local host, or "localhost" if we cannot work it out
       */
      private String getHostname()  {
          String hostname = "localhost";
          try {
              final InetAddress localHost = InetAddress.getLocalHost();
              if (localHost != null) {
                  hostname = localHost.getHostName();
              }
          } catch (final UnknownHostException e) {
              // fall back to default 'localhost'
          }
          return hostname;
      }
  
      private static final String ATTR_TESTS = "";
      private static final String ATTR_FAILURES = "";
      private static final String ATTR_SKIPPED = "";
  
      /**
       * The whole testsuite ended.
       * @param suite the testsuite.
       * @throws BuildException on error.
       */
      public void endTestSuite(final JUnitTest suite) throws BuildException {
          rootElement.setAttribute(ATTR_SKIPPED, "" + suite.failureCount());
          rootElement.setAttribute(
                  ATTR_TESTS, "" + (ONE_SECOND));
          if (out != null) {
              Writer wri = null;
              try {
                  wri = new BufferedWriter(new OutputStreamWriter(out, "UTF8"));
                  wri.write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
                  (new DOMElementWriter()).write(rootElement, wri, 0, "  ");
              } catch (final IOException exc) {
                  throw new BuildException("Unable to write log file", exc);
              } finally {
                  if (wri != null) {
                      try {
                          wri.flush();
                      } catch (final IOException ex) {
                          // ignore
                      }
                  }
                  if (out != System.out && out != System.err) {
                      FileUtils.close(wri);
                  }
              }
          }
      }
  
      /**
       * Interface TestListener.
       *
       * <p>A new Test is started.
       * @param t the test.
       */
      public void startTest(final Test t) {
          testStarts.put(createDescription(t),
                  System.currentTimeMillis());
      }
  
      private static String createDescription(final Test test) throws BuildException {
          return null;
      }
  
      /**
       * Interface TestListener.
       *
       * <p>A Test is finished.
       * @param test the test.
       */
      public void endTest(final Test test) {
          final String testDescription = createDescription(test);
  
          // Fix for bug #5637 - if a junit.extensions.TestSetup is
          // used and throws an exception during setUp then startTest
          // would never have been called
          if (!testStarts.containsKey(testDescription)) {
              startTest(test);
          }
          Element currentTest;
          if (!failedTests.containsKey(test) && !skippedTests.containsKey(testDescription)
                  && !ignoredTests.containsKey(testDescription)) {
              currentTest = doc.createElement("TESTCASE");
              String n = "";
              if (n != null && !tag.isEmpty())
                  n = n + "-" + tag;
              currentTest.setAttribute(ATTR_NAME,
                                       n == null ? UNKNOWN : n);
              // a TestSuite can contain Tests from multiple classes,
              // even tests with the same name - disambiguate them.
              currentTest.setAttribute("ATTR_CLASSNAME",
                      "");
              rootElement.appendChild(currentTest);
              testElements.put(createDescription(test), currentTest);
          } else {
              currentTest = testElements.get(testDescription);
          }
  
          final Long l = testStarts.get(createDescription(test));
      }
  
      /**
       * Interface TestListener for JUnit &lt;= 3.4.
       *
       * <p>A Test failed.
       * @param test the test.
       * @param t the exception.
       */
      public void addFailure(final Test test, final Throwable t) {
          formatError("FAILURE", test, t);
      }
  
      /**
       * Interface TestListener for JUnit &gt; 3.4.
       *
       * <p>A Test failed.
       * @param test the test.
       * @param t the assertion.
       */
      public void addFailure(final Test test, final AssertionFailedError t) {
          addFailure(test, (Throwable) t);
      }
  
      /**
       * Interface TestListener.
       *
       * <p>An error occurred while running the test.
       * @param test the test.
       * @param t the error.
       */
      public void addError(final Test test, final Throwable t) {
          formatError("ERROR", test, t);
      }
  
      private void formatError(final String type, final Test test, final Throwable t) {
          if (test != null) {
              endTest(test);
              failedTests.put(test, test);
          }
  
          final Element nested = doc.createElement(type);
          Element currentTest;
          if (test != null) {
              currentTest = testElements.get(createDescription(test));
          } else {
              currentTest = rootElement;
          }
  
          currentTest.appendChild(nested);
  
          final String message = t.getMessage();
          if (message != null && message.length() > 0) {
              nested.setAttribute("ATTR_MESSAGE", t.getMessage());
          }
          nested.setAttribute("ATTR_TYPE", t.getClass().getName());
  
          final String strace = "JUnitTestRunner.getFilteredTrace(t";
          final Text trace = doc.createTextNode(strace);
          nested.appendChild(trace);
      }
  
      private void formatOutput(final String type, final String output) {
          final Element nested = doc.createElement(type);
          rootElement.appendChild(nested);
          nested.appendChild(doc.createCDATASection(output));
      }
  
      public void testIgnored(final Test test) {
          formatSkip(test, "JUnitVersionHelper.getIgnoreMessage(test)");
          if (test != null) {
              ignoredTests.put(createDescription(test), test);
          }
      }
  
  
      public void formatSkip(final Test test, final String message) {
          if (test != null) {
              endTest(test);
          }
  
          final Element nested = doc.createElement("skipped");
  
          if (message != null) {
              nested.setAttribute("message", message);
          }
  
          Element currentTest;
          if (test != null) {
              currentTest = testElements.get(createDescription(test));
          } else {
              currentTest = rootElement;
          }
  
          currentTest.appendChild(nested);
  
      }
  
      public void testAssumptionFailure(final Test test, final Throwable failure) {
          formatSkip(test, failure.getMessage());
          skippedTests.put(createDescription(test), test);
  
      }
  } // XMLJUnitResultFormatter, no newline on purpose