1 from test.test_importlib import util as test_util
2
3 init = test_util.import_importlib('importlib')
4 machinery = test_util.import_importlib('importlib.machinery')
5 util = test_util.import_importlib('importlib.util')
6
7 import os.path
8 import pathlib
9 from test.support.import_helper import CleanImport
10 import unittest
11 import sys
12 import warnings
13
14
15
16 class ESC[4;38;5;81mTestLoader:
17
18 def __init__(self, path=None, is_package=None):
19 self.path = path
20 self.package = is_package
21
22 def __repr__(self):
23 return '<TestLoader object>'
24
25 def __getattr__(self, name):
26 if name == 'get_filename' and self.path is not None:
27 return self._get_filename
28 if name == 'is_package':
29 return self._is_package
30 raise AttributeError(name)
31
32 def _get_filename(self, name):
33 return self.path
34
35 def _is_package(self, name):
36 return self.package
37
38 def create_module(self, spec):
39 return None
40
41
42 class ESC[4;38;5;81mNewLoader(ESC[4;38;5;149mTestLoader):
43
44 EGGS = 1
45
46 def exec_module(self, module):
47 module.eggs = self.EGGS
48
49
50 class ESC[4;38;5;81mModuleSpecTests:
51
52 def setUp(self):
53 self.name = 'spam'
54 self.path = 'spam.py'
55 self.cached = self.util.cache_from_source(self.path)
56 self.loader = TestLoader()
57 self.spec = self.machinery.ModuleSpec(self.name, self.loader)
58 self.loc_spec = self.machinery.ModuleSpec(self.name, self.loader,
59 origin=self.path)
60 self.loc_spec._set_fileattr = True
61
62 def test_default(self):
63 spec = self.machinery.ModuleSpec(self.name, self.loader)
64
65 self.assertEqual(spec.name, self.name)
66 self.assertEqual(spec.loader, self.loader)
67 self.assertIs(spec.origin, None)
68 self.assertIs(spec.loader_state, None)
69 self.assertIs(spec.submodule_search_locations, None)
70 self.assertIs(spec.cached, None)
71 self.assertFalse(spec.has_location)
72
73 def test_default_no_loader(self):
74 spec = self.machinery.ModuleSpec(self.name, None)
75
76 self.assertEqual(spec.name, self.name)
77 self.assertIs(spec.loader, None)
78 self.assertIs(spec.origin, None)
79 self.assertIs(spec.loader_state, None)
80 self.assertIs(spec.submodule_search_locations, None)
81 self.assertIs(spec.cached, None)
82 self.assertFalse(spec.has_location)
83
84 def test_default_is_package_false(self):
85 spec = self.machinery.ModuleSpec(self.name, self.loader,
86 is_package=False)
87
88 self.assertEqual(spec.name, self.name)
89 self.assertEqual(spec.loader, self.loader)
90 self.assertIs(spec.origin, None)
91 self.assertIs(spec.loader_state, None)
92 self.assertIs(spec.submodule_search_locations, None)
93 self.assertIs(spec.cached, None)
94 self.assertFalse(spec.has_location)
95
96 def test_default_is_package_true(self):
97 spec = self.machinery.ModuleSpec(self.name, self.loader,
98 is_package=True)
99
100 self.assertEqual(spec.name, self.name)
101 self.assertEqual(spec.loader, self.loader)
102 self.assertIs(spec.origin, None)
103 self.assertIs(spec.loader_state, None)
104 self.assertEqual(spec.submodule_search_locations, [])
105 self.assertIs(spec.cached, None)
106 self.assertFalse(spec.has_location)
107
108 def test_has_location_setter(self):
109 spec = self.machinery.ModuleSpec(self.name, self.loader,
110 origin='somewhere')
111 self.assertFalse(spec.has_location)
112 spec.has_location = True
113 self.assertTrue(spec.has_location)
114
115 def test_equality(self):
116 other = type(sys.implementation)(name=self.name,
117 loader=self.loader,
118 origin=None,
119 submodule_search_locations=None,
120 has_location=False,
121 cached=None,
122 )
123
124 self.assertTrue(self.spec == other)
125
126 def test_equality_location(self):
127 other = type(sys.implementation)(name=self.name,
128 loader=self.loader,
129 origin=self.path,
130 submodule_search_locations=None,
131 has_location=True,
132 cached=self.cached,
133 )
134
135 self.assertEqual(self.loc_spec, other)
136
137 def test_inequality(self):
138 other = type(sys.implementation)(name='ham',
139 loader=self.loader,
140 origin=None,
141 submodule_search_locations=None,
142 has_location=False,
143 cached=None,
144 )
145
146 self.assertNotEqual(self.spec, other)
147
148 def test_inequality_incomplete(self):
149 other = type(sys.implementation)(name=self.name,
150 loader=self.loader,
151 )
152
153 self.assertNotEqual(self.spec, other)
154
155 def test_package(self):
156 spec = self.machinery.ModuleSpec('spam.eggs', self.loader)
157
158 self.assertEqual(spec.parent, 'spam')
159
160 def test_package_is_package(self):
161 spec = self.machinery.ModuleSpec('spam.eggs', self.loader,
162 is_package=True)
163
164 self.assertEqual(spec.parent, 'spam.eggs')
165
166 # cached
167
168 def test_cached_set(self):
169 before = self.spec.cached
170 self.spec.cached = 'there'
171 after = self.spec.cached
172
173 self.assertIs(before, None)
174 self.assertEqual(after, 'there')
175
176 def test_cached_no_origin(self):
177 spec = self.machinery.ModuleSpec(self.name, self.loader)
178
179 self.assertIs(spec.cached, None)
180
181 def test_cached_with_origin_not_location(self):
182 spec = self.machinery.ModuleSpec(self.name, self.loader,
183 origin=self.path)
184
185 self.assertIs(spec.cached, None)
186
187 def test_cached_source(self):
188 expected = self.util.cache_from_source(self.path)
189
190 self.assertEqual(self.loc_spec.cached, expected)
191
192 def test_cached_source_unknown_suffix(self):
193 self.loc_spec.origin = 'spam.spamspamspam'
194
195 self.assertIs(self.loc_spec.cached, None)
196
197 def test_cached_source_missing_cache_tag(self):
198 original = sys.implementation.cache_tag
199 sys.implementation.cache_tag = None
200 try:
201 cached = self.loc_spec.cached
202 finally:
203 sys.implementation.cache_tag = original
204
205 self.assertIs(cached, None)
206
207 def test_cached_sourceless(self):
208 self.loc_spec.origin = 'spam.pyc'
209
210 self.assertEqual(self.loc_spec.cached, 'spam.pyc')
211
212
213 (Frozen_ModuleSpecTests,
214 Source_ModuleSpecTests
215 ) = test_util.test_both(ModuleSpecTests, util=util, machinery=machinery)
216
217
218 class ESC[4;38;5;81mModuleSpecMethodsTests:
219
220 @property
221 def bootstrap(self):
222 return self.init._bootstrap
223
224 def setUp(self):
225 self.name = 'spam'
226 self.path = 'spam.py'
227 self.cached = self.util.cache_from_source(self.path)
228 self.loader = TestLoader()
229 self.spec = self.machinery.ModuleSpec(self.name, self.loader)
230 self.loc_spec = self.machinery.ModuleSpec(self.name, self.loader,
231 origin=self.path)
232 self.loc_spec._set_fileattr = True
233
234 # exec()
235
236 def test_exec(self):
237 self.spec.loader = NewLoader()
238 module = self.util.module_from_spec(self.spec)
239 sys.modules[self.name] = module
240 self.assertFalse(hasattr(module, 'eggs'))
241 self.bootstrap._exec(self.spec, module)
242
243 self.assertEqual(module.eggs, 1)
244
245 # load()
246
247 def test_load(self):
248 self.spec.loader = NewLoader()
249 with CleanImport(self.spec.name):
250 loaded = self.bootstrap._load(self.spec)
251 installed = sys.modules[self.spec.name]
252
253 self.assertEqual(loaded.eggs, 1)
254 self.assertIs(loaded, installed)
255
256 def test_load_replaced(self):
257 replacement = object()
258 class ESC[4;38;5;81mReplacingLoader(ESC[4;38;5;149mTestLoader):
259 def exec_module(self, module):
260 sys.modules[module.__name__] = replacement
261 self.spec.loader = ReplacingLoader()
262 with CleanImport(self.spec.name):
263 loaded = self.bootstrap._load(self.spec)
264 installed = sys.modules[self.spec.name]
265
266 self.assertIs(loaded, replacement)
267 self.assertIs(installed, replacement)
268
269 def test_load_failed(self):
270 class ESC[4;38;5;81mFailedLoader(ESC[4;38;5;149mTestLoader):
271 def exec_module(self, module):
272 raise RuntimeError
273 self.spec.loader = FailedLoader()
274 with CleanImport(self.spec.name):
275 with self.assertRaises(RuntimeError):
276 loaded = self.bootstrap._load(self.spec)
277 self.assertNotIn(self.spec.name, sys.modules)
278
279 def test_load_failed_removed(self):
280 class ESC[4;38;5;81mFailedLoader(ESC[4;38;5;149mTestLoader):
281 def exec_module(self, module):
282 del sys.modules[module.__name__]
283 raise RuntimeError
284 self.spec.loader = FailedLoader()
285 with CleanImport(self.spec.name):
286 with self.assertRaises(RuntimeError):
287 loaded = self.bootstrap._load(self.spec)
288 self.assertNotIn(self.spec.name, sys.modules)
289
290 def test_load_legacy_attributes_immutable(self):
291 module = object()
292 with warnings.catch_warnings():
293 warnings.simplefilter("ignore", ImportWarning)
294 class ESC[4;38;5;81mImmutableLoader(ESC[4;38;5;149mTestLoader):
295 def load_module(self, name):
296 sys.modules[name] = module
297 return module
298 self.spec.loader = ImmutableLoader()
299 with CleanImport(self.spec.name):
300 loaded = self.bootstrap._load(self.spec)
301
302 self.assertIs(sys.modules[self.spec.name], module)
303
304 # reload()
305
306 def test_reload(self):
307 self.spec.loader = NewLoader()
308 with CleanImport(self.spec.name):
309 loaded = self.bootstrap._load(self.spec)
310 reloaded = self.bootstrap._exec(self.spec, loaded)
311 installed = sys.modules[self.spec.name]
312
313 self.assertEqual(loaded.eggs, 1)
314 self.assertIs(reloaded, loaded)
315 self.assertIs(installed, loaded)
316
317 def test_reload_modified(self):
318 self.spec.loader = NewLoader()
319 with CleanImport(self.spec.name):
320 loaded = self.bootstrap._load(self.spec)
321 loaded.eggs = 2
322 reloaded = self.bootstrap._exec(self.spec, loaded)
323
324 self.assertEqual(loaded.eggs, 1)
325 self.assertIs(reloaded, loaded)
326
327 def test_reload_extra_attributes(self):
328 self.spec.loader = NewLoader()
329 with CleanImport(self.spec.name):
330 loaded = self.bootstrap._load(self.spec)
331 loaded.available = False
332 reloaded = self.bootstrap._exec(self.spec, loaded)
333
334 self.assertFalse(loaded.available)
335 self.assertIs(reloaded, loaded)
336
337 def test_reload_init_module_attrs(self):
338 self.spec.loader = NewLoader()
339 with CleanImport(self.spec.name):
340 loaded = self.bootstrap._load(self.spec)
341 loaded.__name__ = 'ham'
342 del loaded.__loader__
343 del loaded.__package__
344 del loaded.__spec__
345 self.bootstrap._exec(self.spec, loaded)
346
347 self.assertEqual(loaded.__name__, self.spec.name)
348 self.assertIs(loaded.__loader__, self.spec.loader)
349 self.assertEqual(loaded.__package__, self.spec.parent)
350 self.assertIs(loaded.__spec__, self.spec)
351 self.assertFalse(hasattr(loaded, '__path__'))
352 self.assertFalse(hasattr(loaded, '__file__'))
353 self.assertFalse(hasattr(loaded, '__cached__'))
354
355
356 (Frozen_ModuleSpecMethodsTests,
357 Source_ModuleSpecMethodsTests
358 ) = test_util.test_both(ModuleSpecMethodsTests, init=init, util=util,
359 machinery=machinery)
360
361
362 class ESC[4;38;5;81mFactoryTests:
363
364 def setUp(self):
365 self.name = 'spam'
366 self.path = os.path.abspath('spam.py')
367 self.cached = self.util.cache_from_source(self.path)
368 self.loader = TestLoader()
369 self.fileloader = TestLoader(self.path)
370 self.pkgloader = TestLoader(self.path, True)
371
372 # spec_from_loader()
373
374 def test_spec_from_loader_default(self):
375 spec = self.util.spec_from_loader(self.name, self.loader)
376
377 self.assertEqual(spec.name, self.name)
378 self.assertEqual(spec.loader, self.loader)
379 self.assertIs(spec.origin, None)
380 self.assertIs(spec.loader_state, None)
381 self.assertIs(spec.submodule_search_locations, None)
382 self.assertIs(spec.cached, None)
383 self.assertFalse(spec.has_location)
384
385 def test_spec_from_loader_default_with_bad_is_package(self):
386 class ESC[4;38;5;81mLoader:
387 def is_package(self, name):
388 raise ImportError
389 loader = Loader()
390 spec = self.util.spec_from_loader(self.name, loader)
391
392 self.assertEqual(spec.name, self.name)
393 self.assertEqual(spec.loader, loader)
394 self.assertIs(spec.origin, None)
395 self.assertIs(spec.loader_state, None)
396 self.assertIs(spec.submodule_search_locations, None)
397 self.assertIs(spec.cached, None)
398 self.assertFalse(spec.has_location)
399
400 def test_spec_from_loader_origin(self):
401 origin = 'somewhere over the rainbow'
402 spec = self.util.spec_from_loader(self.name, self.loader,
403 origin=origin)
404
405 self.assertEqual(spec.name, self.name)
406 self.assertEqual(spec.loader, self.loader)
407 self.assertIs(spec.origin, origin)
408 self.assertIs(spec.loader_state, None)
409 self.assertIs(spec.submodule_search_locations, None)
410 self.assertIs(spec.cached, None)
411 self.assertFalse(spec.has_location)
412
413 def test_spec_from_loader_is_package_false(self):
414 spec = self.util.spec_from_loader(self.name, self.loader,
415 is_package=False)
416
417 self.assertEqual(spec.name, self.name)
418 self.assertEqual(spec.loader, self.loader)
419 self.assertIs(spec.origin, None)
420 self.assertIs(spec.loader_state, None)
421 self.assertIs(spec.submodule_search_locations, None)
422 self.assertIs(spec.cached, None)
423 self.assertFalse(spec.has_location)
424
425 def test_spec_from_loader_is_package_true(self):
426 spec = self.util.spec_from_loader(self.name, self.loader,
427 is_package=True)
428
429 self.assertEqual(spec.name, self.name)
430 self.assertEqual(spec.loader, self.loader)
431 self.assertIs(spec.origin, None)
432 self.assertIs(spec.loader_state, None)
433 self.assertEqual(spec.submodule_search_locations, [])
434 self.assertIs(spec.cached, None)
435 self.assertFalse(spec.has_location)
436
437 def test_spec_from_loader_origin_and_is_package(self):
438 origin = 'where the streets have no name'
439 spec = self.util.spec_from_loader(self.name, self.loader,
440 origin=origin, is_package=True)
441
442 self.assertEqual(spec.name, self.name)
443 self.assertEqual(spec.loader, self.loader)
444 self.assertIs(spec.origin, origin)
445 self.assertIs(spec.loader_state, None)
446 self.assertEqual(spec.submodule_search_locations, [])
447 self.assertIs(spec.cached, None)
448 self.assertFalse(spec.has_location)
449
450 def test_spec_from_loader_is_package_with_loader_false(self):
451 loader = TestLoader(is_package=False)
452 spec = self.util.spec_from_loader(self.name, loader)
453
454 self.assertEqual(spec.name, self.name)
455 self.assertEqual(spec.loader, loader)
456 self.assertIs(spec.origin, None)
457 self.assertIs(spec.loader_state, None)
458 self.assertIs(spec.submodule_search_locations, None)
459 self.assertIs(spec.cached, None)
460 self.assertFalse(spec.has_location)
461
462 def test_spec_from_loader_is_package_with_loader_true(self):
463 loader = TestLoader(is_package=True)
464 spec = self.util.spec_from_loader(self.name, loader)
465
466 self.assertEqual(spec.name, self.name)
467 self.assertEqual(spec.loader, loader)
468 self.assertIs(spec.origin, None)
469 self.assertIs(spec.loader_state, None)
470 self.assertEqual(spec.submodule_search_locations, [])
471 self.assertIs(spec.cached, None)
472 self.assertFalse(spec.has_location)
473
474 def test_spec_from_loader_default_with_file_loader(self):
475 spec = self.util.spec_from_loader(self.name, self.fileloader)
476
477 self.assertEqual(spec.name, self.name)
478 self.assertEqual(spec.loader, self.fileloader)
479 self.assertEqual(spec.origin, self.path)
480 self.assertIs(spec.loader_state, None)
481 self.assertIs(spec.submodule_search_locations, None)
482 self.assertEqual(spec.cached, self.cached)
483 self.assertTrue(spec.has_location)
484
485 def test_spec_from_loader_is_package_false_with_fileloader(self):
486 spec = self.util.spec_from_loader(self.name, self.fileloader,
487 is_package=False)
488
489 self.assertEqual(spec.name, self.name)
490 self.assertEqual(spec.loader, self.fileloader)
491 self.assertEqual(spec.origin, self.path)
492 self.assertIs(spec.loader_state, None)
493 self.assertIs(spec.submodule_search_locations, None)
494 self.assertEqual(spec.cached, self.cached)
495 self.assertTrue(spec.has_location)
496
497 def test_spec_from_loader_is_package_true_with_fileloader(self):
498 spec = self.util.spec_from_loader(self.name, self.fileloader,
499 is_package=True)
500
501 self.assertEqual(spec.name, self.name)
502 self.assertEqual(spec.loader, self.fileloader)
503 self.assertEqual(spec.origin, self.path)
504 self.assertIs(spec.loader_state, None)
505 self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
506 self.assertEqual(spec.cached, self.cached)
507 self.assertTrue(spec.has_location)
508
509 # spec_from_file_location()
510
511 def test_spec_from_file_location_default(self):
512 spec = self.util.spec_from_file_location(self.name, self.path)
513
514 self.assertEqual(spec.name, self.name)
515 # Need to use a circuitous route to get at importlib.machinery to make
516 # sure the same class object is used in the isinstance() check as
517 # would have been used to create the loader.
518 SourceFileLoader = self.util.spec_from_file_location.__globals__['SourceFileLoader']
519 self.assertIsInstance(spec.loader, SourceFileLoader)
520 self.assertEqual(spec.loader.name, self.name)
521 self.assertEqual(spec.loader.path, self.path)
522 self.assertEqual(spec.origin, self.path)
523 self.assertIs(spec.loader_state, None)
524 self.assertIs(spec.submodule_search_locations, None)
525 self.assertEqual(spec.cached, self.cached)
526 self.assertTrue(spec.has_location)
527
528 def test_spec_from_file_location_path_like_arg(self):
529 spec = self.util.spec_from_file_location(self.name,
530 pathlib.PurePath(self.path))
531 self.assertEqual(spec.origin, self.path)
532
533 def test_spec_from_file_location_default_without_location(self):
534 spec = self.util.spec_from_file_location(self.name)
535
536 self.assertIs(spec, None)
537
538 def test_spec_from_file_location_default_bad_suffix(self):
539 spec = self.util.spec_from_file_location(self.name, 'spam.eggs')
540
541 self.assertIs(spec, None)
542
543 def test_spec_from_file_location_loader_no_location(self):
544 spec = self.util.spec_from_file_location(self.name,
545 loader=self.fileloader)
546
547 self.assertEqual(spec.name, self.name)
548 self.assertEqual(spec.loader, self.fileloader)
549 self.assertEqual(spec.origin, self.path)
550 self.assertIs(spec.loader_state, None)
551 self.assertIs(spec.submodule_search_locations, None)
552 self.assertEqual(spec.cached, self.cached)
553 self.assertTrue(spec.has_location)
554
555 def test_spec_from_file_location_loader_no_location_no_get_filename(self):
556 spec = self.util.spec_from_file_location(self.name,
557 loader=self.loader)
558
559 self.assertEqual(spec.name, self.name)
560 self.assertEqual(spec.loader, self.loader)
561 self.assertEqual(spec.origin, '<unknown>')
562 self.assertIs(spec.loader_state, None)
563 self.assertIs(spec.submodule_search_locations, None)
564 self.assertIs(spec.cached, None)
565 self.assertTrue(spec.has_location)
566
567 def test_spec_from_file_location_loader_no_location_bad_get_filename(self):
568 class ESC[4;38;5;81mLoader:
569 def get_filename(self, name):
570 raise ImportError
571 loader = Loader()
572 spec = self.util.spec_from_file_location(self.name, loader=loader)
573
574 self.assertEqual(spec.name, self.name)
575 self.assertEqual(spec.loader, loader)
576 self.assertEqual(spec.origin, '<unknown>')
577 self.assertIs(spec.loader_state, None)
578 self.assertIs(spec.submodule_search_locations, None)
579 self.assertIs(spec.cached, None)
580 self.assertTrue(spec.has_location)
581
582 def test_spec_from_file_location_smsl_none(self):
583 spec = self.util.spec_from_file_location(self.name, self.path,
584 loader=self.fileloader,
585 submodule_search_locations=None)
586
587 self.assertEqual(spec.name, self.name)
588 self.assertEqual(spec.loader, self.fileloader)
589 self.assertEqual(spec.origin, self.path)
590 self.assertIs(spec.loader_state, None)
591 self.assertIs(spec.submodule_search_locations, None)
592 self.assertEqual(spec.cached, self.cached)
593 self.assertTrue(spec.has_location)
594
595 def test_spec_from_file_location_smsl_empty(self):
596 spec = self.util.spec_from_file_location(self.name, self.path,
597 loader=self.fileloader,
598 submodule_search_locations=[])
599
600 self.assertEqual(spec.name, self.name)
601 self.assertEqual(spec.loader, self.fileloader)
602 self.assertEqual(spec.origin, self.path)
603 self.assertIs(spec.loader_state, None)
604 self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
605 self.assertEqual(spec.cached, self.cached)
606 self.assertTrue(spec.has_location)
607
608 def test_spec_from_file_location_smsl_not_empty(self):
609 spec = self.util.spec_from_file_location(self.name, self.path,
610 loader=self.fileloader,
611 submodule_search_locations=['eggs'])
612
613 self.assertEqual(spec.name, self.name)
614 self.assertEqual(spec.loader, self.fileloader)
615 self.assertEqual(spec.origin, self.path)
616 self.assertIs(spec.loader_state, None)
617 self.assertEqual(spec.submodule_search_locations, ['eggs'])
618 self.assertEqual(spec.cached, self.cached)
619 self.assertTrue(spec.has_location)
620
621 def test_spec_from_file_location_smsl_default(self):
622 spec = self.util.spec_from_file_location(self.name, self.path,
623 loader=self.pkgloader)
624
625 self.assertEqual(spec.name, self.name)
626 self.assertEqual(spec.loader, self.pkgloader)
627 self.assertEqual(spec.origin, self.path)
628 self.assertIs(spec.loader_state, None)
629 self.assertEqual(spec.submodule_search_locations, [os.getcwd()])
630 self.assertEqual(spec.cached, self.cached)
631 self.assertTrue(spec.has_location)
632
633 def test_spec_from_file_location_smsl_default_not_package(self):
634 class ESC[4;38;5;81mLoader:
635 def is_package(self, name):
636 return False
637 loader = Loader()
638 spec = self.util.spec_from_file_location(self.name, self.path,
639 loader=loader)
640
641 self.assertEqual(spec.name, self.name)
642 self.assertEqual(spec.loader, loader)
643 self.assertEqual(spec.origin, self.path)
644 self.assertIs(spec.loader_state, None)
645 self.assertIs(spec.submodule_search_locations, None)
646 self.assertEqual(spec.cached, self.cached)
647 self.assertTrue(spec.has_location)
648
649 def test_spec_from_file_location_smsl_default_no_is_package(self):
650 spec = self.util.spec_from_file_location(self.name, self.path,
651 loader=self.fileloader)
652
653 self.assertEqual(spec.name, self.name)
654 self.assertEqual(spec.loader, self.fileloader)
655 self.assertEqual(spec.origin, self.path)
656 self.assertIs(spec.loader_state, None)
657 self.assertIs(spec.submodule_search_locations, None)
658 self.assertEqual(spec.cached, self.cached)
659 self.assertTrue(spec.has_location)
660
661 def test_spec_from_file_location_smsl_default_bad_is_package(self):
662 class ESC[4;38;5;81mLoader:
663 def is_package(self, name):
664 raise ImportError
665 loader = Loader()
666 spec = self.util.spec_from_file_location(self.name, self.path,
667 loader=loader)
668
669 self.assertEqual(spec.name, self.name)
670 self.assertEqual(spec.loader, loader)
671 self.assertEqual(spec.origin, self.path)
672 self.assertIs(spec.loader_state, None)
673 self.assertIs(spec.submodule_search_locations, None)
674 self.assertEqual(spec.cached, self.cached)
675 self.assertTrue(spec.has_location)
676
677 def test_spec_from_file_location_relative_path(self):
678 spec = self.util.spec_from_file_location(self.name,
679 os.path.basename(self.path), loader=self.fileloader)
680
681 self.assertEqual(spec.name, self.name)
682 self.assertEqual(spec.loader, self.fileloader)
683 self.assertEqual(spec.origin, self.path)
684 self.assertIs(spec.loader_state, None)
685 self.assertIs(spec.submodule_search_locations, None)
686 self.assertEqual(spec.cached, self.cached)
687 self.assertTrue(spec.has_location)
688
689 (Frozen_FactoryTests,
690 Source_FactoryTests
691 ) = test_util.test_both(FactoryTests, util=util, machinery=machinery)
692
693
694 if __name__ == '__main__':
695 unittest.main()