Python util.writeTestFiles函数代码示例

    def testLinkedReBuild(self):
        # test that changing which module is linked triggers a re-build
        linked_in_module_1 = util.writeTestFiles(util.Test_Trivial_Lib, True)
        linked_in_module_2 = util.writeTestFiles(util.Test_Trivial_Lib, True)
        test_module = util.writeTestFiles(util.Test_Testing_Trivial_Lib_Dep, True)

        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'link'], cwd=linked_in_module_1)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'link', 'test-trivial-lib'], cwd=test_module)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'build'], cwd=test_module)
        self.assertEqual(statuscode, 0)

        # check that rebuild is no-op
        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'build'], cwd=test_module)
        self.assertIn('no work to do', stdout+stderr)
        self.assertEqual(statuscode, 0)

        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'link'], cwd=linked_in_module_2)
        self.assertEqual(statuscode, 0)

        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'build'], cwd=test_module)
        self.assertNotIn('no work to do', stdout+stderr)
        self.assertEqual(statuscode, 0)

        util.rmRf(test_module)
        util.rmRf(linked_in_module_1)
        util.rmRf(linked_in_module_2)

 def test_noop_start(self):
     test_dir = util.writeTestFiles(util.Test_Trivial_Exe, True)
     util.writeTestFiles(_nopStartTargetDescription('start-test-target'), test_dir=os.path.join(test_dir, 'yotta_targets', 'start-test-target'))
     output = util.runCheckCommand(['--target', 'start-test-target', 'build'], test_dir)
     output = util.runCheckCommand(['--target', 'start-test-target', 'start'], test_dir)
     self.assertIn('would start source/test-trivial-exe', output)
     util.rmRf(test_dir)

    def test_notfound_start(self):
        test_dir = util.writeTestFiles(util.Test_Trivial_Exe, True)
        target_descr = _nopStartTargetDescription('start-test-target')
        del target_descr['./scripts/nop.py']
        util.writeTestFiles(target_descr, test_dir=os.path.join(test_dir, 'yotta_targets', 'start-test-target'))

        # in this case, without the script present we expect a failure
        output = util.runCheckCommand(['--target', 'start-test-target', 'build'], test_dir)
        stdout, stderr, statuscode = cli.run(['--target', 'start-test-target', 'start'], cwd=test_dir)
        self.assertNotEqual(statuscode, 0)
        util.rmRf(test_dir)

    def testTargetLinkedBuild(self):
        linked_in_target = util.writeTestFiles(util.getNativeTargetDescription(), True)
        test_module = util.writeTestFiles(util.Test_Testing_Trivial_Lib_Dep_Preinstalled, True)

        stdout, stderr, statuscode = cli.run(['-t', 'test-native-target', '--plain', 'link-target'], cwd=linked_in_target)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', 'test-native-target', '--plain', 'link-target', 'test-native-target'], cwd=test_module)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', 'test-native-target', '--plain', 'build'], cwd=test_module)
        self.assertEqual(statuscode, 0)

        util.rmRf(test_module)
        util.rmRf(linked_in_target)

    def testLinkedBuild(self):
        linked_in_module = util.writeTestFiles(util.Test_Trivial_Lib, True)
        test_module = util.writeTestFiles(util.Test_Testing_Trivial_Lib_Dep, True)

        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'link'], cwd=linked_in_module)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'link', 'test-trivial-lib'], cwd=test_module)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'build'], cwd=test_module)
        self.assertEqual(statuscode, 0)

        util.rmRf(test_module)
        util.rmRf(linked_in_module)

    def testUnlinkModule(self):
        linked_in_module = util.writeTestFiles(util.Test_Trivial_Lib, True)
        test_module = util.writeTestFiles(util.Test_Testing_Trivial_Lib_Dep, True)

        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'link'], cwd=linked_in_module)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'link', 'test-trivial-lib'], cwd=test_module)
        self.assertEqual(statuscode, 0)
        self.assertTrue(os.path.exists(os.path.join(test_module, 'yotta_modules', 'test-trivial-lib')))
        stdout, stderr, statuscode = cli.run(['-t', util.nativeTarget(), '--plain', 'unlink', 'test-trivial-lib'], cwd=test_module)
        self.assertEqual(statuscode, 0)
        self.assertTrue(not os.path.exists(os.path.join(test_module, 'yotta_modules', 'test-trivial-lib')))

        util.rmRf(test_module)
        util.rmRf(linked_in_module)

    def testUnlinkTarget(self):
        linked_in_target = util.writeTestFiles(util.getNativeTargetDescription(), True)
        test_module = util.writeTestFiles(util.Test_Testing_Trivial_Lib_Dep_Preinstalled, True)

        stdout, stderr, statuscode = cli.run(['-t', 'test-native-target', '--plain', 'link-target'], cwd=linked_in_target)
        self.assertEqual(statuscode, 0)
        stdout, stderr, statuscode = cli.run(['-t', 'test-native-target', '--plain', 'link-target', 'test-native-target'], cwd=test_module)
        self.assertEqual(statuscode, 0)
        self.assertTrue(os.path.exists(os.path.join(test_module, 'yotta_targets', 'test-native-target')))
        stdout, stderr, statuscode = cli.run(['-t', 'test-native-target', '--plain', 'unlink-target', 'test-native-target'], cwd=test_module)
        self.assertEqual(statuscode, 0)
        self.assertTrue(not os.path.exists(os.path.join(test_module, 'yotta_targets', 'test-native-target')))

        util.rmRf(test_module)
        util.rmRf(linked_in_target)

    def generatedTestMethod(self):
        test_dir = util.writeTestFiles(filesForReporterTest(**kwargs), test_dir=self.test_dir)

        # build first, to make test timing more accurate:
        stdout, stderr, statuscode = cli.run(['--target', systemDefaultTarget(), 'build'], cwd=test_dir)
        #print('build:', stdout)
        #print('build:', stderr)
        #print('build statuscode was:', statuscode)
        self.assertEqual(statuscode, 0)

        tstart = time.time()
        stdout, stderr, statuscode = cli.run(['-vvv', '--target', systemDefaultTarget(), 'test'], cwd=test_dir)
        duration = time.time() - tstart

        # useful output for debugging failed tests:
        if bool(statuscode) == bool(kwargs['test_passes']) or \
                duration >= 5.5 + kwargs['reporter_waits'] or \
                (kwargs['test_speed'] == 'fast' and (duration >= 1.5 + kwargs['reporter_waits'])):
            print(stdout + stderr)
            print(statuscode)
            print('duration:', duration)

        if kwargs['test_passes']:
            self.assertEqual(statuscode, 0)
        else:
            self.assertNotEqual(statuscode, 0)

        # **no** tests should cause a timeout (Which is set at 4.5 seconds in
        # the test reporter), + the wait-for duration (+ 1 second slack for
        # process startup etc.)
        self.assertTrue(duration < 5.5 + kwargs['reporter_waits'])

        # if a test isn't slow, then it should run in less than 1 seconds
        if kwargs['test_speed'] == 'fast':
            self.assertTrue(duration < 1.5 + kwargs['reporter_waits'])

    def test_targetAppConfigMerge(self):
        test_dir = util.writeTestFiles(Test_Target_Config_Merge_App, True)

        os.chdir(test_dir)
        c = validate.currentDirectoryModule()
        target, errors = c.satisfyTarget('bar,')
        merged_config = target.getMergedConfig()

        self.assertIn("foo", merged_config)
        self.assertIn("bar", merged_config)
        self.assertIn("new", merged_config)
        self.assertIn("a", merged_config['foo'])
        self.assertIn("b", merged_config['foo'])
        self.assertIn("c", merged_config['foo'])
        self.assertEqual(merged_config['foo']['a'], 321)
        self.assertEqual(merged_config['foo']['b'], 456)
        self.assertEqual(merged_config['foo']['c'], 112233)
        self.assertIn("bar", merged_config)
        self.assertIn("d", merged_config['bar'])
        self.assertEqual(merged_config['bar']['d'], "ghi")
        self.assertIn("new", merged_config)
        self.assertEqual(merged_config['new'], 123)

        os.chdir(self.restore_cwd)
        util.rmRf(test_dir)

 def test_postInstall_topLevel(self):
     test_dir = util.writeTestFiles({})
     self.runCheckCommand(['--target', util.nativeTarget(), 'install', 'test-post-install'], test_dir)
     output = self.runCheckCommand(['--target', util.nativeTarget(), 'build'], os.path.join(test_dir, 'test-post-install'))
     self.assertIn('post-install generated file compiled', output)
     self.assertIn('post-install generated header file included', output)
     self.assertIn('generated .cmake file included', output)

 def test_binNonExistent(self):
     test_dir = util.writeTestFiles(Test_Bin_Nonexistent)
     stdout, stderr, statuscode = cli.run(['--target', util.nativeTarget(), 'build'], cwd=test_dir)
     self.assertIn('directory "doesntexist" doesn\'t exist', stdout+stderr)
     # !!! FIXME: should this error be fatal?
     # self.assertNotEqual(statuscode, 0)
     util.rmRf(test_dir)

 def testMissingDependenciesShrinkwrap(self):
     test_dir = util.writeTestFiles(Test_Shrinkwrap_Missing_Dependency, True)
     stdout, stderr, statuscode = cli.run(['-t', Test_Target, '--plain', 'shrinkwrap'], cwd=test_dir)
     self.assertNotEqual(statuscode, 0)
     self.assertFalse(os.path.exists(os.path.join(test_dir, 'yotta-shrinkwrap.json')))
     self.assertIn('is missing', stdout+stderr)
     util.rmRf(test_dir)

 def testUnlinkTargetGlobally(self):
     test_target = util.writeTestFiles(util.getNativeTargetDescription(), True)
     stdout, stderr, statuscode = cli.run(['-t', Test_Target, '--plain', 'link-target'], cwd=test_target)
     self.assertEqual(statuscode, 0)
     stdout, stderr, statuscode = cli.run(['-t', Test_Target, '--plain', 'unlink-target'], cwd=test_target)
     self.assertEqual(statuscode, 0)
     util.rmRf(test_target)

 def testUnlinkModuleGlobally(self):
     test_module = util.writeTestFiles(util.Test_Testing_Trivial_Lib_Dep, True)
     stdout, stderr, statuscode = cli.run(['-t', Test_Target, '--plain', 'link'], cwd=test_module)
     self.assertEqual(statuscode, 0)
     stdout, stderr, statuscode = cli.run(['-t', Test_Target, '--plain', 'unlink'], cwd=test_module)
     self.assertEqual(statuscode, 0)
     util.rmRf(test_module)

    def test_outdated(self):
        path = util.writeTestFiles(Test_Outdated, True)

        stdout, stderr, statuscode = cli.run(['-t', 'x86-linux-native', 'outdated'], cwd=path)
        self.assertNotEqual(statuscode, 0)
        self.assertIn('test-testing-dummy', stdout + stderr)

        util.rmRf(path)