PageRenderTime 134ms CodeModel.GetById 4ms app.highlight 120ms RepoModel.GetById 1ms app.codeStats 0ms

/tests/unit/utils/find_test.py

https://github.com/elaboratory/salt
Python | 585 lines | 574 code | 7 blank | 4 comment | 0 complexity | f297d1f5640227ad9517160a6c050306 MD5 | raw file
  1# -*- coding: utf-8 -*-
  2
  3# Import python libs
  4import os
  5import sys
  6import shutil
  7import tempfile
  8import stat
  9
 10# Import Salt Testing libs
 11from salttesting import skipIf, TestCase
 12from salttesting.helpers import ensure_in_syspath
 13ensure_in_syspath('../../')
 14
 15# Import salt libs
 16import integration
 17import salt.utils
 18import salt.utils.find
 19
 20
 21class TestFind(TestCase):
 22
 23    def test_parse_interval(self):
 24        self.assertRaises(ValueError, salt.utils.find._parse_interval, 'w')
 25        self.assertRaises(ValueError, salt.utils.find._parse_interval, '1')
 26        self.assertRaises(ValueError, salt.utils.find._parse_interval, '1s1w')
 27        self.assertRaises(ValueError, salt.utils.find._parse_interval, '1s1s')
 28
 29        result, resolution, modifier = salt.utils.find._parse_interval('')
 30        self.assertEqual(result, 0)
 31        self.assertIs(resolution, None)
 32        self.assertEqual(modifier, '')
 33
 34        result, resolution, modifier = salt.utils.find._parse_interval('1s')
 35        self.assertEqual(result, 1.0)
 36        self.assertEqual(resolution, 1)
 37        self.assertEqual(modifier, '')
 38
 39        result, resolution, modifier = salt.utils.find._parse_interval('1m')
 40        self.assertEqual(result, 60.0)
 41        self.assertEqual(resolution, 60)
 42        self.assertEqual(modifier, '')
 43
 44        result, resolution, modifier = salt.utils.find._parse_interval('1h')
 45        self.assertEqual(result, 3600.0)
 46        self.assertEqual(resolution, 3600)
 47        self.assertEqual(modifier, '')
 48
 49        result, resolution, modifier = salt.utils.find._parse_interval('1d')
 50        self.assertEqual(result, 86400.0)
 51        self.assertEqual(resolution, 86400)
 52        self.assertEqual(modifier, '')
 53
 54        result, resolution, modifier = salt.utils.find._parse_interval('1w')
 55        self.assertEqual(result, 604800.0)
 56        self.assertEqual(resolution, 604800)
 57        self.assertEqual(modifier, '')
 58
 59        result, resolution, modifier = salt.utils.find._parse_interval('1w3d6h')
 60        self.assertEqual(result, 885600.0)
 61        self.assertEqual(resolution, 3600)
 62        self.assertEqual(modifier, '')
 63
 64        result, resolution, modifier = salt.utils.find._parse_interval('1m1s')
 65        self.assertEqual(result, 61.0)
 66        self.assertEqual(resolution, 1)
 67        self.assertEqual(modifier, '')
 68
 69        result, resolution, modifier = salt.utils.find._parse_interval('1m2s')
 70        self.assertEqual(result, 62.0)
 71        self.assertEqual(resolution, 1)
 72        self.assertEqual(modifier, '')
 73
 74        result, resolution, modifier = salt.utils.find._parse_interval('+1d')
 75        self.assertEqual(result, 86400.0)
 76        self.assertEqual(resolution, 86400)
 77        self.assertEqual(modifier, '+')
 78
 79        result, resolution, modifier = salt.utils.find._parse_interval('-1d')
 80        self.assertEqual(result, 86400.0)
 81        self.assertEqual(resolution, 86400)
 82        self.assertEqual(modifier, '-')
 83
 84    def test_parse_size(self):
 85        self.assertRaises(ValueError, salt.utils.find._parse_size, '')
 86        self.assertRaises(ValueError, salt.utils.find._parse_size, '1s1s')
 87        min_size, max_size = salt.utils.find._parse_size('1')
 88        self.assertEqual(min_size, 1)
 89        self.assertEqual(max_size, 1)
 90
 91        min_size, max_size = salt.utils.find._parse_size('1b')
 92        self.assertEqual(min_size, 1)
 93        self.assertEqual(max_size, 1)
 94
 95        min_size, max_size = salt.utils.find._parse_size('1k')
 96        self.assertEqual(min_size, 1024)
 97        self.assertEqual(max_size, 2047)
 98
 99        min_size, max_size = salt.utils.find._parse_size('1m')
