19313674688

Committed 12 Nov 2025 10:19PM UTC coverage: 81.831% (-2.2%) from 84.026%

Build # 19313674688

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #79 from MeindertN/V1.6.0

jumping to V1.7.0

Run Details

2069 of 2635 branches covered (78.52%)

Branch coverage included in aggregate %.

1293 of 1710 new or added lines in 32 files covered. (75.61%)

17 existing lines in 5 files now uncovered.

6322 of 7619 relevant lines covered (82.98%)

189.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.75

/RoboClerk/PluginSupport/DataSourcePluginBase.cs

﻿using System;
using System.Collections.Generic;
using System.IO.Abstractions;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;

namespace RoboClerk
{
    public abstract class DataSourcePluginBase : PluginBase, IDataSourcePlugin
    {
        protected List<RequirementItem> systemRequirements = new List<RequirementItem>();
        protected List<RequirementItem> softwareRequirements = new List<RequirementItem>();
        protected List<RequirementItem> documentationRequirements = new List<RequirementItem>();
        protected List<SoftwareSystemTestItem> testCases = new List<SoftwareSystemTestItem>();
        protected List<AnomalyItem> anomalies = new List<AnomalyItem>();
        protected List<RiskItem> risks = new List<RiskItem>();
        protected List<SOUPItem> soup = new List<SOUPItem>();
        protected List<DocContentItem> docContents = new List<DocContentItem>();
        protected List<UnitTestItem> unitTests = new List<UnitTestItem>();
        protected List<ExternalDependency> dependencies = new List<ExternalDependency>();
        protected List<TestResult> testResults = new List<TestResult>();
        //we also keep track of any items that have been eliminated
        protected List<EliminatedRequirementItem> eliminatedSystemRequirements = new List<EliminatedRequirementItem>();
        protected List<EliminatedRequirementItem> eliminatedSoftwareRequirements = new List<EliminatedRequirementItem>();
        protected List<EliminatedRequirementItem> eliminatedDocumentationRequirements = new List<EliminatedRequirementItem>();
        protected List<EliminatedSoftwareSystemTestItem> eliminatedSoftwareSystemTests = new List<EliminatedSoftwareSystemTestItem>();
        protected List<EliminatedRiskItem> eliminatedRisks = new List<EliminatedRiskItem>();
        protected List<EliminatedDocContentItem> eliminatedDocContents = new List<EliminatedDocContentItem>();
        protected List<EliminatedSOUPItem> eliminatedSOUP = new List<EliminatedSOUPItem>();
        protected List<EliminatedAnomalyItem> eliminatedAnomalies = new List<EliminatedAnomalyItem>();
        protected List<EliminatedTestResult> eliminatedTestResults = new List<EliminatedTestResult>();
        protected List<EliminatedUnitTestItem> eliminatedUnitTests = new List<EliminatedUnitTestItem>();

        public DataSourcePluginBase(IFileSystem fileSystem)
            :base(fileSystem)
        {

        }

        public abstract void RefreshItems();

        public IEnumerable<AnomalyItem> GetAnomalies()
        {
            return anomalies;
        }

        public IEnumerable<RequirementItem> GetSystemRequirements()
        {
            return systemRequirements;
        }

        public IEnumerable<RequirementItem> GetSoftwareRequirements()
        {
            return softwareRequirements;
        }

        public IEnumerable<RequirementItem> GetDocumentationRequirements()
        {
            return documentationRequirements;
        }

        public IEnumerable<DocContentItem> GetDocContents()
        {
            return docContents;
        }

        public IEnumerable<SoftwareSystemTestItem> GetSoftwareSystemTests()
        {
            return testCases;
        }

        public IEnumerable<RiskItem> GetRisks()
        {
            return risks;
        }

        public IEnumerable<SOUPItem> GetSOUP()
        {
            return soup;
        }

        public IEnumerable<UnitTestItem> GetUnitTests()
        {
            return unitTests;
        }

        public IEnumerable<ExternalDependency> GetDependencies()
        {
            return dependencies;
        }

        public IEnumerable<TestResult> GetTestResults()
        {
            return testResults;
        }

        public IEnumerable<EliminatedRequirementItem> GetEliminatedSystemRequirements()
        {
            return eliminatedSystemRequirements;
        }

        public IEnumerable<EliminatedRequirementItem> GetEliminatedSoftwareRequirements()
        {
            return eliminatedSoftwareRequirements;
        }

        public IEnumerable<EliminatedRequirementItem> GetEliminatedDocumentationRequirements()
        {
            return eliminatedDocumentationRequirements;
        }

        public IEnumerable<EliminatedSoftwareSystemTestItem> GetEliminatedSoftwareSystemTests()
        {
            return eliminatedSoftwareSystemTests;
        }

        public IEnumerable<EliminatedRiskItem> GetEliminatedRisks()
        {
            return eliminatedRisks;
        }

        public IEnumerable<EliminatedDocContentItem> GetEliminatedDocContents()
        {
            return eliminatedDocContents;
        }

        public IEnumerable<EliminatedAnomalyItem> GetEliminatedAnomalies()
        {
            return eliminatedAnomalies;
        }

        public IEnumerable<EliminatedSOUPItem> GetEliminatedSOUP()
        {
            return eliminatedSOUP;
        }

        public IEnumerable<EliminatedTestResult> GetEliminatedTestResults()
        {
            return eliminatedTestResults;
        }

        public IEnumerable<EliminatedUnitTestItem> GetEliminatedUnitTests()
        {
            return eliminatedUnitTests;
        }

        protected void ClearAllItems()
        {
            systemRequirements.Clear();
            softwareRequirements.Clear();
            documentationRequirements.Clear();
            testCases.Clear();
            anomalies.Clear();
            risks.Clear();
            soup.Clear();
            docContents.Clear();
            unitTests.Clear();
            dependencies.Clear();
            testResults.Clear();
            eliminatedSystemRequirements.Clear();
            eliminatedSoftwareRequirements.Clear();
            eliminatedDocumentationRequirements.Clear();
            eliminatedSoftwareSystemTests.Clear();
            eliminatedSOUP.Clear();
            eliminatedRisks.Clear();
            eliminatedDocContents.Clear();
            eliminatedAnomalies.Clear();
            eliminatedTestResults.Clear();
            eliminatedUnitTests.Clear();
        }

        public void EliminateItem(string itemID, string reason, EliminationReason eliminationReason)
        {
            // Check system requirements
            var systemReq = systemRequirements.FirstOrDefault(item => item.ItemID == itemID);
            if (systemReq != null)
            {
                systemRequirements.Remove(systemReq);
                eliminatedSystemRequirements.Add(new EliminatedRequirementItem(systemReq, reason, eliminationReason));
                return;
            }

            // Check software requirements
            var softwareReq = softwareRequirements.FirstOrDefault(item => item.ItemID == itemID);
            if (softwareReq != null)
            {
                softwareRequirements.Remove(softwareReq);
                eliminatedSoftwareRequirements.Add(new EliminatedRequirementItem(softwareReq, reason, eliminationReason));
                return;
            }

            // Check documentation requirements
            var docReq = documentationRequirements.FirstOrDefault(item => item.ItemID == itemID);
            if (docReq != null)
            {
                documentationRequirements.Remove(docReq);
                eliminatedDocumentationRequirements.Add(new EliminatedRequirementItem(docReq, reason, eliminationReason));
                return;
            }

            // Check software system tests
            var testCase = testCases.FirstOrDefault(item => item.ItemID == itemID);
            if (testCase != null)
            {
                testCases.Remove(testCase);
                eliminatedSoftwareSystemTests.Add(new EliminatedSoftwareSystemTestItem(testCase, reason, eliminationReason));
                return;
            }

            // Check unit tests
            var unitTest = unitTests.FirstOrDefault(item => item.ItemID == itemID);
            if (unitTest != null)
            {
                unitTests.Remove(unitTest);
                eliminatedUnitTests.Add(new EliminatedUnitTestItem(unitTest, reason, eliminationReason));
                return;
            }

            // Check risks
            var risk = risks.FirstOrDefault(item => item.ItemID == itemID);
            if (risk != null)
            {
                risks.Remove(risk);
                eliminatedRisks.Add(new EliminatedRiskItem(risk, reason, eliminationReason));
                return;
            }

            // Check anomalies
            var anomaly = anomalies.FirstOrDefault(item => item.ItemID == itemID);
            if (anomaly != null)
            {
                anomalies.Remove(anomaly);
                eliminatedAnomalies.Add(new EliminatedAnomalyItem(anomaly, reason, eliminationReason));
                return;
            }

            // Check SOUP items
            var soupItem = soup.FirstOrDefault(item => item.ItemID == itemID);
            if (soupItem != null)
            {
                soup.Remove(soupItem);
                eliminatedSOUP.Add(new EliminatedSOUPItem(soupItem, reason, eliminationReason));
                return;
            }

            // Check doc content items
            var docContent = docContents.FirstOrDefault(item => item.ItemID == itemID);
            if (docContent != null)
            {
                docContents.Remove(docContent);
                eliminatedDocContents.Add(new EliminatedDocContentItem(docContent, reason, eliminationReason));
                return;
            }

            // Check test results
            var testResult = testResults.FirstOrDefault(item => item.ItemID == itemID);
            if (testResult != null)
            {
                testResults.Remove(testResult);
                eliminatedTestResults.Add(new EliminatedTestResult(testResult, reason, eliminationReason));
                return;
            }

            // If we reach here, the item was not found
            throw new ArgumentException($"Item with ID '{itemID}' not found in any item collection for plugin '{Name}'.");
        }

