All Downloads are FREE. Search and download functionalities are using the official Maven repository.

freemarker.requirements.ftl Maven / Gradle / Ivy

Go to download 




<#if requirements.parentRequirement.isPresent()>
    <#assign pageTitle = inflection.of(requirements.parentRequirement.get().type).inPluralForm().asATitle() >
<#else>
    <#assign pageTitle = "Requirements" >


<#assign requirementTypeTitle = inflection.of(requirements.type).asATitle() >
<#assign requirementsSectionTitle = inflection.of(requirements.type).inPluralForm().asATitle() >

    
    ${pageTitle}
    <#include "libraries/favicon.ftl">

    <#include "libraries/common.ftl">
    <#include "libraries/jquery-ui.ftl">
    <#include "libraries/datatables.ftl">
    <#assign pie = true>

    <#include "components/test-outcomes.ftl">
    <#include "components/requirements-list.ftl">

    <#assign testResultData = resultCounts.byTypeFor("success","pending","ignored","skipped","failure","error","compromised") >
    <#assign testLabels = resultCounts.percentageLabelsByTypeFor("success","pending","ignored","skipped","failure","error","compromised") >
    <#assign graphType="automated-and-manual-results" >

    

    
    <#if (prettyTables) >
        
    





    

        
        

            
                ${reportOptions.projectName}
                ${reportOptions.projectSubTitle}
            
        

    




<#if (requirements.parentRequirement.isPresent())>
    <#assign parentRequirement = requirements.parentRequirement.get() >
    <#assign parentTitle = inflection.of(parentRequirement.displayName).asATitle() >
    <#assign parentType = inflection.of(parentRequirement.type).asATitle() >
    <#if (parentRequirement.cardNumber?has_content) >
        <#assign issueNumber = "[" + reportFormatter.addLinks(parentRequirement.cardNumber) + "]" >
    <#else>
        <#assign issueNumber = "">
    




    

        

            
            Home > Requirements

            <#list breadcrumbs as breadcrumb>
                <#assign breadcrumbReport = absoluteReportName.forRequirement(breadcrumb) />
                <#assign breadcrumbTitle = inflection.of(breadcrumb.displayName).asATitle() >
                > ${formatter.htmlCompatibleStoryTitle(breadcrumbTitle)}
            

                <#if requirements.parentRequirement.isPresent()>
                    <#assign parent = requirements.parentRequirement.get()>
                    <#assign parentTitle = inflection.of(parent.displayName).asATitle() >

                    > ${formatter.htmlCompatibleStoryTitle(parentTitle)}
                

            
        

        

    

    


    
    <#include "menu.ftl">

    <#if requirements.parentRequirement.isPresent()>
        <@main_menu selected="${requirements.parentRequirement.get().type}" />
    <#else>
        <@main_menu selected="requirements" />
    

    


    

    

        

            <#if (requirements.parentRequirement.isPresent())>
            

                

                    

                        

                            

                                <#if isLeafRequirement && filteredTags?has_content >
                                

                                    <#else>
                                    

                                        
                                        
                                            
 ${parentType}: ${issueNumber} ${formatter.htmlCompatibleStoryTitle(parentTitle)}

                                        
                                    

                                    <#if isLeafRequirement && filteredTags?has_content >
                                        

                                        
                                            <#list filteredTags as tag>
                                                <#assign tagReport = absoluteReportName.forRequirementOrTag(tag) />
                                                <#assign tagTitle = inflection.of(tag.shortName).asATitle() >
                                                

                                                    <#assign tagStyle = styling.tagStyleFor(tag) >
                                                    
                                                         ${formatter.htmlCompatible(tagTitle)}
                                                        (${tag.type})
                                                    
                                                

                                            
                                        
                                        

                                    
                                

                            

                        

                        <#if parentRequirement.narrative.renderedText?has_content>
                            

                                ${formatter.renderDescriptionWithEmbeddedResults(parentRequirement.narrative.renderedText, requirements)}
                            

                        

                        <#foreach customField in parentRequirement.customFields >
                            <#if parentRequirement.getCustomField(customField).present>
                                

                                    
                                        
                                        ${customField}
                                    

                                    
