/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_ui.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_ui.py
53
53
 
54
54
    def test_text_factory_confirm(self):
55
55
        # turns into reading a regular boolean
56
 
        ui = ui_testing.TestUIFactory('n\n')
57
 
        self.assertEqual(ui.confirm_action(u'Should %(thing)s pass?',
58
 
            'breezy.tests.test_ui.confirmation',
59
 
            {'thing': 'this'},),
60
 
            False)
 
56
        with ui_testing.TestUIFactory('n\n') as ui:
 
57
            self.assertEqual(
 
58
                False,
 
59
                ui.confirm_action(
 
60
                    u'Should %(thing)s pass?',
 
61
                    'breezy.tests.test_ui.confirmation',
 
62
                    {'thing': 'this'}))
61
63
 
62
64
    def test_text_factory_ascii_password(self):
63
65
        ui = ui_testing.TestUIFactory('secret\n')
64
 
        pb = ui.nested_progress_bar()
65
 
        try:
 
66
        with ui.nested_progress_bar():
66
67
            self.assertEqual('secret',
67
68
                             self.apply_redirected(ui.stdin, ui.stdout,
68
69
                                                   ui.stderr,
72
73
            self.assertEqual('', ui.stdout.readline())
73
74
            # stdin should be empty
74
75
            self.assertEqual('', ui.stdin.readline())
75
 
        finally:
76
 
            pb.finished()
77
76
 
78
77
    def test_text_factory_unicode_password(self):
79
78
        """Test a unicode password."""
80
79
        ui = ui_testing.TextUIFactory(u'baz\u1234')
81
 
        password = ui.get_password(u'Hello \u1234 %(user)s', user=u'some\u1234')
 
80
        password = ui.get_password(
 
81
            u'Hello \u1234 %(user)s', user=u'some\u1234')
82
82
        self.assertEqual(u'baz\u1234', password)
83
83
        self.assertEqual(u'Hello \u1234 some\u1234: ', ui.stderr.getvalue())
84
84
        # stdin and stdout should be empty
87
87
 
88
88
    def test_text_ui_get_boolean(self):
89
89
        stdin_text = (
90
 
            "y\n" # True
91
 
            "n\n" # False
92
 
            " \n y \n" # True
93
 
            " no \n" # False
94
 
            "yes with garbage\nY\n" # True
95
 
            "not an answer\nno\n" # False
96
 
            "I'm sure!\nyes\n" # True
97
 
            "NO\n" # False
 
90
            "y\n"  # True
 
91
            "n\n"  # False
 
92
            " \n y \n"  # True
 
93
            " no \n"  # False
 
94
            "yes with garbage\nY\n"  # True
 
95
            "not an answer\nno\n"  # False
 
96
            "I'm sure!\nyes\n"  # True
 
97
            "NO\n"  # False
98
98
            "foo\n")
99
 
        factory = ui_testing.TextUIFactory(stdin_text)
100
 
        self.assertEqual(True, factory.get_boolean(u""))
101
 
        self.assertEqual(False, factory.get_boolean(u""))
102
 
        self.assertEqual(True, factory.get_boolean(u""))
103
 
        self.assertEqual(False, factory.get_boolean(u""))
104
 
        self.assertEqual(True, factory.get_boolean(u""))
105
 
        self.assertEqual(False, factory.get_boolean(u""))
106
 
        self.assertEqual(True, factory.get_boolean(u""))
107
 
        self.assertEqual(False, factory.get_boolean(u""))
108
 
        self.assertEqual("foo\n", factory.stdin.read())
109
 
        # stdin should be empty
110
 
        self.assertEqual('', factory.stdin.readline())
111
 
        # return false on EOF
112
 
        self.assertEqual(False, factory.get_boolean(u""))
 
99
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
100
            self.assertEqual(True, factory.get_boolean(u""))
 
101
            self.assertEqual(False, factory.get_boolean(u""))
 
102
            self.assertEqual(True, factory.get_boolean(u""))
 
103
            self.assertEqual(False, factory.get_boolean(u""))
 
104
            self.assertEqual(True, factory.get_boolean(u""))
 
105
            self.assertEqual(False, factory.get_boolean(u""))
 
106
            self.assertEqual(True, factory.get_boolean(u""))
 
107
            self.assertEqual(False, factory.get_boolean(u""))
 
108
            self.assertEqual("foo\n", factory.stdin.read())
 
109
            # stdin should be empty
 
110
            self.assertEqual('', factory.stdin.readline())
 
111
            # return false on EOF
 
112
            self.assertEqual(False, factory.get_boolean(u""))
113
113
 
114
114
    def test_text_ui_choose_bad_parameters(self):
115
 
        factory = ui_testing.TextUIFactory(u"")
116
 
        # invalid default index
117
 
        self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)
118
 
        # duplicated choice
119
 
        self.assertRaises(ValueError, factory.choose, u"", u"&choice\n&ChOiCe")
120
 
        # duplicated shortcut
121
 
        self.assertRaises(ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")
 
115
        with ui_testing.TextUIFactory(u"") as factory:
 
116
            # invalid default index
 
117
            self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)
 
118
            # duplicated choice
 
119
            self.assertRaises(
 
120
                ValueError, factory.choose, u"", u"&choice\n&ChOiCe")
 
121
            # duplicated shortcut
 
122
            self.assertRaises(
 
123
                ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")
122
124
 
123
125
    def test_text_ui_choose_prompt_explicit(self):
124
126
        # choices with explicit shortcuts
125
 
        factory = ui_testing.TextUIFactory(u"")
126
 
        factory.choose(u"prompt", u"&yes\n&No\nmore &info")
127
 
        self.assertEqual("prompt ([y]es, [N]o, more [i]nfo): \n", factory.stderr.getvalue())
 
127
        with ui_testing.TextUIFactory(u"") as factory:
 
128
            factory.choose(u"prompt", u"&yes\n&No\nmore &info")
 
129
            self.assertEqual(
 
130
                "prompt ([y]es, [N]o, more [i]nfo): \n",
 
131
                factory.stderr.getvalue())
128
132
 
129
133
    def test_text_ui_choose_prompt_automatic(self):
130
134
        # automatic shortcuts
131
 
        factory = ui_testing.TextUIFactory(u"")
132
 
        factory.choose(u"prompt", u"yes\nNo\nmore info")
133
 
        self.assertEqual("prompt ([y]es, [N]o, [m]ore info): \n", factory.stderr.getvalue())
 
135
        with ui_testing.TextUIFactory(u"") as factory:
 
136
            factory.choose(u"prompt", u"yes\nNo\nmore info")
 
137
            self.assertEqual(
 
138
                "prompt ([y]es, [N]o, [m]ore info): \n",
 
139
                factory.stderr.getvalue())
134
140
 
135
141
    def test_text_ui_choose_return_values(self):
136
 
        choose = lambda: factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
 
142
        def choose():
 
143
            return factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
137
144
        stdin_text = (
138
 
            "y\n" # 0
139
 
            "n\n" # 1
140
 
            " \n" # default: 3
141
 
            " no \n" # 1
142
 
            "b\na\nd \n" # bad shortcuts, all ignored
143
 
            "yes with garbage\nY\n" # 0
144
 
            "not an answer\nno\n" # 1
145
 
            "info\nmore info\n" # 3
146
 
            "Maybe\n" # 2
 
145
            "y\n"  # 0
 
146
            "n\n"  # 1
 
147
            " \n"  # default: 3
 
148
            " no \n"  # 1
 
149
            "b\na\nd \n"  # bad shortcuts, all ignored
 
150
            "yes with garbage\nY\n"  # 0
 
151
            "not an answer\nno\n"  # 1
 
152
            "info\nmore info\n"  # 3
 
153
            "Maybe\n"  # 2
147
154
            "foo\n")
148
 
        factory = ui_testing.TextUIFactory(stdin_text)
149
 
        self.assertEqual(0, choose())
150
 
        self.assertEqual(1, choose())
151
 
        self.assertEqual(3, choose())
152
 
        self.assertEqual(1, choose())
153
 
        self.assertEqual(0, choose())
154
 
        self.assertEqual(1, choose())
155
 
        self.assertEqual(3, choose())
156
 
        self.assertEqual(2, choose())
157
 
        self.assertEqual("foo\n", factory.stdin.read())
158
 
        # stdin should be empty
159
 
        self.assertEqual('', factory.stdin.readline())
160
 
        # return None on EOF
161
 
        self.assertEqual(None, choose())
 
155
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
156
            self.assertEqual(0, choose())
 
157
            self.assertEqual(1, choose())
 
158
            self.assertEqual(3, choose())
 
159
            self.assertEqual(1, choose())
 
160
            self.assertEqual(0, choose())
 
161
            self.assertEqual(1, choose())
 
162
            self.assertEqual(3, choose())
 
163
            self.assertEqual(2, choose())
 
164
            self.assertEqual("foo\n", factory.stdin.read())
 
165
            # stdin should be empty
 
166
            self.assertEqual('', factory.stdin.readline())
 
167
            # return None on EOF
 
168
            self.assertEqual(None, choose())
162
169
 
163
170
    def test_text_ui_choose_no_default(self):
164
171
        stdin_text = (
165
 
            " \n" # no default, invalid!
166
 
            " yes \n" # 0
 
172
            " \n"  # no default, invalid!
 
173
            " yes \n"  # 0
167
174
            "foo\n")
168
 
        factory = ui_testing.TextUIFactory(stdin_text)
169
 
        self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))
