content: /*
   * Copyright (C) 2020 The Android Open Source Project
   *
   * Licensed 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 androidx.test.services.events;
  
  import static java.util.Collections.emptyList;
  
  import android.util.Log;
  import androidx.annotation.NonNull;
  import androidx.annotation.Nullable;
  import androidx.annotation.RestrictTo;
  import androidx.test.services.events.internal.StackTrimmer;
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Array;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  import org.junit.runner.Description;
  import org.junit.runner.notification.Failure;
  
  /**
   * Utility to convert JUnit {@link Description} and related test data classes to parcelables for
   * sending to a remote service.
   *
   * @hide
   */
  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
  public final class ParcelableConverter {
  
    private static final String TAG = "ParcelableConverter";
  
    private ParcelableConverter() {}
  
    /** Converts a JUnit {@link Description} to a {@link TestCaseInfo} parcelable. */
    @NonNull
    public static TestCaseInfo getTestCaseFromDescription(@NonNull Description description)
        throws TestEventException {
      if (!isValidJUnitDescription(description)) {
        throw new TestEventException("Unexpected description instance: " + description);
      }
      List<AnnotationInfo> methodAnnotations =
          getAnnotationsFromCollection(description.getAnnotations());
      List<AnnotationInfo> classAnnotations =
          description.getTestClass() != null
              ? getAnnotationsFromArray(description.getTestClass().getAnnotations())
              : emptyList();
      // Note that getMethodName() may return null as in the case of TestRunStartedEvent.
      return new TestCaseInfo(
          description.getClassName(),
          description.getMethodName() != null ? description.getMethodName() : "",
          methodAnnotations,
          classAnnotations);
    }
  
    /** Checks if the specified JUnit {@link Description} contains a valid test case name. */
    public static boolean isValidJUnitDescription(@NonNull Description description) {
      return !description.equals(Description.TEST_MECHANISM);
    }
  
    /**
     * Converts an array of Java {@link Annotation}s to a list of {@link AnnotationInfo} parcelables.
     */
    @NonNull
    public static List<AnnotationInfo> getAnnotationsFromArray(@NonNull Annotation[] annotations) {
      List<AnnotationInfo> result = new ArrayList<>(annotations.length);
      for (Annotation annotation : annotations) {
        result.add(getAnnotation(annotation));
      }
      return result;
    }
  
    /**
     * Converts a {@link Collection} of Java {@link Annotation}s to a list of {@link AnnotationInfo}
     * parcelables.
     */
    @NonNull
    public static List<AnnotationInfo> getAnnotationsFromCollection(
        @NonNull Collection<Annotation> annotations) {
      List<AnnotationInfo> result = new ArrayList<>(annotations.size());
      for (Annotation annotation : annotations) {
        result.add(getAnnotation(annotation));
      }
      return result;
    }
  
    /** Converts a JUnit {@link Failure} to a {@link FailureInfo} parcelable. */
    @NonNull
    public static FailureInfo getFailure(@NonNull Failure junitFailure) throws TestEventException {
      return new FailureInfo(
          junitFailure.getMessage(),
          junitFailure.getTestHeader(),
          StackTrimmer.getTrimmedStackTrace(junitFailure),
          getTestCaseFromDescription(junitFailure.getDescription()));
    }
  
    /**
     * Converts a list of JUnit {@link Failure} objects to a list of {@link FailureInfo} parcelable
     * objects.
     */
    @NonNull
    public static List<FailureInfo> getFailuresFromList(@NonNull List<Failure> failures)
        throws TestEventException {
      List<FailureInfo> result = new ArrayList<>();
      for (Failure failure : failures) {
        result.add(getFailure(failure));
      }
      return result;
    }
  
    /**
     * Convert a Java {@link Annotation} to a parcelable {@link AnnotationInfo}.
     *
     * @return a parcelable {@link AnnotationInfo}
     */
    @NonNull
    public static AnnotationInfo getAnnotation(@NonNull Annotation javaAnnotation) {
      List<AnnotationValue> annotationValues = new ArrayList<>();
  
      // Since java annotations fields are represented as methods we iterate on the object's methods.
      for (Method method : javaAnnotation.annotationType().getDeclaredMethods()) {
        AnnotationValue annotationValue = getAnnotationValue(javaAnnotation, method);
        annotationValues.add(annotationValue);
      }
  
      return new AnnotationInfo(javaAnnotation.annotationType().getName(), annotationValues);
    }
  
    /**
     * Gets the Java annotation field value and type and returns it as an {@link AnnotationValue}
     * parcelable.
     *
     * @param javaAnnotation the {@link Annotation} to get a field value from
     * @param annotationField the field of a {@link Annotation} to get the type and values from
     * @return an {@link AnnotationValue} - a {@link android.os.Parcelable} class containing the
     *     field's value and type as strings
     */
    @NonNull
    private static AnnotationValue getAnnotationValue(
        @NonNull Annotation javaAnnotation, @NonNull Method annotationField) {
      String annotationFieldName = annotationField.getName();
      List<String> annotationFieldValues;
      String valueType = "NULL";
  
      try {
        Object fieldValues = annotationField.invoke(javaAnnotation, (Object[]) null);
        valueType = getFieldValuesType(fieldValues);
  
        // If the annotation value is an array, then convert each one to a String and
        // add it to the list.
        annotationFieldValues = getArrayElements(fieldValues);
      } catch (Exception e) {
        Log.e(
            TAG,
            "Unable to get annotation values for field '"
                + annotationFieldName
                + "': ["
                + javaAnnotation
                + "]",
            e);
        annotationFieldValues = new ArrayList<>();
      }
      return new AnnotationValue(annotationFieldName, annotationFieldValues, valueType);
    }
  
    @NonNull
    private static String getFieldValuesType(Object fieldValues) {
      // Removes "[" and "]" from the valueType. E.g String[] -> String
      return fieldValues.getClass().getSimpleName().replace("[", "").replace("]", "");
    }
  
    /** Tries to convert an object's value(s) to a List of Strings. */
    @NonNull
    static List<String> getArrayElements(@Nullable Object obj) {
      List<String> result = new ArrayList<>();
      if (obj == null) {
        result.add("<null>");
      } else if (obj.getClass().isArray()) {
        for (int n = 0; n < Array.getLength(obj); n++) {
          result.add(Array.get(obj, n).toString());
        }
      } else if (obj instanceof Iterable<?>) {
        for (Object element : ((Iterable<?>) obj)) {
          result.add(element.toString());
        }
      } else {
        result.add(obj.toString());
      }
      return result;
    }
  }
  