dotnet/Qpid.Integration.Tests/framework/ExceptionMonitor.csx

/*
 *
 * 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
 *
 *   http://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.
 *
 */
using log4net;

using javax.jms.ExceptionListener;
using javax.jms.JMSException;

using java.io.PrintWriter;
using java.io.StringWriter;
using java.util.ArrayList;
using System.Collections.Generic.IList;

namespace Apache.Qpid.Integration.Tests.framework
{
    /// <summary>
    /// An exception monitor, listens for JMS exception on a connection or consumer. It record all exceptions that it receives
    /// and provides methods to test the number and type of exceptions received.
    ///
    /// <p/><table id="crc"><caption>CRC Card</caption>
    /// <tr><th> Responsibilities <th> Collaborations
    /// <tr><td> Record all exceptions received.
    /// </table>
    /// </summary>
    public class ExceptionMonitor : ExceptionListener
    {
        /// <summary> Used for debugging. </summary>
        private static ILog log = LogManager.GetLogger(typeof(ExceptionMonitor));

        /// <summary> Holds the received exceptions. </summary>
        IList<Exception> exceptions = new ArrayList<Exception>();

        /// <summary>
        /// Receives incoming exceptions.
        /// </summary>
        /// <param name="e"> The exception to record. </param>
        public synchronized void onException(JMSException e)
        {
            log.debug("public void onException(JMSException e): called", e);

            exceptions.add(e);
        }

        /// <summary>
        /// Checks that no exceptions have been received.
        /// </summary>
        /// <return> <tt>true</tt> if no exceptions have been received, <tt>false</tt> otherwise. </return>
        public synchronized bool assertNoExceptions()
        {
            return exceptions.isEmpty();
        }

        /// <summary>
        /// Checks that exactly one exception has been received.
        /// </summary>
        /// <return> <tt>true</tt> if exactly one exception been received, <tt>false</tt> otherwise. </return>
        public synchronized bool assertOneJMSException()
        {
            return exceptions.size() == 1;
        }

        /// <summary>
        /// Checks that exactly one exception, with a linked cause of the specified type, has been received.
        /// </summary>
        /// <param name="aClass"> The type of the linked cause. </param>
        ///
        /// <return> <tt>true</tt> if exactly one exception, with a linked cause of the specified type, been received, </return>
        ///         <tt>false</tt> otherwise.
        public synchronized bool assertOneJMSExceptionWithLinkedCause(Class aClass)
        {
            if (exceptions.size() == 1)
            {
                Exception e = exceptions.get(0);

                if (e instanceof JMSException)
                {
                    JMSException jmse = (JMSException) e;

                    Exception linkedCause = jmse.getLinkedException();

                    if ((linkedCause != null) && aClass.isInstance(linkedCause))
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// Checks that at least one exception of the the specified type, has been received.
        /// </summary>
        /// <param name="exceptionClass"> The type of the exception. </param>
        ///
        /// <return> <tt>true</tt> if at least one exception of the specified type has been received, <tt>false</tt> otherwise. </return>
        public synchronized bool assertExceptionOfType(Class exceptionClass)
        {
            // Start by assuming that the exception has no been received.
            bool passed = false;

            // Scan all the exceptions for a match.
            for (Exception e : exceptions)
            {
                if (exceptionClass.isInstance(e))
                {
                    passed = true;

                    break;
                }
            }

            return passed;
        }

        /// <summary>
        /// Reports the number of exceptions held by this monitor.
        /// </summary>
        /// <return> The number of exceptions held by this monitor. </return>
        public synchronized int size()
        {
            return exceptions.size();
        }

        /// <summary>
        /// Clears the record of received exceptions.
        /// </summary>
        public synchronized void reset()
        {
            exceptions = new ArrayList<Exception>();
        }

        /// <summary>
        /// Provides a dump of the stack traces of all exceptions that this exception monitor was notified of. Mainly
        /// use for debugging/test failure reporting purposes.
        /// </summary>
        /// <return> A string containing a dump of the stack traces of all exceptions. </return>
        public synchronized string ToString()
        {
            string result = "ExceptionMonitor: holds " + exceptions.size() + " exceptions.\n\n";

            for (Exception ex : exceptions)
            {
                result += getStackTrace(ex) + "\n";
            }

            return result;
        }

        /// <summary>
        /// Prints an exception stack trace into a string.
        /// </summary>
        /// <param name="t"> The throwable to get the stack trace from. </param>
        ///
        /// <return> A string containing the throwables stack trace. </return>
        public static string getStackTrace(Throwable t)
        {
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw, true);
            t.printStackTrace(pw);
            pw.flush();
            sw.flush();

            return sw.ToString();
        }
    }
}