base/test/android/javatests/src/org/chromium/base/test/TestListInstrumentationRunListener.java

// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.base.test;

import android.support.test.internal.runner.listener.InstrumentationRunListener;

import org.json.JSONArray;
import org.json.JSONObject;
import org.junit.runner.Description;

import org.chromium.base.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * A RunListener that list out all the test information into a json file.
 */
public class TestListInstrumentationRunListener extends InstrumentationRunListener {
    private static final String TAG = "TestListRunListener";
    private static final Set<String> SKIP_METHODS = new HashSet<>(
            Arrays.asList(new String[] {"toString", "hashCode", "annotationType", "equals"}));

    private final Map<Class<?>, JSONObject> mTestClassJsonMap = new HashMap<>();

    /**
     * Store the test method description to a Map at the beginning of a test run.
     */
    @Override
    public void testStarted(Description desc) throws Exception {
        if (mTestClassJsonMap.containsKey(desc.getTestClass())) {
            ((JSONArray) mTestClassJsonMap.get(desc.getTestClass()).get("methods"))
                .put(getTestMethodJSON(desc));
        } else {
            Class<?> testClass = desc.getTestClass();
            mTestClassJsonMap.put(desc.getTestClass(), new JSONObject()
                    .put("class", testClass.getName())
                    .put("superclass", testClass.getSuperclass().getName())
                    .put("annotations",
                            getAnnotationJSON(Arrays.asList(testClass.getAnnotations())))
                    .put("methods", new JSONArray().put(getTestMethodJSON(desc))));
        }
    }

    /**
     * Create a JSONArray with all the test class JSONObjects and save it to listed output path.
     */
    public void saveTestsToJson(String outputPath) throws IOException {
        Writer writer = null;
        File file = new File(outputPath);
        try {
            writer = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
            JSONArray allTestClassesJSON = new JSONArray(mTestClassJsonMap.values());
            writer.write(allTestClassesJSON.toString());
        } catch (IOException e) {
            Log.e(TAG, "failed to write json to file", e);
            throw e;
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    // Intentionally ignore IOException when closing writer
                }
            }
        }
    }

    /**
     * Return a JSONOject that represent a Description of a method".
     */
    static JSONObject getTestMethodJSON(Description desc) throws Exception {
        return new JSONObject()
                .put("method", desc.getMethodName())
                .put("annotations", getAnnotationJSON(desc.getAnnotations()));
    }

    /**
     * Create a JSONObject that represent a collection of anntations.
     *
     * For example, for the following group of annotations for ExampleClass
     * <code>
     * @A
     * @B(message = "hello", level = 3)
     * public class ExampleClass() {}
     * </code>
     *
     * This method would return a JSONObject as such:
     * <code>
     * {
     *   "A": {},
     *   "B": {
     *     "message": "hello",
     *     "level": "3"
     *   }
     * }
     * </code>
     *
     * The method accomplish this by though through each annotation and reflectively call the
     * annotation's method to get the element value, with exceptions to methods like "equals()"
     * or "hashCode".
     */
    static JSONObject getAnnotationJSON(Collection<Annotation> annotations)
            throws Exception {
        JSONObject annotationsJsons = new JSONObject();
        for (Annotation a : annotations) {
            JSONObject elementJsonObject = new JSONObject();
            for (Method method : a.annotationType().getMethods()) {
                if (SKIP_METHODS.contains(method.getName())) {
                    continue;
                }
                try {
                    Object value = method.invoke(a);
                    if (value == null) {
                        elementJsonObject.put(method.getName(), null);
                    } else {
                        elementJsonObject.put(method.getName(),
                                value.getClass().isArray()
                                        ? new JSONArray(Arrays.asList((Object[]) value))
                                        : value.toString());
                    }
                } catch (IllegalArgumentException e) {
                }
            }
            annotationsJsons.put(a.annotationType().getSimpleName(), elementJsonObject);
        }
        return annotationsJsons;
    }
}