<?xml version="1.0" encoding="UTF-8"?>
<Export generator="Cache" version="25" zv="Cache for Windows (x86-64) 2017.2 (Build 744U)" ts="2018-09-26 18:28:56">
<Class name="lite.test.coverage.linebyline.Runner">
<Description>
Principal Class</Description>
<Abstract>1</Abstract>
<TimeChanged>64917,52850.057326</TimeChanged>
<TimeCreated>64832,56786.788376</TimeCreated>

<Parameter name="ReStart">
<Description>
RegEx start</Description>
<Type>%String</Type>
<Default>(?mi)^\s*</Default>
</Parameter>

<Parameter name="ReEmbedded">
<Description>
RegEx to parse html, js and sql tags</Description>
<Type>%String</Type>
<Default><![CDATA[(?:(?:&html<|&js<|&sql\())]]></Default>
</Parameter>

<Parameter name="ReDim">
<Description>
RegEx to parse DIMs</Description>
<Type>%String</Type>
<Default>(?:(?:#dim[^=]+=))</Default>
</Parameter>

<Parameter name="ReCommon">
<Description>
RegEx to parse cache commands. Some are ignored in purpose.</Description>
<Type>%String</Type>
<Default>(?:return|ret|if|i|do|d|set|s|kill|k|new|n|while|for|f|write|w|zwrite|zw|zzwrite|break|b|close|c|continue|goto|g|halt|h|hang|job|j|lock|l|merge|m|open|o|read|r|tcommit|tc|throw|trollback|tro|tstart|ts|use|u|view|v|xecute|zkill|zk|znspace|zn|ztrap|zzdump|quit|q)(?:\s+|\(|\{|$)</Default>
</Parameter>

<Parameter name="ReEnd">
<Description>
RegEx end</Description>
<Type>%String</Type>
<Default>.*</Default>
</Parameter>

<Parameter name="IsExecutableRegExp">
<Description>
Ignored tokens: try,catch,else,e,elseif</Description>
<Type>%String</Type>
<Expression>..#ReStart_"(?:"_..#ReEmbedded_"|"_..#ReDim_"|"_..#ReCommon_")"_..#ReEnd</Expression>
</Parameter>

<UDLText name="T">
<Content><![CDATA[/* END Line is executable RegEx */
]]></Content>
</UDLText>

<Parameter name="TranslateIntToClassRegEx">
<Description>
RegEx used to parse a routine name</Description>
<Type>%String</Type>
<Default>(^.+)\.G?[0-9]$</Default>
</Parameter>

<Method name="OnAfterRunOneTestCase">
<Description>
OnAfterRunOneTestCase</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pstrOutputLogFile:%String</FormalSpec>
<Implementation><![CDATA[
	$$$ThrowOnError(##class(%Monitor.System.LineByLine).Pause())

	#Dim intRtnCount As %Integer = ##class(%Monitor.System.LineByLine).GetRoutineCount()
	
	Write !,"MonLBL Routines to process: "_intRtnCount, !
	
	#Dim i As %Integer
	For i = 1 : 1 : intRtnCount
	{
		Do ..ProcessCoverageRoutine(i, i)
	}
	
	Do ..WorkerProcessPackage()
	Do ..WorkerMigrateRoutineToClass()
	Do ..GenerateXML(pstrOutputLogFile)
	// Stop the monitor.
	$$$ThrowOnError(##class(%Monitor.System.LineByLine).Stop())
]]></Implementation>
</Method>

<Method name="OnBeforeRunOneTestCase">
<Description>
OnBeforeRunOneTestCase</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pstrTestSuite:%String,pstrMetrics:%String="RtnLine"</FormalSpec>
<Implementation><![CDATA[
	#Dim lstJobsInfo As %List
	Set lstJobsInfo = $ListBuild($Job)
	
	&sql(delete from lite_test_coverage_linebyline_dm_tables.LineCoverage)
	Kill ^gTestCoverageMethodMaps
		
	$$$ThrowOnError(##class(%Monitor.System.LineByLine).Start($ListBuild(pstrTestSuite), $ListBuild(pstrMetrics), lstJobsInfo))
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
/*
* pstrMetrics: RtnLine, Time, TotalTime
*/
]]></Content>
</UDLText>

<Method name="RunOneTestCase">
<ClassMethod>1</ClassMethod>
<FormalSpec>ptheLogicSuite:%String="lite.test.coverage.linebyline.co.*",ptheTestClass:%String="lite.test.coverage.linebyline.test.co.ComponentTest",ptheTestMethod:%String="TestAdd",pstrOutputLogFile:%String="C:\Temp\Coverage.xml",pstrMetrics:%String="RtnLine"</FormalSpec>
<Implementation><![CDATA[
	try
	{
		Do ..OnBeforeRunOneTestCase(ptheLogicSuite, pstrMetrics)
			
		#Dim manager As %UnitTest.Manager = ##class(%UnitTest.Manager).%New()
		Do manager.RunOneTestCase(ptheLogicSuite, ptheTestClass, ptheTestMethod)
		
		Do ..OnAfterRunOneTestCase(pstrOutputLogFile)
	}
	catch 
	{
		$$$ThrowOnError(##class(%Monitor.System.LineByLine).Stop())
	}
	
	Write !,""
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
/*
ClassMethod foo1()
{
	#Dim strOutputLogFile As %String = "C:\Temp\Coverage.xml"
	Do ..RunOneTestCase(,,, strOutputLogFile)
}

ClassMethod foo2()
{
	#Dim theLogicSuite As %String = "lite.test.coverage.linebyline.co.*"
	#Dim theTestClass As %String = "lite.test.coverage.linebyline.test.co.ComponentTest"
	#Dim theMethod As %String = "TestAdd"
	#Dim strOutputLogFile As %String = "C:\Temp\Coverage.xml"
	
	Do ..RunOneTestCase(theLogicSuite, theTestClass, theMethod, strOutputLogFile)
}

ClassMethod foo3()
{
	#Dim theLogicSuite As %String = "asanso.co.*"
	#Dim theTestClass As %String = "asanso.test.co.Comp1Test"
	#Dim theMethod As %String = "TestAdd1"
	#Dim strOutputLogFile As %String = "C:\Temp\Coverage.xml"
	
	Do ..RunOneTestCase(theLogicSuite, theTestClass, theMethod, strOutputLogFile)
}*/
]]></Content>
</UDLText>

<Method name="ProcessCoverageRoutine">
<Description>
ProcessCoverageRoutine</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pintLogIndex:%Integer=0,pintRoutine:%Integer</FormalSpec>
<Implementation><![CDATA[
	#Dim strRtnName As %Integer = ##class(%Monitor.System.LineByLine).GetRoutineName(pintRoutine)

	&sql(insert into lite_test_coverage_linebyline_dm_tables.LineCoverage
		 (TestIndex,
			RoutineName, RoutineType,
			LineText, LineNumber, LineCovered)
		 select :pintLogIndex,
			:strRtnName, 'int',
			lite_test_coverage_linebyline_dm.LineCoverage_GetLineText(:strRtnName,'int',LineNumber), LineNumber, LineCovered
		 from (select * from lite_test_coverage_linebyline_dm.LineCoverage_Result(:strRtnName)) R
	)

	If (SQLCODE < 0)
	{
		Throw ##class(%Exception.SQL).CreateFromSQLCODE(SQLCODE,$Get(%msg))
	}
]]></Implementation>
</Method>

<Method name="WorkerMigrateRoutineToClass">
<Description>
WorkerMigrateRoutineToClass</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	#Dim exc As %Exception.AbstractException
	#Dim sta As %Status = $$$OK
	
	Try
	{
				// Try to map each executed line in the routine back to a line in the class.
		#Dim tResLines As %SQL.StatementResult = ##class(%SQL.Statement).%ExecDirect(,"select distinct LineNumber,RoutineName,TestIndex "_
				"from lite_test_coverage_linebyline_dm_tables.LineCoverage "_
				"where RoutineType = 'int' "_
				"	and LineCovered = 1 ")
		
		#Dim tSC As %Status
		While (tResLines.%Next(.tSC))
		{
			$$$ThrowOnError(tSC)
			w !,tResLines.%Get("RoutineName")
			
			Set pTestIndex = tResLines.%Get("TestIndex")
			#Dim tOther As %String = ..FromIntToCls(tResLines.%Get("RoutineName"))
			If (tOther = "")
			{
				//Throw ##class(%Exception.General).%New("<INT TO CLS ERROR>",,, "Unnable to get class for routine "_tResLines.%Get("RoutineName"))
				Continue
			}
			#Dim tClassName As %String = $Piece(tOther,".",1,*-1)
			
			#Dim tMap
			Kill tMap
			#Dim tLineNumber As %Integer = tResLines.%Get("LineNumber")
			Set a = ##class(%Studio.Debugger).SourceLine(tResLines.%Get("RoutineName"), tLineNumber, 1, tLineNumber, $Length(..GetLineText(tResLines.%Get("RoutineName"),"int",tLineNumber)), $Namespace, .tMap)
			
			#Dim tData1
			#Dim tData2
			If ($Data(tMap("CLS",1),tData1) && $Data(tMap("CLS",2),tData2))
			{
				#Dim tClass1 As %String
				#Dim tMethod1 As %String
				#Dim tLine1 As %Integer
				Set $ListBuild(tClass1,tMethod1,tLine1) = tData1
				#Dim tClass2 As %String
				#Dim tMethod2 As %String
				#Dim tLine2 As %Integer
				Set $ListBuild(tClass2,tMethod2,tLine2) = tData2
				
				#Dim tMethodOffset As %Integer
				If ($Data(^gTestCoverageMethodMaps(tOther,tMethod1), tMethodOffset))
				{
					#Dim tLine As %Integer
					For tLine = tLine1 : 1 : tLine2
					{
						Set tClassLine = tMethodOffset + 1 + tLine
											
						&sql(update lite_test_coverage_linebyline_dm_tables.LineCoverage
							set LineCovered = 1
							where TestIndex = :pTestIndex
								and RoutineType = 'cls'
								and RoutineName = :tClassName
								and LineNumber = :tClassLine
						)
						If (SQLCODE < 0)
						{
							Throw ##class(%Exception.SQL).CreateFromSQLCODE(SQLCODE,%msg)
						}
					}
				}
			}
		}
		$$$ThrowOnError(tSC)
	}
	Catch (exc)
	{
		Set sta = exc.AsStatus()
	}
	
	Return sta
]]></Implementation>
</Method>

<Method name="FromIntToCls">
<Description>
FromIntToCls</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pstrRoutineName:%String</FormalSpec>
<Private>1</Private>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	#Dim strCls As %String = ""
	
	Set objTranslateIntToClsMatcher = ##class(%Regex.Matcher).%New(..#TranslateIntToClassRegEx)
	Set objTranslateIntToClsMatcher.Text = pstrRoutineName
	If (objTranslateIntToClsMatcher.Locate())
	{
		Set strCls = objTranslateIntToClsMatcher.Group(1)_".CLS"
	}
	Else
	{
		Write "WARNING: Unnable to find a class for routine "_pstrRoutineName, !
	}
	
	Return strCls
]]></Implementation>
</Method>

<Method name="GetLineText">
<Description>
GetLineText</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pRoutineName,pRoutineType,pLineNumber</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	#Dim strText As %String = "not yet implemented"
	If (pRoutineType = "int")
	{
		Return $Text(@("+"_pLineNumber_"^"_pRoutineName))
	}
	
	Return strText
]]></Implementation>
</Method>

<Method name="WorkerProcessPackage">
<Description>
WorkerProcessPackage</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	#Dim exc As %Exception.AbstractException
	#Dim sta As %Status = $$$OK
	
	Try
	{
		Set objIsExecutableMatcher = ##class(%Regex.Matcher).%New(..#IsExecutableRegExp)
		
		#Dim strQuery As %String
		Set strQuery =  "SELECT DISTINCT C.ID,LC.TestIndex "_
						"FROM %Dictionary.ClassDefinition C,lite_test_coverage_linebyline_dm_tables.LineCoverage LC "_
						"WHERE C.ID = $Extract(LC.RoutineName,1,$Length(LC.RoutineName)-2) "_
						"AND LC.RoutineType = 'int'"
		#Dim objResult As %SQL.StatementResult = ##class(%SQL.Statement).%ExecDirect(, strQuery)
		While (objResult.%Next())
		{
			Do ..ProcessClassName(objIsExecutableMatcher, objResult.ID_".CLS", objResult.TestIndex)
		}
	}
	Catch (exc)
	{
		Set sta = exc.AsStatus()
	}
	
	Return sta
]]></Implementation>
</Method>

