Home | History | Annotate | Download | only in ddmlib
      1 /*
      2  * Copyright (C) 2018 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.tradefed.result.ddmlib;
     17 
     18 import com.android.ddmlib.testrunner.ITestRunListener;
     19 import com.android.ddmlib.testrunner.TestIdentifier;
     20 import com.android.tradefed.log.LogUtil.CLog;
     21 import com.android.tradefed.result.ITestLifeCycleReceiver;
     22 import com.android.tradefed.result.TestDescription;
     23 import com.android.tradefed.util.proto.TfMetricProtoUtil;
     24 
     25 import java.util.Arrays;
     26 import java.util.Collection;
     27 import java.util.Map;
     28 
     29 /**
     30  * Forwarder from ddmlib {@link ITestRunListener} to {@link ITestLifeCycleReceiver}. Interface that
     31  * ensure the convertion of results from ddmlib interface to Tradefed Interface.
     32  *
     33  * <p>Ddmlib interface is linked to running instrumentation tests.
     34  */
     35 public class TestRunToTestInvocationForwarder implements ITestRunListener {
     36 
     37     private Collection<ITestLifeCycleReceiver> mListeners;
     38 
     39     public TestRunToTestInvocationForwarder(Collection<ITestLifeCycleReceiver> listeners) {
     40         mListeners = listeners;
     41     }
     42 
     43     public TestRunToTestInvocationForwarder(ITestLifeCycleReceiver listener) {
     44         mListeners = Arrays.asList(listener);
     45     }
     46 
     47     @Override
     48     public void testStarted(TestIdentifier testId) {
     49         for (ITestLifeCycleReceiver listener : mListeners) {
     50             try {
     51                 listener.testStarted(TestDescription.createFromTestIdentifier(testId));
     52             } catch (RuntimeException any) {
     53                 CLog.e(
     54                         "RuntimeException when invoking %s#testStarted",
     55                         listener.getClass().getName());
     56                 CLog.e(any);
     57             }
     58         }
     59     }
     60 
     61     @Override
     62     public void testStarted(TestIdentifier testId, long startTime) {
     63         for (ITestLifeCycleReceiver listener : mListeners) {
     64             try {
     65                 listener.testStarted(TestDescription.createFromTestIdentifier(testId), startTime);
     66             } catch (RuntimeException any) {
     67                 CLog.e(
     68                         "RuntimeException when invoking %s#testStarted",
     69                         listener.getClass().getName());
     70                 CLog.e(any);
     71             }
     72         }
     73     }
     74 
     75     @Override
     76     public void testAssumptionFailure(TestIdentifier testId, String trace) {
     77         for (ITestLifeCycleReceiver listener : mListeners) {
     78             try {
     79                 listener.testAssumptionFailure(
     80                         TestDescription.createFromTestIdentifier(testId), trace);
     81             } catch (RuntimeException any) {
     82                 CLog.e(
     83                         "RuntimeException when invoking %s#testAssumptionFailure",
     84                         listener.getClass().getName());
     85                 CLog.e(any);
     86             }
     87         }
     88     }
     89 
     90     @Override
     91     public void testFailed(TestIdentifier testId, String trace) {
     92         for (ITestLifeCycleReceiver listener : mListeners) {
     93             try {
     94                 listener.testFailed(TestDescription.createFromTestIdentifier(testId), trace);
     95             } catch (RuntimeException any) {
     96                 CLog.e(
     97                         "RuntimeException when invoking %s#testFailed",
     98                         listener.getClass().getName());
     99                 CLog.e(any);
    100             }
    101         }
    102     }
    103 
    104     @Override
    105     public void testIgnored(TestIdentifier testId) {
    106         for (ITestLifeCycleReceiver listener : mListeners) {
    107             try {
    108                 listener.testIgnored(TestDescription.createFromTestIdentifier(testId));
    109             } catch (RuntimeException any) {
    110                 CLog.e(
    111                         "RuntimeException when invoking %s#testIgnored",
    112                         listener.getClass().getName());
    113                 CLog.e(any);
    114             }
    115         }
    116     }
    117 
    118     @Override
    119     public void testEnded(TestIdentifier testId, Map<String, String> testMetrics) {
    120         for (ITestLifeCycleReceiver listener : mListeners) {
    121             try {
    122                 listener.testEnded(
    123                         TestDescription.createFromTestIdentifier(testId),
    124                         TfMetricProtoUtil.upgradeConvert(testMetrics));
    125             } catch (RuntimeException any) {
    126                 CLog.e(
    127                         "RuntimeException when invoking %s#testEnded",
    128                         listener.getClass().getName());
    129                 CLog.e(any);
    130             }
    131         }
    132     }
    133 
    134     @Override
    135     public void testEnded(TestIdentifier testId, long endTime, Map<String, String> testMetrics) {
    136         for (ITestLifeCycleReceiver listener : mListeners) {
    137             try {
    138                 listener.testEnded(
    139                         TestDescription.createFromTestIdentifier(testId),
    140                         endTime,
    141                         TfMetricProtoUtil.upgradeConvert(testMetrics));
    142             } catch (RuntimeException any) {
    143                 CLog.e(
    144                         "RuntimeException when invoking %s#testEnded",
    145                         listener.getClass().getName());
    146                 CLog.e(any);
    147             }
    148         }
    149     }
    150 
    151     @Override
    152     public void testRunEnded(long elapsedTime, Map<String, String> runMetrics) {
    153         for (ITestLifeCycleReceiver listener : mListeners) {
    154             try {
    155                 listener.testRunEnded(elapsedTime, TfMetricProtoUtil.upgradeConvert(runMetrics));
    156             } catch (RuntimeException any) {
    157                 CLog.e(
    158                         "RuntimeException when invoking %s#testRunEnded",
    159                         listener.getClass().getName());
    160                 CLog.e(any);
    161             }
    162         }
    163     }
    164 
    165     @Override
    166     public void testRunFailed(String failure) {
    167         for (ITestLifeCycleReceiver listener : mListeners) {
    168             try {
    169                 listener.testRunFailed(failure);
    170             } catch (RuntimeException any) {
    171                 CLog.e(
    172                         "RuntimeException when invoking %s#testRunFailed",
    173                         listener.getClass().getName());
    174                 CLog.e(any);
    175             }
    176         }
    177     }
    178 
    179     @Override
    180     public void testRunStarted(String runName, int testCount) {
    181         for (ITestLifeCycleReceiver listener : mListeners) {
    182             try {
    183                 listener.testRunStarted(runName, testCount);
    184             } catch (RuntimeException any) {
    185                 CLog.e(
    186                         "RuntimeException when invoking %s#testRunStarted",
    187                         listener.getClass().getName());
    188                 CLog.e(any);
    189             }
    190         }
    191     }
    192 
    193     @Override
    194     public void testRunStopped(long elapsedTime) {
    195         for (ITestLifeCycleReceiver listener : mListeners) {
    196             try {
    197                 listener.testRunStopped(elapsedTime);
    198             } catch (RuntimeException any) {
    199                 CLog.e(
    200                         "RuntimeException when invoking %s#testRunStopped",
    201                         listener.getClass().getName());
    202                 CLog.e(any);
    203             }
    204         }
    205     }
    206 }
    207