public Test_Case() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("General"),
new Checkitem("Name"),
new Checkitem("Brief Description"),
new Checkitem("Test Data Needs")
};
}
public Risk_List() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Have all potential risks to the project been identified?"),
new Checkitem("Have all risks been described without ambiguity?"),
new Checkitem("Have all major risks been evaluated?"),
new Checkitem("Are there interdependencies between risks?")
};
}
public Iteration_Plan() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Have you elaborated on the plan with the team?"),
new Checkitem("Are iteration objectives clear?"),
new Checkitem("Have key milestones for the iteration been identified ?"),
new Checkitem("Do the team members feel confident about their Work Item assignments ?")
};
}
public Project_Plan() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Has the plan been elaborated with the team?"),
new Checkitem("Has the team agreed on development practices for the project?"),
new Checkitem("Have the project milestones been defined ?"),
new Checkitem("Has the deployment strategy been discussed ?")
};
}
public Work_Items_List() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Have Work Items been described without ambiguity?"),
new Checkitem("Have Work Items been prioritized?"),
new Checkitem("Have Work Items been estimated?"),
new Checkitem("Are the Work Items being tracked?"),
new Checkitem("Are scheduled Work Items the right size?")
};
}
public Developer_Test() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("The test coverage is acceptable"),
new Checkitem("Developer test names or IDs are consistent with project naming conventions"),
new Checkitem("The test logic is correct"),
new Checkitem("Branch coverage is acceptable."),
new Checkitem("The test is easy to maintain.")
};
}
public Implementation() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("The implementation conforms to the architecture and design"),
new Checkitem("The implementation is testable"),
new Checkitem("The implementation is correct"),
new Checkitem("The implementation is understandable"),
new Checkitem("There is no redundancy")
};
}
public Test_Script() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("The test script conforms to the related test case"),
new Checkitem("The test script is testable"),
new Checkitem("The test script is reusable"),
new Checkitem("The test script is prescriptive and unambiguous"),
new Checkitem("The test script is named consistently with the other test work products"),
new Checkitem("The test script provides appropriate test coverage")
};
}
public Deployment_Plan() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Who are the end users of the features to be released?"),
new Checkitem("What features must be deployed?"),
new Checkitem("When do the features need to be available?"),
new Checkitem("Where are the end users located?"),
new Checkitem("Why is the release taking place?"),
new Checkitem("Who will support the release after it is deployed?"),
new Checkitem("When is the release \"done\"?")
};
}
public Use_Case_Model() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("It is easy to understand what the system does by reviewing the model"),
new Checkitem("All use cases have been identified"),
new Checkitem("The model is consistent"),
new Checkitem("All relationships between use cases are required"),
new Checkitem("Use-case packages are used appropriately"),
new Checkitem("All model elements have appropriate names"),
new Checkitem("Individual use cases are properly specified")
};
}
public Use_Case() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("The use-case name is meaningful and un-ambiguous"),
new Checkitem("The brief description clearly describes the primary goal of the use case "),
new Checkitem("Associated actors and information exchanged are clearly defined"),
new Checkitem("Pre-conditions have been specified"),
new Checkitem("The Basic Flow and Alternate Flows are complete, correct and consistent"),
new Checkitem("Post-conditions have been specified"),
new Checkitem("Applicable non-functional requirements have been captured")
};
}
public Test_Data() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Test data has been provided for the test cases to be implemented"),
new Checkitem("The test data supports boundary testing"),
new Checkitem("The system under test has been tested under conditions with sufficient data, insufficient data, and the wrong type of data"),
new Checkitem("The test data is organized into production and generated data"),
new Checkitem("The test data has been updated to apply to the appropriate iteration"),
new Checkitem("The test data is complete for the given test effort"),
new Checkitem("Data has been identified for input numeric variables, output numeric variables, arrays, and vectors")
};
}
public System_Wide_Requirements() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Global functional requirements have been captured and validated"),
new Checkitem("Usability requirements have been captured and validated"),
new Checkitem("Reliability requirements have been captured and validated"),
new Checkitem("Performance requirements have been captured and validated"),
new Checkitem("Supportability requirements have been captured and validated"),
new Checkitem("Constraints have been captured and validated"),
new Checkitem("External interfaces have been identified"),
new Checkitem("Business rules have been captured and validated"),
new Checkitem("Applicable standards and regulatory compliance requirements have been identified")
};
}
public General_Requirements() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("The requirement is correct"),
new Checkitem("The requirement is complete"),
new Checkitem("The requirement is clear"),
new Checkitem("The requirement is consistent"),
new Checkitem("The requirement is verifiable"),
new Checkitem("The requirement is traceable"),
new Checkitem("The requirement is feasible"),
new Checkitem("The requirement is design independent"),
new Checkitem("The requirement is atomic"),
};
}
public Vision() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("The problem behind the problem has been fully explored"),
new Checkitem("The problem statement is correctly formulated"),
new Checkitem("The list of stakeholders is complete and correct"),
new Checkitem("Everyone agrees on the definition of the system boundaries"),
new Checkitem("Constraints on the system have been sufficiently explored"),
new Checkitem("All kinds of constraints, including political, economic, and environmental, have been covered."),
new Checkitem("All key features of the system been identified and defined"),
new Checkitem("The features solve the identified problems"),
new Checkitem("The features are consistent with the identified constraints"),
new Checkitem("Someone unfamiliar with the project can understand the project objectives")
};
}
public Architecture_Notebook() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("Is the architecture understandable?"),
new Checkitem("Have the architectural goals, constraints and requirements been adequately described and handled?"),
new Checkitem("Have necessary architectural mechanisms been identified and described?"),
new Checkitem("Have the system partitions been adequately defined?"),
new Checkitem("Have the key elements been adequately defined?"),
new Checkitem("Have interfaces to external systems been adequately represented?"),
new Checkitem("Has all reuse been identified?"),
new Checkitem("Has the architecture been built to evolve?"),
new Checkitem("Can the architecture be delivered by the team?"),
new Checkitem("Has the software been adequately mapped to the hardware?")
};
}
public Design() : base()
{
checkItems = new Checkitem[]
{
new Checkitem("The design is understandable"),
new Checkitem("The design is consistent"),
new Checkitem("The design is maintainable"),
new Checkitem("The design is traceable"),
new Checkitem("The design reflects the architectural objectives of the system"),
new Checkitem("The design elements are modular"),
new Checkitem("The system can be implemented from the information in the design"),
new Checkitem("The design provide enough information for developer testing"),
new Checkitem("The design describe the system at the appropriate level of abstraction"),
new Checkitem("The design supports a coarse - grained perspective of the system"),
new Checkitem("Packages and Organization"),
new Checkitem("Views"),
new Checkitem("UML"),
new Checkitem("Non - UML Visual Modeling"),
};
}