<Method name="ProcessClassName">
<Description>
ProcessClassName</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pobjIsExecutableMatcher:%Regex.Matcher,tOther:%String,pTestIndex:%Integer</FormalSpec>
<Implementation><![CDATA[
	Set tClassName = tOther
	If ($Extract(tOther,$Length(tOther)-3, $Length(tOther)) = ".CLS")
	{
		Set tClassName = $Piece(tOther,".",1,*-1)
	}
	
	#Dim tDocumentText
	$$$ThrowOnError(##class(%Compiler.UDL.TextServices).GetTextAsArray(, tClassName, .tDocumentText))
	
	// Create table with class document's text
	#Dim tMethod As %String = ""
	#Dim tInBlockComment As %Integer = 0
	
	Set tDocumentText = $Order(tDocumentText(""),-1)
	
	#Dim blnIsCacheCode As %Boolean = 1
	
	#Dim i As %Integer
	For i = 1 : 1 : $Get(tDocumentText)
	{
		Set tLine = tDocumentText(i)
		
		#Dim blnExecutable As %Boolean = 0
		If (blnIsCacheCode)
		{
			Set pobjIsExecutableMatcher.Text = tLine
			Set blnExecutable = (pobjIsExecutableMatcher.Locate() = 1)
		}

		&sql(insert into lite_test_coverage_linebyline_dm_tables.LineCoverage
			(TestIndex, 
				RoutineName, RoutineType,
				LineText, LineNumber, LineCovered, Executable)
			 values (:pTestIndex,
				:tClassName, 'cls',
				:tLine, :i, 0, :blnExecutable))
		
		If (SQLCODE < 0)
		{
			Throw ##class(%Exception.SQL).CreateFromSQLCODE(SQLCODE,%msg)
		}

		// Extract line offset of method in class
		#Dim tStart As %String = $Extract(tLine, 1, 7)
		
		If (tStart = "ClassMe") || (tStart = "Method ")
		{
			Set tMethod = $Piece($Piece(tLine,"(")," ",2)
			#Dim tMethodMap
			Set tMethodMap(tMethod) = i
			Set blnIsCacheCode = 1
		}
		If (tStart = "ClientM")
		{
			Set blnIsCacheCode = 0
		}
	}
	
	Merge ^gTestCoverageMethodMaps(tOther) = tMethodMap
]]></Implementation>
</Method>

<Method name="GenerateXML">
<Description>
GenerateXML</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pstrPath:%String</FormalSpec>
<Implementation><![CDATA[
	Set objXML = ##class(lite.test.coverage.linebyline.xml.coverage).%New()
			
	#Dim strSQL As %String = "SELECT LineCovered, LineNumber, RoutineName, RoutineType FROM lite_test_coverage_linebyline_dm_tables.LineCoverage WHERE Executable = 1 AND RoutineType = 'cls' ORDER BY RoutineName"
	#Dim objQuery As %SQL.StatementResult = ##class(%SQL.Statement).%ExecDirect(, strSQL)
	#Dim strOldRoutineName As %String = ""
	#Dim objXMLFile As test.fwk.tool.xmlCoverage.xml.file = ""
	While (objQuery.%Next())
	{
		#Dim strRoutineName As %String = objQuery.RoutineName
		#Dim strRoutineType As %String = objQuery.RoutineType
		#Dim intLineCovered As %Integer = objQuery.LineCovered
		#Dim intLineNumber As %Integer = objQuery.LineNumber
		
		If (strOldRoutineName '= strRoutineName)
		{
			Set objXMLFile = ##class(lite.test.coverage.linebyline.xml.file).%New()
			Set objXMLFile.path = $Replace(strRoutineName, ".", "/")_"."_strRoutineType
			
			Do objXML.file.Insert(objXMLFile)
			Set strOldRoutineName = strRoutineName
		}
		
		Set objXMLLine = ##class(lite.test.coverage.linebyline.xml.LineToCover).%New()
		Set objXMLLine.lineNumber = intLineNumber
		Set objXMLLine.covered = intLineCovered
		
		Do objXMLFile.lineToCover.Insert(objXMLLine)
	}
	
	Do ..ExportXMLToFile(objXML, pstrPath)
]]></Implementation>
</Method>

<Method name="ExportXMLToFile">
<Description>
ExportXMLToFile</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pobjXML:lite.test.coverage.linebyline.xml.coverage,pstrPath:%String</FormalSpec>
<Private>1</Private>
<Implementation><![CDATA[
	#Dim pstrPathToFile As %String = pstrPath
	
	Write " Writing output to: "_pstrPathToFile,!
	
	#Dim objFile As %File = ##class(%File).%New(pstrPathToFile)
	$$$ThrowOnError(objFile.Open("WNS"))
	
	#Dim objXMLWriter As %XML.Writer = ##class(%XML.Writer).%New()
	Set objXMLWriter.Format = "literal"
	Set objXMLWriter.Indent = 0
	Do objXMLWriter.OutputToStream(objFile)
	Do objXMLWriter.RootElement("coverage")
	Do objXMLWriter.WriteAttribute("version", "1")
	
	#Dim i As %Integer
	For i = 1 : 1 : pobjXML.file.Count()
	{
		Do objXMLWriter.Object(pobjXML.file.GetAt(i))
	}
	
	Do objXMLWriter.EndRootElement()

	$$$ThrowOnError(objFile.%Save())
	$$$ThrowOnError(objFile.%Close())
	
	Write "Done",!
]]></Implementation>
</Method>
</Class>


<Class name="lite.test.coverage.linebyline.dm.LineCoverage">
<Description>
lite.test.coverage.linebyline.dm.LineCoverage</Description>
<Abstract>1</Abstract>
<TimeChanged>64917,66460.078711</TimeChanged>
<TimeCreated>64832,58352.910303</TimeCreated>

<Query name="Result">
<Type>%Query</Type>
<FormalSpec>pRoutine:%String</FormalSpec>
<SqlProc>1</SqlProc>
<Parameter name="ROWSPEC" value="LineNumber:%Integer,LineCovered:%Boolean"/>
</Query>

<Method name="ResultExecute">
<Description>
ResultExecute</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[&qHandle:%Binary,pRoutine:%String]]></FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(%Monitor.System.LineByLine).ResultExecute(.qHandle,pRoutine)
]]></Implementation>
</Method>

<Method name="ResultFetch">
<Description>
ResultFetch</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[&qHandle:%Binary,&Row:%List,&AtEnd:%Integer=0]]></FormalSpec>
<PlaceAfter>ResultExecute</PlaceAfter>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set tLine = $Piece(qHandle,"^",2)
	Set tSC = ##class(%Monitor.System.LineByLine).ResultFetch(.qHandle,.Row,.AtEnd)
	If 'AtEnd {
		Set tCovered = $Case($ListGet($List(Row,1),1),0:0,"":0,:1)
		Set Row = $ListBuild(tLine,tCovered)
	}
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="ResultClose">
<Description>
ResultClose</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec><![CDATA[&qHandle:%Binary]]></FormalSpec>
<PlaceAfter>ResultExecute</PlaceAfter>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(%Monitor.System.LineByLine).ResultClose(.qHandle)
]]></Implementation>
</Method>

<Method name="GetLineText">
<Description>
GetLineText</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>pRoutineName,pRoutineType,pLineNumber</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	#Dim strText As %String = "not yet implemented"
	If (pRoutineType = "int")
	{
		Return $Text(@("+"_pLineNumber_"^"_pRoutineName))
	}
	
	Return strText
]]></Implementation>
</Method>
</Class>


<Class name="lite.test.coverage.linebyline.dm.tables.LineCoverage">
<Description>
lite.test.coverage.linebyline.dm.tables.LineCoverage</Description>
<Super>%Persistent</Super>
<TimeChanged>64917,66498.324151</TimeChanged>
<TimeCreated>64832,58643.086081</TimeCreated>

