1 /*
<lambda>null2  * Copyright (C) 2023 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 
17 package android.tools.flicker.extractor
18 
19 import android.tools.Timestamps
20 import android.tools.flicker.extractors.ITransitionMatcher
21 import android.tools.flicker.extractors.ShellTransitionScenarioExtractor
22 import android.tools.getTraceReaderFromScenario
23 import android.tools.traces.wm.Transition
24 import android.tools.traces.wm.TransitionType
25 import com.google.common.truth.Truth
26 import org.junit.Test
27 
28 class ShellTransitionScenarioExtractorTest {
29     @Test
30     fun canExtractWithNoFilter() {
31         val reader = getTraceReaderFromScenario("AppLaunch")
32         val transitions =
33             (reader.readTransitionsTrace() ?: error("Missing transitions trace")).entries.filter {
34                 it.played
35             }
36 
37         val noFilterExtractor =
38             ShellTransitionScenarioExtractor(
39                 object : ITransitionMatcher {
40                     override fun findAll(
41                         transitions: Collection<Transition>
42                     ): Collection<Transition> {
43                         // No Filter
44                         return transitions
45                     }
46                 }
47             )
48         val slices = noFilterExtractor.extract(reader)
49         Truth.assertThat(slices).hasSize(2)
50         Truth.assertThat(slices.all { it.associatedTransition != null }).isTrue()
51         transitions.forEachIndexed { index, transition ->
52             Truth.assertThat(slices[index].associatedTransition).isEqualTo(transition)
53         }
54     }
55 
56     @Test
57     fun canExtractWithSimpleFilter() {
58         val reader = getTraceReaderFromScenario("AppLaunch")
59         val transitions =
60             (reader.readTransitionsTrace() ?: error("Missing transitions trace")).entries
61 
62         val filterToFrontExtractor =
63             ShellTransitionScenarioExtractor(
64                 object : ITransitionMatcher {
65                     override fun findAll(
66                         transitions: Collection<Transition>
67                     ): Collection<Transition> {
68                         return transitions.filter { it.type == TransitionType.OPEN }
69                     }
70                 }
71             )
72         val slices = filterToFrontExtractor.extract(reader)
73         Truth.assertThat(slices).hasSize(1)
74         Truth.assertThat(slices.first().startTimestamp)
75             .isEqualTo(
76                 Timestamps.from(
77                     unixNanos = 1682433264342452347,
78                     systemUptimeNanos = 2766599071189,
79                     elapsedNanos = 2755182606546,
80                 )
81             )
82         Truth.assertThat(slices.first().endTimestamp)
83             .isEqualTo(
84                 Timestamps.from(
85                     unixNanos = 1682433277025674745,
86                     systemUptimeNanos = 2767865667794,
87                     elapsedNanos = 2767949503328,
88                 )
89             )
90         Truth.assertThat(slices.first().associatedTransition)
91             .isEqualTo(transitions.first { it.type == TransitionType.OPEN })
92     }
93 
94     @Test
95     fun canExtractWithNoMatches() {
96         val reader = getTraceReaderFromScenario("AppLaunch")
97 
98         val filterToBackExtractor =
99             ShellTransitionScenarioExtractor(
100                 object : ITransitionMatcher {
101                     override fun findAll(
102                         transitions: Collection<Transition>
103                     ): Collection<Transition> {
104                         return transitions.filter { it.type == TransitionType.TO_BACK }
105                     }
106                 }
107             )
108         Truth.assertThat(filterToBackExtractor.extract(reader)).hasSize(0)
109     }
110 }
111