170
 
        self.assertEqual("foo\n", factory.stdin.read())
 
175
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
176
            self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))
 
177
            self.assertEqual("foo\n", factory.stdin.read())
171
178
 
172
179
    def test_text_ui_get_integer(self):
173
180
        stdin_text = (
174
181
            "1\n"
175
182
            "  -2  \n"
176
183
            "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n")
177
 
        factory = ui_testing.TextUIFactory(stdin_text)
178
 
        self.assertEqual(1, factory.get_integer(u""))
179
 
        self.assertEqual(-2, factory.get_integer(u""))
180
 
        self.assertEqual(42, factory.get_integer(u""))
 
184
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
185
            self.assertEqual(1, factory.get_integer(u""))
 
186
            self.assertEqual(-2, factory.get_integer(u""))
 
187
            self.assertEqual(42, factory.get_integer(u""))
181
188
 
182
189
    def test_text_factory_prompt(self):
183
190
        # see <https://launchpad.net/bugs/365891>
184
 
        factory = ui_testing.TextUIFactory()
185
 
        factory.prompt(u'foo %2e')
186
 
        self.assertEqual('', factory.stdout.getvalue())
187
 
        self.assertEqual('foo %2e', factory.stderr.getvalue())
 
191
        with ui_testing.TextUIFactory() as factory:
 