<Property name="TestIndex">
<Description>
Test instance index</Description>
<Type>%String</Type>
<Required>1</Required>
</Property>

<Property name="RoutineName">
<Description>
Routine or classname</Description>
<Type>%String</Type>
<Parameter name="COLLATION" value="EXACT"/>
<Parameter name="MAXLEN"/>
</Property>

<Property name="RoutineType">
<Description>
"cls" or "int"</Description>
<Type>%String</Type>
<Required>1</Required>
<Parameter name="MAXLEN" value="3"/>
</Property>

<Property name="LineNumber">
<Description>
Line number</Description>
<Type>%Integer</Type>
</Property>

<Property name="LineText">
<Description>
Source code for that routine, line number</Description>
<Type>%String</Type>
<Parameter name="MAXLEN"/>
</Property>

<Property name="LineCovered">
<Description>
Is this line covered?</Description>
<Type>%Boolean</Type>
</Property>

<Property name="Executable">
<Description>
Is this line executable?</Description>
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Index name="CoverageDataPK">
<Properties>TestIndex,RoutineType,RoutineName,LineNumber</Properties>
<Unique>1</Unique>
</Index>

<Index name="TestIndex">
<Type>bitmap</Type>
<Properties>TestIndex</Properties>
</Index>

<Index name="LineCovered">
<Type>bitmap</Type>
<Properties>LineCovered</Properties>
</Index>

