/*
 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * 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.
 */
package org.apache.qetest;

/**
 * Base class defining common functionality of logging handlers.
 * <p>
 * Common functionality used for testing when implementing various Handlers and
 * Listeners. Provides common ways to set Loggers and levels, reset, and set
 * expected errors or the like. Likely used to implement testing wrapper classes
 * for things like javax.xml.transform.ErrorListener and
 * org.xml.sax.ErrorHandler</p>
 * <p>
 * The best description for this class can be seen in an example; see
 * trax.LoggingErrorHandler.java for one.</p>
 */
public interface CheckingHandler {
    /**
     * Reset any items or counters we've handled. Resets any data about what
     * we've handled or logged so far, like getLast() and getCounters() data, as
     * well as any expected items from setExpected(). Does not change our Logger
     * or loggingLevel.
     */
    public void reset();

    /**
     * Ask us to report checkPass/Fail for certain events we handle. Since we
     * may have to handle many events between when a test will be able to call
     * us, testers can set this to have us automatically call checkPass when we
     * see an item that matches, or to call checkFail when we get an unexpected
     * item. Generally, we only call check* methods when:
     * <ul>
     * <li>containsString is not set, reset, or is ITEM_DONT_CARE, we do nothing
     * (i.e. never call check* for this item)</li>
     * <li>containsString is ITEM_CHECKFAIL, we will always call checkFail with
     * the contents of any item if it occurs</li>
     * <li>containsString is anything else, we will grab a String representation
     * of every item of that type that comes along, and if the containsString is
     * found, case-sensitive, within the handled item's string, call checkPass,
     * otherwise call checkFail</li>
     * </ul>
     * Note that most implementations will only validate the first event of a
     * specific type, and then will reset validation for that event type. This
     * is because many events may be raised in between the time that a calling
     * Test class could tell us of the 'next' expected event.
     *
     * @param itemType which of the various types of items we might handle;
     * should be defined as a constant by subclasses
     * @param expectation a set expectation if we care this event or not.
     */
    public void setExpected(int itemType, Expectation expectation);

    enum Expectation {
        ITEM_DONT_CARE,
        ITEM_CHECKFAIL,
        ITEM_CHECKPASS,
        ITEM_RESOLVE
    }
}