192
            factory.prompt(u'foo %2e')
 
193
            self.assertEqual('', factory.stdout.getvalue())
 
194
            self.assertEqual('foo %2e', factory.stderr.getvalue())
188
195
 
189
196
    def test_text_factory_prompts_and_clears(self):
190
197
        # a get_boolean call should clear the pb before prompting
191
198
        out = ui_testing.StringIOAsTTY()
192
199
        self.overrideEnv('TERM', 'xterm')
193
200
        factory = ui_testing.TextUIFactory("yada\ny\n", stdout=out, stderr=out)
194
 
        pb = factory.nested_progress_bar()
195
 
        pb._avail_width = lambda: 79
196
 
        pb.show_bar = False
197
 
        pb.show_spinner = False
198
 
        pb.show_count = False
199
 
        pb.update("foo", 0, 1)
200
 
        self.assertEqual(True,
201
 
                         self.apply_redirected(None, factory.stdout,
202
 
                                               factory.stdout,
203
 
                                               factory.get_boolean,
204
 
                                               u"what do you want"))
205
 
        output = out.getvalue()
206
 
        self.assertContainsRe(output,
207
 
            "| foo *\r\r  *\r*")
208
 
        self.assertContainsString(output,
209
 
            r"what do you want? ([y]es, [n]o): what do you want? ([y]es, [n]o): ")
210
 
        # stdin should have been totally consumed
211
 
        self.assertEqual('', factory.stdin.readline())
 
201
        with factory:
 
202
            pb = factory.nested_progress_bar()
 
203
            pb._avail_width = lambda: 79
 
204
            pb.show_bar = False
 
205
            pb.show_spinner = False
 
206
            pb.show_count = False
 
207
            pb.update("foo", 0, 1)
 
208
            self.assertEqual(
 
209
                True,
 
210
                self.apply_redirected(
 
211
                    None, factory.stdout, factory.stdout, factory.get_boolean,
 
212
                    u"what do you want"))
 
213
            output = out.getvalue()
 
214
            self.assertContainsRe(output,
 
215
                                  "| foo *\r\r  *\r*")
 
216
            self.assertContainsString(
 
217
                output,
 
218
                r"what do you want? ([y]es, [n]o): what do you want? "
 
219
                r"([y]es, [n]o): ")
 
220
            # stdin should have been totally consumed
 
221
            self.assertEqual('', factory.stdin.readline())
212
222
 
213
223
    def test_text_tick_after_update(self):
214
224
        ui_factory = ui_testing.TextUIFactory()