${parentRequirement.getCustomField(customField).get().renderedText}

                                

                            
                        
                    

                

                


                <#if (requirements.overview?has_content)>
                    

                        

                            

                                

                                    ${formatter.renderDescriptionWithFormattedTables(requirements.overview, requirements)}
                                

                            

                        

                    

                
                

                    


                        
                        

                        
                        

                            

                                

                                    

                                        

                                            


                                                <#if !isLeafRequirement>
                                                    
Requirements Overview


                                                    


                                                <#else>
                                                    
                                                    

                                                        
Overview

                                                        
                                                            <#list scenarioGroups as scenarioGroup>
                                                                <#assign scenarioInRule = false />
                                                                <#if scenarioGroup.ruleName?has_content>
                                                                    <#assign scenarioInRule = true />
                                                                    
                                                                
                                                                <#if scenarioGroup.hasScenarios() >
                                                                    <#list scenarioGroup.mainScenarios as scenario>
                                                                        <#assign outcome_icon = formatter.resultIcon().forResult(scenario.result) />
                                                                        

                                                                        
                                                                            
                                                                            Rule: ${scenarioGroup.ruleName}
                                                                        
                                                                    

                                                                            
                                                                                <#if scenarioInRule>
                                                                                    <#assign scenarioClass = "scenario-toc-entry"/>
                                                                                <#else>
                                                                                    <#assign scenarioClass = "orphan-scenario-toc-entry"/>
                                                                                
                                                                                
                                                                                    
                                                                                         ${scenario.type}: ${formatter.renderTitle(scenario.simplifiedName)}
                                                                                    
                                                                                    <#if scenario.hasExamples() >
                                                                                        (${scenario.numberOfExamples})
                                                                                    
                                                                                
                                                                            
                                                                            
                                                                                
                                                                                        <#if outcome_icon?has_content>
                                                                                            

                                                                                    

                                                                                        
                                                                                            <#if outcome_icon?has_content>
                                                                                            
                                                                                                
                                                                                                ${outcome_icon}
                                                                                                <#if outcome_icon?has_content>

                                                                                            <#if (scenario.isManual())>
                                                                                                
                                                                                        
                                                                                                
                                                                                                    
                                                                                                
                                                                                            
                                                                                        
                                                                                    

                                                                                

                                                                            		
                                                                        

                                                                    
                                                                
                                                            
                                                        

                                                    

                                                    

                                                    
Scenarios


                                                    <#list scenarioGroups as scenarioGroup>
                                                        
                                                        <#if scenarioGroup.ruleName?has_content>
                                                            
Rule: ${scenarioGroup.ruleName}

                                                        
                                                        <#if scenarioGroup.ruleDescription?has_content>
                                                            

                                                                ${formatter.renderText(scenarioGroup.ruleDescription)}
                                                            

                                                        
                                                        <#if scenarioGroup.hasBackground()>
                                                            

                                                                

                                                                    
                                                                    Background: <#if scenarioGroup.backgroundTitle?has_content>${formatter.renderText(scenarioGroup.backgroundTitle)}
                                                                     
                                                                    <#if scenarioGroup.backgroundDescription?has_content>
                                                                    

                                                                        ${formatter.renderText(scenarioGroup.backgroundDescription)}
                                                                    

                                                                    
                                                                

                                                                

                                                                    <#list scenarioGroup.backgroundSteps as step>
                                                                        
${formatter.renderHtmlEscapedDescription(step)}

                                                                    
                                                                

                                                            

                                                        

                                                        <#list scenarioGroup.mainScenarios as scenario>
                                                            <#assign outcome_icon = formatter.resultIcon().forResult(scenario.result) />

                                                            

                                                                

                                                                    

                                                            
                                                                ${scenario.type}: ${formatter.renderTitle(scenario.title)}
                                                            
                                                                        
                                                                <#if (scenario.isManual())> 

                                                                            <#if outcome_icon?has_content>
                                                                                ${outcome_icon}
                                                                            <#else>
                                                                                
                                                                            
                                                            
                                                                    

                                                                    <#--<#if outcome_icon?has_content>-->
                                                                    <#--
-->
                                                                    <#--<#list scenario.scenarioReportBadges as scenarioReporBadge>-->
                                                                    <#--${scenarioReporBadge}-->
                                                                    <#---->
                                                                    <#--
-->
                                                                    <#---->
                                                                

                                                                

                                                                    <#if scenario.description?has_content>
                                                                        

                                                                             ${formatter.renderHtmlEscapedDescription(scenario.description)}
                                                                        

                                                                    
                                                                    <#list scenario.steps as step>
                                                                        
${formatter.renderHtmlEscapedDescription(step)}

                                                                    
                                                                    

                                                                        <#list scenario.examples as example>
                                                                            
${formatter.renderTableDescription(example, requirements)}

                                                                        
                                                                    

                                                                

                                                            

                                                        
                                                    
                                                
                                            

                                        

                                    

                                


                                

                                    

                                        

                                            <#if resultCounts.getTotalOverallTestCount() != 0>
                                            


                                                

                                                    

                                                

                                                
                                            

                                            

                                                <#else>
                                                

                                                    
                                                    <#assign successReport = reportName.withPrefix(currentTag).forTestResult("success") >
                                                    <#assign brokenReport = reportName.withPrefix(currentTag).forTestResult("broken") >
                                                    <#assign failureReport = reportName.withPrefix(currentTag).forTestResult("failure") >
                                                    <#assign errorReport = reportName.withPrefix(currentTag).forTestResult("error") >
                                                    <#assign compromisedReport = reportName.withPrefix(currentTag).forTestResult("compromised") >
                                                    <#assign pendingReport = reportName.withPrefix(currentTag).forTestResult("pending") >
                                                    <#assign skippedReport = reportName.withPrefix(currentTag).forTestResult("skipped") >
                                                    <#assign ignoredReport = reportName.withPrefix(currentTag).forTestResult("ignored") >

                                                    
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if (resultCounts.getOverallTestCount("success") != 0)>
                                                                
                                                            <#else>
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if (resultCounts.getOverallTestCount("pending") != 0)>
                                                                
                                                            <#else>
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if (resultCounts.getOverallTestCount("ignored") != 0)>
                                                                
                                                            <#else>
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if (resultCounts.getOverallTestCount("skipped") != 0)>
                                                                
                                                            <#else>
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                <#if (resultCounts.getOverallTestsCount("failure","error","compromised") != 0)>
                                                                    
                                                                <#else>
                                                                    
                                                                
                                                            <#else>
                                                                <#if (resultCounts.getOverallTestsCount("failure","error","compromised") != 0)>
                                                                    
                                                                <#else>
                                                                    
                                                            <#if (resultCounts.getOverallTestCount("failure") != 0)>
                                                                
                                                            <#else>
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if (resultCounts.getOverallTestCount("error") != 0)>
                                                                
                                                            <#else>
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if (resultCounts.getOverallTestCount("compromised") != 0)>
                                                                
                                                            <#else>
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                
                                                            <#if resultCounts.hasManualTests() >
                                                                

                                                        
                                                        

                                                            Scenario Results (including rows of test
                                                                data)
                                                            
                                                            
                                                                Automated
                                                            
                                                                    Manual
                                                                
                                                                 Total
                                                                
                                                            
                                                        

                                                        
                                                        
                                                        

                                                                     Passing
                                                                 Passing
                                                                
                                                            
                                                            ${resultCounts.getAutomatedTestCount("success")}
                                                            ${resultCounts.getAutomatedTestPercentageLabel("success")}${resultCounts.getManualTestCount("success")}
                                                                ${resultCounts.getManualTestPercentageLabel("success")}
                                                                ${resultCounts.getOverallTestCount("success")}
                                                                ${resultCounts.getOverallTestPercentageLabel("success")}
                                                            
                                                        

                                                        

                                                                     Pending
                                                                 Pending
                                                                
                                                            
                                                            ${resultCounts.getAutomatedTestCount("pending")}
                                                            ${resultCounts.getAutomatedTestPercentageLabel("pending")}${resultCounts.getManualTestCount("pending")}
                                                                ${resultCounts.getManualTestPercentageLabel("pending")}
                                                                ${resultCounts.getOverallTestCount("pending")}
                                                                ${resultCounts.getOverallTestPercentageLabel("pending")}
                                                            
                                                        

                                                        

                                                                     Ignored
                                                                 Ignored
                                                                
                                                            
                                                            ${resultCounts.getAutomatedTestCount("ignored")}
                                                            ${resultCounts.getAutomatedTestPercentageLabel("ignored")}${resultCounts.getManualTestCount("ignored")}
                                                                ${resultCounts.getManualTestPercentageLabel("ignored")}
                                                                ${resultCounts.getOverallTestCount("ignored")}
                                                                ${resultCounts.getOverallTestPercentageLabel("ignored")}
                                                            
                                                        

                                                        

                                                                     Skipped
                                                                 Skipped
                                                                
                                                            
                                                            ${resultCounts.getAutomatedTestCount("skipped")}
                                                            ${resultCounts.getAutomatedTestPercentageLabel("skipped")}${resultCounts.getManualTestCount("skipped")}
                                                                ${resultCounts.getManualTestPercentageLabel("skipped")}
                                                                ${resultCounts.getOverallTestCount("skipped")}
                                                                ${resultCounts.getOverallTestPercentageLabel("skipped")}
                                                            
                                                        

                                                        
 Unsuccessful
                                                                     Unsuccessful
                                                                     Unsuccessful
                                                                     Unsuccessful
                                                                    
                                                                
                                                            

                                                        


                                                        

                                                                     Failed
                                                                
                                                                     Failed
                                                                
                                                            
                                                            ${resultCounts.getAutomatedTestCount("failure")}
                                                            ${resultCounts.getAutomatedTestPercentageLabel("failure")}${resultCounts.getManualTestCount("failure")}
                                                                ${resultCounts.getManualTestPercentageLabel("failure")}
                                                                ${resultCounts.getOverallTestCount("failure")}
                                                                ${resultCounts.getOverallTestPercentageLabel("failure")}
                                                            
                                                        

                                                                     Broken
                                                                
                                                                     Broken
                                                                
                                                            
                                                            ${resultCounts.getAutomatedTestCount("error")}
                                                            ${resultCounts.getAutomatedTestPercentageLabel("error")}${resultCounts.getManualTestCount("error")}
                                                                ${resultCounts.getManualTestPercentageLabel("error")}
                                                                ${resultCounts.getOverallTestCount("error")}
                                                                ${resultCounts.getOverallTestPercentageLabel("error")}
                                                            
                                                        

                                                                     Compromised
                                                                
                                                                     Compromised
                                                                
                                                            
                                                            ${resultCounts.getAutomatedTestCount("compromised")}
                                                            ${resultCounts.getAutomatedTestPercentageLabel("compromised")}${resultCounts.getManualTestCount("compromised")}
                                                                ${resultCounts.getManualTestPercentageLabel("compromised")}
                                                                ${resultCounts.getOverallTestCount("compromised")}
                                                                ${resultCounts.getOverallTestPercentageLabel("compromised")}
                                                            
                                                        

                                                        

                                                            Total
                                                            ${resultCounts.getTotalAutomatedTestCount()}
                                                            ${resultCounts.getTotalManualTestCount()}
                                                                
                                                                ${resultCounts.getTotalOverallTestCount()}
                                                                
                                                            
                                                        

                                                        
                                                    

                                                

                                            


                                            

                                                

                                                    

                                                        
                                                        

                                                            Execution Time
                                                            Clock Time
                                                            Fastest Test
                                                            Slowest Test
                                                            Average Execution Time
                                                        

                                                        
                                                        
                                                        

                                                            ${totalTestDuration}
                                                            ${totalClockDuration}
                                                            ${minTestDuration}
                                                            ${maxTestDuration}
                                                            ${averageTestDuration}
                                                        

                                                        
                                                    

                                                

                                            


                                            <#if (requirements.requirementOutcomes?has_content)>
                                                <#assign workingRequirementsTitle = inflection.of(requirements.type).inPluralForm().asATitle() >

                                                

                                                    

                                                        
 Functional Coverage
                                                        


                                                        <@requirements_results requirements=requirements title=requirementTypeTitle requirementType=workingRequirementsTitle id="req-results-table"/>

                                                    

                                                

                                            

                                            

                                                

                                                    
 Automated Tests


                                                    <#if (automatedTestCases?has_content)>
                                                        
                                                                <#if !isLeafRequirement>
                                                                    
                                                            <#list automatedTestCases as scenario>
                                                                <#assign outcome_icon = formatter.resultIcon().forResult(scenario.result) />
                                                                
                                                                    <#if !isLeafRequirement>
                                                                        

                                                            
                                                            
