* governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

public class ResultOffsetExceededException extends FessSystemException {
    private static final long serialVersionUID = 1L;

    public ResultOffsetExceededException(final String message) {
        super(message);
    }

 */
package org.codelibs.fess.crawler.exception;

/**
 * @author shinsuke
 *
 */
public class MaxLengthExceededException extends CrawlingAccessException {

    private static final long serialVersionUID = 1L;

    public MaxLengthExceededException(final String message) {
        super(message);
    }

                      public InputStream openStream() {
                        return new ByteArrayInputStream(newPreFilledByteArray(0, 50)) {
                          @Override
                          public long skip(long n) {
                            return 0;
                          }
                        };
                      }
                    })
                .iterator());

        settings.set(key, value);
        assertEquals(value, settings.getAsInt(key, -1));
    }

    @Test
    public void test_setAndGetAsLong() {
        String key = "key";
        long value = Long.MAX_VALUE;
        settings.set(key, value);
        assertEquals(value, settings.getAsLong(key, -1));
    }

    @Test
    public void test_setAndGetAsFloat() {
        String key = "key";

        if (value != null) {
            extractData.putValue(name, value);
        }
    }

    public long getTimeout() {
        return timeout;
    }

    public void setTimeout(final long timeout) {
        this.timeout = timeout;
    }

    public void setDaemonThread(final boolean isDaemonThread) {
        this.isDaemonThread = isDaemonThread;

  /**
   * Shortcut for {@code newHasher().putLong(input).hash()}; returns the hash code for the given
   * {@code long} value, interpreted in little-endian byte order. The implementation <i>might</i>
   * perform better than its longhand equivalent, but should not perform worse.
   */
  HashCode hashLong(long input);

  /**
   * Shortcut for {@code newHasher().putBytes(input).hash()}. The implementation <i>might</i>

  /**
   * Shortcut for {@code newHasher().putLong(input).hash()}; returns the hash code for the given
   * {@code long} value, interpreted in little-endian byte order. The implementation <i>might</i>
   * perform better than its longhand equivalent, but should not perform worse.
   */
  HashCode hashLong(long input);

  /**
   * Shortcut for {@code newHasher().putBytes(input).hash()}. The implementation <i>might</i>

package jcifs.spnego;


import jcifs.CIFSException;


/**
 * @author mbechler
 *
 */
public class SpnegoException extends CIFSException {

    /**
     * 
     */
    private static final long serialVersionUID = -4591854684249021395L;


    /**
     * 
     */
    public SpnegoException () {
        super();
    }


    /**
     * @param message
     * @param cause
     */

 */
package jcifs.util.transport;


/**
 * @author mbechler
 *
 */
public class RequestTimeoutException extends TransportException {

    /**
     * 
     */
    private static final long serialVersionUID = -8825922797594232534L;


    /**
     * 
     */
    public RequestTimeoutException () {
        super();
    }


    /**
     * @param msg
     * @param rootCause
     */

    @Size(max = 10000)
    public String queries;

    @Size(max = 1000)
    public String virtualHost;

    @Size(max = 1000)
    public String createdBy;

    @ValidateTypeFailure
    public Long createdTime;

    public void initialize() {
        crudMode = CrudMode.CREATE;
        createdBy = ComponentUtil.getSystemHelper().getUsername();
        createdTime = ComponentUtil.getSystemHelper().getCurrentTimeAsLong();