Пример #1
0
    def test_positive_02(self):
        "Three node digraph C -> B -> A"
        config = TestConfig()
        reqset = RequirementSet(config)
        req1 = Requirement('''Name: A
Type: master requirement
Solved by: B''', 'A', None, None, None)
        reqset.add_node(RequirementDNode(req1))
        req2 = Requirement('''Name: B
Type: requirement
Solved by: C''', 'B', None, None, None)
        reqset.add_node(RequirementDNode(req2))
        req3 = Requirement('''Name: C
Type: requirement''', 'C', None, None, None)
        reqset.add_node(RequirementDNode(req3))
        reqset.resolve_solved_by()
        reqset.find_master_nodes()

        reqset.graph_master_node = reqset.find("A")
        reqset.find("A").get_requirement().set_value("Factor", 1.0)
        reqset.find("B").get_requirement().set_value("Factor", 0.8)
        reqset.find("C").get_requirement().set_value("Factor", 0.5)

        rdep = RDepPriority(config)
        rdep.rewrite(reqset)

        assert (
            reqset.find("A").get_requirement().get_value("Priority") == 1.0)
        assert (
            reqset.find("B").get_requirement().get_value("Priority") == 0.8)

        assert (
            reqset.find("C").get_requirement().get_value("Priority") == 0.4)
Пример #2
0
    def __read_one_requirement(self, fileinfo, input_mods, object_cache):
        '''Read in one requirement from the file info.'''
        tracer.debug("Called.")
        # Check for correct filename
        if not fileinfo.get_filename().endswith(".req"):
            tracer.info("skipping file [%s]" % fileinfo.get_filename())
            return
        # Handle caching.
        vcs_id = fileinfo.get_vcs_id()
        rid = fileinfo.get_filename_sub_part()[:-4]
        req = object_cache.get("Requirement", vcs_id)
        tracer.info("Reading requirement [%s]" % rid)

        if req == None:
            file_content = fileinfo.get_content()
            req = Requirement(file_content, rid, fileinfo.get_filename(),
                              input_mods, self._config)
            # Add the requirement to the cache.
            object_cache.add(vcs_id, "Requirement", req)

        self._adapt_usablility(req)

        if req.is_usable():
            dnreq = RequirementDNode(req)
            # Store in the map, so that it is easy to access the
            # node by id.
            ### ToDo: needed            self._add_requirement(req)
            self.add_node(dnreq)
            # Also store it in the digraph's node list for simple
            # access to the digraph algorithms.
            # self.nodes.append(req)
        else:
            logger.error(LogFormatter.format(45, "could not be parsed",
                                             req.id))
        tracer.debug("Finished.")
Пример #3
0
    def test_neg_02(self):
        "LaTeX output: check invalid tag in requirement output config"

        tcfg = TestConfig()
        tcfg.set_output_cfg()

        tvcs = TestVCS(tcfg)
        tfile = tvcs.get_tfile1()

        tmpdir = create_tmp_dir()
        mconfig = { "req_attributes": ["Status", "Class", "DoesNotExists"],
                    "output_filename": os.path.join(tmpdir, "TestLateX2Out.tex")}

        l2 = latex2(mconfig)
        req = Requirement(None, "TestReq", None, None, None)
        req.values = {}
        req.values["Name"] = RecordEntry("Name", "my name")
        req.values["Type"] = Requirement.rt_requirement
        req.values["Description"] = RecordEntry("Description", "my desc")
        req.values["Status"] = RequirementStatusFinished(
                None, "rid", "finished:meiner:2011-04-15:4h")
        req.values["Class"] = ClassTypeImplementable()

        dnreq = RequirementDNode(req)

        ce3set = CE3Set()
        ce3 = CE3()
        ce3set.insert("TestReq", ce3)

        rset = RequirementSet(tcfg)
        ttopic_set = TestTopicSet(rset)

        try:
            l2.topic_set_pre(None)
            dnreq.execute(l2, "")
            assert(False)
        except RMTException, rmte:
            pass