        protected string EscapeNonTablePipes(string text)
        {
            string tableBlockPattern = @"(?ms)(^\|===\s*$.*?^\|===\s*$)";

            // Use Regex.Split with a capturing group so that the table blocks are kept in the result.
            string[] segments = Regex.Split(text, tableBlockPattern);
            var sb = new StringBuilder();

            foreach (string segment in segments)
            {
                // If the segment itself matches our table block pattern, leave it unmodified.
                if (Regex.IsMatch(segment, @"(?ms)^\|===\s*$.*?^\|===\s*$"))
                {
                    sb.Append(segment);
                }
                else
                {
                    // Otherwise, escape any unescaped "|" in this segment.
                    string processed = Regex.Replace(segment, @"(?<!\\)\|", @"\|");
                    sb.Append(processed);
                }
            }
            return sb.ToString();
        }

        private void ScrubItemsFields<T>(IEnumerable<T> items)
        {
            foreach (var obj in items)
            {
                Type type = obj.GetType();
                PropertyInfo[] properties = type.GetProperties();

                foreach (PropertyInfo property in properties)
                {
                    if (property.PropertyType == typeof(string) && property.CanWrite)
                    {
                        string currentValue = (string)property.GetValue(obj);
                        if (currentValue != null)
                        {
                            // Escape pipes in non-table parts of the content.
                            string newValue = EscapeNonTablePipes(currentValue);
                            property.SetValue(obj, newValue);
                        }
                    }
                }
            }
        }

