1#!/usr/bin/env python3
2
3#
4# Copyright (C) 2018 The Android Open Source Project
5#
6# Licensed under the Apache License, Version 2.0 (the "License");
7# you may not use this file except in compliance with the License.
8# You may obtain a copy of the License at
9#
10#      http://www.apache.org/licenses/LICENSE-2.0
11#
12# Unless required by applicable law or agreed to in writing, software
13# distributed under the License is distributed on an "AS IS" BASIS,
14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15# See the License for the specific language governing permissions and
16# limitations under the License.
17#
18
19"""This module contains the unit tests to check evaluate_default(s)."""
20
21import unittest
22
23from blueprint import Dict, evaluate_default, evaluate_defaults
24
25
26#------------------------------------------------------------------------------
27# Evaluate Default
28#------------------------------------------------------------------------------
29
30class EvaluateDefaultTest(unittest.TestCase):
31    """Test cases for evaluate_default()."""
32
33    def test_evaluate_default(self):
34        """Test evaluate_default()."""
35
36        attrs = {'a': 'specified_a', 'b': 'specified_b'}
37        default_attrs = {'a': 'default_a', 'c': 'default_c'}
38
39        result = evaluate_default(attrs, default_attrs)
40
41        self.assertEqual(len(result), 3)
42        self.assertEqual(result['a'], 'specified_a')
43        self.assertEqual(result['b'], 'specified_b')
44        self.assertEqual(result['c'], 'default_c')
45
46
47    def test_evaluate_default_nested(self):
48        """Test evaluate_default() with nested properties."""
49
50        attrs = {'c': Dict({'a': 'specified_a'})}
51        default_attrs = {'c': Dict({'a': 'default_a', 'b': 'default_b'})}
52
53        result = evaluate_default(attrs, default_attrs)
54
55        self.assertEqual(len(result), 1)
56        self.assertEqual(len(result['c']), 2)
57        self.assertEqual(result['c']['a'], 'specified_a')
58        self.assertEqual(result['c']['b'], 'default_b')
59
60
61#------------------------------------------------------------------------------
62# Evaluate Defaults
63#------------------------------------------------------------------------------
64
65class EvaluateDefaultsTest(unittest.TestCase):
66    """Test cases for evaluate_defaults()."""
67
68    def test_evaluate_defaults(self):
69        """Test evaluate_defaults()."""
70
71        modules = [
72            ('cc_defaults', {
73                'name': 'libfoo-defaults',
74                'a': 'default_a',
75                'b': 'default_b',
76            }),
77            ('cc_library', {
78                'name': 'libfoo',
79                'defaults': ['libfoo-defaults'],
80                'a': 'specified_a',
81            }),
82        ]
83
84        modules = evaluate_defaults(modules)
85
86        module = modules[-1][1]
87        self.assertEqual(module['name'], 'libfoo')
88        self.assertEqual(module['a'], 'specified_a')
89        self.assertEqual(module['b'], 'default_b')
90
91
92    def test_evaluate_two_defaults(self):
93        """Test evaluate_defaults() with two defaults."""
94
95        modules = [
96            ('cc_defaults', {
97                'name': 'libfoo-defaults',
98                'a': 'libfoo_default_a',
99                'b': 'libfoo_default_b',
100            }),
101            ('cc_defaults', {
102                'name': 'libbar-defaults',
103                'a': 'libbar_default_a',
104                'b': 'libbar_default_b',
105                'c': 'libbar_default_c',
106            }),
107            ('cc_library', {
108                'name': 'libfoo',
109                'defaults': ['libfoo-defaults', 'libbar-defaults'],
110                'a': 'specified_a',
111            }),
112        ]
113
114        modules = evaluate_defaults(modules)
115
116        module = modules[-1][1]
117        self.assertEqual(module['name'], 'libfoo')
118        self.assertEqual(module['a'], 'specified_a')
119        self.assertEqual(module['b'], 'libfoo_default_b')
120        self.assertEqual(module['c'], 'libbar_default_c')
121
122
123    def test_skip_modules_without_name(self):
124        """Test whether evaluate_defaults() skips modules without names."""
125
126        modules = [('special_rules', {})]
127
128        try:
129            modules = evaluate_defaults(modules)
130        except KeyError:
131            self.fail('modules without names must not cause KeyErrors')
132
133
134    def test_evaluate_recursive(self):
135        """Test whether evaluate_defaults() can evaluate defaults
136        recursively."""
137
138        modules = [
139            ('cc_defaults', {
140                'name': 'libfoo-defaults',
141                'defaults': ['libtest-defaults'],
142                'a': 'libfoo_default_a',
143                'b': 'libfoo_default_b',
144            }),
145            ('cc_defaults', {
146                'name': 'libbar-defaults',
147                'a': 'libbar_default_a',
148                'b': 'libbar_default_b',
149                'c': 'libbar_default_c',
150                'd': 'libbar_default_d',
151            }),
152            ('cc_defaults', {
153                'name': 'libtest-defaults',
154                'a': 'libtest_default_a',
155                'b': 'libtest_default_b',
156                'c': 'libtest_default_c',
157                'e': 'libtest_default_e',
158            }),
159            ('cc_library', {
160                'name': 'libfoo',
161                'defaults': ['libfoo-defaults', 'libbar-defaults'],
162                'a': 'specified_a',
163            }),
164        ]
165
166        modules = evaluate_defaults(modules)
167
168        module = modules[-1][1]
169        self.assertEqual(module['name'], 'libfoo')
170        self.assertEqual(module['a'], 'specified_a')
171        self.assertEqual(module['b'], 'libfoo_default_b')
172        self.assertEqual(module['c'], 'libtest_default_c')
173        self.assertEqual(module['d'], 'libbar_default_d')
174        self.assertEqual(module['e'], 'libtest_default_e')
175
176
177    def test_evaluate_recursive_diamond(self):
178        """Test whether evaluate_defaults() can evaluate diamond defaults
179        recursively."""
180
181        modules = [
182            ('cc_defaults', {
183                'name': 'libfoo-defaults',
184                'defaults': ['libtest-defaults'],
185                'a': 'libfoo_default_a',
186                'b': 'libfoo_default_b',
187            }),
188            ('cc_defaults', {
189                'name': 'libbar-defaults',
190                'defaults': ['libtest-defaults'],
191                'a': 'libbar_default_a',
192                'b': 'libbar_default_b',
193                'c': 'libbar_default_c',
194                'd': 'libbar_default_d',
195            }),
196            ('cc_defaults', {
197                'name': 'libtest-defaults',
198                'a': 'libtest_default_a',
199                'b': 'libtest_default_b',
200                'c': 'libtest_default_c',
201                'e': 'libtest_default_e',
202            }),
203            ('cc_library', {
204                'name': 'libfoo',
205                'defaults': ['libfoo-defaults', 'libbar-defaults'],
206                'a': 'specified_a',
207            }),
208        ]
209
210        modules = evaluate_defaults(modules)
211
212        module = modules[-1][1]
213        self.assertEqual(module['name'], 'libfoo')
214        self.assertEqual(module['a'], 'specified_a')
215        self.assertEqual(module['b'], 'libfoo_default_b')
216        self.assertEqual(module['c'], 'libtest_default_c')
217        self.assertEqual(module['d'], 'libbar_default_d')
218        self.assertEqual(module['e'], 'libtest_default_e')
219
220
221if __name__ == '__main__':
222    unittest.main()
223