100        self.assertEqual(min_size, 1048576)
101        self.assertEqual(max_size, 2097151)
102
103        min_size, max_size = salt.utils.find._parse_size('1g')
104        self.assertEqual(min_size, 1073741824)
105        self.assertEqual(max_size, 2147483647)
106
107        min_size, max_size = salt.utils.find._parse_size('1t')
108        self.assertEqual(min_size, 1099511627776)
109        self.assertEqual(max_size, 2199023255551)
110
111        min_size, max_size = salt.utils.find._parse_size('0m')
112        self.assertEqual(min_size, 0)
113        self.assertEqual(max_size, 1048575)
114
115        min_size, max_size = salt.utils.find._parse_size('-1m')
116        self.assertEqual(min_size, 0)
117        self.assertEqual(max_size, 1048576)
118
119        min_size, max_size = salt.utils.find._parse_size('+1m')
120        self.assertEqual(min_size, 1048576)
121        self.assertEqual(max_size, sys.maxint)
122
123        min_size, max_size = salt.utils.find._parse_size('+1M')
124        self.assertEqual(min_size, 1048576)
125        self.assertEqual(max_size, sys.maxint)
126
127    def test_option_requires(self):
128        option = salt.utils.find.Option()
129        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_PATH)
130
131    def test_name_option_match(self):
132        option = salt.utils.find.NameOption('name', '*.txt')
133        self.assertIs(option.match('', '', ''), None)
134        self.assertIs(option.match('', 'hello.txt', '').group(), 'hello.txt')
135        self.assertIs(option.match('', 'HELLO.TXT', ''), None)
136
137    def test_iname_option_match(self):
138        option = salt.utils.find.InameOption('name', '*.txt')
139        self.assertIs(option.match('', '', ''), None)
140        self.assertIs(option.match('', 'hello.txt', '').group(), 'hello.txt')
141        self.assertIs(option.match('', 'HELLO.TXT', '').group(), 'HELLO.TXT')
142
143    def test_regex_option_match(self):
144        self.assertRaises(
145            ValueError, salt.utils.find.RegexOption, 'name', '(.*}'
146        )
147
148        option = salt.utils.find.RegexOption('name', r'.*\.txt')
149        self.assertIs(option.match('', '', ''), None)
150        self.assertIs(option.match('', 'hello.txt', '').group(), 'hello.txt')
151        self.assertIs(option.match('', 'HELLO.TXT', ''), None)
152
153    def test_iregex_option_match(self):
154        self.assertRaises(
155            ValueError, salt.utils.find.IregexOption, 'name', '(.*}'
156        )
157
158        option = salt.utils.find.IregexOption('name', r'.*\.txt')
159        self.assertIs(option.match('', '', ''), None)
160        self.assertIs(option.match('', 'hello.txt', '').group(), 'hello.txt')
161        self.assertIs(option.match('', 'HELLO.TXT', '').group(), 'HELLO.TXT')
162
163    def test_type_option_requires(self):
164        self.assertRaises(ValueError, salt.utils.find.TypeOption, 'type', 'w')
165
166        option = salt.utils.find.TypeOption('type', 'd')
167        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_STAT)
168
169    def test_type_option_match(self):
170        option = salt.utils.find.TypeOption('type', 'b')
171        self.assertEqual(option.match('', '', [stat.S_IFREG]), False)
172
173        option = salt.utils.find.TypeOption('type', 'c')
174        self.assertEqual(option.match('', '', [stat.S_IFREG]), False)
175
176        option = salt.utils.find.TypeOption('type', 'd')
177        self.assertEqual(option.match('', '', [stat.S_IFREG]), False)
178
179        option = salt.utils.find.TypeOption('type', 'f')
180        self.assertEqual(option.match('', '', [stat.S_IFREG]), True)
181
182        option = salt.utils.find.TypeOption('type', 'l')
183        self.assertEqual(option.match('', '', [stat.S_IFREG]), False)
184
185        option = salt.utils.find.TypeOption('type', 'p')
186        self.assertEqual(option.match('', '', [stat.S_IFREG]), False)
187
188        option = salt.utils.find.TypeOption('type', 's')
189        self.assertEqual(option.match('', '', [stat.S_IFREG]), False)
190
191        option = salt.utils.find.TypeOption('type', 'b')
192        self.assertEqual(option.match('', '', [stat.S_IFBLK]), True)
193
194        option = salt.utils.find.TypeOption('type', 'c')
195        self.assertEqual(option.match('', '', [stat.S_IFCHR]), True)
196
197        option = salt.utils.find.TypeOption('type', 'd')
198        self.assertEqual(option.match('', '', [stat.S_IFDIR]), True)
199
200        option = salt.utils.find.TypeOption('type', 'l')
201        self.assertEqual(option.match('', '', [stat.S_IFLNK]), True)
202
203        option = salt.utils.find.TypeOption('type', 'p')
204        self.assertEqual(option.match('', '', [stat.S_IFIFO]), True)
205
206        option = salt.utils.find.TypeOption('type', 's')
207        self.assertEqual(option.match('', '', [stat.S_IFSOCK]), True)
208
209    @skipIf(sys.platform.startswith('win'), 'No /dev/null on Windows')
210    def test_owner_option_requires(self):
211        self.assertRaises(
212            ValueError, salt.utils.find.OwnerOption, 'owner', 'notexist'
213        )
214
215        option = salt.utils.find.OwnerOption('owner', 'root')
216        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_STAT)
217
218    @skipIf(sys.platform.startswith('win'), 'No /dev/null on Windows')
219    def test_owner_option_match(self):
220        option = salt.utils.find.OwnerOption('owner', 'root')
221        self.assertEqual(option.match('', '', [0] * 5), True)
222
223        option = salt.utils.find.OwnerOption('owner', '500')
224        self.assertEqual(option.match('', '', [500] * 5), True)
225
226    @skipIf(sys.platform.startswith('win'), 'No /dev/null on Windows')
227    def test_group_option_requires(self):
228        self.assertRaises(
229            ValueError, salt.utils.find.GroupOption, 'group', 'notexist'
230        )
231
232        if sys.platform.startswith(('darwin', 'freebsd')):
233            group_name = 'wheel'
234        else:
235            group_name = 'root'
236        option = salt.utils.find.GroupOption('group', group_name)
237        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_STAT)
238
239    @skipIf(sys.platform.startswith('win'), 'No /dev/null on Windows')
240    def test_group_option_match(self):
241        if sys.platform.startswith(('darwin', 'freebsd')):
242            group_name = 'wheel'
243        else:
244            group_name = 'root'
245        option = salt.utils.find.GroupOption('group', group_name)
246        self.assertEqual(option.match('', '', [0] * 6), True)
247
248        option = salt.utils.find.GroupOption('group', '500')
249        self.assertEqual(option.match('', '', [500] * 6), True)
250
251    def test_size_option_requires(self):
252        self.assertRaises(
253            ValueError, salt.utils.find.SizeOption, 'size', '1s1s'
254        )
255
256        option = salt.utils.find.SizeOption('size', '+1G')
257        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_STAT)
258
259    def test_size_option_match(self):
260        option = salt.utils.find.SizeOption('size', '+1k')
261        self.assertEqual(option.match('', '', [10000] * 7), True)
262
263        option = salt.utils.find.SizeOption('size', '+1G')
264        self.assertEqual(option.match('', '', [10000] * 7), False)
265
266    def test_mtime_option_requires(self):
267        self.assertRaises(
268            ValueError, salt.utils.find.MtimeOption, 'mtime', '4g'
269        )
270
271        option = salt.utils.find.MtimeOption('mtime', '1d')
272        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_STAT)
273
274    def test_mtime_option_match(self):
275        option = salt.utils.find.MtimeOption('mtime', '-1w')
276        self.assertEqual(option.match('', '', [1] * 9), False)
277
278        option = salt.utils.find.MtimeOption('mtime', '-1s')
279        self.assertEqual(option.match('', '', [10 ** 10] * 9), True)
280
281
282class TestGrepOption(TestCase):
283
284    def setUp(self):
285        super(TestGrepOption, self).setUp()
286        self.tmpdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
287
288    def tearDown(self):
289        shutil.rmtree(self.tmpdir)
290        super(TestGrepOption, self).tearDown()
291
292    def test_grep_option_requires(self):
293        self.assertRaises(
294            ValueError, salt.utils.find.GrepOption, 'grep', '(foo)|(bar}'
295        )
296
297        option = salt.utils.find.GrepOption('grep', '(foo)|(bar)')
298        find = salt.utils.find
299        self.assertEqual(
300            option.requires(), (find._REQUIRES_CONTENTS | find._REQUIRES_STAT)
301        )
302
303    def test_grep_option_match_regular_file(self):
304        hello_file = os.path.join(self.tmpdir, 'hello.txt')
305        fd = salt.utils.fopen(hello_file, 'w')
306        fd.write("foo")
307        fd.close()
308        option = salt.utils.find.GrepOption('grep', 'foo')
309        self.assertEqual(
310            option.match(self.tmpdir, 'hello.txt', os.stat(hello_file)),
311            hello_file
312        )
313
314        option = salt.utils.find.GrepOption('grep', 'bar')
315        self.assertEqual(
316            option.match(self.tmpdir, 'hello.txt', os.stat(hello_file)),
317            None
318        )
319
320    @skipIf(sys.platform.startswith('win'), 'No /dev/null on Windows')
321    def test_grep_option_match_dev_null(self):
322        option = salt.utils.find.GrepOption('grep', 'foo')
323        self.assertEqual(
324            option.match('dev', 'null', os.stat('/dev/null')), None
325        )
326
327
328class TestPrintOption(TestCase):
329
330    def setUp(self):
331        super(TestPrintOption, self).setUp()
332        self.tmpdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
333
334    def tearDown(self):
335        shutil.rmtree(self.tmpdir)
336        super(TestPrintOption, self).tearDown()
337
338    def test_print_option_defaults(self):
339        option = salt.utils.find.PrintOption('print', '')
340        self.assertEqual(option.need_stat, False)
341        self.assertEqual(option.print_title, False)
342        self.assertEqual(option.fmt, ['path'])
343
344    def test_print_option_requires(self):
345        option = salt.utils.find.PrintOption('print', '')
346        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_PATH)
347
348        option = salt.utils.find.PrintOption('print', 'name')
349        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_PATH)
350
351        option = salt.utils.find.PrintOption('print', 'path')
352        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_PATH)
353
354        option = salt.utils.find.PrintOption('print', 'name,path')
355        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_PATH)
356
357        option = salt.utils.find.PrintOption('print', 'user')
358        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_STAT)
359
360        option = salt.utils.find.PrintOption('print', 'path user')
361        self.assertEqual(option.requires(), salt.utils.find._REQUIRES_STAT)
362
363    def test_print_option_execute(self):
364        hello_file = os.path.join(self.tmpdir, 'hello.txt')
365        fd = salt.utils.fopen(hello_file, 'w')
366        fd.write("foo")
367        fd.close()
368
369        option = salt.utils.find.PrintOption('print', '')
370        self.assertEqual(option.execute('', [0] * 9), '')
371
372        option = salt.utils.find.PrintOption('print', 'path')
373        self.assertEqual(option.execute('test_name', [0] * 9), 'test_name')
374
375        option = salt.utils.find.PrintOption('print', 'name')
376        self.assertEqual(option.execute('test_name', [0] * 9), 'test_name')
377
378        option = salt.utils.find.PrintOption('print', 'size')
379        self.assertEqual(option.execute(hello_file, os.stat(hello_file)), 3)
380
381        option = salt.utils.find.PrintOption('print', 'type')
382        self.assertEqual(option.execute(hello_file, os.stat(hello_file)), 'f')
383
384        option = salt.utils.find.PrintOption('print', 'mode')
385        self.assertEqual(option.execute(hello_file, range(10)), 0)
386
387        option = salt.utils.find.PrintOption('print', 'mtime')
388        self.assertEqual(option.execute(hello_file, range(10)), 8)
389
390        option = salt.utils.find.PrintOption('print', 'md5')
391        self.assertEqual(
392            option.execute(hello_file, os.stat(hello_file)),
393            'acbd18db4cc2f85cedef654fccc4a4d8'
394        )
395
396        option = salt.utils.find.PrintOption('print', 'path name')
397        self.assertEqual(
398            option.execute('test_name', [0] * 9), ['test_name', 'test_name']
399        )
400
401        option = salt.utils.find.PrintOption('print', 'size name')
402        self.assertEqual(
403            option.execute('test_name', [0] * 9), [0, 'test_name']
404        )
405
406    @skipIf(sys.platform.startswith('Windows'), "no /dev/null on windows")
407    def test_print_user(self):
408        option = salt.utils.find.PrintOption('print', 'user')
409        self.assertEqual(option.execute('', [0] * 10), 'root')
410
411        option = salt.utils.find.PrintOption('print', 'user')
412        self.assertEqual(option.execute('', [2 ** 31] * 10), 2 ** 31)
413
414    @skipIf(sys.platform.startswith('Windows'), "no /dev/null on windows")
415    def test_print_group(self):
416        option = salt.utils.find.PrintOption('print', 'group')
417        if sys.platform.startswith(('darwin', 'freebsd')):
418            group_name = 'wheel'
419        else:
420            group_name = 'root'
421        self.assertEqual(option.execute('', [0] * 10), group_name)
422
423        # This seems to be not working in Ubuntu 12.04 32 bit
424        #option = salt.utils.find.PrintOption('print', 'group')
425        #self.assertEqual(option.execute('', [2 ** 31] * 10), 2 ** 31)
426
427    @skipIf(sys.platform.startswith('Windows'), "no /dev/null on windows")
428    def test_print_md5(self):
429        option = salt.utils.find.PrintOption('print', 'md5')
430        self.assertEqual(option.execute('/dev/null', os.stat('/dev/null')), '')
431
432
433class TestFinder(TestCase):
434
435    def setUp(self):
436        super(TestFinder, self).setUp()
437        self.tmpdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
438
439    def tearDown(self):
440        shutil.rmtree(self.tmpdir)
441        super(TestFinder, self).tearDown()
442
443    @skipIf(sys.platform.startswith('win'), 'No /dev/null on Windows')
444    def test_init(self):
445        finder = salt.utils.find.Finder({})
446        self.assertEqual(
447            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
448        )
449        self.assertEqual(finder.criteria, [])
450
451        finder = salt.utils.find.Finder({'_': None})
452        self.assertEqual(
453            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
454        )
455        self.assertEqual(finder.criteria, [])
456
457        self.assertRaises(ValueError, salt.utils.find.Finder, {'': None})
458        self.assertRaises(ValueError, salt.utils.find.Finder, {'name': None})
459        self.assertRaises(
460            ValueError, salt.utils.find.Finder, {'nonexist': 'somevalue'}
461        )
462
463        finder = salt.utils.find.Finder({'name': 'test_name'})
464        self.assertEqual(
465            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
466        )
467        self.assertEqual(
468            str(finder.criteria[0].__class__)[-12:-2], 'NameOption'
469        )
470
471        finder = salt.utils.find.Finder({'iname': 'test_name'})
472        self.assertEqual(
473            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
474        )
475        self.assertEqual(
476            str(finder.criteria[0].__class__)[-13:-2], 'InameOption'
477        )
478
479        finder = salt.utils.find.Finder({'regex': r'.*\.txt'})
480        self.assertEqual(
481            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
482        )
483        self.assertEqual(
484            str(finder.criteria[0].__class__)[-13:-2], 'RegexOption'
485        )
486
487        finder = salt.utils.find.Finder({'iregex': r'.*\.txt'})
488        self.assertEqual(
489            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
490        )
491        self.assertEqual(
492            str(finder.criteria[0].__class__)[-14:-2], 'IregexOption'
493        )
494
495        finder = salt.utils.find.Finder({'type': 'd'})
496        self.assertEqual(
497            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
498        )
499        self.assertEqual(
500            str(finder.criteria[0].__class__)[-12:-2], 'TypeOption'
501        )
502
503        finder = salt.utils.find.Finder({'owner': 'root'})
504        self.assertEqual(
505            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
506        )
507        self.assertEqual(
508            str(finder.criteria[0].__class__)[-13:-2], 'OwnerOption'
509        )
510
511        if sys.platform.startswith(('darwin', 'freebsd')):
512            group_name = 'wheel'
513        else:
514            group_name = 'root'
515        finder = salt.utils.find.Finder({'group': group_name})
516        self.assertEqual(
517            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
518        )
519        self.assertEqual(
520            str(finder.criteria[0].__class__)[-13:-2], 'GroupOption'
521        )
522
523        finder = salt.utils.find.Finder({'size': '+1G'})
524        self.assertEqual(
525            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
526        )
527        self.assertEqual(
528            str(finder.criteria[0].__class__)[-12:-2], 'SizeOption'
529        )
530
531        finder = salt.utils.find.Finder({'mtime': '1d'})
532        self.assertEqual(
533            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
534        )
535        self.assertEqual(
536            str(finder.criteria[0].__class__)[-13:-2], 'MtimeOption'
537        )
538
539        finder = salt.utils.find.Finder({'grep': 'foo'})
540        self.assertEqual(
541            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
542        )
543        self.assertEqual(
544            str(finder.criteria[0].__class__)[-12:-2], 'GrepOption'
545        )
546
547        finder = salt.utils.find.Finder({'print': 'name'})
548        self.assertEqual(
549            str(finder.actions[0].__class__)[-13:-2], 'PrintOption'
550        )
551        self.assertEqual(finder.criteria, [])
552
553    def test_find(self):
554        hello_file = os.path.join(self.tmpdir, 'hello.txt')
555        fd = salt.utils.fopen(hello_file, 'w')
556        fd.write("foo")
557        fd.close()
558
559        finder = salt.utils.find.Finder({'name': 'test_name'})
560        self.assertEqual(list(finder.find('')), [])
561
562        finder = salt.utils.find.Finder({'name': 'hello.txt'})
563        self.assertEqual(list(finder.find(self.tmpdir)), [hello_file])
564
565        finder = salt.utils.find.Finder({'type': 'f', 'print': 'path'})
566        self.assertEqual(list(finder.find(self.tmpdir)),
567            [os.path.join(self.tmpdir, 'hello.txt')])
568
569        finder = salt.utils.find.Finder({'size': '+1G', 'print': 'path'})
570        self.assertEqual(list(finder.find(self.tmpdir)), [])
571
572        finder = salt.utils.find.Finder(
573            {'name': 'hello.txt', 'print': 'path name'}
574        )
575        self.assertEqual(
576            list(finder.find(self.tmpdir)), [[hello_file, 'hello.txt']]
577        )
578
579
580if __name__ == '__main__':
581    from integration import run_tests
582    run_tests(
583        [TestFind, TestGrepOption, TestPrintOption, TestFinder],
584        needs_daemon=False
585    )