Debian Codegraph @

Lib/test/test_importlib/test_spec.py

raw
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 TestLoader:
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 NewLoader(TestLoader):
43
44 EGGS = 1
45
46 def exec_module(self, module):
47 module.eggs = self.EGGS
48
49
50 class ModuleSpecTests:
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 ModuleSpecMethodsTests:
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.assertNotHasAttr(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 ReplacingLoader(TestLoader):
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 FailedLoader(TestLoader):
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 FailedLoader(TestLoader):
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 ImmutableLoader(TestLoader):
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.assertNotHasAttr(loaded, '__path__')
352 self.assertNotHasAttr(loaded, '__file__')
353 self.assertNotHasAttr(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 FactoryTests:
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 Loader:
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 location = cwd if (cwd := os.getcwd()) != '/' else ''
506 self.assertEqual(spec.submodule_search_locations, [location])
507 self.assertEqual(spec.cached, self.cached)
508 self.assertTrue(spec.has_location)
509
510 # spec_from_file_location()
511
512 def test_spec_from_file_location_default(self):
513 spec = self.util.spec_from_file_location(self.name, self.path)
514
515 self.assertEqual(spec.name, self.name)
516 # Need to use a circuitous route to get at importlib.machinery to make
517 # sure the same class object is used in the isinstance() check as
518 # would have been used to create the loader.
519 SourceFileLoader = self.util.spec_from_file_location.__globals__['SourceFileLoader']
520 self.assertIsInstance(spec.loader, SourceFileLoader)
521 self.assertEqual(spec.loader.name, self.name)
522 self.assertEqual(spec.loader.path, self.path)
523 self.assertEqual(spec.origin, self.path)
524 self.assertIs(spec.loader_state, None)
525 self.assertIs(spec.submodule_search_locations, None)
526 self.assertEqual(spec.cached, self.cached)
527 self.assertTrue(spec.has_location)
528
529 def test_spec_from_file_location_path_like_arg(self):
530 spec = self.util.spec_from_file_location(self.name,
531 pathlib.PurePath(self.path))
532 self.assertEqual(spec.origin, self.path)
533
534 def test_spec_from_file_location_default_without_location(self):
535 spec = self.util.spec_from_file_location(self.name)
536
537 self.assertIs(spec, None)
538
539 def test_spec_from_file_location_default_bad_suffix(self):
540 spec = self.util.spec_from_file_location(self.name, 'spam.eggs')
541
542 self.assertIs(spec, None)
543
544 def test_spec_from_file_location_loader_no_location(self):
545 spec = self.util.spec_from_file_location(self.name,
546 loader=self.fileloader)
547
548 self.assertEqual(spec.name, self.name)
549 self.assertEqual(spec.loader, self.fileloader)
550 self.assertEqual(spec.origin, self.path)
551 self.assertIs(spec.loader_state, None)
552 self.assertIs(spec.submodule_search_locations, None)
553 self.assertEqual(spec.cached, self.cached)
554 self.assertTrue(spec.has_location)
555
556 def test_spec_from_file_location_loader_no_location_no_get_filename(self):
557 spec = self.util.spec_from_file_location(self.name,
558 loader=self.loader)
559
560 self.assertEqual(spec.name, self.name)
561 self.assertEqual(spec.loader, self.loader)
562 self.assertEqual(spec.origin, '<unknown>')
563 self.assertIs(spec.loader_state, None)
564 self.assertIs(spec.submodule_search_locations, None)
565 self.assertIs(spec.cached, None)
566 self.assertTrue(spec.has_location)
567
568 def test_spec_from_file_location_loader_no_location_bad_get_filename(self):
569 class Loader:
570 def get_filename(self, name):
571 raise ImportError
572 loader = Loader()
573 spec = self.util.spec_from_file_location(self.name, loader=loader)
574
575 self.assertEqual(spec.name, self.name)
576 self.assertEqual(spec.loader, loader)
577 self.assertEqual(spec.origin, '<unknown>')
578 self.assertIs(spec.loader_state, None)
579 self.assertIs(spec.submodule_search_locations, None)
580 self.assertIs(spec.cached, None)
581 self.assertTrue(spec.has_location)
582
583 def test_spec_from_file_location_smsl_none(self):
584 spec = self.util.spec_from_file_location(self.name, self.path,
585 loader=self.fileloader,
586 submodule_search_locations=None)
587
588 self.assertEqual(spec.name, self.name)
589 self.assertEqual(spec.loader, self.fileloader)
590 self.assertEqual(spec.origin, self.path)
591 self.assertIs(spec.loader_state, None)
592 self.assertIs(spec.submodule_search_locations, None)
593 self.assertEqual(spec.cached, self.cached)
594 self.assertTrue(spec.has_location)
595
596 def test_spec_from_file_location_smsl_empty(self):
597 spec = self.util.spec_from_file_location(self.name, self.path,
598 loader=self.fileloader,
599 submodule_search_locations=[])
600
601 self.assertEqual(spec.name, self.name)
602 self.assertEqual(spec.loader, self.fileloader)
603 self.assertEqual(spec.origin, self.path)
604 self.assertIs(spec.loader_state, None)
605 location = cwd if (cwd := os.getcwd()) != '/' else ''
606 self.assertEqual(spec.submodule_search_locations, [location])
607 self.assertEqual(spec.cached, self.cached)
608 self.assertTrue(spec.has_location)
609
610 def test_spec_from_file_location_smsl_not_empty(self):
611 spec = self.util.spec_from_file_location(self.name, self.path,
612 loader=self.fileloader,
613 submodule_search_locations=['eggs'])
614
615 self.assertEqual(spec.name, self.name)
616 self.assertEqual(spec.loader, self.fileloader)
617 self.assertEqual(spec.origin, self.path)
618 self.assertIs(spec.loader_state, None)
619 self.assertEqual(spec.submodule_search_locations, ['eggs'])
620 self.assertEqual(spec.cached, self.cached)
621 self.assertTrue(spec.has_location)
622
623 def test_spec_from_file_location_smsl_default(self):
624 spec = self.util.spec_from_file_location(self.name, self.path,
625 loader=self.pkgloader)
626
627 self.assertEqual(spec.name, self.name)
628 self.assertEqual(spec.loader, self.pkgloader)
629 self.assertEqual(spec.origin, self.path)
630 self.assertIs(spec.loader_state, None)
631 location = cwd if (cwd := os.getcwd()) != '/' else ''
632 self.assertEqual(spec.submodule_search_locations, [location])
633 self.assertEqual(spec.cached, self.cached)
634 self.assertTrue(spec.has_location)
635
636 def test_spec_from_file_location_smsl_default_not_package(self):
637 class Loader:
638 def is_package(self, name):
639 return False
640 loader = Loader()
641 spec = self.util.spec_from_file_location(self.name, self.path,
642 loader=loader)
643
644 self.assertEqual(spec.name, self.name)
645 self.assertEqual(spec.loader, loader)
646 self.assertEqual(spec.origin, self.path)
647 self.assertIs(spec.loader_state, None)
648 self.assertIs(spec.submodule_search_locations, None)
649 self.assertEqual(spec.cached, self.cached)
650 self.assertTrue(spec.has_location)
651
652 def test_spec_from_file_location_smsl_default_no_is_package(self):
653 spec = self.util.spec_from_file_location(self.name, self.path,
654 loader=self.fileloader)
655
656 self.assertEqual(spec.name, self.name)
657 self.assertEqual(spec.loader, self.fileloader)
658 self.assertEqual(spec.origin, self.path)
659 self.assertIs(spec.loader_state, None)
660 self.assertIs(spec.submodule_search_locations, None)
661 self.assertEqual(spec.cached, self.cached)
662 self.assertTrue(spec.has_location)
663
664 def test_spec_from_file_location_smsl_default_bad_is_package(self):
665 class Loader:
666 def is_package(self, name):
667 raise ImportError
668 loader = Loader()
669 spec = self.util.spec_from_file_location(self.name, self.path,
670 loader=loader)
671
672 self.assertEqual(spec.name, self.name)
673 self.assertEqual(spec.loader, loader)
674 self.assertEqual(spec.origin, self.path)
675 self.assertIs(spec.loader_state, None)
676 self.assertIs(spec.submodule_search_locations, None)
677 self.assertEqual(spec.cached, self.cached)
678 self.assertTrue(spec.has_location)
679
680 def test_spec_from_file_location_relative_path(self):
681 spec = self.util.spec_from_file_location(self.name,
682 os.path.basename(self.path), loader=self.fileloader)
683
684 self.assertEqual(spec.name, self.name)
685 self.assertEqual(spec.loader, self.fileloader)
686 self.assertEqual(spec.origin, self.path)
687 self.assertIs(spec.loader_state, None)
688 self.assertIs(spec.submodule_search_locations, None)
689 self.assertEqual(spec.cached, self.cached)
690 self.assertTrue(spec.has_location)
691
692 (Frozen_FactoryTests,
693 Source_FactoryTests
694 ) = test_util.test_both(FactoryTests, util=util, machinery=machinery)
695
696
697 if __name__ == '__main__':
698 unittest.main()