        // with the exception of docContent items, all other items are visualized
        // in tables and they need to escape the | character
        protected void ScrubItemContents()
        {
            ScrubItemsFields(systemRequirements);
            ScrubItemsFields(softwareRequirements);
            ScrubItemsFields(documentationRequirements);
            ScrubItemsFields(testCases);
            foreach (var testCase in testCases)
            {
                ScrubItemsFields(testCase.TestCaseSteps);
            }
            ScrubItemsFields(anomalies);
            ScrubItemsFields(risks);
            ScrubItemsFields(soup);
            ScrubItemsFields(unitTests);
            ScrubItemsFields(dependencies);
            ScrubItemsFields(testResults);
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.IO.Abstractions;
4	using System.Linq;
5	using System.Reflection;
6	using System.Text;
7	using System.Text.RegularExpressions;
8
9	namespace RoboClerk
10	{
11	public abstract class DataSourcePluginBase : PluginBase, IDataSourcePlugin
12	{
13	protected List<RequirementItem> systemRequirements = new List<RequirementItem>();	136✔
14	protected List<RequirementItem> softwareRequirements = new List<RequirementItem>();	136✔
15	protected List<RequirementItem> documentationRequirements = new List<RequirementItem>();	136✔
16	protected List<SoftwareSystemTestItem> testCases = new List<SoftwareSystemTestItem>();	136✔
17	protected List<AnomalyItem> anomalies = new List<AnomalyItem>();	136✔
18	protected List<RiskItem> risks = new List<RiskItem>();	136✔
19	protected List<SOUPItem> soup = new List<SOUPItem>();	136✔
20	protected List<DocContentItem> docContents = new List<DocContentItem>();	136✔
21	protected List<UnitTestItem> unitTests = new List<UnitTestItem>();	136✔
22	protected List<ExternalDependency> dependencies = new List<ExternalDependency>();	136✔
23	protected List<TestResult> testResults = new List<TestResult>();	136✔
24	//we also keep track of any items that have been eliminated
25	protected List<EliminatedRequirementItem> eliminatedSystemRequirements = new List<EliminatedRequirementItem>();	136✔
26	protected List<EliminatedRequirementItem> eliminatedSoftwareRequirements = new List<EliminatedRequirementItem>();	136✔
27	protected List<EliminatedRequirementItem> eliminatedDocumentationRequirements = new List<EliminatedRequirementItem>();	136✔
28	protected List<EliminatedSoftwareSystemTestItem> eliminatedSoftwareSystemTests = new List<EliminatedSoftwareSystemTestItem>();	136✔
29	protected List<EliminatedRiskItem> eliminatedRisks = new List<EliminatedRiskItem>();	136✔
30	protected List<EliminatedDocContentItem> eliminatedDocContents = new List<EliminatedDocContentItem>();	136✔
31	protected List<EliminatedSOUPItem> eliminatedSOUP = new List<EliminatedSOUPItem>();	136✔
32	protected List<EliminatedAnomalyItem> eliminatedAnomalies = new List<EliminatedAnomalyItem>();	136✔
33	protected List<EliminatedTestResult> eliminatedTestResults = new List<EliminatedTestResult>();	136✔
34	protected List<EliminatedUnitTestItem> eliminatedUnitTests = new List<EliminatedUnitTestItem>();	136✔
35
36	public DataSourcePluginBase(IFileSystem fileSystem)
37	:base(fileSystem)	136✔
38	{	136✔
39
40	}	136✔
41
42	public abstract void RefreshItems();
43
44	public IEnumerable<AnomalyItem> GetAnomalies()
45	{	4✔
46	return anomalies;	4✔
47	}	4✔
48
49	public IEnumerable<RequirementItem> GetSystemRequirements()
50	{	4✔
51	return systemRequirements;	4✔
52	}	4✔
53
54	public IEnumerable<RequirementItem> GetSoftwareRequirements()
55	{	4✔
56	return softwareRequirements;	4✔
57	}	4✔
58
59	public IEnumerable<RequirementItem> GetDocumentationRequirements()
60	{	4✔
61	return documentationRequirements;	4✔
62	}	4✔
63
64	public IEnumerable<DocContentItem> GetDocContents()
65	{	4✔
66	return docContents;	4✔
67	}	4✔
68
69	public IEnumerable<SoftwareSystemTestItem> GetSoftwareSystemTests()
70	{	15✔
71	return testCases;	15✔
72	}	15✔
73
74	public IEnumerable<RiskItem> GetRisks()
75	{	4✔
76	return risks;	4✔
77	}	4✔
78
79	public IEnumerable<SOUPItem> GetSOUP()
80	{	4✔
81	return soup;	4✔
82	}	4✔
83
84	public IEnumerable<UnitTestItem> GetUnitTests()
85	{	41✔
86	return unitTests;	41✔
87	}	41✔
88
89	public IEnumerable<ExternalDependency> GetDependencies()
90	{	×
91	return dependencies;	×
92	}	×
93
94	public IEnumerable<TestResult> GetTestResults()
95	{	10✔
96	return testResults;	10✔
97	}	10✔
98
99	public IEnumerable<EliminatedRequirementItem> GetEliminatedSystemRequirements()
100	{	4✔
101	return eliminatedSystemRequirements;	4✔
102	}	4✔
103
104	public IEnumerable<EliminatedRequirementItem> GetEliminatedSoftwareRequirements()
105	{	2✔
106	return eliminatedSoftwareRequirements;	2✔
107	}	2✔
108
109	public IEnumerable<EliminatedRequirementItem> GetEliminatedDocumentationRequirements()
110	{	2✔
111	return eliminatedDocumentationRequirements;	2✔
112	}	2✔
113
114	public IEnumerable<EliminatedSoftwareSystemTestItem> GetEliminatedSoftwareSystemTests()
115	{	2✔
116	return eliminatedSoftwareSystemTests;	2✔
117	}	2✔
118
119	public IEnumerable<EliminatedRiskItem> GetEliminatedRisks()
120	{	2✔
121	return eliminatedRisks;	2✔
122	}	2✔
123
124	public IEnumerable<EliminatedDocContentItem> GetEliminatedDocContents()
125	{	2✔
126	return eliminatedDocContents;	2✔
127	}	2✔
128
129	public IEnumerable<EliminatedAnomalyItem> GetEliminatedAnomalies()
130	{	4✔
131	return eliminatedAnomalies;	4✔
132	}	4✔
133
134	public IEnumerable<EliminatedSOUPItem> GetEliminatedSOUP()
135	{	2✔
136	return eliminatedSOUP;	2✔
137	}	2✔
138
139	public IEnumerable<EliminatedTestResult> GetEliminatedTestResults()
NEW 140	{	×
NEW 141	return eliminatedTestResults;	×
NEW 142	}	×
143
144	public IEnumerable<EliminatedUnitTestItem> GetEliminatedUnitTests()
NEW 145	{	×
NEW 146	return eliminatedUnitTests;	×
NEW 147	}	×
148
149	protected void ClearAllItems()
150	{	4✔
151	systemRequirements.Clear();	4✔
152	softwareRequirements.Clear();	4✔
153	documentationRequirements.Clear();	4✔
154	testCases.Clear();	4✔
155	anomalies.Clear();	4✔
156	risks.Clear();	4✔
157	soup.Clear();	4✔
158	docContents.Clear();	4✔
159	unitTests.Clear();	4✔
160	dependencies.Clear();	4✔
161	testResults.Clear();	4✔
162	eliminatedSystemRequirements.Clear();	4✔
163	eliminatedSoftwareRequirements.Clear();	4✔
164	eliminatedDocumentationRequirements.Clear();	4✔
165	eliminatedSoftwareSystemTests.Clear();	4✔
166	eliminatedSOUP.Clear();	4✔
167	eliminatedRisks.Clear();	4✔
168	eliminatedDocContents.Clear();	4✔
169	eliminatedAnomalies.Clear();	4✔
170	eliminatedTestResults.Clear();	4✔
171	eliminatedUnitTests.Clear();	4✔
172	}	4✔
173
174	public void EliminateItem(string itemID, string reason, EliminationReason eliminationReason)
NEW 175	{	×
176	// Check system requirements
NEW 177	var systemReq = systemRequirements.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 178	if (systemReq != null)	×
NEW 179	{	×
NEW 180	systemRequirements.Remove(systemReq);	×
NEW 181	eliminatedSystemRequirements.Add(new EliminatedRequirementItem(systemReq, reason, eliminationReason));	×
NEW 182	return;	×
183	}
184
185	// Check software requirements
NEW 186	var softwareReq = softwareRequirements.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 187	if (softwareReq != null)	×
NEW 188	{	×
NEW 189	softwareRequirements.Remove(softwareReq);	×
NEW 190	eliminatedSoftwareRequirements.Add(new EliminatedRequirementItem(softwareReq, reason, eliminationReason));	×
NEW 191	return;	×
192	}
193
194	// Check documentation requirements
NEW 195	var docReq = documentationRequirements.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 196	if (docReq != null)	×
NEW 197	{	×
NEW 198	documentationRequirements.Remove(docReq);	×
NEW 199	eliminatedDocumentationRequirements.Add(new EliminatedRequirementItem(docReq, reason, eliminationReason));	×
NEW 200	return;	×
201	}
202
203	// Check software system tests
NEW 204	var testCase = testCases.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 205	if (testCase != null)	×
NEW 206	{	×
NEW 207	testCases.Remove(testCase);	×
NEW 208	eliminatedSoftwareSystemTests.Add(new EliminatedSoftwareSystemTestItem(testCase, reason, eliminationReason));	×
NEW 209	return;	×
210	}
211
212	// Check unit tests
NEW 213	var unitTest = unitTests.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 214	if (unitTest != null)	×
NEW 215	{	×
NEW 216	unitTests.Remove(unitTest);	×
NEW 217	eliminatedUnitTests.Add(new EliminatedUnitTestItem(unitTest, reason, eliminationReason));	×
NEW 218	return;	×
219	}
220
221	// Check risks
NEW 222	var risk = risks.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 223	if (risk != null)	×
NEW 224	{	×
NEW 225	risks.Remove(risk);	×
NEW 226	eliminatedRisks.Add(new EliminatedRiskItem(risk, reason, eliminationReason));	×
NEW 227	return;	×
228	}
229
230	// Check anomalies
NEW 231	var anomaly = anomalies.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 232	if (anomaly != null)	×
NEW 233	{	×
NEW 234	anomalies.Remove(anomaly);	×
NEW 235	eliminatedAnomalies.Add(new EliminatedAnomalyItem(anomaly, reason, eliminationReason));	×
NEW 236	return;	×
237	}
238
239	// Check SOUP items
NEW 240	var soupItem = soup.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 241	if (soupItem != null)	×
NEW 242	{	×
NEW 243	soup.Remove(soupItem);	×
NEW 244	eliminatedSOUP.Add(new EliminatedSOUPItem(soupItem, reason, eliminationReason));	×
NEW 245	return;	×
246	}
247
248	// Check doc content items
NEW 249	var docContent = docContents.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 250	if (docContent != null)	×
NEW 251	{	×
NEW 252	docContents.Remove(docContent);	×
NEW 253	eliminatedDocContents.Add(new EliminatedDocContentItem(docContent, reason, eliminationReason));	×
NEW 254	return;	×
255	}
256
257	// Check test results
NEW 258	var testResult = testResults.FirstOrDefault(item => item.ItemID == itemID);	×
NEW 259	if (testResult != null)	×
NEW 260	{	×
NEW 261	testResults.Remove(testResult);	×
NEW 262	eliminatedTestResults.Add(new EliminatedTestResult(testResult, reason, eliminationReason));	×
NEW 263	return;	×
264	}
265
266	// If we reach here, the item was not found
NEW 267	throw new ArgumentException($"Item with ID '{itemID}' not found in any item collection for plugin '{Name}'.");	×
UNCOV 268	}	×
269
270	protected string EscapeNonTablePipes(string text)
271	{	91✔
272	string tableBlockPattern = @"(?ms)(^\\|===\s$.?^\\|===\s*$)";	91✔
273
274	// Use Regex.Split with a capturing group so that the table blocks are kept in the result.
275	string[] segments = Regex.Split(text, tableBlockPattern);	91✔
276	var sb = new StringBuilder();	91✔
277
278	foreach (string segment in segments)	471✔
279	{	99✔
280	// If the segment itself matches our table block pattern, leave it unmodified.
281	if (Regex.IsMatch(segment, @"(?ms)^\\|===\s$.?^\\|===\s*$"))	99✔
282	{	4✔
283	sb.Append(segment);	4✔
284	}	4✔
285	else
286	{	95✔
287	// Otherwise, escape any unescaped "\|" in this segment.
288	string processed = Regex.Replace(segment, @"(?<!\\)\\|", @"\\|");	95✔
289	sb.Append(processed);	95✔
290	}	95✔
291	}	99✔
292	return sb.ToString();	91✔
293	}	91✔
294
295	private void ScrubItemsFields<T>(IEnumerable<T> items)
296	{	21✔
297	foreach (var obj in items)	79✔
298	{	8✔
299	Type type = obj.GetType();	8✔
300	PropertyInfo[] properties = type.GetProperties();	8✔
301
302	foreach (PropertyInfo property in properties)	294✔
303	{	135✔
304	if (property.PropertyType == typeof(string) && property.CanWrite)	135✔
305	{	85✔
306	string currentValue = (string)property.GetValue(obj);	85✔
307	if (currentValue != null)	85✔
308	{	85✔
309	// Escape pipes in non-table parts of the content.
310	string newValue = EscapeNonTablePipes(currentValue);	85✔
311	property.SetValue(obj, newValue);	85✔
312	}	85✔
313	}	85✔
314	}	135✔
315	}	8✔
316	}	21✔
317
318	// with the exception of docContent items, all other items are visualized
319	// in tables and they need to escape the \| character
320	protected void ScrubItemContents()
321	{	2✔
322	ScrubItemsFields(systemRequirements);	2✔
323	ScrubItemsFields(softwareRequirements);	2✔
324	ScrubItemsFields(documentationRequirements);	2✔
325	ScrubItemsFields(testCases);	2✔
326	foreach (var testCase in testCases)	8✔
327	{	1✔
328	ScrubItemsFields(testCase.TestCaseSteps);	1✔
329	}	1✔
330	ScrubItemsFields(anomalies);	2✔
331	ScrubItemsFields(risks);	2✔
332	ScrubItemsFields(soup);	2✔
333	ScrubItemsFields(unitTests);	2✔
334	ScrubItemsFields(dependencies);	2✔
335	ScrubItemsFields(testResults);	2✔
336	}	2✔
337	}
338	}

MeindertN / RoboClerk / 19313674688

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous