• Home
• net.serenity-bdd
• serenity-report-resources
• 1.1.22-rc.9
• source code
• requirements-list.ftl

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

freemarker.components.requirements-list.ftl Maven / Gradle / Ivy

<#macro requirements_results(requirements, title, id)>

    

        
                <#if (requirements.childrenType?has_content) >
                    <#assign childrenTitle = inflection.of(requirements.childrenType).inPluralForm().asATitle()>
                    
                <#if reportOptions.showManualTests>
                    

                <#foreach requirementOutcome in requirements.requirementOutcomes>
                    <#assign status_icon = formatter.resultIcon().forResult(requirementOutcome.testOutcomes.result) />
                    <#assign status_rank = formatter.resultRank().forResult(requirementOutcome.testOutcomes.result) />

                

                    <#assign requirementReport = reportName.forRequirement(requirementOutcome.requirement) >
                    

                    <#if (requirements.childrenType?has_content) >
                        

                    <#assign successCount = requirementOutcome.testOutcomes.totalTests.withResult("success") >
                    <#assign pendingCount = requirementOutcome.testOutcomes.totalTests.withResult("pending") >
                    <#assign ignoredCount = requirementOutcome.testOutcomes.totalTests.withResult("ignored") >
                    <#assign indeterminateCount = requirementOutcome.testOutcomes.totalTests.withIndeterminateResult() >
                    <#assign skipCount = requirementOutcome.testOutcomes.totalTests.withResult("skipped") >
                    <#assign failureCount = requirementOutcome.testOutcomes.totalTests.withResult("failure") >
                    <#assign errorCount = requirementOutcome.testOutcomes.totalTests.withResult("error") >
                    <#assign compromisedCount = requirementOutcome.testOutcomes.totalTests.withResult("compromised") >

                <#---->
                <#---->
                <#---->
                <#---->
                <#---->

                    <#assign totalAutomated = requirementOutcome.tests.count("AUTOMATED").withAnyResult()/>
                    <#assign automatedPassedPercentage = requirementOutcome.tests.getFormattedPercentage("AUTOMATED").withResult("SUCCESS")/>
                    <#assign automatedFailedPercentage = requirementOutcome.tests.getFormattedPercentage("AUTOMATED").withFailureOrError()/>
                    <#assign automatedPendingPercentage = requirementOutcome.tests.getFormattedPercentage("AUTOMATED").withIndeterminateResult()/>
                    <#assign automatedPassed = requirementOutcome.tests.count("AUTOMATED").withResult("SUCCESS")/>
                    <#assign automatedPending = requirementOutcome.tests.count("AUTOMATED").withIndeterminateResult()/>
                    <#assign automatedFailed = requirementOutcome.tests.count("AUTOMATED").withResult("FAILURE")/>
                    <#assign automatedError = requirementOutcome.tests.count("AUTOMATED").withResult("ERROR")/>
                    <#assign automatedCompromised = requirementOutcome.tests.count("AUTOMATED").withResult("COMPROMISED")/>
                    <#assign totalManual = requirementOutcome.tests.count("MANUAL").withAnyResult()/>
                    <#assign manualPassedPercentage = requirementOutcome.tests.getFormattedPercentage("MANUAL").withResult("SUCCESS")/>
                    <#assign manualFailedPercentage = requirementOutcome.tests.getFormattedPercentage("MANUAL").withFailureOrError()/>
                    <#assign manualPending = requirementOutcome.tests.count("MANUAL").withIndeterminateResult()/>
                    <#assign manualPendingPercentage = requirementOutcome.tests.getFormattedPercentage("MANUAL").withIndeterminateResult()/>
                    <#assign manualPassed = requirementOutcome.tests.count("MANUAL").withResult("SUCCESS")/>
                    <#assign manualFailed = requirementOutcome.tests.count("MANUAL").withResult("FAILURE")/>
                    <#assign manualError = requirementOutcome.tests.count("MANUAL").withResult("ERROR")/>

                    
                    <#if reportOptions.showManualTests>
                        

            

            

                
 
                
ID
                
${title}
${childrenTitle}
                
                
Auto.
Tests
                

                
                

                
                

                

                

                    
                
Manual
Tests
                    

                    
                    

                    
                    

                    

                


                
Coverage
            
            

                    

                        ${status_icon}
                        ${status_rank}
                    
                    
${requirementOutcome.cardNumberWithLinks}

                    
                        <#---->
                    
                        ${requirementOutcome.requirement.displayName}

                        
${formatter.renderDescription(requirementOutcome.requirement.narrative.renderedText)}
                    
${requirementOutcome.requirement.childrenCount}
                    
${requirementOutcome.testOutcomes.total}
${successCount}
${failureCount}
${errorCount}
${indeterminateCount}
${totalAutomated}
                    
${automatedPassed}
                    
${automatedPending}
                    
${automatedFailed}
                    
${automatedError}
                    
${automatedCompromised}
${totalManual}
                        
${manualPassed}
                        
${manualPending}
                        
${manualFailed}
                        
${manualError}
                    

                    

                        <#assign percentPending = requirementOutcome.percent.withResult("PENDING")/>
                        <#assign percentIgnored = requirementOutcome.percent.withResult("IGNORED") + requirementOutcome.percent.withResult("SKIPPED")/>
                        <#assign percentError = requirementOutcome.percent.withResult("ERROR")/>
                        <#assign percentCompromised = requirementOutcome.percent.withResult("COMPROMISED")/>
                        <#assign percentFailing = requirementOutcome.percent.withResult("FAILURE")/>
                        <#assign percentPassing = requirementOutcome.percent.withResult("SUCCESS")/>
                        <#assign percentIndeterminate = requirementOutcome.percent.withIndeterminateResult()/>
                        <#assign passing = requirementOutcome.formattedPercentage.withResult("SUCCESS")>
                        <#assign failing = requirementOutcome.formattedPercentage.withResult("FAILURE")>
                        <#assign error = requirementOutcome.formattedPercentage.withResult("ERROR")>
                        <#assign compromised = requirementOutcome.formattedPercentage.withResult("COMPROMISED")>
                        <#assign pending = requirementOutcome.formattedPercentage.withResult("PENDING")>
                        <#assign ignored = requirementOutcome.formattedPercentage.withSkippedOrIgnored()>
                        <#assign indeterminate = requirementOutcome.formattedPercentage.withIndeterminateResult()>

                        <#assign ignoredbar = (percentPassing + percentFailing + percentError + percentCompromised + percentIgnored)*125>
                        <#assign compromisedbar = (percentPassing + percentFailing + percentError + percentCompromised)*125>
                        <#assign errorbar = (percentPassing + percentFailing + percentError)*125>
                        <#assign failingbar = (percentPassing + percentFailing)*125>
                        <#assign passingbar = percentPassing*125>


                        <#assign tests = inflection.of(requirementOutcome.testOutcomes.total).times("test") >

                        <#assign overviewCaption =
                        "${requirementOutcome.requirement.displayName}
Tests implemented: ${requirementOutcome.testCount}
  - Passing tests: ${successCount} (${passing} of specified requirements)
  - Failing tests: ${failureCount} (${failing} of specified requirements)
  - Tests with errors: ${errorCount} (${error} of specified requirements)
  - Compromised tests ${compromisedCount} (${compromised} of specified requirements)

Tests not implemented or not executed: ${pendingCount + ignoredCount}
  - Pending tests: ${pendingCount} (${pending} of specified requirements)
  - Ignored or skipped tests: ${ignoredCount} (${ignored} of specified requirements)

Requirements specified:     ${requirementOutcome.flattenedRequirementCount}
Requirements with no tests: ${requirementOutcome.requirementsWithoutTestsCount}


Estimated unimplemented tests: ${requirementOutcome.estimatedUnimplementedTests}
Estimated unimplemented or pending requirements: ${pending}
Estimated ignored or skipped requirements: ${ignored}"
                        >

                        

                            

                                

                                    
${passing}