Example #1
0
        private static void InsertIntoSwitchCase(
            CoverageInfo info, XElement node, LanguageSupport support, string relativePath)
        {
            var analyzer         = support.AstAnalyzer;
            var startSwitchIndex = info.TargetGroups.Count;
            var switchNodes      = analyzer.FindSwitches(node);

            foreach (var switchNode in switchNodes.ToList())
            {
                var caseElements = new List <CoverageElement>();
                var caseNodes    = analyzer.FindCaseLabelTails(switchNode);
                foreach (var caseNode in caseNodes.ToList())
                {
                    // ステートメントに測定用コードを埋め込む
                    support.AstTransformer.InsertStatementAfter(
                        caseNode, info.Targets.Count, Done, ElementType.SwitchCase);
                    // カバレッジ情報を生成
                    var covElem = new CoverageElement(relativePath, caseNode, support.Tagger);
                    info.Targets.Add(covElem);
                    caseElements.Add(covElem);
                }
                // switchのカバレッジ情報を生成
                var element = new CoverageElement(relativePath, switchNode, support.Tagger);
                // 条件分岐と論理項のカバレッジ情報をまとめる
                var elementGroup = new CoverageElementGroup(element, caseElements);
                info.TargetGroups.Add(elementGroup);
            }
            info.SwitchRanges.Add(Tuple.Create(startSwitchIndex, info.TargetGroups.Count));
        }
Example #2
0
        private static void InsertIntoBnrachAndComparison(
            CoverageInfo info, XElement root, LanguageSupport support, string relativePath)
        {
            var analyzer                  = support.AstAnalyzer;
            var branchNodes               = analyzer.FindBranches(root);
            var startBranchIndex          = info.Targets.Count;
            var startBranchConditionIndex = info.TargetGroups.Count;

            foreach (var branchNode in branchNodes.ToList())
            {
                // 全ての論理項を列挙
                var condNodeList = analyzer.FindConditions(branchNode).ToList();
                // 論理項に測定用コードを埋め込み,カバレッジ情報を生成
                var condElements = InsertIntoConditionCoverage(info, condNodeList, support,
                                                               relativePath);

                // 条件分岐のカバレッジ情報を生成
                var element = new CoverageElement(relativePath, branchNode, support.Tagger);
                // 条件分岐と論理項のカバレッジ情報をまとめる
                var elementGroup = new CoverageElementGroup(element, condElements);
                info.TargetGroups.Add(elementGroup);

                // 論理項を含む条件式か否かを判断
                support.AstTransformer.InsertPredicate(
                    branchNode, info.Targets.Count,
                    elementGroup.Targets.Count > 0
                                ? ElementType.Decision
                                : ElementType.DecisionAndCondition);
                info.Targets.Add(element);
            }
            info.BranchConditionRanges.Add(Tuple.Create(startBranchConditionIndex,
                                                        info.TargetGroups.Count));
            info.BranchRanges.Add(Tuple.Create(startBranchIndex, info.Targets.Count));
        }
Example #3
0
        private static void InsertIntoForeach(
            CoverageInfo info, XElement node, LanguageSupport support, string relativePath)
        {
            var startBranchIndex          = info.Targets.Count;
            var startBranchConditionIndex = info.TargetGroups.Count;
            var analyzer     = support.AstAnalyzer;
            var transformer  = support.AstTransformer;
            var foreachNodes = analyzer.FindForeach(node);

            foreach (var foreachNode in foreachNodes.ToList())
            {
                // ステートメントに測定用コードを埋め込む
                var head = analyzer.FindForeachHead(foreachNode).First();
                var tail = analyzer.FindForeachTail(foreachNode).First();
                // 同じid( = count)を共有
                var id = info.Targets.Count;
                // Record(TrueOnly)    _lastState = TrueOnly
                // foreach() {
                //   Record(FalseOnly) ループ判定成立 (State |= FalseOnly)
                //   statement;
                //   Record(TrueOnly)  _lastState = TrueOnly
                // }
                // Record(TrueOnly)    ループ判定不成立 (State |= TrueOnly if _lastState == TrueOnly)
                transformer.InsertStatementBefore(
                    foreachNode, id, TrueOnly, ElementType.DecisionAndCondition);
                transformer.InsertStatementAfter(
                    head, id, FalseOnly, ElementType.DecisionAndCondition);
                transformer.InsertStatementBefore(
                    tail, id, TrueOnly, ElementType.DecisionAndCondition);
                transformer.InsertStatementAfter(
                    tail, id, TrueOnly, ElementType.DecisionAndCondition);
                // カバレッジ情報を生成
                var covElem = new ForeachCoverageElement(relativePath, foreachNode, support.Tagger);
                info.Targets.Add(covElem);
                var elementGroup = new CoverageElementGroup(covElem);
                info.TargetGroups.Add(elementGroup);
            }
            info.BranchRanges.Add(Tuple.Create(startBranchIndex, info.Targets.Count));
            info.BranchConditionRanges.Add(Tuple.Create(startBranchConditionIndex,
                                                        info.TargetGroups.Count));
        }