16399665579

Committed 17 Feb 2025 07:53AM UTC coverage: 100.0%. First build

Build # 16399665579

Build Type

push

github

Committed by

web-flow

Commit Message

Update Python version support. (#63)

* Drop support for Python 3.8,
* Add preliminary support for Python 3.14.

Run Details

96 of 96 branches covered (100.0%)

Branch coverage included in aggregate %.

266 of 266 relevant lines covered (100.0%)

6.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/zope/i18nmessageid/tests.py

##############################################################################
#
# Copyright (c) 2003 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Message ID tests.
"""
import sys
import unittest

from zope.i18nmessageid import message as messageid


class PyMessageTests(unittest.TestCase):

    _TEST_READONLY = True

    def _getTargetClass(self):
        return messageid.pyMessage

    def _makeOne(self, *args, **kw):
        return self._getTargetClass()(*args, **kw)

    def test_defaults(self):
        message = self._makeOne('testing')
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, None)
        self.assertEqual(message.default, None)
        self.assertEqual(message.mapping, None)
        self.assertEqual(message.msgid_plural, None)
        self.assertEqual(message.default_plural, None)
        self.assertEqual(message.number, None)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_values(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 2)

        with self.assertRaises(TypeError):
            message.mapping['key'] = 'new value'

        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_mapping_is_readonly(self):
        mapping = {'key': 'value'}
        message = self._makeOne('testing', 'domain', mapping=mapping)

        with self.assertRaises(TypeError):
            message.mapping['key'] = 'new value'

    def test_values_without_defaults(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', mapping=mapping,
            msgid_plural='testings', number=2)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, None)
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, None)
        self.assertEqual(message.number, 2)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_values_with_float_for_number(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2.2)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 2.2)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_values_with_zero(self):
        mapping = {'key': 'value'}
        message = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=0)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 0)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_copy(self):
        mapping = {'key': 'value'}
        source = self._makeOne(
            'testing', 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=0)
        message = self._makeOne(source)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 0)

        # Besides just being equal, they maintain their identity
        for attr in (
                'domain',
                'default',
                'mapping',
                'msgid_plural',
                'default_plural',
                'number',
        ):
            self.assertIs(getattr(source, attr),
                          getattr(message, attr))

        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_copy_with_overrides(self):
        mapping = {'key': 'value'}
        source = self._makeOne(
            'testing', 'domain', default='other', mapping=mapping,
            msgid_plural='workings', default_plural='others', number=3)
        message = self._makeOne(
            source, mapping=None, msgid_plural='override', number=0)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'other')
        self.assertEqual(message.mapping, None)
        self.assertEqual(message.msgid_plural, 'override')
        self.assertEqual(message.default_plural, 'others')
        self.assertEqual(message.number, 0)
        if self._TEST_READONLY:
            self.assertTrue(message._readonly)

    def test_copy_no_default(self):
        # https://github.com/zopefoundation/zope.i18nmessageid/issues/14
        pref_msg = self._makeOne("${name} Preferences")
        self.assertIsNone(pref_msg.default)
        copy = self._makeOne(pref_msg, mapping={'name': 'name'})
        self.assertIsNone(copy.default)

    def test_copy_no_overrides(self):
        # https://github.com/zopefoundation/zope.i18nmessageid/issues/14
        pref_msg = self._makeOne("${name} Preferences")

        copy = self._makeOne(pref_msg)
        for attr in (
                'domain',
                'default',
                'mapping',
                'msgid_plural',
                'default_plural',
                'number',
        ):
            self.assertIsNone(getattr(pref_msg, attr))
            self.assertIsNone(getattr(copy, attr))

    def test_domain_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.domain = 'domain'

    def test_default_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.default = 'default'

    def test_mapping_immutable(self):
        mapping = {'key': 'value'}
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.mapping = mapping

    def test_msgid_plural_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.msgid_plural = 'bar'

    def test_default_plural_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.default_plural = 'bar'

    def test_number_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.number = 23

    def test_unknown_immutable(self):
        message = self._makeOne('testing')
        with self.assertRaises((TypeError, AttributeError)):
            message.unknown = 'unknown'

    def test___reduce___wo_values(self):
        message = self._makeOne('testing')
        klass, state = message.__reduce__()
        self.assertIs(klass, self._getTargetClass())
        self.assertIsNone(message.mapping)
        self.assertEqual(
            state,
            ('testing', None, None, None, None, None, None)
        )

    def test___reduce__(self):
        mapping = {'key': 'value'}
        source = self._makeOne('testing')
        message = self._makeOne(
            source, 'domain', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2)
        klass, state = message.__reduce__()
        self.assertIs(klass, self._getTargetClass())
        self.assertEqual(
            state,
            ('testing', 'domain', 'default', {'key': 'value'},
             'testings', 'defaults', 2))

    def test_non_unicode_default(self):
        message = self._makeOne('str', default=123)
        self.assertEqual(message.default, 123)

    def test_non_numeric_number(self):
        with self.assertRaises((TypeError, AttributeError)):
            self._makeOne('str', default=123, number="one")


@unittest.skipIf(messageid.Message is messageid.pyMessage, "Duplicate tests")
class MessageTests(PyMessageTests):

    _TEST_READONLY = False

    def _getTargetClass(self):
        return messageid.Message

    def test_base_type_is_immutable(self):
        klass = self._getTargetClass()

        with self.assertRaises(TypeError):
            klass.foo = "Foo"


@unittest.skipIf('java' in sys.platform or hasattr(sys, 'pypy_version_info'),
                 "We don't expect the C implementation here")
class OptimizationTests(unittest.TestCase):

    def test_optimizations_available(self):
        self.assertIsNot(messageid.Message, messageid.pyMessage)


class MessageFactoryTests(unittest.TestCase):

    def _getTargetClass(self):
        return messageid.MessageFactory

    def _makeOne(self, *args, **kw):
        return self._getTargetClass()(*args, **kw)

    def test___call___defaults(self):
        factory = self._makeOne('domain')
        message = factory('testing')
        self.assertIsInstance(message, messageid.Message)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, None)
        self.assertEqual(message.mapping, None)
        self.assertEqual(message.msgid_plural, None)
        self.assertEqual(message.default_plural, None)
        self.assertEqual(message.number, None)

    def test___call___explicit(self):
        mapping = {'key': 'value'}
        factory = self._makeOne('domain')
        message = factory(
            'testing', 'default', mapping,
            msgid_plural='testings', default_plural="defaults", number=2)
        self.assertIsInstance(message, messageid.Message)
        self.assertEqual(message, 'testing')
        self.assertEqual(message.domain, 'domain')
        self.assertEqual(message.default, 'default')
        self.assertEqual(message.mapping, mapping)
        self.assertEqual(message.msgid_plural, 'testings')
        self.assertEqual(message.default_plural, 'defaults')
        self.assertEqual(message.number, 2)


def test_suite():
    return unittest.TestSuite((
        unittest.defaultTestLoader.loadTestsFromName(__name__),
    ))

1	##############################################################################
2	#
3	# Copyright (c) 2003 Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE.
12	#
13	##############################################################################
14	"""Message ID tests.	7✔
15	"""
16	import sys	7✔
17	import unittest	7✔
18
19	from zope.i18nmessageid import message as messageid	7✔
20
21
22	class PyMessageTests(unittest.TestCase):	7✔
23
24	_TEST_READONLY = True	7✔
25
26	def _getTargetClass(self):	7✔
27	return messageid.pyMessage	7✔
28
29	def _makeOne(self, args, *kw):	7✔
30	return self._getTargetClass()(args, *kw)	7✔
31
32	def test_defaults(self):	7✔
33	message = self._makeOne('testing')	7✔
34	self.assertEqual(message, 'testing')	7✔
35	self.assertEqual(message.domain, None)	7✔
36	self.assertEqual(message.default, None)	7✔
37	self.assertEqual(message.mapping, None)	7✔
38	self.assertEqual(message.msgid_plural, None)	7✔
39	self.assertEqual(message.default_plural, None)	7✔
40	self.assertEqual(message.number, None)	7✔
41	if self._TEST_READONLY:	7✔
42	self.assertTrue(message._readonly)	7✔
43
44	def test_values(self):	7✔
45	mapping = {'key': 'value'}	7✔
46	message = self._makeOne(	7✔
47	'testing', 'domain', 'default', mapping,
48	msgid_plural='testings', default_plural="defaults", number=2)
49	self.assertEqual(message, 'testing')	7✔
50	self.assertEqual(message.domain, 'domain')	7✔
51	self.assertEqual(message.default, 'default')	7✔
52	self.assertEqual(message.mapping, mapping)	7✔
53	self.assertEqual(message.msgid_plural, 'testings')	7✔
54	self.assertEqual(message.default_plural, 'defaults')	7✔
55	self.assertEqual(message.number, 2)	7✔
56
57	with self.assertRaises(TypeError):	7✔
58	message.mapping['key'] = 'new value'	7✔
59
60	if self._TEST_READONLY:	7✔
61	self.assertTrue(message._readonly)	7✔
62
63	def test_mapping_is_readonly(self):	7✔
64	mapping = {'key': 'value'}	7✔
65	message = self._makeOne('testing', 'domain', mapping=mapping)	7✔
66
67	with self.assertRaises(TypeError):	7✔
68	message.mapping['key'] = 'new value'	7✔
69
70	def test_values_without_defaults(self):	7✔
71	mapping = {'key': 'value'}	7✔
72	message = self._makeOne(	7✔
73	'testing', 'domain', mapping=mapping,
74	msgid_plural='testings', number=2)
75	self.assertEqual(message, 'testing')	7✔
76	self.assertEqual(message.domain, 'domain')	7✔
77	self.assertEqual(message.default, None)	7✔
78	self.assertEqual(message.mapping, mapping)	7✔
79	self.assertEqual(message.msgid_plural, 'testings')	7✔
80	self.assertEqual(message.default_plural, None)	7✔
81	self.assertEqual(message.number, 2)	7✔
82	if self._TEST_READONLY:	7✔
83	self.assertTrue(message._readonly)	7✔
84
85	def test_values_with_float_for_number(self):	7✔
86	mapping = {'key': 'value'}	7✔
87	message = self._makeOne(	7✔
88	'testing', 'domain', 'default', mapping,
89	msgid_plural='testings', default_plural="defaults", number=2.2)
90	self.assertEqual(message, 'testing')	7✔
91	self.assertEqual(message.domain, 'domain')	7✔
92	self.assertEqual(message.default, 'default')	7✔
93	self.assertEqual(message.mapping, mapping)	7✔
94	self.assertEqual(message.msgid_plural, 'testings')	7✔
95	self.assertEqual(message.default_plural, 'defaults')	7✔
96	self.assertEqual(message.number, 2.2)	7✔
97	if self._TEST_READONLY:	7✔
98	self.assertTrue(message._readonly)	7✔
99
100	def test_values_with_zero(self):	7✔
101	mapping = {'key': 'value'}	7✔
102	message = self._makeOne(	7✔
103	'testing', 'domain', 'default', mapping,
104	msgid_plural='testings', default_plural="defaults", number=0)
105	self.assertEqual(message, 'testing')	7✔
106	self.assertEqual(message.domain, 'domain')	7✔
107	self.assertEqual(message.default, 'default')	7✔
108	self.assertEqual(message.mapping, mapping)	7✔
109	self.assertEqual(message.msgid_plural, 'testings')	7✔
110	self.assertEqual(message.default_plural, 'defaults')	7✔
111	self.assertEqual(message.number, 0)	7✔
112	if self._TEST_READONLY:	7✔
113	self.assertTrue(message._readonly)	7✔
114
115	def test_copy(self):	7✔
116	mapping = {'key': 'value'}	7✔
117	source = self._makeOne(	7✔
118	'testing', 'domain', 'default', mapping,
119	msgid_plural='testings', default_plural="defaults", number=0)
120	message = self._makeOne(source)	7✔
121	self.assertEqual(message, 'testing')	7✔
122	self.assertEqual(message.domain, 'domain')	7✔
123	self.assertEqual(message.default, 'default')	7✔
124	self.assertEqual(message.mapping, mapping)	7✔
125	self.assertEqual(message.msgid_plural, 'testings')	7✔
126	self.assertEqual(message.default_plural, 'defaults')	7✔
127	self.assertEqual(message.number, 0)	7✔
128
129	# Besides just being equal, they maintain their identity
130	for attr in (	7✔
131	'domain',
132	'default',
133	'mapping',
134	'msgid_plural',
135	'default_plural',
136	'number',
137	):
138	self.assertIs(getattr(source, attr),	7✔
139	getattr(message, attr))
140
141	if self._TEST_READONLY:	7✔
142	self.assertTrue(message._readonly)	7✔
143
144	def test_copy_with_overrides(self):	7✔
145	mapping = {'key': 'value'}	7✔
146	source = self._makeOne(	7✔
147	'testing', 'domain', default='other', mapping=mapping,
148	msgid_plural='workings', default_plural='others', number=3)
149	message = self._makeOne(	7✔
150	source, mapping=None, msgid_plural='override', number=0)
151	self.assertEqual(message, 'testing')	7✔
152	self.assertEqual(message.domain, 'domain')	7✔
153	self.assertEqual(message.default, 'other')	7✔
154	self.assertEqual(message.mapping, None)	7✔
155	self.assertEqual(message.msgid_plural, 'override')	7✔
156	self.assertEqual(message.default_plural, 'others')	7✔
157	self.assertEqual(message.number, 0)	7✔
158	if self._TEST_READONLY:	7✔
159	self.assertTrue(message._readonly)	7✔
160
161	def test_copy_no_default(self):	7✔
162	# https://github.com/zopefoundation/zope.i18nmessageid/issues/14
163	pref_msg = self._makeOne("${name} Preferences")	7✔
164	self.assertIsNone(pref_msg.default)	7✔
165	copy = self._makeOne(pref_msg, mapping={'name': 'name'})	7✔
166	self.assertIsNone(copy.default)	7✔
167
168	def test_copy_no_overrides(self):	7✔
169	# https://github.com/zopefoundation/zope.i18nmessageid/issues/14
170	pref_msg = self._makeOne("${name} Preferences")	7✔
171
172	copy = self._makeOne(pref_msg)	7✔
173	for attr in (	7✔
174	'domain',
175	'default',
176	'mapping',
177	'msgid_plural',
178	'default_plural',
179	'number',
180	):
181	self.assertIsNone(getattr(pref_msg, attr))	7✔
182	self.assertIsNone(getattr(copy, attr))	7✔
183
184	def test_domain_immutable(self):	7✔
185	message = self._makeOne('testing')	7✔
186	with self.assertRaises((TypeError, AttributeError)):	7✔
187	message.domain = 'domain'	7✔
188
189	def test_default_immutable(self):	7✔
190	message = self._makeOne('testing')	7✔
191	with self.assertRaises((TypeError, AttributeError)):	7✔
192	message.default = 'default'	7✔
193
194	def test_mapping_immutable(self):	7✔
195	mapping = {'key': 'value'}	7✔
196	message = self._makeOne('testing')	7✔
197	with self.assertRaises((TypeError, AttributeError)):	7✔
198	message.mapping = mapping	7✔
199
200	def test_msgid_plural_immutable(self):	7✔
201	message = self._makeOne('testing')	7✔
202	with self.assertRaises((TypeError, AttributeError)):	7✔
203	message.msgid_plural = 'bar'	7✔
204
205	def test_default_plural_immutable(self):	7✔
206	message = self._makeOne('testing')	7✔
207	with self.assertRaises((TypeError, AttributeError)):	7✔
208	message.default_plural = 'bar'	7✔
209
210	def test_number_immutable(self):	7✔
211	message = self._makeOne('testing')	7✔
212	with self.assertRaises((TypeError, AttributeError)):	7✔
213	message.number = 23	7✔
214
215	def test_unknown_immutable(self):	7✔
216	message = self._makeOne('testing')	7✔
217	with self.assertRaises((TypeError, AttributeError)):	7✔
218	message.unknown = 'unknown'	7✔
219
220	def test___reduce___wo_values(self):	7✔
221	message = self._makeOne('testing')	7✔
222	klass, state = message.__reduce__()	7✔
223	self.assertIs(klass, self._getTargetClass())	7✔
224	self.assertIsNone(message.mapping)	7✔
225	self.assertEqual(	7✔
226	state,
227	('testing', None, None, None, None, None, None)
228	)
229
230	def test___reduce__(self):	7✔
231	mapping = {'key': 'value'}	7✔
232	source = self._makeOne('testing')	7✔
233	message = self._makeOne(	7✔
234	source, 'domain', 'default', mapping,
235	msgid_plural='testings', default_plural="defaults", number=2)
236	klass, state = message.__reduce__()	7✔
237	self.assertIs(klass, self._getTargetClass())	7✔
238	self.assertEqual(	7✔
239	state,
240	('testing', 'domain', 'default', {'key': 'value'},
241	'testings', 'defaults', 2))
242
243	def test_non_unicode_default(self):	7✔
244	message = self._makeOne('str', default=123)	7✔
245	self.assertEqual(message.default, 123)	7✔
246
247	def test_non_numeric_number(self):	7✔
248	with self.assertRaises((TypeError, AttributeError)):	7✔
249	self._makeOne('str', default=123, number="one")	7✔
250
251
252	@unittest.skipIf(messageid.Message is messageid.pyMessage, "Duplicate tests")	7✔
253	class MessageTests(PyMessageTests):	7✔
254
255	_TEST_READONLY = False	7✔
256
257	def _getTargetClass(self):	7✔
258	return messageid.Message	6✔
259
260	def test_base_type_is_immutable(self):	7✔
261	klass = self._getTargetClass()	6✔
262
263	with self.assertRaises(TypeError):	6✔
264	klass.foo = "Foo"	6✔
265
266
267	@unittest.skipIf('java' in sys.platform or hasattr(sys, 'pypy_version_info'),	7✔
268	"We don't expect the C implementation here")
269	class OptimizationTests(unittest.TestCase):	7✔
270
271	def test_optimizations_available(self):	7✔
272	self.assertIsNot(messageid.Message, messageid.pyMessage)	6✔
273
274
275	class MessageFactoryTests(unittest.TestCase):	7✔
276
277	def _getTargetClass(self):	7✔
278	return messageid.MessageFactory	7✔
279
280	def _makeOne(self, args, *kw):	7✔
281	return self._getTargetClass()(args, *kw)	7✔
282
283	def test___call___defaults(self):	7✔
284	factory = self._makeOne('domain')	7✔
285	message = factory('testing')	7✔
286	self.assertIsInstance(message, messageid.Message)	7✔
287	self.assertEqual(message, 'testing')	7✔
288	self.assertEqual(message.domain, 'domain')	7✔
289	self.assertEqual(message.default, None)	7✔
290	self.assertEqual(message.mapping, None)	7✔
291	self.assertEqual(message.msgid_plural, None)	7✔
292	self.assertEqual(message.default_plural, None)	7✔
293	self.assertEqual(message.number, None)	7✔
294
295	def test___call___explicit(self):	7✔
296	mapping = {'key': 'value'}	7✔
297	factory = self._makeOne('domain')	7✔
298	message = factory(	7✔
299	'testing', 'default', mapping,
300	msgid_plural='testings', default_plural="defaults", number=2)
301	self.assertIsInstance(message, messageid.Message)	7✔
302	self.assertEqual(message, 'testing')	7✔
303	self.assertEqual(message.domain, 'domain')	7✔
304	self.assertEqual(message.default, 'default')	7✔
305	self.assertEqual(message.mapping, mapping)	7✔
306	self.assertEqual(message.msgid_plural, 'testings')	7✔
307	self.assertEqual(message.default_plural, 'defaults')	7✔
308	self.assertEqual(message.number, 2)	7✔
309
310
311	def test_suite():	7✔
312	return unittest.TestSuite((	7✔
313	unittest.defaultTestLoader.loadTestsFromName(__name__),
314	))

zopefoundation / zope.i18nmessageid / 16399665579

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous