• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (C) 2024 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
17import {assertDefined} from 'common/assert_utils';
18import {HierarchyTreeBuilder} from 'test/unit/hierarchy_tree_builder';
19import {LayerCompositionType} from 'trace/layer_composition_type';
20import {
21  DUPLICATE_CHIP,
22  GPU_CHIP,
23  HIDDEN_BY_POLICY_CHIP,
24  HWC_CHIP,
25  MISSING_Z_PARENT_CHIP,
26  RELATIVE_Z_CHIP,
27  RELATIVE_Z_PARENT_CHIP,
28  VISIBLE_CHIP,
29} from 'viewers/common/chip';
30import {UiHierarchyTreeNode} from 'viewers/common/ui_hierarchy_tree_node';
31import {AddChips} from './add_chips';
32
33describe('AddChips', () => {
34  let hierarchyRoot: UiHierarchyTreeNode;
35  let operation: AddChips;
36
37  beforeEach(() => {
38    operation = new AddChips();
39  });
40
41  it('adds GPU_CHIP', () => {
42    hierarchyRoot = UiHierarchyTreeNode.from(
43      new HierarchyTreeBuilder()
44        .setId('test')
45        .setName('node')
46        .setChildren([
47          {
48            id: 1,
49            name: 'node',
50            properties: {compositionType: LayerCompositionType.GPU},
51          },
52        ])
53        .build(),
54    );
55
56    operation.apply(hierarchyRoot);
57    expect(
58      assertDefined(hierarchyRoot.getChildByName('node')).getChips(),
59    ).toEqual([GPU_CHIP]);
60  });
61
62  it('adds HWC_CHIP', () => {
63    hierarchyRoot = UiHierarchyTreeNode.from(
64      new HierarchyTreeBuilder()
65        .setId('test')
66        .setName('node')
67        .setChildren([
68          {
69            id: 1,
70            name: 'node',
71            properties: {compositionType: LayerCompositionType.HWC},
72          },
73        ])
74        .build(),
75    );
76
77    operation.apply(hierarchyRoot);
78    expect(
79      assertDefined(hierarchyRoot.getChildByName('node')).getChips(),
80    ).toEqual([HWC_CHIP]);
81  });
82
83  it('adds VISIBLE_CHIP', () => {
84    hierarchyRoot = UiHierarchyTreeNode.from(
85      new HierarchyTreeBuilder()
86        .setId('test')
87        .setName('node')
88        .setChildren([
89          {
90            id: 1,
91            name: 'node',
92            properties: {isComputedVisible: true},
93          },
94        ])
95        .build(),
96    );
97
98    operation.apply(hierarchyRoot);
99    expect(
100      assertDefined(hierarchyRoot.getChildByName('node')).getChips(),
101    ).toEqual([VISIBLE_CHIP]);
102  });
103
104  it('adds DUPLICATE_CHIP', () => {
105    hierarchyRoot = UiHierarchyTreeNode.from(
106      new HierarchyTreeBuilder()
107        .setId('test')
108        .setName('node')
109        .setChildren([
110          {
111            id: 1,
112            name: 'node',
113            properties: {isDuplicate: true},
114          },
115        ])
116        .build(),
117    );
118
119    operation.apply(hierarchyRoot);
120    expect(
121      assertDefined(hierarchyRoot.getChildByName('node')).getChips(),
122    ).toEqual([DUPLICATE_CHIP]);
123  });
124
125  it('adds RELATIVE_Z_CHIP', () => {
126    hierarchyRoot = UiHierarchyTreeNode.from(
127      new HierarchyTreeBuilder()
128        .setId('test')
129        .setName('node')
130        .setChildren([
131          {
132            id: 1,
133            name: 'node',
134            properties: {zOrderRelativeOf: 2},
135          },
136        ])
137        .build(),
138    );
139
140    operation.apply(hierarchyRoot);
141    expect(
142      assertDefined(hierarchyRoot.getChildByName('node')).getChips(),
143    ).toEqual([RELATIVE_Z_CHIP]);
144  });
145
146  it('adds MISSING_Z_PARENT_CHIP', () => {
147    hierarchyRoot = UiHierarchyTreeNode.from(
148      new HierarchyTreeBuilder()
149        .setId('test')
150        .setName('node')
151        .setChildren([
152          {
153            id: 1,
154            name: 'node',
155            properties: {zOrderRelativeOf: 2, isMissingZParent: true},
156          },
157        ])
158        .build(),
159    );
160
161    operation.apply(hierarchyRoot);
162    expect(
163      assertDefined(hierarchyRoot.getChildByName('node')).getChips(),
164    ).toEqual([RELATIVE_Z_CHIP, MISSING_Z_PARENT_CHIP]);
165  });
166
167  it('adds RELATIVE_Z_PARENT_CHIP', () => {
168    hierarchyRoot = UiHierarchyTreeNode.from(
169      new HierarchyTreeBuilder()
170        .setId('test')
171        .setName('node')
172        .setChildren([
173          {
174            id: 2,
175            name: 'parentNode',
176            properties: {id: 2, zOrderRelativeOf: -1},
177            children: [
178              {
179                id: 1,
180                name: 'node',
181                properties: {id: 1, zOrderRelativeOf: 2},
182              },
183            ],
184          },
185        ])
186        .build(),
187    );
188
189    operation.apply(hierarchyRoot);
190    const parentWithChips = assertDefined(
191      hierarchyRoot.getChildByName('parentNode'),
192    );
193    expect(parentWithChips.getChips()).toEqual([RELATIVE_Z_PARENT_CHIP]);
194    expect(
195      assertDefined(parentWithChips.getChildByName('node')).getChips(),
196    ).toEqual([RELATIVE_Z_CHIP]);
197  });
198
199  it('adds HIDDEN_BY_POLICY_CHIP', () => {
200    hierarchyRoot = UiHierarchyTreeNode.from(
201      new HierarchyTreeBuilder()
202        .setId('test')
203        .setName('node')
204        .setChildren([
205          {
206            id: 1,
207            name: 'node',
208            properties: {isHiddenByPolicy: true},
209          },
210        ])
211        .build(),
212    );
213
214    operation.apply(hierarchyRoot);
215    expect(
216      assertDefined(hierarchyRoot.getChildByName('node')).getChips(),
217    ).toEqual([HIDDEN_BY_POLICY_CHIP]);
218  });
219});
220