${leafRequirementType}
                                                                
                                                                Scenario
                                                                Steps
                                                                Started
                                                                Duration
                                                                Result
                                                            

                                                            
                                                            

                                                                            <#if scenario.parentName?has_content>
                                                                                ${scenario.parentName}
                                                                            
                                                                        
                                                                    
                                                                    
                                                                        <#if outcome_icon?has_content>
                                                                            ${formatter.renderTitle(scenario.title)}
                                                                        <#else>
                                                                            ${formatter.renderTitle(scenario.title)}
                                                                        
                                                                        <#if scenario.hasExamples() >
                                                                            (${scenario.numberOfExamples})
                                                                        
                                                                    
                                                                    ${scenario.stepCount}
                                                                    ${scenario.formattedStartTime}
                                                                    ${scenario.formattedDuration}
                                                                    
                                                                        <#if outcome_icon?has_content >
                                                                            ${outcome_icon} ${scenario.result}
                                                                        <#else>
                                                                            
                                                                        
                                                                    
                                                                

                                                            
                                                            
                                                        

                                                    <#else>
                                                        No automated tests were executed
                                                    

                                                

                                            


                                            

                                                

                                                    
 Manual Tests


                                                    <#if (manualTestCases?has_content)>
                                                        
                                                                <#if !isLeafRequirement>
                                                                    
                                                            <#list manualTestCases as scenario>
                                                                <#assign outcome_icon = formatter.resultIcon().forResult(scenario.result) />
                                                                
                                                                    <#if !isLeafRequirement>
                                                                        

                                                            
                                                            