<Index name="Executable">
<Type>bitmap</Type>
<Properties>Executable</Properties>
</Index>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^lite.test.covBF8B.LineCoverageD</DataLocation>
<DefaultData>LineCoverageDefaultData</DefaultData>
<IdLocation>^lite.test.covBF8B.LineCoverageD</IdLocation>
<IndexLocation>^lite.test.covBF8B.LineCoverageI</IndexLocation>
<StreamLocation>^lite.test.covBF8B.LineCoverageS</StreamLocation>
<Data name="LineCoverageDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>TestIndex</Value>
</Value>
<Value name="3">
<Value>RoutineName</Value>
</Value>
<Value name="4">
<Value>RoutineType</Value>
</Value>
<Value name="5">
<Value>LineNumber</Value>
</Value>
<Value name="6">
<Value>LineText</Value>
</Value>
<Value name="7">
<Value>LineCovered</Value>
</Value>
<Value name="8">
<Value>Executable</Value>
</Value>
</Data>
</Storage>
</Class>


<Class name="lite.test.coverage.linebyline.xml.LineToCover">
<Description>
Compatible with the Generic coverage plugin for Jenkins</Description>
<ProcedureBlock>1</ProcedureBlock>
<Super>%RegisteredObject,%XML.Adaptor</Super>
<TimeChanged>64837,72679</TimeChanged>
<TimeCreated>64314,33698.012127</TimeCreated>