215
 
        pb = ui_factory.nested_progress_bar()
216
 
        try:
 
225
        with ui_factory.nested_progress_bar() as pb:
217
226
            pb.update('task', 0, 3)
218
227
            # Reset the clock, so that it actually tries to repaint itself
219
228
            ui_factory._progress_view._last_repaint = time.time() - 1.0
220
229
            pb.tick()
221
 
        finally:
222
 
            pb.finished()
223
230
 
224
231
    def test_text_ui_getusername(self):
225
232
        ui = ui_testing.TextUIFactory('someuser\n\n')
242
249
        self.overrideEnv('BRZ_PROGRESS_BAR', 'text')
243
250
        ui_factory = ui_testing.TextUIFactory(
244
251
            stderr=ui_testing.StringIOAsTTY())
245
 
        self.assertIsInstance(ui_factory._progress_view,
246
 
            _mod_ui_text.TextProgressView)
247
 
        ui_factory.be_quiet(True)
248
 
        self.assertIsInstance(ui_factory._progress_view,
249
 
            _mod_ui_text.NullProgressView)
 
252
        with ui_factory:
 
253
            self.assertIsInstance(ui_factory._progress_view,
 
254
                                  _mod_ui_text.TextProgressView)
 
255
            ui_factory.be_quiet(True)
 
256
            self.assertIsInstance(ui_factory._progress_view,
 
257
                                  _mod_ui_text.NullProgressView)
250
258
 
251
259
    def test_text_ui_show_user_warning(self):
252
260
        from ..bzr.groupcompress_repo import RepositoryFormat2a
254
262
        ui = ui_testing.TextUIFactory()
255
263
        remote_fmt = remote.RemoteRepositoryFormat()
256
264
        remote_fmt._network_name = RepositoryFormatKnitPack5().network_name()
257
 
        ui.show_user_warning('cross_format_fetch', from_format=RepositoryFormat2a(),
 
265
        ui.show_user_warning(
 
266
            'cross_format_fetch', from_format=RepositoryFormat2a(),
258
267
            to_format=remote_fmt)
259
268
        self.assertEqual('', ui.stdout.getvalue())
260
269
        self.assertContainsRe(
261
270
            ui.stderr.getvalue(),
262
271
            "^Doing on-the-fly conversion from RepositoryFormat2a\\(\\) to "
263
 
                "RemoteRepositoryFormat\\(_network_name="
264
 
                "b?'Bazaar RepositoryFormatKnitPack5 \\(bzr 1.6\\)\\\\n'\\)\\.\n"
 
272
            "RemoteRepositoryFormat\\(_network_name="
 
273
            "b?'Bazaar RepositoryFormatKnitPack5 \\(bzr 1.6\\)\\\\n'\\)\\.\n"
265
274
            "This may take some time. Upgrade the repositories to "
266
 
                "the same format for better performance\\.\n$")
 
275
            "the same format for better performance\\.\n$")
267
276
        # and now with it suppressed please
268
277
        ui = ui_testing.TextUIFactory()
269
278
        ui.suppressed_warnings.add('cross_format_fetch')
270
 
        ui.show_user_warning('cross_format_fetch', from_format=RepositoryFormat2a(),
 
279
        ui.show_user_warning(
 
280
            'cross_format_fetch', from_format=RepositoryFormat2a(),
271
281
            to_format=remote_fmt)
272
282
        self.assertEqual('', ui.stdout.getvalue())
273
283
        self.assertEqual('', ui.stderr.getvalue())
279
289
    def test_output_clears_terminal(self):
280
290
        clear_calls = []
281
291
 
282
 
        uif =  ui_testing.TextUIFactory()
 
292
        uif = ui_testing.TextUIFactory()
283
293
        uif.clear_term = lambda: clear_calls.append('clear')
284
294
 
285
 
        stream = _mod_ui_text.TextUIOutputStream(uif, uif.stdout, 'utf-8', 'strict')
 
295
        stream = _mod_ui_text.TextUIOutputStream(
 
296
            uif, uif.stdout, 'utf-8', 'strict')
286
297
        stream.write(u"Hello world!\n")
287
298
        stream.write(u"there's more...\n")
288
299
        stream.writelines([u"1\n", u"2\n", u"3\n"])
289
300
 
290
301
        self.assertEqual(uif.stdout.getvalue(),
291
 
            u"Hello world!\n"
292
 
            u"there's more...\n"
293
 
            u"1\n2\n3\n")
 
302
                         u"Hello world!\n"
 
303
                         u"there's more...\n"
 
304
                         u"1\n2\n3\n")
294
305
        self.assertEqual(['clear', 'clear', 'clear'],
295
 
            clear_calls)
 
306
                         clear_calls)
296
307
 
297
308
        stream.flush()
298
309
 
305
316
        FileStringIO = ui_testing.StringIOWithEncoding
306
317
        TTYStringIO = ui_testing.StringIOAsTTY
307
318
        for (file_class, term, pb, expected_pb_class) in (
308
 
            # on an xterm, either use them or not as the user requests,
309
 
            # otherwise default on
310
 
            (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),
311
 
            (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),
312
 
            (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),
313
 
            # on a dumb terminal, again if there's explicit configuration do
314
 
            # it, otherwise default off
315
 
            (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),
316
 
            (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
317
 
            (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
318
 
            # on a non-tty terminal, it's null regardless of $TERM
319
 
            (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),
320
 
            (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
321
 
            # however, it can still be forced on
322
 
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
323
 
            ):
 
319
                # on an xterm, either use them or not as the user requests,
 
320
                # otherwise default on
 
321
                (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),
 
322
                (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),
 
323
                (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),
 
324
                # on a dumb terminal, again if there's explicit configuration
 
325
                # do it, otherwise default off
 
326
                (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),
 
327
                (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
328
                (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
329
                # on a non-tty terminal, it's null regardless of $TERM
 
330
                (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),
 
331
                (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
332
                # however, it can still be forced on
 
333
                (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
334
                ):
324
335
            self.overrideEnv('TERM', term)
325
336
            self.overrideEnv('BRZ_PROGRESS_BAR', pb)
326
337
            stdin = file_class(u'')
327
338
            stderr = file_class()
328
339
            stdout = file_class()
329
340
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
330
 
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
 
341
            self.assertIsInstance(
 
342
                uif, _mod_ui_text.TextUIFactory,
331
343
                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
332
 
            self.assertIsInstance(uif.make_progress_view(),
 
344
            self.assertIsInstance(
 
345
                uif.make_progress_view(),
333
346
                expected_pb_class,
334
347
                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
335
348
 
340
353
            self.overrideEnv('TERM', term_type)
341
354
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
342
355
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
343
 
                'TERM=%r' % (term_type,))
 
356
                                  'TERM=%r' % (term_type,))
344
357
 
345
358
 
346
359
class SilentUITests(tests.TestCase):
373
386
        # there's no output; we just want to make sure this doesn't crash -
374
387
        # see https://bugs.launchpad.net/bzr/+bug/408201
375
388
        ui = ui_testing.TestUIFactory()
376
 
        pb = ui.nested_progress_bar()
377
 
        pb.update('hello')
378
 
        pb.tick()
379
 
        pb.finished()
 
389
        with ui.nested_progress_bar() as pb:
 
390
            pb.update('hello')
 
391
            pb.tick()
380
392
 
381
393
 
382
394
class CannedInputUIFactoryTests(tests.TestCase):
455
467
            self.assertEqual(
456
468
                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})
457
469
                .confirm_action("Do something?",
458
 
                    "breezy.tests.do_something", {}),
 
470
                                "breezy.tests.do_something", {}),
459
471
                answer)
460
472
 
461
473
    def test_confirm_action_specific(self):
464
476
            for specific_answer in [True, False]:
465
477
                for conf_id in ['given_id', 'other_id']:
466
478
                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
467
 
                        base_ui, default_answer, dict(given_id=specific_answer))
468
 
                    result = wrapper.confirm_action("Do something?", conf_id, {})
 
479
                        base_ui, default_answer,
 
480
                        dict(given_id=specific_answer))
 
481
                    result = wrapper.confirm_action(
 
482
                        "Do something?", conf_id, {})
469
483
                    if conf_id == 'given_id':
470
484
                        self.assertEqual(result, specific_answer)
471
485
                    else:
476
490
        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
477
491
            base_ui, True, dict(a=2))
478
492
        self.assertThat(repr(wrapper),
479
 
            Equals("ConfirmationUserInterfacePolicy("
480
 
                "NoninteractiveUIFactory(), True, {'a': 2})"))
 
493
                        Equals("ConfirmationUserInterfacePolicy("
 
494
                               "NoninteractiveUIFactory(), True, {'a': 2})"))
481
495
 
482
496
 
483
497
class TestProgressRecordingUI(tests.TestCase):