<?xml version="1.0" encoding="UTF-8"?>
<org.eclipse.epf.uma:ContentDescription xmi:version="2.0"
    xmlns:xmi="http://www.omg.org/XMI" xmlns:org.eclipse.epf.uma="http://www.eclipse.org/epf/uma/1.0.5/uma.ecore"
    xmlns:epf="http://www.eclipse.org/epf" epf:version="1.5.0" xmi:id="_FuQswLv-EdmmUvZAZjqE3g"
    name="test,_0TkKQMlgEdmt3adZL5Dmdw" guid="_FuQswLv-EdmmUvZAZjqE3g" changeDate="2007-07-24T11:14:40.953-0700"
    version="1.0.0">
  <mainDescription>&lt;p>&#xD;
    The purpose of this discipline is to:&#xD;
&lt;/p>&#xD;
&lt;ul>&#xD;
    &lt;li>&#xD;
        Provide early and frequent &lt;em>feedback&lt;/em> that the system satisfies the requirements&#xD;
    &lt;/li>&#xD;
    &lt;li>&#xD;
        Objectively measure progress in small increments&#xD;
    &lt;/li>&#xD;
    &lt;li>&#xD;
        Identify issues with the solution&#xD;
    &lt;/li>&#xD;
    &lt;li>&#xD;
        Provide assurance that changes to the system do not introduce new defects&#xD;
    &lt;/li>&#xD;
    &lt;li>&#xD;
        Improve velocity by facilitating the discovery of issues with requirements, designs, and implementations as early&#xD;
        as possible&#xD;
    &lt;/li>&#xD;
&lt;/ul>&#xD;
&lt;p>&#xD;
    The Test discipline is iterative and incremental. It applies the strategy of “test early and test often” in order to&#xD;
    retire risks as early in the system’s lifecycle as possible.&#xD;
&lt;/p>&#xD;
&lt;p>&#xD;
    Testing occurs in each iteration of the lifecycle, beginning with the earliest builds of the system. In fact, it’s&#xD;
    common for one iteration to have many test cycles, depending on the frequency of new builds.&#xD;
&lt;/p>&#xD;
&lt;p>&#xD;
    Testing asks the question: “What does the Solution have to &lt;em>do&lt;/em> in order for us to consider a requirement&#xD;
    implemented?” Tests elaborate on the requirements with specific conditions of satisfaction that the Solution must meet.&#xD;
&lt;/p>&#xD;
&lt;p>&#xD;
    This discipline challenges the assumptions, risks, and uncertainty inherent in the development of highly technical&#xD;
    artifacts, and addresses those concerns using concrete demonstration and impartial evaluation.&#xD;
&lt;/p>&#xD;
&lt;p>&#xD;
    The Test discipline relates to the other disciplines in the following ways:&#xD;
&lt;/p>&#xD;
&lt;ul>&#xD;
    &lt;li>&#xD;
        &lt;a href=&quot;./../../openup/disciplines/requirements.html&quot; guid=&quot;_0TR2ZMlgEdmt3adZL5Dmdw&quot;>Discipline: Requirements&lt;/a>&#xD;
        identifies the &lt;em>intent&lt;/em> of the system. Testing elaborates on the requirements with detailed tests that&#xD;
        measure how the system supports the requirements.&#xD;
    &lt;/li>&#xD;
    &lt;li>&#xD;
        &lt;a href=&quot;./../../openup/disciplines/development.html&quot; guid=&quot;_0TeDoMlgEdmt3adZL5Dmdw&quot;>Discipline: Development&lt;/a>&#xD;
        creates incremental builds of the system that the Test discipline evaluates. In each iteration, testing provides&#xD;
        objective feedback. Effective testing enables Developers to focus on implementing new functionality, and improving&#xD;
        the design of the system.&#xD;
    &lt;/li>&#xD;
    &lt;li>&#xD;
        &lt;a href=&quot;./../../openup/disciplines/project_management.html&quot; guid=&quot;_0TqQ4MlgEdmt3adZL5Dmdw&quot;>Discipline: Project&#xD;
        Management&lt;/a> plans the overall project, and the scope of work, for each iteration. The Test discipline provides&#xD;
        an objective measure of progress, which enables adaptive planning.&#xD;
    &lt;/li>&#xD;
    &lt;li>&#xD;
        &lt;a href=&quot;./../../openup/disciplines/config_and_change_management.html&quot; guid=&quot;_0TwXgMlgEdmt3adZL5Dmdw&quot;>Discipline:&#xD;
        Configuration and Change Management&lt;/a> controls changes within the project. The test effort verifies that each&#xD;
        change to the Solution is tested appropriately. Test assets are kept under configuration management.&#xD;
    &lt;/li>&#xD;
&lt;/ul></mainDescription>
</org.eclipse.epf.uma:ContentDescription>