${leafRequirementType}
                                                                
                                                                
                                                                    Scenario
                                                                
                                                                Steps
                                                                Result
                                                            

                                                            
                                                            

                                                                            <#if scenario.parentName?has_content>
                                                                                ${scenario.parentName}
                                                                            
                                                                        
                                                                    
                                                                    
                                                                        ${scenario.title}
                                                                        <#if scenario.hasExamples() >
                                                                            (${scenario.numberOfExamples})
                                                                        
                                                                    
                                                                    ${scenario.stepCount}
                                                                    ${outcome_icon} ${scenario.result}
                                                                    
                                                                

                                                            
                                                            
                                                        

                                                    <#else>
                                                        No manual tests were recorded
                                                    

                                                

                                            


                                            <#if evidence?has_content>
                                                

                                                    

                                                        
 Evidence

                                                        
                                                            <#list evidence as evidenceRecord>
                                                                

                                                            
                                                            

                                                                Scenario
                                                                Title
                                                                Details
                                                            

                                                            
                                                            

                                                                    ${evidenceRecord.scenario}
                                                                    ${evidenceRecord.title}
                                                                    ${evidenceRecord.detailsLink}
                                                                

                                                            
                                                            
                                                        

                                                    

                                                

                                            
                                        

                                    

                                

                            

                        

                    

                

            

            

                

                    

                        Serenity BDD version ${serenityVersionNumber!"SNAPSHOT-BUILD"}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy