| /* |
| * 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.uima.collection.impl.cpm.utils; |
| |
| import java.io.IOException; |
| |
| import org.apache.uima.UIMAFramework; |
| import org.apache.uima.analysis_engine.annotator.AnnotatorConfigurationException; |
| import org.apache.uima.analysis_engine.annotator.AnnotatorInitializationException; |
| import org.apache.uima.analysis_engine.annotator.AnnotatorProcessException; |
| import org.apache.uima.collection.CollectionException; |
| import org.apache.uima.resource.ResourceInitializationException; |
| import org.apache.uima.resource.ResourceProcessException; |
| import org.apache.uima.util.Level; |
| import org.apache.uima.util.Logger; |
| |
| |
| public class FunctionErrorStore { |
| |
| private static final String LS = System.getProperties().getProperty("line.separator"); |
| |
| private static int allCountedExceptions = 0; |
| |
| private String functionError = "Exception"; |
| |
| private String functionName = ""; |
| |
| private int functionCounter = 0; |
| |
| private int functionCounted = 0; |
| |
| private static int collectionReaderCount = 0; |
| |
| private static int collectionReaderGetNextCount = 0; |
| |
| private static int annotatorCount = 0; |
| |
| private static int annotatorProcessCount = 0; |
| |
| private static int casConsumerCount = 0; |
| |
| private static int casConsumerProcessCount = 0; |
| |
| private Logger logger; |
| |
| private final static Level LOG_LEVEL = Level.SEVERE; |
| |
| protected FunctionErrorStore(String exception, int functionCount, String functionName) { |
| functionCounter = functionCount; |
| functionError = exception; |
| this.functionName = functionName; |
| logger = UIMAFramework.getLogger(this.getClass()); |
| // logger = Logger_impl.getInstance(); |
| } |
| |
| // exceptions from JTextAnnotator_ImplBase.process |
| public synchronized void methodeCalled1() throws AnnotatorProcessException { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| if (functionError.equals("AnnotatorProcessException")) { |
| throw new AnnotatorProcessException(); |
| } else { |
| throwAnException(functionError); |
| } |
| } |
| } |
| |
| // exceptions from JTextAnnotator_ImplBase.initialize and JTextAnnotator_ImplBase.reconfigure |
| public synchronized void methodeCalled2() throws AnnotatorConfigurationException, |
| AnnotatorInitializationException { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| if (functionError.equals("AnnotatorConfigurationException")) { |
| throw new AnnotatorConfigurationException(); |
| } else if (functionError.equals("AnnotatorInitializationException")) { |
| throw new AnnotatorInitializationException(); |
| } else { |
| throwAnException(functionError); |
| } |
| } |
| } |
| |
| // exceptions from ErrorTestCasConsumer.processCas |
| public synchronized void methodeCalled3() throws ResourceProcessException { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| if (functionError.equals("ResourceProcessException")) { |
| throw new ResourceProcessException(); |
| } else { |
| throwAnException(functionError); |
| } |
| } |
| } |
| |
| // exceptions from ErrorTestCasConsumer.initialize |
| public synchronized void methodeCalled4() throws ResourceInitializationException { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| if (functionError.equals("ResourceInitializationException")) { |
| throw new ResourceInitializationException(); |
| } else { |
| throwAnException(functionError); |
| } |
| } |
| } |
| |
| // exceptions from ErrorTestCollectionReader.initialize |
| public synchronized void methodeCalled5() throws ResourceInitializationException { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| if (functionError.equals("ResourceInitializationException")) { |
| throw new ResourceInitializationException(); |
| } else { |
| throwAnException(functionError); |
| } |
| } |
| } |
| |
| // exceptions from ErrorTestCasConsumer.initialize |
| public synchronized void methodeCalled6() throws IOException, CollectionException { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| if (functionError.equals("IOException")) { |
| throw new IOException(); |
| } else if (functionError.equals("CollectionException")) { |
| throw new CollectionException(); |
| } else { |
| throwAnException(functionError); |
| } |
| } |
| } |
| |
| // exceptions from ErrorTestCollectionReader.initialize |
| public synchronized void methodeCalled7() throws IOException { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| if (functionError.equals("IOException")) { |
| throw new IOException(); |
| } else { |
| throwAnException(functionError); |
| } |
| } |
| } |
| |
| // exceptions from ErrorTestCollectionReader.initialize |
| public synchronized void methodeCalled8() { |
| functionCounted++; |
| |
| if (functionCounted >= functionCounter) { |
| exceptionThrown(); |
| logger.log(LOG_LEVEL, "the function " + functionName |
| + " is trying to throw the following exception: " + functionError); |
| throwAnException(functionError); |
| } |
| } |
| |
| // runtime exceptions |
| private void throwAnException(String exception) { |
| if (exception.equals("IndexOutOfBoundsException")) { |
| throw new IndexOutOfBoundsException(); |
| } else if (exception.equals("OutOfMemoryError")) { |
| throw new OutOfMemoryError(); |
| } else if (exception.equals("NullPointerException")) { |
| throw new NullPointerException(); |
| } else if (exception.equals("RuntimeException")) { |
| throw new RuntimeException(); |
| } |
| } |
| |
| /** |
| * indicates that an exception was or will be thrown |
| */ |
| private void exceptionThrown() { |
| allCountedExceptions++; // all counted exception |
| functionCounted = 0; // function call counter since the last exception |
| // System.out.println("Exception: " + allCountedExceptions); |
| } |
| |
| /** |
| * reset all static values for a new test cycle for instance |
| */ |
| public static synchronized void resetCount() { |
| allCountedExceptions = 0; |
| collectionReaderCount = 0; |
| annotatorCount = 0; |
| casConsumerCount = 0; |
| casConsumerProcessCount = 0; |
| annotatorProcessCount = 0; |
| collectionReaderGetNextCount = 0; |
| } |
| |
| /** |
| * @return allCountedExceptions since last run |
| */ |
| public static int getCount() { |
| return allCountedExceptions; |
| } |
| |
| /** |
| * @return the number of annotators |
| */ |
| public static int getAnnotatorCount() { |
| return annotatorCount; |
| } |
| |
| /** |
| * @return the CasConsumer count calls |
| */ |
| public static int getCasConsumerCount() { |
| return casConsumerCount; |
| } |
| |
| /** |
| * @return the number of CollectionReader instances |
| */ |
| public static int getCollectionReaderCount() { |
| return collectionReaderCount; |
| } |
| |
| /** |
| * increases the (instance) count of annotators |
| */ |
| public static synchronized void increaseAnnotatorCount() { |
| annotatorCount++; |
| } |
| |
| /** |
| * increases the (instance) count of CasConsumers |
| */ |
| public static synchronized void increaseCasConsumerCount() { |
| casConsumerCount++; |
| } |
| |
| /** |
| * increase the (instance) count of CollectionReaders |
| */ |
| public static synchronized void increaseCollectionReaderCount() { |
| collectionReaderCount++; |
| } |
| |
| /** |
| * increase the CasConsumer 'process'-methode calls count |
| */ |
| public static synchronized void increaseCasConsumerProcessCount() { |
| casConsumerProcessCount++; |
| } |
| |
| /** |
| * @return the number of process calls |
| */ |
| public static int getCasConsumerProcessCount() { |
| return casConsumerProcessCount; |
| } |
| |
| /** |
| * increase the count of 'process'-methode calls for the Annotator |
| */ |
| public static synchronized void increaseAnnotatorProcessCount() { |
| annotatorProcessCount++; |
| } |
| |
| /** |
| * @return the number of 'process'-methode calls |
| */ |
| public static int getAnnotatorProcessCount() { |
| return annotatorProcessCount; |
| } |
| |
| /** |
| * increase the count of the 'getNext'-methode calls for the CollectionReader |
| */ |
| public static synchronized void increaseCollectionReaderGetNextCount() { |
| collectionReaderGetNextCount++; |
| } |
| |
| /** |
| * @return the number of 'getNext'-methode calls |
| */ |
| public static int getCollectionReaderGetNextCount() { |
| return collectionReaderGetNextCount; |
| } |
| |
| public static String printStats() { |
| StringBuffer sb = new StringBuffer(); |
| sb.append("All counted Exceptions: " + allCountedExceptions + LS); |
| sb.append("CollectionReader instances: " + collectionReaderCount + LS); |
| sb |
| .append("CollectionReader 'getNext'-methode call count: " |
| + collectionReaderGetNextCount + LS); |
| sb.append("Annotator instances: " + annotatorCount + LS); |
| sb.append("Annotator 'process'-methode call count: " + annotatorProcessCount + LS); |
| sb.append("CasConsumer instances: " + casConsumerCount + LS); |
| sb.append("CasConsumer 'process'-methode call count:" + casConsumerProcessCount + LS); |
| return sb.toString(); |
| } |
| } |