/*
    * Copyright (c) 2002-2025 Gargoyle Software Inc.
    *
    * Licensed 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 org.htmlunit.junit;
  
  import java.io.ByteArrayOutputStream;
  import java.io.OutputStream;
  import java.io.PrintStream;
  import java.util.Optional;
  import java.util.regex.Pattern;
  
  import org.apache.commons.lang3.StringUtils;
  import org.htmlunit.WebDriverTestCase;
  import org.junit.jupiter.api.extension.AfterEachCallback;
  import org.junit.jupiter.api.extension.BeforeEachCallback;
  import org.junit.jupiter.api.extension.ExtensionContext;
  
  /**
   * JUnit callback verifying that nothing is printed to {@link System#err}
   * during test execution. If this is the case, the rule generates a failure for
   * the unit test.
   *
   * @author Marc Guillemot
   * @author Ronald Brill
   * @author Ahmed Ashour
   * @author Frank Danek
   */
  public class ErrorOutputChecker implements BeforeEachCallback, AfterEachCallback {
      private PrintStream originalErr_;
      private final ByteArrayOutputStream baos_ = new ByteArrayOutputStream();
      private static final Pattern[] PATTERNS = {
              // jetty
              Pattern.compile(".*Logging initialized .* to org.eclipse.jetty.util.log.StdErrLog.*\r?\n"),
  
              // slf4j
              Pattern.compile("SLF4J\\(I\\): .*\r?\n"),
  
              // Quercus
              Pattern.compile(".*com.caucho.quercus.servlet.QuercusServlet initImpl\r?\n"),
              Pattern.compile(".*QuercusServlet starting as QuercusServletImpl\r?\n"),
              Pattern.compile(".*Quercus finished initialization in \\d*ms\r?\n"),
  
              // XSLT
              Pattern.compile("ERROR:  'Use of the extension function .*\r?\n"),
      };
  
      @Override
      public void beforeEach(final ExtensionContext context) throws Exception {
          wrapSystemErr();
      }
  
      @Override
      public void afterEach(final ExtensionContext context) throws Exception {
          try {
              final Optional<Object> testInstance = context.getTestInstance();
  
              if (testInstance.isPresent()
                      && testInstance.get() instanceof WebDriverTestCase) {
                  final WebDriverTestCase webDriverTestCase = (WebDriverTestCase) testInstance.get();
                  if (!webDriverTestCase.useRealBrowser()) {
                      verifyNoOutput();
                  }
              }
              else {
                  verifyNoOutput();
              }
          }
          finally {
              restoreSystemErr();
          }
      }
  
      void verifyNoOutput() {
          if (baos_.size() != 0) {
              String output = baos_.toString();
  
              // remove webdriver messages
              for (final Pattern pattern : PATTERNS) {
                  output = pattern.matcher(output).replaceAll("");
              }
  
              if (!output.isEmpty()) {
                  if (output.contains("ChromeDriver")) {
                      throw new RuntimeException("Outdated Chrome driver version: " + output);
                  }
                  if (output.contains("geckodriver")) {
                      throw new RuntimeException("Outdated Gecko driver version: " + output);
                  }
                 output = StringUtils.replaceEach(output, new String[] {"\n", "\r"}, new String[]{"\\n", "\\r"});
                 throw new RuntimeException("Test has produced output to System.err: " + output);
             }
         }
     }
 
     private void wrapSystemErr() {
         originalErr_ = System.err;
         System.setErr(new NSAPrintStreamWrapper(originalErr_, baos_));
     }
 
     void restoreSystemErr() {
         System.setErr(originalErr_);
     }
 }
 
 /**
  * A {@link PrintStream} spying what is written on the wrapped stream.
  * It prints the content to the wrapped {@link PrintStream} and captures it simultaneously.
  */
 class NSAPrintStreamWrapper extends PrintStream {
     private PrintStream wrapped_;
 
     NSAPrintStreamWrapper(final PrintStream original, final OutputStream spyOut) {
         super(spyOut, true);
         wrapped_ = original;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public int hashCode() {
         return wrapped_.hashCode();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean equals(final Object obj) {
         return wrapped_.equals(obj);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String toString() {
         return wrapped_.toString();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void flush() {
         super.flush();
         wrapped_.flush();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void close() {
         super.close();
         wrapped_.close();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean checkError() {
         super.checkError();
         return wrapped_.checkError();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void write(final int b) {
         super.write(b);
         wrapped_.write(b);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void write(final byte[] buf, final int off, final int len) {
         super.write(buf, off, len);
         wrapped_.write(buf, off, len);
     }
 }