duke@1: /*
ohair@554:  * Copyright (c) 2004, 2007, Oracle and/or its affiliates. All rights reserved.
duke@1:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1:  *
duke@1:  * This code is free software; you can redistribute it and/or modify it
duke@1:  * under the terms of the GNU General Public License version 2 only, as
duke@1:  * published by the Free Software Foundation.
duke@1:  *
duke@1:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@1:  * version 2 for more details (a copy is included in the LICENSE file that
duke@1:  * accompanied this code).
duke@1:  *
duke@1:  * You should have received a copy of the GNU General Public License version
duke@1:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@1:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1:  *
ohair@554:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
ohair@554:  * or visit www.oracle.com if you need additional information or have any
ohair@554:  * questions.
duke@1:  */
duke@1: 
duke@1: 
duke@1: import java.lang.reflect.Method;
duke@1: import java.util.*;
duke@1: import com.sun.mirror.apt.*;
duke@1: 
duke@1: 
duke@1: /**
duke@1:  * Annotation processor for the @Test annotation.
duke@1:  * Invokes each method so annotated, and verifies the result.
duke@1:  * Throws an Error on failure.
duke@1:  *
duke@1:  * @author Scott Seligman
duke@1:  */
duke@1: public class TestProcessor implements AnnotationProcessor {
duke@1: 
duke@1:     AnnotationProcessorEnvironment env;
duke@1: 
duke@1:     // The tester that's running.
duke@1:     Tester tester = Tester.activeTester;
duke@1: 
duke@1:     TestProcessor(AnnotationProcessorEnvironment env,
duke@1:                   Tester tester) {
duke@1:         this.env = env;
duke@1:         this.tester = tester;
duke@1:     }
duke@1: 
duke@1: 
duke@1:     /**
duke@1:      * Reflectively invoke the @Test-annotated methods of the live
duke@1:      * tester.  Those methods perform the actual exercising of the
duke@1:      * mirror API.  Then back here to verify the results by
duke@1:      * reading the live annotations.  Convoluted, you say?
duke@1:      */
duke@1:     public void process() {
duke@1:         System.out.printf("\n> Processing %s\n", tester.getClass());
duke@1: 
duke@1:         boolean failed = false;         // true if a test returns wrong result
duke@1: 
duke@1:         for (Method m : tester.getClass().getDeclaredMethods()) {
duke@1:             Test anno = m.getAnnotation(Test.class);
duke@1:             Ignore ignore = m.getAnnotation(Ignore.class);
duke@1:             if (anno != null) {
duke@1:                 if (ignore == null) {
duke@1:                     System.out.println(">> Invoking test " + m.getName());
duke@1:                     Object result;
duke@1:                     try {
duke@1:                         result = m.invoke(tester);
duke@1:                     } catch (Exception e) {
duke@1:                         throw new Error("Test invocation failed", e);
duke@1:                     }
duke@1:                     boolean ok = true;  // result of this test
duke@1:                     if (Collection.class.isAssignableFrom(m.getReturnType())) {
duke@1:                         ok = verifyResults((Collection) result,
duke@1:                                            anno.result(), anno.ordered());
duke@1:                     } else if (m.getReturnType() != void.class) {
duke@1:                         ok = verifyResult(result, anno.result());
duke@1:                     }
duke@1:                     if (!ok) {
duke@1:                         System.out.println(">>> Expected: " + anno);
duke@1:                         System.out.println(">>> Got: " + result);
duke@1:                         failed = true;
duke@1:                     }
duke@1:                 } else {
duke@1:                     System.out.println(">> Ignoring test " + m.getName());
duke@1:                     if (ignore.value().length() > 0) {
duke@1:                         System.out.println(">>> Reason: " + ignore.value());
duke@1:                     }
duke@1:                 }
duke@1:             }
duke@1:         }
duke@1:         if (failed) {
duke@1:             throw new Error("Test(s) returned unexpected result");
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Verify that a single-valued (non-Collection) result matches
duke@1:      * its expected value.
duke@1:      */
duke@1:     private boolean verifyResult(Object result, String[] expected) {
duke@1:         assert expected.length == 1 :
duke@1:             "Single-valued test expecting " + expected.length + " results";
duke@1:         return expected[0].equals(String.valueOf(result));
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Verify that a multi-valued result (a Collection) matches
duke@1:      * its expected values.
duke@1:      */
duke@1:     private boolean verifyResults(Collection result,
duke@1:                                   String[] expected, boolean ordered) {
duke@1:         if (result.size() != expected.length) {
duke@1:             return false;
duke@1:         }
duke@1: 
duke@1:         // Convert result to an array of strings.
duke@1:         String[] res = new String[result.size()];
duke@1:         int i = 0;
duke@1:         for (Object e : result) {
duke@1:             res[i++] = String.valueOf(e);
duke@1:         }
duke@1: 
duke@1:         if (!ordered) {
duke@1:             Arrays.sort(res);
duke@1:             Arrays.sort(expected);
duke@1:         }
duke@1:         return Arrays.equals(res, expected);
duke@1:     }
duke@1: }