<Parameter name="XMLNAME">
<Default>lineToCover</Default>
</Parameter>

<Parameter name="XMLSEQUENCE">
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="lineNumber">
<Type>%xsd.positiveInteger</Type>
<Required>1</Required>
<Parameter name="XMLNAME" value="lineNumber"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="covered">
<Type>%Boolean</Type>
<Required>1</Required>
<Parameter name="XMLNAME" value="covered"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="branchesToCover">
<Type>%xsd.nonNegativeInteger</Type>
<Parameter name="XMLNAME" value="branchesToCover"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="coveredBranches">
<Type>%xsd.nonNegativeInteger</Type>
<Parameter name="XMLNAME" value="coveredBranches"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>
</Class>


<Class name="lite.test.coverage.linebyline.xml.coverage">
<Description>
Compatible with the Generic coverage plugin for Jenkins</Description>
<ProcedureBlock>1</ProcedureBlock>
<Super>%RegisteredObject,%XML.Adaptor</Super>
<TimeChanged>64837,72679</TimeChanged>
<TimeCreated>64314,33698.003727</TimeCreated>

<Parameter name="XMLNAME">
<Default>coverage</Default>
</Parameter>

<Parameter name="XMLSEQUENCE">
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="file">
<Type>lite.test.coverage.linebyline.xml.file</Type>
<Collection>list</Collection>
<Parameter name="XMLNAME" value="file"/>
<Parameter name="XMLPROJECTION" value="ELEMENT"/>
</Property>

<Property name="version">
<Type>%xsd.positiveInteger</Type>
<InitialExpression>1</InitialExpression>
<Required>1</Required>
<Parameter name="XMLNAME" value="version"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>
</Class>


<Class name="lite.test.coverage.linebyline.xml.file">
<Description>
Compatible with the Generic coverage plugin for Jenkins</Description>
<ProcedureBlock>1</ProcedureBlock>
<Super>%RegisteredObject,%XML.Adaptor</Super>
<TimeChanged>64837,72679</TimeChanged>
<TimeCreated>64314,33698.008103</TimeCreated>

<Parameter name="XMLNAME">
<Default>file</Default>
</Parameter>

<Parameter name="XMLSEQUENCE">
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="lineToCover">
<Type>lite.test.coverage.linebyline.xml.LineToCover</Type>
<Collection>list</Collection>
<Parameter name="XMLNAME" value="lineToCover"/>
<Parameter name="XMLPROJECTION" value="ELEMENT"/>
</Property>

<Property name="path">
<Type>%String</Type>
<Required>1</Required>
<Parameter name="MAXLEN"/>
<Parameter name="XMLNAME" value="path"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>
</Class>
</Export>
