Abstract:
A requirements testing system facilitates the review and analysis of requirement statements for software applications. The requirements testing system generates test artifacts from the requirement statements. The test artifacts characterize the requirements statements to provide valuable analysis information that aids understanding whether the requirement statements are testable, what the intentions of the requirement statements are, and other useful analysis information. Because the system generates the analysis information from the requirement statements, the system provides benefits in terms of early feedback along the software application development timeline.

Description:
BACKGROUND 
     1. Priority Claim 
     This application claims the benefit of priority from Indian provisional patent application no. 1370/CHE/2011 filed Apr. 21, 2011, and from Indian provisional patent application no. 1613/CHE/2011 filed May 10, 2011, both of which are incorporated by reference. 
     2. Technical Field 
     This disclosure relates to test automation. More specifically, this disclosure relates to assisted generation of early test analysis and design artifacts from natural language (e.g., English language) specification documents. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The system may be better understood with reference to the following drawings and description. In the figures, like reference numerals designate corresponding parts throughout the different views. 
         FIG. 1  illustrates a requirements testing system architecture. 
         FIG. 2  shows examples of determining testability artifacts for requirement statements. 
         FIG. 3  shows additional examples of determining testability artifacts for requirement statements. 
         FIG. 4  shows an example of determining an intent artifact for a requirement statement in active voice. 
         FIG. 5  shows an example of determining an intent artifact for a requirement statement in passive voice. 
         FIG. 6  shows an example of determining an intent artifact for a compound requirement statement. 
         FIG. 7  shows an example of determining an intent artifact for a requirement statement with dependent clauses. 
         FIG. 8  shows an example of determining a category artifact for requirement statements. 
         FIG. 9  shows an example of determining a data artifact for requirement statements. 
         FIG. 10  shows a requirements testing system. 
         FIG. 11  shows a flow diagram of requirement testing logic that the requirements testing system may execute. 
         FIGS. 12-27  illustrate examples of the application of various rules by the system to requirement statements. 
         FIG. 28  illustrates examples of inter-module test and input/output domain requirement statements. 
         FIG. 29  illustrates examples of condition/dependency and usability/conformance requirement statements. 
         FIG. 30  illustrates examples of number and time data located in requirement statements. 
         FIG. 31  illustrates examples of handling date data in requirement statements. 
         FIG. 32  illustrates examples of handling numeric data in requirement statements. 
         FIG. 33  illustrates examples of handling range data in requirement statements. 
         FIG. 34  illustrates examples of handling Boolean data in requirement statements. 
         FIG. 35  illustrates examples of handling range data in requirement statements. 
         FIG. 36  shows an example of a requirement statement parsed into a constituent tree. 
         FIG. 37  shows an example of a requirement statement parsed into links and a constituent tree. 
         FIGS. 38 and 39  illustrate examples of the application of various rules by the system to requirement statements. 
     
    
    
     DETAILED DESCRIPTION 
       FIG. 1  illustrates a requirements testing system architecture  100 . The architecture  100  includes a requirements testing system  102  (“system  102 ”), an implementation of which is described in more detail below. The system  102  analyzes requirement statements to determine test artifacts. To that end, the system  102  receives requirement documents  104  including requirement statements  106 . The system  102  may obtain the requirement documents  104  through the communication interface  108 . The communication interface  108  may connect to networks  110  to obtain the requirement documents  104  from local or remote sources. 
     The network  110  may follow any of a wide variety of network topologies and technologies. As examples, the network  110  may include Local Area Networks (LANs), Wide Area Networks (WANs), Internet connections, Ethernet networks, or Fiber Distributed Data Interconnect (FDDI) packet switched networks that may communicate Transmission Control Protocol/Internet Protocol (TCP/IP) packets, or any data following any other communication protocol. The network  110  provides a transport mechanism or interconnection of multiple transport mechanisms supporting data exchange between the system  102  and any source of documents to analyze, including the requirement documents  104 . 
     An analysis engine  112  in the system  102  analyzes the requirement statements to determine the test artifacts. A requirement statement may, for example, be implemented as a single sentence or other sequence of one or more words. The requirement statement may, for example, be in unconstrained natural language, structured formats, or model based formats. An example of a requirement statement in a structured format may be a requirement statement limited to subject, action and object (denoted by SAO in Link Grammar notation). Such a restriction may exclude requirement statements with multiple objects, or requirement statements with nouns which are neither subjects nor objects. Other examples are possible. 
     In some instances, the requirement statements may include data that is not intended for processing. Such data may be marked, e.g. the data not intended for processing may be enclosed in brackets. The requirement statements may first be processed by the preprocessor  111  as described in more detail below. Among other things, the preprocessor  111  may remove data enclosed in brackets as well as the brackets themselves. The analysis engine  112  may generate, e.g., on the display  114 , an analysis report  116 . The analysis report  116  may specify the test artifacts or any other analysis details that the system  102  determines. 
     An artifact may be a tangible by-product produced during the development of software (e.g. a use case or a class diagram). Artifacts of a software project may be or resemble deliverables of the software project, though the software itself (i.e. the released end-product) may not be an artifact. A test artifact may be a tangible by-product produced during software testing. Test artifacts may relate to a characteristic of a requirement statement. Examples of test artifacts may include an indication of one or more of the following: requirement testability, requirement intent, requirement category, requirement data and requirement ambiguity. Testability artifacts, intent artifacts, category artifacts, and data artifacts may be examples of test artifacts, as well as or alternatively an ambiguous phrase identified in a requirement statement. For example, the test artifacts may include: Testability  118 , specifying, for example, whether the requirement statement is testable; Intent  120 , specifying, for example, the intent or purpose of the requirement statement; Category  122 , specifying, for example, what type of requirement the requirement statement establishes; Data  124 , specifying, for example, the data that the requirement statement operates on; and Ambiguity  126 , specifying whether all or parts of a requirement statement are ambiguous with regard to its testability. The system  102  may determine additional, fewer, or different artifacts, including grammatical correctness of the requirement statement in whole or in part. 
       FIGS. 2-9  give examples of the types of analyses that the system  102  may carry out. Specific examples of rulesets that the system  102  may implement to execute the analyses and determine the test artifacts are given in detail below. 
       FIG. 2  shows examples  200  of determining testability artifacts for requirement statements. In one implementation, the system  102  recognizes testable requirement statements as those that involve the use of modal verbs and that follow, as examples, one or more of the following properties governing the relation of the modal verbs with other words: 
     (1) Modal verbs connect to the subject and object, as in the requirement statement  202 : “The system should display the numbers in ascending order.” (2) Modal verbs connect to the subject and a preposition or participle, as in the requirement statement  204 : “The numbers displayed should be in ascending order.” (3) The modal verb connects to the subject through a participle and in turn connects to an object/preposition/participle, as in the requirement statement  206 : “The numbers are required to be displayed in ascending order.” 
     Not all requirement statements are testable. For example, “Project staffing report is defined as a report containing information about the project name, project description, total employee count, staffing status.” The system  102  determines that this statement is not testable because none of the testability rules fire. One reason is that this requirement statement gives the definition of the report, but does not tell how the report can be generated. As such, the requirement statement fits better into the assumptions section of the requirement document. Another example is, “Resource allocation request is associated with only one role.” This requirement statement is not clearly a requirement to be coded or a logical association made by the requirement writer. If it is to be encoded, it is better phrased included a modal verb, such as, “The resource allocation request should be associated with only one role.” 
       FIG. 3  shows additional examples  300  of determining testability artifacts for requirement statements. The system  102  may identify ambiguous phrases of requirement statements, such as “highly scalable” in the requirement statement  302  by analyzing the semantics of words in the requirement statement which are classified in one or more parts of speech, such as adjectives, adverbs, and/or other parts of speech. The system  102  also recognizes that the mere presence of a word does not imply ambiguity, as in the requirement statement  304 , where the ambiguity of the word “some” is resolved because it unambiguously modifies “users.” The system  102  may also make a decision concerning ambiguity by analyzing the usage of a word in relation to others, as shown in the requirement statement  306 . An example implementation of a testability ruleset for the system  102  for performing analyses such as those noted above in  FIGS. 2 and 3  is given below. 
       FIG. 4  shows an example  400  of determining an intent artifact  404  for a requirement statement  402  in active voice: “The system should display the numbers in ascending order.” In this example, the intent artifact  404  that the system  102  determined includes a first intent  406  to verify that the system is able to display the numbers, and a second intent  408  to verify that the display of the numbers happens in ascending order. To determine intent, the system  102  may determine other characteristics  410  of the requirement statement, such as the agent, action, object, and modifier. 
       FIG. 5  shows an example  500  of determining an intent artifact  504  for a requirement statement  502  in passive voice: “The numbers displayed by the system should be in ascending order.” In this example, the intent artifact  504  that the system  102  determined includes a first intent  506  to verify that the system is able to display the numbers, and a second intent  508  to verify that the display of the numbers happens in ascending order. To determine intent, the system  102  may determine other characteristics  510  of the requirement statement, such as the agent, action, object, and modifier. 
     A compound sentence or statement may be a sentence or statement that has multiple subjects. A simple sentence or statement may be a sentence or statement that has a single subject. A subject may be a word, phrase or formal expression about which something is predicated. The subject may be, for example, a noun, noun phrase or noun substitute. 
       FIG. 6  shows an example  600  of determining an intent artifact  602  for a compound requirement statement  604 : “The user should be able to add or delete data from the table.” The intent artifact  602  that the system  102  determined includes multiple intents that the system  102  extracted from the compound requirement statement: 1) Verify that the user is able to add data; 2) Verify the add of data happens from the table; 3) Verify the user is able to delete data; 4) Verify the delete of data happens from the table; 5) Verify that add or delete is possible. As with the examples above, the system  102  may determine other characteristics  606  of the requirement statement, such as the agent, multiple actions, a modifier, conjunction, and object. 
       FIG. 7  shows an example  700  of determining an intent artifact  702  for a requirement statement  704  with dependent clauses: “If the password is correct, then homescreen should be displayed.” The intent artifact  702  includes two intents in this example: 1) Verify the password is correct; 2) Verify homescreen is displayed and the overall intent 3) Verify that &lt;intent1&gt; leads to &lt;intent2&gt;. Again, the system  102  may determine other characteristics  706  of the requirement statement, such as the agents and actions. 
     An intent may, for example, be a logical step that must be executed in order to perform a test. The intent may be the most atomic unit that conveys enough information for a test to be made. In some cases, the intent may be a set of words along a path of links bounded by noun phrases. The intents of a requirement statement may be represented by an intent artifact. The links of the requirement statement identified by a grammatical parser may be traversed in order to identify the intents. A grammatical parser may, for example, be implemented as a syntactic parser or a dependency parser, such as a dependency parser with an extensible dictionary. Static text may be added to each intent through an intent template, i.e. action, (discussed in more detail below) in order to maintain the meaning of the intent. Identifying test intents may increase the comprehensibility of the requirement statement by breaking the requirement statement into individual testable components, such as test steps corresponding to the requirement statement. Intents may be useful when analyzing long requirement statements and/or may be used to remove syntactic ambiguity (such as ambiguity arising from the structure of the requirement statement). Intents may also act as a proxy to estimate the amount of testing effort needed to test a requirement statement. Other uses may be possible. 
       FIG. 8  shows examples  800  of determining category artifacts for requirement statements. Possible categories may, for example, include a) Input/Output, b) Intermodule, c) Security, d) Usability, e) Conformance, f) Dependency, g) Non-Functional (NFR), and h) Business Logic, and/or various other categories. 
     In the first requirement statement  802 , the system  102  determines that two applicable categories are Input and Security. The Input category is applicable due to the noun/verb construct “user enters,” while the Security category is applicable due to the presence of the word “password.” In the requirement statement  804 , the system  102  determines that the applicable category is Non-Functional Requirement (NFR), due to the presence of the non-functional requirement “within 3 seconds.” A NFR may define characteristics such as performance, availability, or other non-functional aspects, as opposed to functional or behavioral aspects. 
     In some systems, it may be useful or necessary to determine whether the requirement statement can be categorized as NFR, Input/Output, or Intermodule. Syntactic patterns and semantic rules may be used to determine whether the requirement statement is in the ‘Input/Output’ or ‘Intermodule’ category. For example, a requirement statement in one of these two categories may be characterized by two noun phrases connected by either a verb or an adverb. According to a more specific example, if both the noun phrases are “system” nouns, the category may be ‘Intermodule’. If one of the nouns is a “person noun”, the requirement statement may be categorized as ‘Input/Output’. Semantic rules may be used with a category glossary  1030  to determine what constitutes “system nouns”, and “person nouns”. 
     In some systems and methods, a requirement statement may be categorized as Security if any phrase from a security glossary is present in the requirement statement. Other examples are possible. 
       FIG. 9  shows examples  900  of determining data artifacts  902  and  904  for requirement statements  906  and  908  respectively. In particular, the system  102  has determined that the data artifact  902  should be: test data “&lt;3 seconds”, which gives criteria and data for testing the code that implements the requirement statement  906 . Similarly, the system  102  has determined that the data artifact  904  should be: test data &gt;6 characters and &lt;8 characters. 
       FIG. 10  shows one example implementation of the requirements testing system  102 . As an overview, the system  102  may include a natural language parser which provides parts of speech and relational links between words. In one implementation, the system  102  employs the Link Grammar (LG) Parser from CMU (available at http://www.link.cs.cmu.edu/link/). The examples below are expressed in terms of the LG parser nomenclature, however, the system may instead implement other parser logic and corresponding rulesets. The link types are summarized at http://www.link.cs.cmu.edu/link/dict/summarize-links.html, and more detail is given in individual web pages for each link type named following a regular pattern and building from the root URL http://www.link.cs.cmu.edu/link/dict/. For example, additional information on the SI link may be found at http://www.link.cs.cmu.edu/link/dict/section-SI.html. 
     The system  102  may also include a set of pattern matching rules which identify link structure patterns, referred to as primary structures, that determine test artifacts including the initial intents of the requirement statement. In addition, a set of extended rules identify extensions to the initial intents to provide secondary intents. The extended rules may analyze noun, verb modifiers, gerunds and other modifiers, as examples. A set of entity mapping rules maps noun phrases and verb phrases to a keyword list or glossary to categorize requirements into test categories. The system  102  may also include a set of quantifier constraints (and other modifiers) that identify test data and logic to generate a test data range. Example implementations of the rulesets are provided in the tables below. The system  102  may implement additional, fewer, or different rulesets to analyze requirements statements for additional, fewer, or different test artifacts. 
     In some systems and methods, the rules in a ruleset may specify a contiguous set of links that must be present in a requirement statement. For example, the testability ruleset may specify a contiguous set of links that must be present in a requirement statement in order for the requirement statement to be classified as testable. Other examples are possible. 
     The system  102  may include a processor  1002  and a memory  1004  (with logic for execution by the processor  1002 ) that implement the analysis engine  112 . The system  102  receives (from either local or remote sources) and stores in the memory  1004  a requirement statement  1006  for analysis. Preprocessor logic  1008  may first filter each requirement statement  1006 . 
     The preprocessor logic  1008  includes preprocessing rulesets (e.g., the preprocessing rulesets  1010  and  1012 ). The preprocessing rulesets cause the preprocessing logic  1008  to perform analysis, modification, or other actions on requirement statements. Table 1 and Table 2 give examples of the preprocessing rulesets. 
     
       
         
               
             
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 Preprocessor Ruleset 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 Rule1: Prune ending punctuation marks. 
               
               
                 Rule 2: Convert Unicode text to ASCII text 
               
               
                 Rule 3: Convert URLs in text into an Acronym 
               
               
                 Rule 4: Replace quoted words into Acronyms. Replace other words 
               
               
                 which are in title case with Acronyms. 
               
               
                 Rule 5: Add a space before and after a comma (if not present) 
               
               
                 Rule 6: Remove extra white spaces 
               
               
                 Rule 7: Remove text enclosed in brackets and the brackets themselves 
               
               
                 Rule 8: Replace terms in the entity glossary with Acronyms 
               
               
                 Rule 9: Convert the sentence to lower case. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
             
           
               
                 TABLE 2 
               
               
                   
               
               
                 Preprocessor Ruleset 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 Rule: Replace won&#39;t −&gt; would not 
               
               
                 Rule: Replace can&#39;t −&gt; can not 
               
               
                 Rule: Replace mustn&#39;t −&gt; must not 
               
               
                 Rule: Replace couldn&#39;t −&gt; could not 
               
               
                 Rule: Replace shouldn&#39;t −&gt; should not 
               
               
                 Rule: Replace cannot −&gt; can not 
               
               
                 Rule: Replace needn&#39;t−&gt; need not 
               
               
                 Rule: Replace wouldn&#39;t−&gt;would not 
               
               
                 Rule: Replace “no later than” with “by” 
               
               
                 Rule: Replace “no sooner than” with “after” 
               
               
                 Rule: Replace “less than”, “lesser than”, “lower than”, “fewer than” with 
               
               
                 “&lt;” 
               
               
                 Rule: Replace “as many as”, “as much as”, “up-to”, “at most”, “some”, 
               
               
                 “about”, with &lt;= 
               
               
                 Rule: Replace “more than”, “greater than”, “higher than”, “further than”, 
               
               
                 “just over”, “well over”, ”” with &gt; 
               
               
                 Rule: Replace “at least” with &gt;= 
               
               
                   
               
             
          
         
       
     
     In some instances, when the preprocessor logic  1008  converts the words in the sentence to lower case, the words (e.g., when they are acronyms) may not be recognized as valid entries in the parser logic dictionary. To address this situation, the system  102  may modify the parser logic dictionary to treat all unknown words as a noun, and associate with the unknown words with the links given to recognized nouns. The system  102  may also handle verbs used as nouns, as with the word “update” in the example “The system should disable the update button.” In one implementation, the system  102  identifies as dual use words those words that may be used both as a verb and as a noun, updates the parser logic dictionary to indicate that the dual use words may be used as both a verb and a noun, and associates the links given to verbs and nouns with the dual use words. Words may be identified as dual use words in many ways, such as by scanning a dictionary or other grammatical database such as the Word Net™ database (wordnet.princeton.edu). Identifying dual use words in the parser logic dictionary may be advantageous in some instances, such as where a requirement statement might not otherwise be properly parsed, like where a noun may be incorrectly identified as a verb. 
     The pre-processed requirement statement is passed onto the parser logic  1014 . If no linkages are found by the parser logic  1014  (null count&gt;0), the system  102  highlights the requirement statement as grammatically incorrect. If the parser logic  1014  has found a complete linkage, then the parser output, including grammatical links between words and phrases, the constituent tree and the classification of words into the parts of speech (which may be based on the suffix put after the input words) are saved in memory  1004 . The constituent tree may classify the words in the requirement statement into parts of speech and arranges words into phrases. The parser output may be evaluated by the analysis logic  1018 , including, for example, by submission of the parser output and requirement statement  1006  as input data to one or more analysis rulesets  1032 . The rules within the analysis rulesets that fire on the input data indicate the test artifacts  1020  for the requirement statements. 
     Furthermore, the analysis logic  1018  may reference one or more glossaries, such as, for example, the ambiguity glossary  1022 , conformance glossary  1024 , usability glossary  1026 , entity glossary  1028 , and category glossary  1030  as noted in the rules below to facilitate processing the requirement statement  1006 . The glossaries may be leveraged from the document commenting and analysis applications (DARAs) identified below and incorporated by reference. 
     The example analysis rulesets given below show the condition to be checked on the parser outputs  1016  of the parser logic  1014 , the corresponding action to be taken, and whether a specific test artifact  1034  is determined. The examples referred to by number in the tables are found in the drawings. For instance, Examples 5.1, 5.1.1, and 5.1.2 are found in  FIG. 12 . 
     
       
         
               
             
               
               
               
               
             
           
               
                 TABLE 3 
               
             
             
               
                   
               
               
                 Testability Ruleset 
               
               
                 If any of the following rules fire the analysis logic 1018 determines 
               
               
                 that the requirement statement is testable, otherwise the requirement 
               
               
                 statement is untestable. The analysis logic 1018 may then proceed to 
               
               
                 determine ambiguity, intent, categorization and data artifacts. 
               
             
          
           
               
                 Rule 
                   
                 Rule in LG 
                   
               
               
                 ID 
                 Rule 
                 nomenclature 
                 Examples 
               
               
                   
               
               
                 T.1 
                 Subject - Modal -Verb - Object 
                 S-l*-O 
                 5.1, 
               
               
                   
                   
                   
                 FIG. 12 
               
               
                 T.2 
                 Subject-Modal-Passive Verb- 
                 S-lx-P* 
                 5.3, 
               
               
                   
                 Prepositions 
                   
                 FIG. 19 
               
               
                 T.3 
                 Subject - Modal - Passive Verb - 
                 S-lx-OF 
                 5.4, 
               
               
                   
                 Prepositions 
                   
                 FIG. 20 
               
               
                 T.4 
                 Subject-Participles-‘in order to’- 
                 S-Pv-TO-l*-O 
                 5.5, 
               
               
                   
                 Modal-Verb-Object 
                   
                 FIG. 21 
               
               
                   
               
             
          
         
       
     
     The system  102  may recognize a testable requirement statement based on whether the testable requirement statement includes a modal verb represented with links “I” (rule IDs T.1 and T.4) and “Ix” (rule IDs T.2 and T.3) in Table 3. For example, the requirement statement may be determined to be testable based on the presence of contiguous links, e.g. S-I-O (rule ID T.1). The linkage S-I-O denotes that a subject (link S) should connect to a modal verb (link I) which in turn should connect to an object (link O). In some configurations, the requirement statement may be determined to be testable based on the presence of a combination of 8 links, as shown in Table 3 (i.e. links S, I, Ix, P, O, OF, Pv, TO, as specified in LG nomenclature in Table 3). Other examples are possible. 
     Sentence Simplification Ruleset 
     
       
         
               
               
               
               
               
             
           
               
                   
               
               
                 Rule 
                   
                 Rule in LG 
                   
                   
               
               
                 Id 
                 Rule 
                 Nomenclature 
                 Breakup/simplification 
                 Examples 
               
               
                   
               
             
             
               
                 S.1 
                 Sentences of 
                 MVs-Cs 
                 Break the sentence into 
                 FIG. 38 
               
               
                   
                 type 
                   
                 two clauses, &lt;clause−&gt; &amp; 
               
               
                   
                 dependency 
                   
                 &lt;clause+&gt;. 
               
               
                   
                 (with 
                   
                 &lt;clause−&gt; starts from the 
               
               
                   
                 antecedent 
                   
                 sentence beginning up to 
               
               
                   
                 and 
                   
                 the word before the Cs+ 
               
               
                   
                 consequent) 
                   
                 word. 
               
               
                   
                   
                   
                 Skip the Cs+ word. This 
               
               
                   
                   
                   
                 word is recorded for use 
               
               
                   
                   
                   
                 in Intents 
               
               
                   
                   
                   
                 &lt;clause+&gt; starts from the 
               
               
                   
                   
                   
                 Cs− word beginning up to 
               
               
                   
                   
                   
                 the end of the sentence. 
               
               
                 S.2 
                 Sentence 
                 CO, CO*s 
                 Break the sentence into 
                 5.6 FIG. 21 
               
               
                   
                 openers 
                   
                 two clauses, &lt;clause−&gt; &amp; 
               
               
                   
                   
                   
                 &lt;clause+&gt;. 
               
               
                   
                   
                   
                 &lt;clause−&gt; is the set of 
               
               
                   
                   
                   
                 words that can be 
               
               
                   
                   
                   
                 reached from CO*s+. 
               
               
                   
                   
                   
                 &lt;clause+&gt; that can be 
               
               
                   
                   
                   
                 reached through CO*s−. 
               
               
                   
                   
                   
                 Record the Type of 
               
               
                   
                   
                   
                 breakup with the word 
               
               
                   
                   
                   
                 pointed by CO*s 
               
               
                 1.2 
                 Independent 
                 CC, Xx 
                 Break the sentences into 
                 5.7 
               
               
                   
                 clauses 
                   
                 two clauses. &lt;clause−&gt; is 
                 FIG. 22 
               
               
                   
                   
                   
                 the set of words that can 
               
               
                   
                   
                   
                 be reached from CC−. 
               
               
                   
                   
                   
                 &lt;clause+&gt; is the set of 
               
               
                   
                   
                   
                 words that can be 
               
               
                   
                   
                   
                 reached through &lt;CC+&gt;. 
               
               
                   
                   
                   
                 Similar operation for Xx 
               
               
                 1.4 
                 Conjunctions 
                 VJ, MJ, RJ, SJ 
                 Break the sentence into 
                 5.9 
               
               
                   
                 (Verb, Noun, 
                   
                 two clauses, &lt;clause−&gt; &amp; 
                 FIG. 24, 25, 
               
               
                   
                 Prepositions, 
                   
                 &lt;clause+&gt;. 
                 26, 27 
               
               
                   
                 adverbs) 
                   
                 &lt;clause−&gt; starts with the 
               
               
                   
                   
                   
                 sentence beginning up to 
               
               
                   
                   
                   
                 Jl+ word. It then 
               
               
                   
                   
                   
                 continuous from the word 
               
               
                   
                   
                   
                 after Jr− up to the end of 
               
               
                   
                   
                   
                 the sentence. 
               
               
                   
                   
                   
                 &lt;clause+&gt; starts with the 
               
               
                   
                   
                   
                 sentence beginning up to 
               
               
                   
                   
                   
                 the word before Jl−. It 
               
               
                   
                   
                   
                 then continuous from the 
               
               
                   
                   
                   
                 Jr− word up to the end of 
               
               
                   
                   
                   
                 the sentence. 
               
               
                 1.5 
                 Sentence with 
                 SJn 
                 If the Sentence contains 
                 5.1.1 
               
               
                   
                 ”Neither - 
                   
                 an &lt;N&gt; link, flag as error 
                 FIG. 12 
               
               
                   
                 Nor” 
                   
                 and proceed to the next 
               
               
                   
                   
                   
                 analysis. 
               
               
                   
                   
                   
                 Find the word (other than 
               
               
                   
                   
                   
                 SJr) that connects to the 
               
               
                   
                   
                   
                 SJn− word. Introduce 
               
               
                   
                   
                   
                 ‘not’ after this word. 
               
               
                   
                   
                   
                 Remove the Dn+ word. 
               
               
                   
                   
                   
                 Replace SJn− with ‘and’ 
               
               
                 1.6 
                 Relative 
                 B-R-RS, B-R- 
                 Break the sentence into 
               
               
                   
                 Clauses 
                 Cr 
                 two clauses, &lt;clause−&gt; &amp; 
               
               
                   
                   
                   
                 &lt;clause+&gt; at the B link. 
               
               
                   
                   
                   
                 &lt;clause−&gt; contains the 
               
               
                   
                   
                   
                 words reachable from the 
               
               
                   
                   
                   
                 B+ word but not 
               
               
                   
                   
                   
                 connected to the B− 
               
               
                   
                   
                   
                 word. 
               
               
                   
                   
                   
                 &lt;clause+&gt; starts with the 
               
               
                   
                   
                   
                 B+ word. 
               
               
                   
                   
                   
                 Include a determiner 
               
               
                   
                   
                   
                 ‘the’; delete the word 
               
               
                   
                   
                   
                 with the R− link. Continue 
               
               
                   
                   
                   
                 till the end of the 
               
               
                   
                   
                   
                 sentence. 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
               
             
           
               
                 TABLE 4 
               
             
             
               
                   
               
               
                 Ambiguity Ruleset 
               
             
          
           
               
                 Rule 
                   
                 Rule in LG 
                   
               
               
                 ID 
                 Rule 
                 nomenclature 
                 Examples 
               
               
                   
               
               
                 T.A.1 
                 Identify word acting as an adjective 
                 A, AJl, AJr, 
                   
               
               
                   
                   
                 Ma, Pa, MJla, MJra 
               
               
                 T.A.1.1 
                 Check if the word is not present in 
                 — 
                 Described 
               
               
                   
                 the non-ambiguous list (e.g., by 
                   
                 below with 
               
               
                   
                 checking the glossary for 
                   
                 regard to 
               
               
                   
                 unambiguous terms)- if so, the 
                   
                 the ambiguity 
               
               
                   
                 system 102 marks the word as 
                   
                 checker and 
               
               
                   
                 ambiguous 
                   
                 ambiguity 
               
               
                   
                   
                   
                 glossary. 
               
               
                 T.A.2 
                 Identify adverbs 
                 EA, MVa, RJl, RJr, EN, 
               
               
                   
                   
                 EE, EC, El 
               
               
                 T.A.2.1 
                 Check if the word is not present in 
                 — 
                 Described 
               
               
                   
                 the non-ambiguous list - if so, the 
                   
                 below with 
               
               
                   
                 system 102 marks the word as 
                   
                 regard to 
               
               
                   
                 ambiguous 
                   
                 the ambiguity 
               
               
                   
                   
                   
                 checker and 
               
               
                   
                   
                   
                 ambiguity 
               
               
                   
                   
                   
                 glossary. 
               
               
                 T.A.3 
                 Identify determiners to nouns 
                 Dmc*, Ds, p 
               
               
                 T.A.3.1 
                 Check if the word is not present in 
                 — 
                 Described 
               
               
                   
                 the non-ambiguous list - if so, the 
                   
                 below with 
               
               
                   
                 system 102 marks the word as 
                   
                 regard to 
               
               
                   
                 ambiguous 
                   
                 the ambiguity 
               
               
                   
                   
                   
                 checker and 
               
               
                   
                   
                   
                 ambiguity 
               
               
                   
                   
                   
                 glossary. 
               
               
                 T.A.4 
                 Identify the presence of ambiguous 
                 l*m, lfm, lcm 
               
               
                   
                 modal verbs 
               
               
                 T.A.4.1 
                 If the link is present, mark the modal 
               
               
                   
                 word attached to the link as 
               
               
                   
                 ambiguous 
               
               
                 T.A.5 
                 Identify Adverbs connected to E 
                 E 
               
               
                 T.A.5.1 
                 If such words have a type “.a” or 
               
               
                   
                 nothing, then we check if the word is 
               
               
                   
                 not present in the non-ambiguous list - 
               
               
                   
                 if so, the system 102 marks the 
               
               
                   
                 word as ambiguous 
               
               
                   
               
             
          
         
       
     
     When a particular rule fires for a parsed sentence, the system  102  generates a corresponding intent template (e.g, “Verify &lt;NP&gt; was &lt;VP&gt; &lt;MV:CT&gt;”). The system  102  fills the template with appropriate words from the constituent tree of the sentence. The system  102  may implement a set of rules developed over any set of example sentences created for setting up the system  102 . With regard to notation, the notation &lt;L:T&gt; denotes the phrase encapsulated within the tag ‘T’ in the constituent tree. Any word of the phrase should have a link ‘L’. The link ‘L’ may specify (e.g., using the ‘+’ or ‘−’ flag) whether the system  102  should analyze the start or the end of the link. 
     
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE 5a 
               
             
             
               
                   
               
               
                 Intent Ruleset 
               
             
          
           
               
                   
                   
                   
                 Primary Rule in 
                 Secondary 
               
               
                 Rule 
                   
                   
                 LG 
                 Rule in LG 
               
               
                 ID 
                 Primary Rule 
                 Secondary Rule 
                 nomenclature 
                 nomenclature 
               
               
                   
               
               
                 I.1 
                 Subj-Modal- 
                 — 
                 S-l-O 
                   
               
               
                   
                 Verb--Object 
               
               
                 I.1.2 
                   
                 Noun Modifiers—Adjectival; 
                   
                 &lt;NP&gt;-Ma 
               
               
                   
                   
                 Prepositional; Participle; 
                   
                 &lt;NP&gt;-Mp 
               
               
                   
                   
                 Gerund 
                   
                 &lt;NP&gt;-Mv 
               
               
                   
                   
                   
                   
                 &lt;NP&gt;-Mg 
               
               
                 I.1.4 
                   
                 Noun modifiers—infinitive 
                   
                 &lt;NP&gt;-TO-l- 
               
               
                   
                   
                 ‘to’-object 
                   
                 O 
               
               
                 I.1.4.1 
                   
                   
                   
                 &lt;:NP&gt;- 
               
               
                   
                   
                   
                   
                 &lt;:VP&gt;-MV 
               
               
                 I.1.5 
                   
                 Noun modifiers—preposition- 
                   
                 TO-l 
               
               
                   
                   
                 infinitive 
               
               
                 I.1.7 
                   
                 Verb Modifiers—Adverbs; 
                   
                 l-E 
               
               
                   
                   
                 Adjectival 
                   
                 l-MVa 
               
               
                 I.1.8 
                   
                 Verb Modifiers—Prepositions; 
                   
                 l-MVp 
               
               
                   
                   
                   
                   
                 l-PP 
               
               
                 I.1.9 
                   
                 Verb Modifiers—conjunctions 
                   
                 l-MVs 
               
               
                 I.1.10 
                   
                 Verb Modifiers—“in order to” 
                   
                 l-MVi 
               
               
                 I.1.11 
                   
                 Verb Modified by forms of ‘be’ 
                   
                 l-Pp 
               
               
                 I.2 
                 Subject - 
                   
                 S-lf-O 
               
               
                   
                 Modal - 
               
               
                   
                 Forms of 
               
               
                   
                 Verb “be” - 
               
               
                   
                 Object 
               
               
                 I.2.1 
                   
                 Noun modifiers—Infinitive 
                   
                 TO-l-O 
               
               
                   
                   
                 ‘to’-object 
               
               
                 I.2.2 
                   
                 Noun modifiers—Infinitive 
                   
                 TO-l 
               
               
                   
                   
                 ‘to’ 
               
               
                 I.2.3 
                   
                 Verb modifiers—adjectival 
                   
                 lf-MV 
               
               
                   
                   
                 Prepositions; conjunctions 
               
               
                 I.2.4 
                   
                 Verb Modifiers—Connecting 
                   
                 lf-MV-M 
               
               
                   
                   
                 to noun modifiers 
               
               
                 I.3 
                 Subject- 
                   
                 S-lx 
               
               
                   
                 Modal- 
               
               
                   
                 Passive 
               
               
                   
                 Verb- 
               
               
                 I.3.1 
                   
                 Modal Verb 
                   
                 Pa 
               
               
                   
                   
                 Modifiers—Adjectival 
               
               
                 I.3.2 
                   
                 Modal Verb 
                   
                 Pv, 
               
               
                   
                   
                 Modifiers—Participle; gerund 
                   
                 Pg 
               
               
                 I.3.3 
                   
                 Modal Verb 
                   
                 Pp, OF 
               
               
                   
                   
                 Modifiers—Prepositions 
               
               
                 I.3.4 
                   
                 Modal Verb Modifiers 
                   
                 P*-MVp 
               
               
                   
                   
                 connecting to Verb 
               
               
                   
                   
                 Modifiers—Prepositions 
               
               
                 I.3.5 
                   
                 Modal Verb Modifiers 
                   
                 P*-MVi 
               
               
                   
                   
                 connecting to Verb 
               
               
                   
                   
                 Modifiers—“in order to” 
               
               
                 I.3.6 
                   
                 Modal Verb Adjectival 
                   
                 Pa-TO-l-O 
               
               
                   
                   
                 Modifier—Connecting 
               
               
                   
                   
                 to infinitival ‘to’ - object 
               
               
                 I.4 
                 - Subject- 
                   
                 S-Pv-TO-l*-O 
               
               
                   
                 Participles- 
               
               
                   
                 ‘in order to’- 
               
               
                   
                 Modal-Verb- 
               
               
                   
                 Object 
               
               
                 I.4.1 
                   
                 Noun &amp; Verb modifiers 
                   
                 All the links 
               
               
                   
                   
                 of I.1 
                   
                 which S-l-O 
               
               
                   
                   
                   
                   
                 can take, 
               
               
                   
                   
                   
                   
                 can come 
               
               
                   
                   
                   
                   
                 here. 
               
               
                 I.5 
                 Subject - 
                   
                 S-l(w)-TO-l*-O 
               
               
                   
                 Modal - 
               
               
                   
                 Weak Verb - 
               
               
                   
                 ‘TO’ - Verb - 
               
               
                   
                 Object 
               
               
                 I.5.1 
                   
                 Noun &amp; Verb Modifiers 
                   
                 All the links 
               
               
                   
                   
                   
                   
                 which S-l-O 
               
               
                   
                   
                   
                   
                 can take 
               
               
                   
                   
                   
                   
                 come here. 
               
               
                   
                   
                   
                   
                 There would 
               
               
                   
                   
                   
                   
                 be no 
               
               
                   
                   
                   
                   
                 secondary 
               
               
                   
                   
                   
                   
                 links for the 
               
               
                   
                   
                   
                   
                 weak verb - 
               
               
                   
                   
                   
                   
                 l(w) 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
               
             
           
               
                 TABLE 5b 
               
             
             
               
                   
               
               
                 Intent Ruleset 
               
             
          
           
               
                   
                 Template 
                   
                   
               
               
                   
                 Note: in some cases, the 
               
               
                   
                 object may not exist - thus 
                   
                 Example 
               
               
                 Rule 
                 the entire line of the object 
                   
                 (See FIGS. 
               
               
                 ID 
                 is not included in the intent. 
                 Meaning 
                 12-27, 38-39) 
               
               
                   
               
               
                 I.1 
                 Intent: Verify &lt;agent&gt; 
                 &lt;agent&gt; is the noun phrase in 
                 5.1, 
               
               
                   
                 Is/are &lt;N&gt; able to &lt;action&gt; 
                 the constituent tree, collected 
                 FIG. 
               
               
                   
                 &lt;object&gt; 
                 recursively within NP starting 
                 12 
               
               
                   
                 (E.g., Verify &lt;S+:NP&gt; is/are 
                 from the word with the S+ 
               
               
                   
                 {&lt;N−&gt;} able to &lt;l−&gt; &lt;O−: 
                 link. Note: the immediate 
               
               
                   
                 NP&gt;) 
                 keyword may be ADVP (only 
               
               
                   
                   
                 system A can) 
               
               
                   
                   
                 &lt;action&gt; is the verb phrase 
               
               
                   
                   
                 (VP) from the constituent tree 
               
               
                   
                   
                 &lt;object&gt; is the noun phrase 
               
               
                   
                   
                 in the constituent tree, 
               
               
                   
                   
                 collected recursively within 
               
               
                   
                   
                 NP starting from the word 
               
               
                   
                   
                 with the O− link. 
               
               
                   
                   
                 If agent is plural denoted by a 
               
               
                   
                   
                 subscript p (of Sp) or if there 
               
               
                   
                   
                 are multiple subjects (denoted 
               
               
                   
                   
                 by SJl &amp; SJr), use ‘are’, else 
               
               
                   
                   
                 ‘is’ 
               
               
                   
                   
                 &lt;N&gt; = ‘Not’ when an ‘N’ link 
               
               
                   
                   
                 connects after S 
               
               
                 I.1.2 
                 &lt;Base Intent&gt; 
                 &lt;CT&gt; (constituent tree): 
                 5.1.2, 
               
               
                   
                 If secondary rule connected 
                 Ma: 
                 FIG. 
               
               
                   
                 to Subject: 
                 &lt;Ma*n&gt;&lt;ADJP&gt;&lt;PP&gt;&lt;NP&gt;&lt; 
                 12 
               
               
                   
                 Intent#: verify &lt;subject&gt; 
                 VP&gt; . . . 
               
               
                   
                 Is/are &lt;CT&gt;. 
                 Mp: 
               
               
                   
                 If secondary rule connected 
                 &lt;Mp*n&gt;&lt;PP&gt;&lt;NP&gt;&lt;ADJP&gt;&lt; 
               
               
                   
                 to Object: 
                 VP&gt; . . . 
               
               
                   
                 Intent#: verify &lt;object&gt; 
                 Mv: &lt;Mp*n&gt;&lt;VP&gt; 
               
               
                   
                 Is/are &lt;CT&gt;. 
                 Mg: &lt;Mg*n&gt;&lt;VP&gt; 
               
               
                   
                 (e.g., Verify &lt;NP&gt; is/are 
                 Where the new intent is 
               
               
                   
                 &lt;M+:CT&gt;*) 
                 started if one of the 
               
               
                   
                   
                 secondary links are found 
               
               
                   
                   
                 connected to the primary. 
               
               
                   
                   
                 &lt;ADJP&gt; is the word indicated 
               
               
                   
                   
                 by Ma−, MVa− 
               
               
                   
                   
                 &lt;PP&gt; is the word indicated by 
               
               
                   
                   
                 Mp−, MVp− 
               
               
                   
                   
                 &lt;NP&gt; is the word indicated by 
               
               
                   
                   
                 &lt;J−&gt; 
               
               
                   
                   
                 Is/are is similarly decided on 
               
               
                   
                   
                 the plurality of the Object. If 
               
               
                   
                   
                 Op, ‘are’, else ‘is’ 
               
               
                 I.1.4 
                 &lt;Base Intent&gt; 
                 &lt;object2&gt; &amp; &lt;action2&gt; comes 
                 5.1.4, 
               
               
                   
                 {connected to subject:} 
                 from l-O 
                 FIG. 
               
               
                   
                 Intent#: Verify &lt;subject&gt; 
                   
                 13 
               
               
                   
                 Is/are able to &lt;action2&gt; 
               
               
                   
                 &lt;Object2&gt; 
               
               
                   
                 {connected to object:} 
               
               
                   
                 Intent#: Verify &lt;object&gt; 
               
               
                   
                 Is/are able to &lt;action2&gt; 
               
               
                   
                 &lt;Object2&gt; 
               
               
                   
                 (E.g., Verify &lt;S′+NP&gt; is/are 
               
               
                   
                 able to &lt;l−&gt; the &lt;O′−&gt; using 
               
               
                   
                 &lt;O−:NP&gt;) 
               
               
                 I.1.4.1 
                 Verify &lt;NP&gt; was &lt;VP&gt; 
               
               
                   
                 &lt;MV:CT&gt; 
               
               
                   
                 Where: 
               
               
                   
                 &lt;MV:CT&gt; is 
               
               
                   
                 If MVa: &lt;MVa−:ADVP&gt; 
               
               
                   
                 If MVp: &lt;MVp−:PP&gt;&lt;J+:NP&gt; 
               
               
                   
                 If MVs: &lt;MVs−:SBAR&gt; 
               
               
                   
                 If MVl: &lt;MVl−&gt; 
               
               
                 I.1.5 
                 &lt;Base Intent&gt; 
                   
                 5.1.5, 
               
               
                   
                 {connected to subject:} 
                   
                 FIG. 
               
               
                   
                 Intent#: Verify &lt;subject&gt; 
                   
                 14 
               
               
                   
                 Is/are able to &lt;action2&gt; 
               
               
                   
                 {connected to object:} 
               
               
                   
                 Intent#: Verify &lt;object&gt; 
               
               
                   
                 Is/are able to &lt;action2&gt; 
               
               
                 I.1.7 
                 &lt;Base Intent&gt; 
                 ADVP is the phrase in the 
                 5.1.7, 
               
               
                   
                 Intent# Verify the &lt;action&gt; 
                 constituent tree identified 
                 FIG. 
               
               
                   
                 Of &lt;object&gt; 
                 either by the E+ link or the 
                 15 
               
               
                   
                 Happens &lt;ADVP&gt; 
                 MVa−. Note: ignore the 
               
               
                   
                   
                 comma if present in the 
               
               
                   
                   
                 ADVP 
               
               
                 I.1.8 
                 &lt;Base Intent&gt; 
                 PP is the phrase in the 
                 5.1.8, 
               
               
                   
                 Intent# Verify the &lt;action&gt; 
                 constituent tree identified with 
                 FIG. 
               
               
                   
                 Of &lt;object&gt; 
                 the MVp− link. NP is the 
                 15 
               
               
                   
                 Happens &lt;PP&gt; &lt;NP&gt; 
                 phrase in the constituent tree 
               
               
                   
                   
                 with the J− link. 
               
               
                 I.1.9 
                 &lt;Base Intent&gt; 
                 &lt;WHADVP&gt; is the phrase in 
                 5.1.9, 
               
               
                   
                 Intent# Verify the &lt;action&gt; 
                 the constituent tree identified 
                 FIG. 
               
               
                   
                 Of &lt;object&gt; 
                 with the MVs− link. VP is the 
                 16 
               
               
                   
                 Happens &lt;WHADVP&gt; or 
                 phrase in the constituent tree 
               
               
                   
                 &lt;SBAR&gt;or&lt;VP&gt; 
                 with Mv− 
               
               
                 I.1.10 
                 &lt;Base Intent&gt; 
                 &lt;action2&gt; is the VP from the 
                 5.1.10, 
               
               
                   
                 Intent# Verify the &lt;action&gt; 
                 constituent tree with the 
                 FIG. 
               
               
                   
                 Of &lt;Object&gt; 
                 second l−. 
                 16 
               
               
                   
                 Is/are able to &lt;action2&gt; 
                 &lt;object2&gt; is the NP from the 
               
               
                   
                 &lt;object2&gt; 
                 constituent tree with the O− 
               
               
                   
                   
                 link. 
               
               
                   
                   
                 Note: there may be multiple O 
               
               
                   
                   
                 links from the l, the analysis 
               
               
                   
                   
                 logic 1018 may pick up all the 
               
               
                   
                   
                 NP and simply append them 
               
               
                 I.1.11 
                 &lt;Base Intent&gt; 
                 PP is the phrase in the 
                 5.1.11, 
               
               
                   
                 &lt;PP&gt;&lt;NP&gt; 
                 constituent tree identified with 
                 FIG. 
               
               
                   
                   
                 the Pp− link. NP is the phrase 
                 17 
               
               
                   
                   
                 in the constituent tree with the 
               
               
                   
                   
                 J− link. 
               
               
                 I.2 
                 Verify &lt;agent&gt; 
                 {has} logic is like this: 
                 5.2, 
               
               
                   
                 {has} &lt;object&gt; 
                 If N link is present with S− 
                 FIG. 
               
               
                   
                   
                 “does not have”, else 
                 17 
               
               
                   
                   
                 If agent is plural - “have”, 
               
               
                   
                   
                 else “has” 
               
               
                 I.2.1 
                 &lt;Base Intent&gt; 
                 Note: the TO-l-O can be with 
                 5.2.1, 
               
               
                   
                 To &lt;action2&gt;&lt;object2&gt; 
                 the subject or the object 
                 FIG. 
               
               
                   
                   
                   
                 17 
               
               
                 I.2.2 
                 &lt;Base Intent&gt; 
                 Note: the TO-l-O can be with 
                 5.2.2, 
               
               
                   
                 To &lt;action2&gt; 
                 the subject or the object 
                 FIG. 
               
               
                   
                   
                   
                 18 
               
               
                 I.2.3 
                 &lt;Base Intent&gt; 
                 &lt;PP&gt; is the phrase from the 
                 5.2.3, 
               
               
                   
                 &lt;PP&gt;&lt;NP&gt; 
                 constituent tree connected by 
                 FIG. 
               
               
                   
                   
                 the MV− link 
                 18 
               
               
                   
                   
                 Similarly, the NP is the 
               
               
                   
                   
                 phrase with the J− link 
               
               
                 I.2.4 
                 &lt;Base Intent&gt; 
                 &lt;PP2&gt; is the phrase from the 
                 5.2.4, 
               
               
                   
                 &lt;PP&gt;&lt;NP&gt; 
                 constituent tree connected by 
                 FIG. 
               
               
                   
                 &lt;PP2&gt;&lt;NP2&gt; 
                 the M− link 
                 18 
               
               
                   
                   
                 Similarly, the NP2 is the 
               
               
                   
                   
                 phrase with the J− link 
               
               
                 I.3 
                   
                   
                 5.3, 
               
               
                   
                   
                   
                 FIG. 
               
               
                   
                   
                   
                 19 
               
               
                 I.3.1 
                 Verify &lt;agent&gt; 
                 ADJP is the ADJP phrase in 
                 5.3.1, 
               
               
                   
                 Is/are &lt;N&gt; &lt;ADJP&gt; 
                 the constituent tree pointed 
                 FIG. 
               
               
                   
                   
                 by the Pa− link 
                 19 
               
               
                 I.3.2 
                 Verify &lt;agent&gt; 
                 VP is the phrase in the 
                 5.3.2, 
               
               
                   
                 Is/are &lt;N&gt; &lt;VP&gt; 
                 constituent tree pointed by 
                 FIG. 
               
               
                   
                   
                 the Pv− link 
                 19 
               
               
                 I.3.3 
                 Verify &lt;agent&gt; 
                 If PP is there, then the 
                 5.3.3, 
               
               
                   
                 Is/are &lt;N&gt; &lt;PP&gt; 
                 analysis logic 1018 may 
                 FIG. 
               
               
                   
                   
                 analyze the &lt;PP&gt; in the 
                 19 
               
               
                   
                   
                 constituent tree linked by Pp− 
               
               
                 I.3.4 
                 &lt;Base Intent&gt; 
                   
                 5.3.3, 
               
               
                   
                 &lt;PP&gt;&lt;NP&gt; 
                   
                 FIG. 
               
               
                   
                 &lt;PP2&gt;&lt;NP2&gt; 
                   
                 19 
               
               
                 I.3.5 
                 &lt;Base Intent&gt; 
                 VP is the phrase pointed by l− 
                 5.3.4, 
               
               
                   
                 &lt;VP&gt;&lt;NP&gt; 
                   
                 FIG. 
               
               
                   
                   
                   
                 19 
               
               
                 I.3.6 
                 &lt;Base Intent&gt; 
                   
                 5.3.5, 
               
               
                   
                 To &lt;action&gt; &lt;object&gt; 
                   
                 FIG. 
               
               
                   
                   
                   
                 20 
               
               
                 I.4 
                 Verify &lt;agent&gt; 
                   
                 5.5, 
               
               
                   
                 Is able to &lt;action&gt; 
                   
                 FIG. 
               
               
                   
                 &lt;object&gt; 
                   
                 21 
               
               
                 I.4.1 
                 Take the same intent as the 
                   
                 5.1, 
               
               
                   
                 corresponding link i.e. 
                   
                 FIG. 
               
               
                   
                 consider S-Pv-TO-l-O as S- 
                   
                 12 
               
               
                   
                 l-O 
               
               
                 I.5 
                 Intent: Verify &lt;agent&gt; 
                 &lt;action1&gt; corresponds to the 
                 FIG. 
               
               
                   
                 Is/are &lt;N&gt; able to 
                 first verb (which is weak) 
                 39 
               
               
                   
                 &lt;action1&gt; 
                 while &lt;action2&gt; corresponds 
               
               
                   
                 &lt;object1&gt; 
                 to the next action. 
               
               
                   
                 &lt;action 2&gt; 
                 Similarly &lt;object1&gt; and 
               
               
                   
                 &lt;object2&gt; 
                 &lt;object2&gt; correspond to the 
               
               
                   
                   
                 first and second objects 
               
               
                   
                   
                 respectively. 
               
               
                   
               
             
          
         
       
     
     With regard to categorization, the system  102  may implement categorization by identifying the occurrence of phrases and their relation to an action. The system  102  may also, as described below, leverage the categorization processing described in the document commenting, analysis, and reporting applications (“DARAs”), including U.S. Pat. Publication Nos. 2011-0022902, 2010-0005386, and 2009-0138793, which are incorporated by reference in this document in their entireties. 
     
       
         
               
             
               
               
               
               
             
           
               
                 TABLE 6 
               
             
             
               
                   
               
               
                 Category Ruleset 
               
             
          
           
               
                 Rule 
                   
                 Rule in LG 
                   
               
               
                 ID 
                 Rule 
                 nomenclature 
                 Example 
               
               
                   
               
               
                 C.1 
                 Check if any phrase from the NFR 
                 — 
                 Described 
               
               
                   
                 security glossary is present in the input 
                   
                 below 
               
               
                   
                 sentence. 
               
               
                   
                 Tag as “Security” 
               
               
                 C.2 
                 Check if any phrase from the NFR 
                 — 
                 Described 
               
               
                   
                 logging glossary is present in the input 
                   
                 below 
               
               
                   
                 sentence. 
               
               
                   
                 Tag as “Error Handling” 
               
               
                 C.3 
                 If category is not (C.1 or C.2) and a 
                 — 
                 Described 
               
               
                   
                 phrase from NFR glossary is present in 
                   
                 below 
               
               
                   
                 the input sentence. 
               
               
                   
                 Tag as “NFR” 
               
               
                 C.4 
                 Noun−&gt;action−&gt;noun 
                 S-l-O 
                 FIG. 28, 
               
               
                   
                 Where either of the nouns are “people”, 
                 S-MVp-J 
                 2802 
               
               
                   
                 Tag as “Input/Output” 
                 S-lx-Pa-TO-MVp- 
               
               
                   
                 Else if both the nouns are “system 
                 J 
               
               
                   
                 nouns”, 
                 S-l-MVs 
               
               
                 C.5 
                 Noun−&gt;action−&gt;noun 
                 S-l-O 
                 FIG. 28, 
               
               
                   
                 Where either of the nouns is a “person”. 
                 S-MVp-J 
                 2804 
               
               
                   
                 If the “person noun” is connected to the 
                 S-lx-Pa-TO-MVp- 
               
               
                   
                 “input” side of the verb, 
                 J 
               
               
                   
                 Tag as “Input test” 
                 S-l-MVs 
               
               
                 C.6 
                 Noun−&gt;action−&gt;noun 
                 S-l-O 
                 FIG. 28, 
               
               
                   
                 Where either of the nouns is a “person”. 
                 S-MVp-J 
                 2806 
               
               
                   
                 If the “person noun” is connected to the 
                 S-lx-Pa-TO-MVp- 
               
               
                   
                 “output” side of the verb, 
                 J 
               
               
                   
                 Tag as “Output test” 
                 S-l-MVs 
               
               
                 C.7 
                 Check if the sentence has an if/then, 
                 Cs 
                 FIG. 29, 
               
               
                   
                 when, 
                   
                 2902 
               
               
                 C.8 
                 Check if any of the phrases in the 
                 — 
                 FIG. 29, 
               
               
                   
                 system 102 Conformance glossary is 
                   
                 2904 
               
               
                   
                 present in the input sentence. 
               
               
                   
                 Tag as “Conformance” 
               
               
                 C.9 
                 Check if any of the phrases in the 
                 — 
                 FIG. 29, 
               
               
                   
                 system 102 Usability glossary is present 
                   
                 2904 
               
               
                   
                 in the input sentence. 
               
               
                   
                 Tag as “Usability” 
               
               
                 C.10 
                 No rules fire 
               
               
                   
                 Tag as “Business Logic” 
               
               
                   
               
             
          
         
       
     
     The system  102  may employ the entity glossary and the category keyword glossary from the DARAs, or may employ customized glossaries including additional, different, or fewer glossary entries. In particular, the entity glossary may be implemented as the agent glossary in the DARAs. An example NFR dictionary, including a logging and security section is given below in Table 12. 
     Table 7 shows some examples of categories that the system  102  may recognize. 
     
       
         
               
             
               
               
             
           
               
                 TABLE 7 
               
             
             
               
                   
               
               
                 Example Categories 
               
             
          
           
               
                 Category Types 
                 Example 
               
               
                   
               
               
                 Function (or 
                 User shall update the table to overwrite 
               
               
                 Business Logic) test 
                 system default 
               
               
                 Interface/Inter- 
                 The user shall use a touch-screen kiosk to 
               
               
                 module test 
                 select options 
               
               
                 Input domain 
                 The user must enter an 8 digit alphanumeric 
               
               
                 test 
                 password NOT containing special character 
               
               
                   
                 “!” 
               
               
                 Usability/ 
                 75% of the portal content must be viewable in 
               
               
                 conformance 
                 standard 1024*768 browser resolution without 
               
               
                   
                 scrolling down 
               
               
                 Output 
                 The system should emit “1” on successful exit 
               
               
                 correctness 
               
               
                 Condition/ 
                 The invoice is generated only after the 
               
               
                 dependency test 
                 shipment entry tag is processed. 
               
               
                 Error 
                 The exception should be captured and a user 
               
               
                 handling 
                 specific error code should be displayed 
               
               
                 Security 
                 For any secure browser sessions an inactivity 
               
               
                   
                 and timeout condition must be set 
               
               
                 NFR 
                 The system should support 300 logged in 
               
               
                   
                 users and 40 concurrent users 
               
               
                   
               
             
          
         
       
     
     For the security category, the system  102  may compare the requirement statement  1006  to the indicator phrases in the DARAs NFR glossary marked as security. For error handling, the system  102  may compare the requirement statement  1006  to the indicator phrases in the DARAs NFR glossary marked as “logging”, “disaster recovery”, “DisasterRecoveryRequirements”, “Recovery Time”, or any other phrases that indicate error handling. 
     As noted above, the non-functional requirement (NFR) statement specifies how a system should behave. What the behavior should be is captured in the functional requirement. The system  102  may compare the requirement statement  1006  to the indicator phrases in the DARAs NFR glossary, except those marked for security or error handling (as noted above). 
     The system  102  may categorize a requirement statement as involving an inter-module test as follows: 
     Noun→Modal Verb→{Preposition, condition}→Noun 
     Then, the system  102  may confirm that both the nouns are not actors and not persons. An example inter-module test statement  2802  is shown in  FIG. 28  for the requirement statement “The system should send the report to the xyz module.” 
     The system  102  may classify verbs as input/output. For example, the system  102  may regard “send” and “click” as outputs and “receive” as an input. The system  102  may then determine whether a person noun phrase occurs to the left of the verb or to the right of the verb. If the person noun phrase is to the left, the system  102  may categorize the requirement statement as an “Input domain”, else as an “Output domain.” An example Input domain statement  2804  is present in  FIG. 28 . An example output domain statement  2806  is also present in  FIG. 28 . 
     The system  102  may determine that a requirement statement is of the category Condition/Dependency, when the parser logic  1014  locates condition “C” structures in the requirement statement. An example Condition/Dependency statement  2902  is shown in  FIG. 29 . 
     The system  102  may determine that a requirement statement is of the category Usability/Conformance, when the parser logic  1014  locates any of the keywords in the usability glossary or in the conformance glossary, respectively, in the requirement statement. An example Usability/Conformance statement  2904  is shown in  FIG. 29 . 
     With regard to data test artifacts, the system  102  may proceed under the assumption that the preprocessor logic  1008  has executed whatever rulesets have been implemented (e.g., the preprocessor rulesets shown in Tables 1 and 2). For example, the system  102  may assume that the preprocessor logic  1008  has made the following replacements (and optionally other or different replacements defined in the preprocessor rulesets noted above) by the time that the system  102  analyzes the requirement statement for data test artifacts: 
     Replace “no later than” with “by”; 
     Replace “no sooner than” with “after”; 
     Replace “less than”, “lesser than”, “lower than”, “fewer than” with “&lt;”; 
     Replace “as many as”, “as much as”, “up to”, “at most”, “some”, “about”, with &lt;=; 
     Replace “more than”, “greater than”, “higher than”, “further than”, “just over”, “well over”, with &gt;, and 
     Replace “at least” with &gt;=. 
     If the parser logic  1014  output has Nlf &amp; Nit, and either “between” or “from”, then the system  102  may loop through the results until Nlr or threshold. Accordingly, the system  102  may ensure that it handles a range keyword, such as between and from, in the correct manner. The system  102  may, when the parser logic  1014  generates multiple linkages, select the linkage that facilitates further processing of the requirement statement (e.g., the linkage that facilitates a rule firing). 
     
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE 8 
               
             
             
               
                   
               
               
                 Data Ruleset 
               
             
          
           
               
                 Rule 
                   
                 Rule in LG 
                   
                   
               
               
                 ID 
                 Rule 
                 nomenclature 
                 Meaning 
                 Example 
               
               
                   
               
               
                 D.1 
                 Identify all 
                 Pull out the abs number 
                 All numerals will 
                 Described 
               
               
                   
                 numerals 
                 which has the suffix .# 
                 have a suffix of 
                 below 
               
               
                   
                   
                   
                 .# 
               
               
                 D.1.1 
                 Identify unit 
                 If abs no. has an (ND+ 
                 Test Data = abs. 
                 FIG. 30, 
               
               
                   
                 for time 
                 link or (Nlf*or Nit*) −&gt; 
                 no &amp; unit 
                 3002, 
               
               
                   
                 numeral 
                 ND+ link) and ND− 
                 Data Type = time 
                 3006 
               
               
                   
                   
                 connects to a word with 
               
               
                   
                   
                 a suffix of .ti; 
               
               
                   
                   
                 Then data unit = word 
               
               
                   
                   
                 with ND− and data type = 
               
               
                   
                   
                 time 
               
               
                 D.1.2 
                 Identify 
                 If abs no. has (TM+ or 
                   
                 FIG. 30, 
               
               
                   
                 month 
                 TM− link) or (Nlf*or Nit*)−&gt;TM; 
                   
                 3008 and 
               
               
                   
                   
                 data type = day. 
                   
                 FIG. 31, 
               
               
                   
                   
                 Month = the other end of 
                   
                 3102, 
               
               
                   
                   
                 the TM link. 
                   
                 3104 
               
               
                 D.1.3 
                 Identify the 
                 If abs. no has TY− link, 
                 Test Data = day 
                 FIG. 30, 
               
               
                   
                 year 
                 data type = year. Month = 
                 (abs no) + Month + 
                 3008 and 
               
               
                   
                   
                 other end of TY link 
                 year (abs no) 
                 FIG. 31, 
               
               
                   
                   
                 (TY+). Check the month 
                 Data type = Date 
                 3102 
               
               
                   
                   
                 is the same. Else log 
               
               
                   
                   
                 error and keep month as 
               
               
                   
                   
                 that pointed by TY+ 
               
               
                 D.1.4 
                 Identify other 
                 If abs. no has ND+, 
                 Test Data = abs 
                 FIG. 32, 
               
               
                   
                 units 
                 Dmc+, Dmnc+ or AN, 
                 no. &amp; unit 
                 3202, 
               
               
                   
                   
                 or (Nit* or Nlf*) −&gt; ND+, 
                 Data Type = 
                 3204, 
               
               
                   
                   
                 Dmc+, Dmnc+ or AN 
                 natural number 
                 3206 
               
               
                   
                   
                 the unit is that pointed 
               
               
                   
                   
                 by the other end of the 
               
               
                   
                   
                 link 
               
               
                 D.2 
                 Identify 
                 If the LG output has .#b 
                   
                 FIG. 34, 
               
               
                   
                 Boolean data 
                 data 
                   
                 3402, 
               
               
                   
                   
                   
                   
                 3404 
               
               
                 D.2.1 
                 Identify the 
                 Pull out the word with 
                 Test Data = NP 
                 FIG. 34, 
               
               
                   
                 units 
                 the subscript as .#b 
                 Data Type = 
                 3402, 
               
               
                   
                   
                   
                 Boolean 
                 3404 
               
               
                 D.3 
                 Identify the 
                 For all .# data, check the 
                   
                 Described 
               
               
                   
                 condition by 
                 SBAR or PP phrase 
                   
                 below 
               
               
                   
                 looking at the 
                 before the tag 
               
               
                   
                 preposition 
                 containing the .# 
               
               
                   
                 before the 
               
               
                   
                 numeral 
               
               
                 D.3.1 
                 Cases of 
                 SBAR or PP = “before”, 
                 Test Condition - &lt; 
                 Described 
               
               
                   
                 lesser than 
                   
                   
                 below 
               
               
                 D.3.2 
                 Cases of 
                 SBAR or PP or VP = 
                 Test Condition - &gt; 
                 Described 
               
               
                   
                 greater than 
                 “after” 
                   
                 below 
               
               
                 D.3.3 
                 Cases of 
                 SBAR or PP = “by” 
                 Test condition - &lt;= 
                 Described 
               
               
                   
                 lesser than 
                   
                   
                 below 
               
               
                   
                 and equal to 
               
               
                 D.3.4 
                 Cases of 
                 SBAR or PP = “from” 
                 Test Condition - &gt;= 
                 Described 
               
               
                   
                 greater than 
                   
                   
                 below 
               
               
                   
                 and equal to 
               
               
                 D.3.5 
                 Cases of 
                 SBAR or PP or VP = 
                 Test Condition - = 
                 Described 
               
               
                   
                 equal to 
                 “on,”, “to”, “at”, “but”, 
                   
                 below 
               
               
                   
                   
                 “in”, “be” 
               
               
                 D.3.6 
                 Cases of 
                 If .# data has an EN link, 
                 Test Condition - 
                 Described 
               
               
                   
                 symbols 
                 pick up the symbol from 
                 symbol from 
                 below 
               
               
                   
                   
                 EN+ 
                 EN+ 
               
               
                 D.4 
                 Conditions 
                 If the sentence has Nlr 
                 Test Condition - &lt; 
                 Described 
               
               
                   
                 with a range 
                 link, 
                 with the Nlf+ 
                 below 
               
               
                   
                   
                   
                 data 
               
               
                   
                   
                   
                 Test Condition - &gt; 
               
               
                   
                   
                   
                 with the Nit− 
               
               
                   
                   
                   
                 data 
               
               
                   
                   
                   
                 * if the condition 
               
               
                   
                   
                   
                 is between (the 
               
               
                   
                   
                   
                 analysis logic 
               
               
                   
                   
                   
                 1018 may check 
               
               
                   
                   
                   
                 the abs. nos. 
               
               
                   
                   
                   
                 before putting &lt; 
               
               
                   
                   
                   
                 &amp; &gt; - eg: 
               
               
                   
                   
                   
                 between 8 and 4 
               
               
                 D.5 
                 Print the test 
                 — 
                 Data = 
               
               
                   
                 date 
                   
                 {condition} {test 
               
               
                   
                   
                   
                 data} 
               
               
                   
                   
                   
                 Type = {data 
               
               
                   
                   
                   
                 type} 
               
               
                   
               
             
          
         
       
     
     Different kinds of test data may be present in a requirement statement. As examples, time data, date data, numeric data, and Boolean data may be present. The system  102  may recognize test data associated with a numeral, a unit, a condition (such as a relational symbol like &lt;, &gt;, =, &lt;=, &gt;=), a variable that takes values. Furthermore, the system  102  may recognize that a requirement statement includes multiple instances of test data, linked by conjunctions or a range, as examples. The system  102  may identify units of data by pulling out the immediate post nominal link from the identified data. Particular links may be analyzed for time and date. Similarly, the system  102  finds units when the data is in a range (e.g., The password should be between 8 and 10 characters). The system  102  may further identify the condition (such as a relational symbol like &lt;, &gt;, etc). To that end, the system  102  may identify the pronominal modifier to the data (e.g., The password should be less than 10 characters). 
     With regard to numerals, the system  102  may recognize natural numbers, fractions, and decimals, time (e.g., 5:35), date (e.g., first, 1st). The parser logic  1014  may link numbers with a “.#” symbol. The system  102  may then identify numbers by searching the parser logic output for data tagged with a “.#”.  FIG. 30  shows an absolute number example  3002 , a fraction example  3004 , a time example  3006 , and a date example  3008 . The parser logic  1014  may include a dictionary that lists the various numerals and other parts of speech that may occur in an English sentence (e.g., 1, first 2011, and so on). The system  102  may employ a modified dictionary for the parser logic  1014  to supply a suffix of “.#” to each occurrence of such a numeral, similar to the way in which the parser logical may apply of suffix of “.v” to verbs, “.a” to adjectives, “.ti” to time or date. 
     The parser logic  1014  may output tags for time units that include a suffix of .ti→for am, pm, a.m., p.m., o&#39;clock &amp; o-clock, with the numeral connected with an ND link. The system  102  may pick up the numeral from the .# and look at the word reached from it through the ND link to find the numeral. If the word also includes a .ti suffix, the system  102  may conclude that the data is time data. In summary Unit=ND− word; Data type=time. 
     Date information may vary from concepts such as the “last day of the month” to “Midnight, noon, quarterly, weekly, monthly, fortnightly, daily, half-yearly, yearly, annually, p.a., p.m.” to “equal installments” or “intervals”, or other phrases. The system  102  may identify the day by the TM− or TM+ link and may identify the year by the TY− link. 
     The system  102  may determine that if the .# has a TM− or a TM+ link, the .# word is the day. The system  102  may then conclude that the word pointed by the complimentary of the TM is the month. Similarly, if the .# has a TY− link, it is the year. The TY+ link corresponding to this is the month. The month from the day &amp; year should be the same. If they are different, the system  102  may log this condition as an error &amp; choose the month from, for example, the TY+ structure. The system  102  may conclude that if .# is connected with a TM or TY, the data type is date. 
       FIG. 31  shows a date example  3102  (Day: first, Month: January, Year: 2011, and Data Type: Date), as well as a date example  3104  (Day: 30, Month: January, Data Type: Date). 
       FIG. 32  shows a fractional number example  3202 , “the input voltage to tpms system can vary from 0.8 v to 2.7 v” where the system  102  picks up the ND+ link.  FIG. 32  also shows numeric examples  3204  and  3206  in which the system  102  captures numeric data through the Dmnc+ and Dmc+ links. In other situations, the system may mark the unit as “none”, such as in the numeric example  3208 . 
     The system  102  may identify units with a range of data or multiple possible data values.  FIG. 33  shows a range example  3302 , and a range example  3304 . For the range example  3302 , the system  102  may determine that if the .# does not have an ND link, but has (Nlf* or Nit*)→ND, the unit is the ND− link. The system  102  may recognize as ambiguous a requirement statement with multiple dates with the month before the date, as shown in the ambiguous example  3306 . 
     Regarding Boolean data, the system  102  may recognize, as examples, ON, OFF, TRUE, FALSE. These may be associated with the variable in the following examples: 
     If the switch is ON 
     if the switch is in ON position 
     The system  102  may make each of these terms behave like a number and therefore act like an object. The parser logic  1014  may give them a suffix of .#b. The system  102  may increase the weight of Pa and Paf for True &amp; False. This is because, when these occur, they would most likely be used in the Boolean context. 
     The system  102  need not modify weights for ‘on’, since ‘on’ will largely be used in two contexts—“switch on” &amp; “on the table.” In both these cases, ‘on’ cannot act like a number. Similarly, ‘off’ can be used in switched off mainly and again cannot act like a number here. In general, the parser logic  1014  may assign grammatical links in a manner that minimizes the number of links. However, in the context of requirements testing, certain links between words do not fit (e.g., “the switch should be in ON mode.”). Here “ON” is to be used as a Boolean as opposed to a conjunction. The system  102  recognizes this by increasing the weight of the conjunction link of “ON”, thus making the Boolean use of “ON” occur before the former. 
       FIG. 34  shows a Boolean example  3402  parsed by the parser logic  1014 , “When tpms pressure is not sampled in off mode, the transmitted pressure value will be zero, else the value should be set to one.” In this case, the system  102  recognizes that: Test data, tpms pressure=off mode (boolean); Transmitted pressure value=zero (numeric); Value=1 (numeric). Another boolean example  3404  is shown for the statement “The alarm is turned on only when the switch is in on position.” (Test data: switch=on (Boolean)). 
     Note that the time &amp; date can have the prepositions: at, on, for by, before, after, from, to; and phrases like no later than, no sooner than. For the system  102  to identify a condition, the system  102  may search for the (PP or SBAR) from the constituent tree before the NP of the data element. 
     If it is “by”, “before”, put “&lt;” 
     if it is “after”, “from”, put “&gt;” 
     else put “=” 
     If the phrase is no later than, replace with “by” in the pre-processor 
     If the phrase is no sooner than, replace with “after” in the pre-processor 
     For example, “The employees enrolled before 30 January should be permitted to attend”: Test Data:&lt;30 January, Test Type: Time/Date. 
     In case of numeric data, the prepositions that occur are: equal to, less than, more than, greater than, lesser than, higher than, lower than, fewer than, further than, as many as, as much as, up to, at least, at most, be, at, all but, none but, within, in, 
     The system  102  may analyze the &lt;PP&gt; phrase in the constituent tree: 
     To, at, but, in: = 
     In some cases, the system  102  may analyze different tags in the constituent tree: 
     Be: &lt;VP&gt;: = 
     “Less than” is generating the EN link as the next option. The system  102  may look for the next, however, the system  102  may replace these terms using the pre-processor logic  1008 : 
     Less than, lesser than, lower than, fewer than, &lt; 
     as many as, as much as, up to, at most, within: &lt;= 
     More than, greater than, higher than, further than, &gt; 
     at least,: &gt;= 
     These are then picked by the EN link, as shown in the range example  3502  in  FIG. 35 . 
     Multiple conditions can occur through: 
     Ranges like (between, from to)→the system  102  finds these by searching for the Nlr structure. 
     and, or (Eg: less than 4 and greater than 5) 
     The system  102  finds ranges through the Nlr structure as shown, for example, in the range example  3504  shown in  FIG. 35 . 
     Words that can have ranges will have an Nlr+ link: between, from, and the system  102  may handle the Nlr structure as follows, &lt;Nlf*+ and &gt;Nit*−, as shown in the range example  3506 . The range example  3508  shows how a statement with and/or may be parsed and recognized by the system  102 . 
     The system  102  may analyze specific words in the requirement statement  1006  with reference to one or more glossaries. For example, the ambiguity glossary  1022  may store selected words as noted for example in Table 9 that when found by the system  102  in the requirement statement  1006  imply non-ambiguity for the phrase in which the words exist. As described in more detail below (e.g., and with respect to  FIG. 11 ), the system  102  may perform the ambiguity tests after establishing the testability of the requirement statement and in parallel or in sequence with the application of other rulesets, including the intent, data, and categorization rulesets. 
     
       
         
               
             
               
               
               
             
           
               
                 TABLE 9 
               
             
             
               
                   
               
               
                 Ambiguity Glossary—glossary for unambiguous terms, with respect to testability, 
               
               
                 used in conjunction with the ambiguity ruleset shown in Table 4. 
               
             
          
           
               
                 Link Type 
                 Word Type 
                 Words 
               
               
                   
               
               
                 Adjective 
                 Rank Comparator 
                 First, last, second, third, fourth, fifth, sixth, 
               
               
                   
                   
                 seventh, eighth, ninth, tenth, eleventh, 
               
               
                   
                   
                 twelfth, thirteenth, fourteenth, fifteenth, 
               
               
                   
                   
                 sixteenth, seventeenth, eighteenth, 
               
               
                   
                   
                 nineteenth, twentieth, twenty-first, twenty- 
               
               
                   
                   
                 second, twenty-third, twenty-fourth, twenty- 
               
               
                   
                   
                 fifth, twenty-sixth, twenty-seventh, twenty- 
               
               
                   
                   
                 eighth, twenty-ninth, thirtieth, thirty-first, 
               
               
                   
                   
                 current, next, previous 
               
               
                 Adjective 
                 Mathematical and 
                 accumulative, analytic, analytical, angular, 
               
               
                   
                 Statistical 
                 arithmetical, asymmetric, asymmetrical, 
               
               
                   
                   
                 circular, concave, concentric, conic, 
               
               
                   
                   
                 conical, convex, cubic, cubical, cuboid, 
               
               
                   
                   
                 cuboid, cylindrical, diagonal, disjunct, 
               
               
                   
                   
                 double, equilateral, exponential, 
               
               
                   
                   
                 hexagonal, nonlinear, orthogonal, oval, 
               
               
                   
                   
                 parallel, polygonal, polyhedral, polynomial, 
               
               
                   
                   
                 probabilistic, quadrupedal, relational, 
               
               
                   
                   
                 round, single, square, tetrahedral, total, 
               
               
                   
                   
                 triangular, trigonal, trilateral, triple, 
               
               
                   
                   
                 absolute, accurate, average, binary, 
               
               
                   
                   
                 canonical, consecutive, decimal, 
               
               
                   
                   
                 hexadecimal, inaccurate, infinite, 
               
               
                   
                   
                 logarithmic, max, maximum, mean, 
               
               
                   
                   
                 median, medium, micro, mid, min, 
               
               
                   
                   
                 minimum, negative, nonzero, ordinal, 
               
               
                   
                   
                 polynomial, positive, positive, prime, 
               
               
                   
                   
                 random, rational, rational, real, zero, 
               
               
                   
                   
                 hundred, thousand, half-thousand, million, 
               
               
                   
                   
                 half-million, quarter-million, billion, half- 
               
               
                   
                   
                 billion, quarter-billion, trillion, half-trillion, 
               
               
                   
                   
                 quarter-trillion, dozen, half-dozen, bajillion, 
               
               
                   
                   
                 bazillion, gadzillion, gagillion, gajillion, 
               
               
                   
                   
                 gazillion, godzillion, jillion, jizillion, kabillion, 
               
               
                   
                   
                 kajillion, katrillion, killion, umptillion, zillion 
               
               
                 Adjective 
                 Technical 
                 abstract, abstracted, accessible, agile, 
               
               
                   
                   
                 anonymous, archival, broadband, cellular, 
               
               
                   
                   
                 clean, columnar, commercial, compliant, 
               
               
                   
                   
                 conditional, constant, deadlocked, 
               
               
                   
                   
                 deterministic, dialup, digital, dimensional, 
               
               
                   
                   
                 dirty, dynamic, handheld, incremental, 
               
               
                   
                   
                 invalid, lazy, logical, lossless, lossy, 
               
               
                   
                   
                 multithreaded, multi-threaded, not null, 
               
               
                   
                   
                 null, online, persistent, plaintext, primitive, 
               
               
                   
                   
                 private, programmable, programmatic, 
               
               
                   
                   
                 public, secure, static, thick, thin, unique, 
               
               
                   
                   
                 valid, void, 
               
               
                 Adjective 
                 General 
                 blank, bold, bolded, handwritten, italic, 
               
               
                   
                   
                 special, typewritten, academic, 
               
               
                   
                   
                 academical, accessible, All, alphabetic, 
               
               
                   
                   
                 alphabetical, automatic, autonomous, 
               
               
                   
                   
                 auxiliary, both, chief, chronological, 
               
               
                   
                   
                 compulsory, computable, computational, 
               
               
                   
                   
                 computerized, concrete, concurrent, 
               
               
                   
                   
                 conditional, constant, discrete, distinct, 
               
               
                   
                   
                 distinctive, double, empty, equal, 
               
               
                   
                   
                 equidistant, exact, excess, final, financial, 
               
               
                   
                   
                 finite, functional, handmade, hierarchical, 
               
               
                   
                   
                 horizontal, hour, hypothetical, identical, 
               
               
                   
                   
                 left, left-handed, lexical, linear, mandatory, 
               
               
                   
                   
                 manual, mathematical, metric, minute, 
               
               
                   
                   
                 numeric, numeric, numerical, numerical, 
               
               
                   
                   
                 onboard, onscreen, ontological, passive, 
               
               
                   
                   
                 perpendicular, radial, regional, regional, 
               
               
                   
                   
                 reusable, righthanded, right-handed, 
               
               
                   
                   
                 secret, successful, sufficient, tabbed, 
               
               
                   
                   
                 technical, technological, textual, topmost, 
               
               
                   
                   
                 unambiguous, unnumbered, unregistered, 
               
               
                   
                   
                 unregulated, unsuccessful, untested, 
               
               
                   
                   
                 untitled, visible, 
               
               
                 Adjective 
                 Colours 
                 Black, blue, orange, red, green, pink, 
               
               
                   
                   
                 purple, gold, yellow, azure, brown, blond, 
               
               
                   
                   
                 gray, green, silver, white 
               
               
                 Adjective 
                 Languages 
                 Arab, Arabian, British, Arabic, American, 
               
               
                   
                   
                 Cantonese, Congolese, Chinese, Danish, 
               
               
                   
                   
                 English, Finnish, french, French, German, 
               
               
                   
                   
                 Guyanese, hispanic, Irish, Italian, 
               
               
                   
                   
                 Japanese, Lebanese, Maltese, Polish, 
               
               
                   
                   
                 Portugese, Roman, Russian, Scottish, 
               
               
                   
                   
                 Senegalese, Spanish, Slavic, Sudanese, 
               
               
                   
                   
                 Surinamese, Swedish, Swiss, Taiwanese, 
               
               
                   
                   
                 Thai, Turkish, Vietnamese, 
               
               
                 Adverbs 
                   
                 alphanumerically, anonymously, 
               
               
                   
                   
                 anticlockwise, clockwise, 
               
               
                   
                   
                 counterclockwise, diagonally, 
               
               
                   
                   
                 experimentally, exponentially, 
               
               
                   
                   
                 hierarchically, insecurely, lazily, 
               
               
                   
                   
                 legislatively, lengthways, lexically, locally, 
               
               
                   
                   
                 logarithmically, loosely, Only, orthogonally, 
               
               
                   
                   
                 previously, programmatically, quarterly, 
               
               
                   
                   
                 randomly, securely, serially, statically, 
               
               
                   
                   
                 successfully, successively, terminal, thrice, 
               
               
                   
                   
                 twice, unclassified, unsuccessfully, 
               
               
                   
                   
                 visually, 
               
               
                 EN Adverbs 
                   
                 by, after, &lt;, &lt;=, &gt;, &gt;=, =, &lt;&gt;, !=, Only, just, 
               
               
                   
                   
                 exactly, all but, nothing_but, an_estimated, 
               
               
                   
                   
                 an_additional, as_much_as 
               
               
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
             
           
               
                 TABLE 10 
               
               
                   
               
               
                 Conformance Glossary 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 Conformance 
                 ICS 
               
               
                   
                 Conform to 
                 HIPAA 
               
               
                   
                 Adhere to 
                 CMI 
               
               
                   
                 Must follow 
                 A4 
               
               
                   
                 Oriented to 
                 Policy 
               
               
                   
                 In orientation with 
                 Style guide 
               
               
                   
                 In accordance to 
                 ANSI 
               
               
                   
                 Browser 
                 FCC 
               
               
                   
                 Browsers 
                 IEC 
               
               
                   
                 Internet Explorer 
                 IETF 
               
               
                   
                 Chrome 
                 Protocol 
               
               
                   
                 Firefox 
                 SIP 
               
               
                   
                 Safari 
                 ASN* 
               
               
                   
                 Compliant with 
                 ITU 
               
               
                   
                 Comply with 
                 TCP 
               
               
                   
                 compliance 
                 IP 
               
               
                   
                 Standard 
                 GSM 
               
               
                   
                 IEEE 
                 ISDN 
               
               
                   
                 W3C 
                 OMA 
               
               
                   
                 ETS 
                 TOGAF 
               
               
                   
                 ISO 
                 UML 
               
               
                   
                 IEC 
                 OASIS 
               
               
                   
                   
                 COTS 
               
               
                   
                   
                 RUP 
               
               
                   
                   
                 Law 
               
               
                   
                   
                 Legal 
               
               
                   
                   
                 Format 
               
               
                   
                   
                 Formatted 
               
               
                   
                   
                 HIPAA 
               
               
                   
                   
                 SOX 
               
               
                   
                   
                 Basel 
               
               
                   
                   
                 UTF* 
               
               
                   
                   
                 Validation/validity 
               
               
                   
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
             
           
               
                 TABLE 11 
               
               
                   
               
               
                 Usability Glossary 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 Usability 
                 UI 
               
               
                   
                 useful 
                 GUI 
               
               
                   
                 Resolution 
                 Graphic 
               
               
                   
                 Scroll 
                 Right approach 
               
               
                   
                 Location 
                 Time to learn 
               
               
                   
                 environment 
                 Less interference 
               
               
                   
                 Look and feel 
                 No interference 
               
               
                   
                 Ease 
                 Satisfaction 
               
               
                   
                 Easy 
                 Satisfactory 
               
               
                   
                 Appeal 
                 Acceptable 
               
               
                   
                 attract 
                 Effective 
               
               
                   
                 Difficult 
                 Internationalization 
               
               
                   
                 Readable 
                 i18n 
               
               
                   
                 legible 
                 Localization 
               
               
                   
                 Display 
                 L10n 
               
               
                   
                 Look at 
                 Locale 
               
               
                   
                 Distortion 
                 Accessibility 
               
               
                   
                 distorted 
                 Navigation 
               
               
                   
                 Brightness 
               
               
                   
                 Color 
               
               
                   
                 Contrast 
               
               
                   
                 Pixels 
               
               
                   
                 Bandwidth 
               
               
                   
                 Size 
               
               
                   
                 Height 
               
               
                   
                 width 
               
               
                   
                 Font 
               
               
                   
                 Picture 
               
               
                   
                 Language 
               
               
                   
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
               
             
           
               
                 TABLE 12 
               
             
             
               
                   
               
               
                 NFR Glossary 
               
             
          
           
               
                   
                 System 
                   
               
               
                 Area 
                 Attribute 
                 Indicator_Phrases 
               
               
                   
               
               
                 Delivery 
                 Delivery channels 
                 Delivery channel, delivery channels, 
               
               
                 Channels 
                   
                 environment, environments, Browser, 
               
               
                   
                   
                 browsers, PDA, printed report, report, 
               
               
                   
                   
                 reports, reporting, Internet Explorer, 
               
               
                   
                   
                 Mozilla, Safari, Netscape, Firefox, 
               
               
                   
                   
                 iPhone, windows mobile, black berry, 
               
               
                   
                   
                 palm, mobile phone, smart phone, fax, 
               
               
                   
                   
                 facsimile, android, RSS, twitter, pdf, Word, 
               
               
                   
                   
                 Excel, cellphone, screen monitor, LCD, 
               
               
                   
                   
                 CRT, Americans with Disabilities Act, 
               
               
                   
                   
                 ADA, screens, display screen, screen 
               
               
                   
                   
                 dimension, screen resolution, VGA, hidef, 
               
               
                   
                   
                 high-def, HD, high definition, GUI, UI, 
               
               
                   
                   
                 query, querying, web service, web 
               
               
                   
                   
                 services, XML, Ajax, sd card, letter, email, 
               
               
                   
                   
                 emails, e-mail, e-mails, text message, 
               
               
                   
                   
                 SMS, WAP, web application, web app, 
               
               
                   
                   
                 desktop application, goggle app, facebook 
               
               
                   
                   
                 app 
               
               
                 Delivery 
                 Connectivity 
                 Dial-up, dial, broadband, dsl, internet, 
               
               
                 Channels 
                 Requirement 
                 web, intranet, leased line, LAN, WLAN, 
               
               
                   
                   
                 3G, Edge, 4G, wifi, wi-fi, landline, fiber, 
               
               
                   
                   
                 twisted pair, https, CDMA, GSM, wimax, 
               
               
                   
                   
                 Bluetooth, Ethernet, dix, WAP, satellite, 
               
               
                   
                   
                 cat5, cat6, fibre, coaxial, coax 
               
               
                 CapacityVolu 
                 Locations 
                 User located, user location, processing 
               
               
                 metrics 
                   
                 location, location, locations, inside 
               
               
                   
                   
                 firewall, onsite, offsite, onshore, offshore, 
               
               
                   
                   
                 local, nationwide, worldwide 
               
               
                 CapacityVolu 
                 Number Of Users 
                 User count, users, average, max, 
               
               
                 metrics 
                   
                 maximum, over, peak, total 
               
               
                 CapacityVolu 
                 Concurrent Users 
                 Logged-in, logged, connections, 
               
               
                 metrics 
                   
                 Concurrent Users, concurrent sessions, 
               
               
                   
                   
                 average, max, maximum, over, peak, 
               
               
                   
                   
                 total 
               
               
                 CapacityVolu 
                 Transaction Mode 
                 Online, asynchronous, transaction, 
               
               
                 metrics 
                   
                 processing, async, interactive, 
               
               
                   
                   
                 transaction, batch mode, batch process, 
               
               
                   
                   
                 batch processing, spring batch, 
               
               
                   
                   
                 scheduling, batch cycle, batch function, 
               
               
                   
                   
                 batch scheduler, batch job, batch- 
               
               
                   
                   
                 queuing, batch queuing, batch queue, 
               
               
                   
                   
                 queue 
               
               
                 CapacityVolu 
                 UseCaseExecution 
                 Use case execution, Per minute, per hour, 
               
               
                 metrics 
                 Rate 
                 per second, per sec, per seconds, 
               
               
                   
                   
                 average, maximum, peak 
               
               
                 CapacityVolu 
                 ServerTransactionP 
                 Transaction, Transactions, server, Hits, 
               
               
                 metrics 
                 erUseCase 
                 http requests, transactions, process hits, 
               
               
                   
                   
                 web service requests, average, max, 
               
               
                   
                   
                 maximum, over, peak, total 
               
               
                 CapacityVolu 
                 TransactionRate 
                 Transaction rate, Per minute, per hour, 
               
               
                 metrics 
                   
                 per second, per sec, per seconds, 
               
               
                   
                   
                 average, maximum, peak 
               
               
                 CapacityVolu 
                 TransactionSize 
                 Transaction, data exchange, data transfer, 
               
               
                 metrics 
                   
                 data interface, upload, download, 
               
               
                   
                   
                 average, byte, Bytes, kilobyte, kilobytes, 
               
               
                   
                   
                 megabytes, megabyte, gigabytes, 
               
               
                   
                   
                 terabytes, pentabytes, kb, MB, GB, TB, 
               
               
                   
                   
                 average number of bytes 
               
               
                 CapacityVolu 
                 DataVolumes 
                 data storage, database, relational 
               
               
                 metrics 
                   
                 database, record Records, byte, Bytes, 
               
               
                   
                   
                 kilobyte, kilobytes, megabytes, megabyte, 
               
               
                   
                   
                 gigabytes, terabytes, pentabytes, kb, MB, 
               
               
                   
                   
                 GB, TB, average number of bytes 
               
               
                 CapacityVolu 
                 DataRetentionReq 
                 Purge, retention, data retention policy, 
               
               
                 metrics 
                   
                 retain, email retention, record retention, 7- 
               
               
                   
                   
                 years, privacy, seven, data, retain, 
               
               
                   
                   
                 account retention, years online, years in 
               
               
                   
                   
                 archive, business records, data deletion, 
               
               
                   
                   
                 delete, discovery request, information 
               
               
                   
                   
                 retention, discovery cost, archiving, 
               
               
                   
                   
                 backup, database, relational database 
               
               
                 Performance 
                 TotalExpectedExec 
                 complete processing, return a response, 
               
               
                   
                 utionTimePerUseCase 
                 execution time, executed, finished, finish, 
               
               
                   
                   
                 millisecond, milliseconds, ms, Seconds, 
               
               
                   
                   
                 second, sec, minute, minutes, mins, hour, 
               
               
                   
                   
                 hours, hr, hrs, use case 
               
               
                 Performance 
                 AverageUserThink 
                 complete processing, return a response, 
               
               
                   
                 TimePerTransaction 
                 execution time, executed, finished, finish, 
               
               
                   
                   
                 millisecond, milliseconds, ms, Seconds, 
               
               
                   
                   
                 second, sec, minute, minutes, mins, hour, 
               
               
                   
                   
                 hours, hr, hrs, use case 
               
               
                 Performance 
                 Concurrent 
                 Concurrent transaction, simultaneously, 
               
               
                   
                 Transactions 
                 simultaneous, combined, synchronous, 
               
               
                   
                   
                 wait, waiting, queue, average, max, 
               
               
                   
                   
                 maximum, over, peak, total, connections, 
               
               
                   
                   
                 concurrent sessions, at the same time 
               
               
                 Performance 
                 Response Time 
                 Response time, response times, respond, 
               
               
                   
                   
                 average response time, 95th percentile, 
               
               
                   
                   
                 millisecond, milliseconds, ms, Seconds, 
               
               
                   
                   
                 second, sec, minute, minutes, mins, hour, 
               
               
                   
                   
                 hours, hr, hrs 
               
               
                 Performance 
                 BatchCycle 
                 batch mode, batch process, batch 
               
               
                   
                   
                 processing, spring batch, scheduling, 
               
               
                   
                   
                 batch cycle, batch function, batch 
               
               
                   
                   
                 scheduler, batch job, batch-queuing, 
               
               
                   
                   
                 batch queuing, batch queue, queue 
               
               
                 Performance 
                 BatchProcessingWi 
                 AM, PM, weekend, weekends, weekday, 
               
               
                   
                 ndow 
                 weekday, workday, Monday, Tuesday, 
               
               
                   
                   
                 Wednesday, Thursday, Friday, Saturday, 
               
               
                   
                   
                 Sunday, between, time, batch mode, 
               
               
                   
                   
                 batch process, batch processing, spring 
               
               
                   
                   
                 batch, scheduling, batch cycle, batch 
               
               
                   
                   
                 function, batch scheduler, batch job, 
               
               
                   
                   
                 batch-queuing, batch queuing, batch 
               
               
                   
                   
                 queue, queue 
               
               
                 Performance 
                 Batch Execution 
                 Maximum execution time, complete 
               
               
                   
                 Time 
                 processing, return a response, execution 
               
               
                   
                   
                 time, executed, finished, finish, 
               
               
                   
                   
                 millisecond, milliseconds, ms, Seconds, 
               
               
                   
                   
                 second, sec, minute, minutes, mins, hour, 
               
               
                   
                   
                 hours, hr, hrs, batch mode, batch process, 
               
               
                   
                   
                 batch processing, spring batch, 
               
               
                   
                   
                 scheduling, batch cycle, batch function, 
               
               
                   
                   
                 batch scheduler, batch job, batch- 
               
               
                   
                   
                 queuing, batch queuing, batch queue, 
               
               
                   
                   
                 queue, average, max, maximum, over, 
               
               
                   
                   
                 peak, total 
               
               
                 Performance 
                 Batch 
                 Start, finish, before, dependent, depends, 
               
               
                   
                 dependencies 
                 batch mode, batch process, batch 
               
               
                   
                   
                 processing, spring batch, scheduling, 
               
               
                   
                   
                 batch cycle, batch function, batch 
               
               
                   
                   
                 scheduler, batch job, batch-queuing, 
               
               
                   
                   
                 batch queuing, batch queue, queue 
               
               
                 Scalability 
                 Scale 
                 Scalable, machines, increase load, 
               
               
                   
                   
                 increases, grow, growth, scale up, readily 
               
               
                   
                   
                 enlarged, performance, enlarge, enlarged, 
               
               
                   
                   
                 augment, increment, transaction volume, 
               
               
                   
                   
                 transaction volumes, data growth, expand 
               
               
                   
                   
                 capacity, expanded, expanding, increased 
               
               
                   
                   
                 number, increased amount 
               
               
                 Availability 
                 Hours of operation 
                 Operation, operate, 7-days, seven days, 
               
               
                   
                   
                 24x7 24/7, AM, PM, 24-hours, 24-hr, 24- 
               
               
                   
                   
                 hrs, weekend, weekday, workday, 365, 
               
               
                   
                   
                 AM, PM, weekend, weekends, weekday, 
               
               
                   
                   
                 weekday, workday, Monday, Tuesday, 
               
               
                   
                   
                 Wednesday, Thursday, Friday, Saturday, 
               
               
                   
                   
                 Sunday 
               
               
                 Availability 
                 Scheduled 
                 Down maintenance, Scheduled 
               
               
                   
                 Maintenance 
                 Maintenance, Operation, operate, AM, PM, 
               
               
                   
                   
                 weekend, weekends, weekday, weekday, 
               
               
                   
                   
                 workday, Monday, Tuesday, Wednesday, 
               
               
                   
                   
                 Thursday, Friday, Saturday, Sunday 
               
               
                 Availability 
                 Percent Availability 
                 Availability percentage, %, percent, 
               
               
                   
                   
                 outage duration, five nines, available, 
               
               
                   
                   
                 99.9, 99.99, 99.999, uptime, high 
               
               
                   
                   
                 availability, SLA 
               
               
                 Availability 
                 Recovery Time 
                 Recover, heart beat ping, detect failure, 
               
               
                   
                   
                 failover, second, seconds, minute, 
               
               
                   
                   
                 minutes, hour, hours, average, maximum, 
               
               
                   
                   
                 failure detection, unavailability, outage, 
               
               
                   
                   
                 outages, downtime, system failure, 
               
               
                   
                   
                 network outage, average, max, maximum, 
               
               
                   
                   
                 over, peak, total, millisecond, 
               
               
                   
                   
                 milliseconds, ms, Seconds, second, sec, 
               
               
                   
                   
                 minute, minutes, mins, hour, hours, hr, hrs 
               
               
                 Availability 
                 DisasterRecoveryR 
                 Disaster recovery, disaster recovery plan, 
               
               
                   
                 equirements 
                 natural disaster, catastrophic, 
               
               
                   
                   
                 catastrophe, outage, unavailability, 
               
               
                   
                   
                 earthquake, sabotage, DOS, DDOS, 
               
               
                   
                   
                 failover, service degradation, critical 
               
               
                   
                   
                 business function, business continuity 
               
               
                   
                   
                 planning, business impact analysis, 
               
               
                   
                   
                 recovery time objective, recovery point 
               
               
                   
                   
                 objective, cyber attack, utility outage, 
               
               
                   
                   
                 terrorism, emergency management 
               
               
                 Security 
                 Information 
                 access rights, access, level access, 
               
               
                   
                 Security 
                 LDAP, microsoft domain authentication, 
               
               
                   
                   
                 authentication, data transfer, VPN, DNS, 
               
               
                   
                   
                 private data, integrity, confidential 
               
               
                 Security 
                 Security Roles 
                 privileged, standard role, access rights 
               
               
                 Security 
                 Security 
                 access request, grant access, request 
               
               
                   
                 Administration 
                 access, transfer access, terminate 
               
               
                   
                   
                 access, password policy, account disable, 
               
               
                   
                   
                 change password 
               
               
                 Security 
                 Access Review 
               
               
                 Security 
                 Security Audit Trail 
                 security audit, transaction audit 
               
               
                 Security 
                 Security Monitoring 
               
               
                 Security 
                 Data Classification 
               
               
                 Security 
                 Encryption 
                 encrypt, encryption, cryptograph, 
               
               
                   
                   
                 cryptographic, unencrypted, digital 
               
               
                   
                   
                 signature, ciphertext, encipher, 
               
               
                   
                   
                 decryption, cipher, DES, AES, RSA 
               
               
                 Security 
                 Operation Security 
               
               
                 Security 
                 Customer Privacy 
               
               
                 Support 
                 Archive 
                 archive, log, recovery 
               
               
                 Requirement 
               
               
                 Support 
                 Backup 
                 backup, log recovery 
               
               
                 Requirement 
               
               
                 Support 
                 Purging 
                 purge, purging 
               
               
                 Requirement 
               
               
                 Support 
                 Logging 
                 log, logging, exception, recovery 
               
               
                 Requirement 
               
               
                 Support 
                 Monitoring 
                 monitor, monitoring, notification, 
               
               
                 Requirement 
                   
                 frequency, dashboard, 
               
               
                 Support 
                 Disaster recovery 
                 disaster, recovery, 
               
               
                 Requirement 
               
               
                   
               
             
          
         
       
     
       FIG. 11  shows a flow diagram of requirement testing logic  1100  that the requirements testing system  102  may execute. Portions of the requirement testing logic  1100  may be implemented in and distributed in any manner, e.g., in the pre-processor  1008 , parser logic  1014 , analysis logic  1018 , or other logic in the system  102 . The system  102  receives a requirement statement ( 1102 ), e.g., locally input, or remotely submitted through the network  110 . The system  102  executes the pre-processor logic  1008  ( 1104 ). The pre-processor logic  1008  applies rulesets (e.g., rulesets  1010  and  1012 ) to initially condition the requirement statement. The pre-processing logic  1008  may also reference the entity glossary  1028  during operation to initially parse the requirement statement. In particular, the pre-processing logic  1008  may use the entity glossary  1028  to identify noun phrases where present and handle the missing determiner case noted above. 
     The system  102  submits the pre-processed requirement statement to the parser logic  1014  ( 1106 ). When the parser logic  1014  determines that the requirement statement is syntactically invalid ( 1108 ), then the system  102  may report that the requirement statement is invalid ( 1110 ) and continue analyzing additional requirement statements. 
     Otherwise, the parser logic outputs, such as the grammatical links, constituent tree, and the classification of words into the parts of speech are saved in the memory  1004  ( 1112 ). The analysis logic  1018  may then perform any desired analyses on the requirement statement by applying analysis rulesets to the requirement statement with reference to the parser logic outputs. For example, the analysis logic  1018  may apply a testability ruleset to determine whether any of the testability rules fire and the requirement statement is testable ( 1114 ). If the requirement statement is not testable, then the system  102  may report that the requirement statement is not testable ( 1116 ) continue on to other requirement statements for analysis. 
     The analysis logic  1018  may then invoke statement simplifier rules ( 1118 ). Examples of such rules include analysis and delimiting of compound sentences, and processing of conditional statements. The statement simplifier rules are explained in more detail above in the Compound Sentences ruleset with respect to the C, CC, B, VJ, and MJ rules. Given a resulting simplified sentence, the analysis logic  1018  may apply any other desired rulesets, such as the ambiguity ruleset ( 1126 ), the intent ruleset ( 1122 ), the category ruleset ( 1120 ), or the data ruleset ( 1124 ) to determine any desired test artifacts for the requirement statement. Each resulting simplified sentence may include the modal verb of the compound sentence from which it is derived. Simplifying a compound sentence and applying the rulesets to simple sentences derived from the compound sentence may resolve ambiguity in the compound sentence and improve the accuracy and utility of test artifacts. The analysis logic  1018  may store the determined test artifacts in memory ( 1128 ). A reporting module running in the system  102  may then read the test artifact results and generate and display an analysis report  116  ( 1130 ). 
       FIGS. 12-39  show many examples of parsed requirement statements. With reference to  FIG. 36 , an example generally applicable to the above noted figures is explained for the requirement statement  3602 : “The user shall update the table to overwrite system default.” The parser logic  1014  has parsed the requirement statement  3602  into grammatical links  3604 , parts of speech (e.g., the noun “user”  3606  and the verb “shall”  3608 ), and the constituent tree  3610 . As examples, the grammatical links  3604  include an “I” link  3612  between “shall” and “update,” that connects an infinitive verb form to words including modal verbs and to “to”; an “AN” link  3614 , that connects noun modifiers to subsequent nouns; and a “O” link  3616 , that connects transitive verbs to direct or indirect objects. 
     The constituent tree  3610  shows how the requirement statement  3602  is composed by individual grammatical units. The graphical representation  3618  of the constituent tree also shows how the requirement statement  3602  flows through its component noun phrases (NP) (e.g., the noun phrase  3620 : “the user”) and verb phrases (VP) (e.g., the verb phrase  3622 : “overwrite”). The constituent tree also identifies the subject (in this case “The user”). The numbers next to each node give a unique identifier for each node. 
     A specific example of the test artifacts that the system  102  generates is now given for the sentence “The PRTS system should send 3 bits of functional information containing the WAKE code.”  FIG. 37  shows the resulting parse  3700  by the parser logic  1014  into links  3702  and a constituent tree  3704 . For this sentence, the following rules fire and the system  102  outputs the following test artifacts shown in Table 13: 
     
       
         
               
               
             
           
               
                 TABLE 13 
               
               
                   
               
               
                 Rule 
                 Artifact 
               
               
                   
               
             
             
               
                 Testability Rule: T.1, S-l-O 
                 Testable: Yes 
               
               
                 Ambiguity Rule: T.A.1 - A 
                 Functional 
               
               
                 Ambiguity Rule: T.A.1.1 
                 Not Ambiguous 
               
               
                 Intent Rule: I.1 - S-l-O 
                 Template with words from constituent 
               
               
                   
                 tree: 
               
               
                   
                 Verify the PRTS system is able to send 
               
               
                   
                 3 bits 
               
               
                 Intent Rule I.1.2 - NP-Mp 
                 Template with words from constituent 
               
               
                   
                 tree: 
               
               
                   
                 Verify 3 bits Is of Functional information 
               
               
                 Intent Rule I.1.2 - NP-Mg 
                 Template with words from constituent 
               
               
                   
                 tree: 
               
               
                   
                 Verify functional information Is 
               
               
                   
                 Containing WAKE code. 
               
               
                 Category Rule C.10 - None 
                 Business Logic 
               
               
                 Data Rule D.1. - .# 
                 Data: 3 
               
               
                 Data Rule D.1.4 - D 
                 Unit: bits 
               
               
                 Data Rule D.5 
                 Test Data: = 3 bits 
               
               
                   
               
             
          
         
       
     
     The system  102  provides a framework for identification and analysis for early testing artifacts from natural language requirements. For any software project and in particular for large-sized software implementation projects, it is critical to identify and analyze if the functional requirement specifications, written in natural language (e.g., the English language), are testable in terms of business and user acceptance criteria. For example, a business analyst, test architect, or other personnel may benefit from knowing whether a functional requirement is un-ambiguously testable, what would be the intents of such tests (e.g., what functional/non-functional needs would those requirements be tested for), what category of test would the requirement belong to, and if there are any test data embedded in the requirement. These are significant test artifacts to identify and understand because in absence of such an exercise early in the test analysis and design phase, many ambiguous requirements may propagate downstream. 
     This gives rise to improper, ambiguous, or un-defined test specifications. Test case generation and test coverage may suffer as well. Also, from such imprecise test specifications, one cannot prepare a valid testing plan and estimate the testing effort required, and determine whether the functional coverage will be adequately achieved through testing. Although test cases can be generated automatically from properly specified and elaborate requirements and models, the activity of testability checking and generation of early testing artifacts from high-level functional requirements has been in the past mainly manual, subjective and error-prone. In contrast, the system  102  provides a novel automated framework for identification and analysis for early testing artifacts from functional requirement sentences. The framework leverages natural language processing techniques to obtain structural dependencies in the sentence (e.g., a requirement statement) and parts-of-speech phrase tagging. The system  102  employs a set of pattern matching rules to identify syntactic structure(s) of possible test intents, and a set of entity/keyword mapping rules to identify and tag test category and data from the phrases and mark ambiguity, if any. 
     Requirements testing systems and methods may be used for testing a requirement statement. Requirements testing systems may gather and analyze sentences to determine if the sentence is testable, invoke sentence simplifier rules to simplify the sentence, and extract test artifacts about the sentence. For example, in gathering and analyzing sentences to determine testability, some systems may execute pre-processing rulesets on the gathered sentences. The pre-processed sentences may be submitted to a parser logic which may be used to determine if the sentence is valid. Where the sentence is valid, the outputs from the parser logic may be stored and a testability ruleset may be applied to the sentence. Where the sentence is testable, the simplifier rules, such as compound sentence rules and conditional statement rules, may be applied to the sentence to simplify the sentence. Then, the various test artifact rules, such as ambiguity rules, test data rules, intent rules, and/or category rules may be applied to the sentence. The test artifacts obtained from the application of these rules may be stored. Such test artifacts may be used in reports or other analysis or processing as discussed. 
     In some requirements testing systems and methods, a requirement statement is obtained and stored in a memory. The requirement statement is submitted to a grammatical parser executed by a processor to obtain parser outputs characterizing the requirement statement. A test artifact ruleset is applied with the processor to the parser outputs to determine a test artifact applicable to the requirement statement. 
     These and other requirements testing systems and methods allow for developers to check for testability and various features of statements and documents. Another benefit of the requirements testing system is that it facilitates creation of test artifacts from requirement statements. The test artifacts reduce testing cycle time, effort, and expense, and improve test quality. As a result, the resulting software application is more reliable, less expensive, and is more timely delivered. This allows developers to implement complex statements and documents in less time and with fewer mistakes or ambiguities, increasing efficiency and effectiveness of the requirements statements. Requirements testing systems also result in various other advantages and effects. 
     The methods, systems, and logic described above may be implemented in many different ways in many different combinations of hardware, software or both hardware and software. For example, the logic executed by the system  102  may be circuitry in a controller, a microprocessor, or an application specific integrated circuit (ASIC), or may be implemented with discrete logic, or a combination of other types of circuitry. The logic may be encoded or stored in a machine-readable or computer-readable medium such as a compact disc read only memory (CDROM), magnetic or optical disk, flash memory, random access memory (RAM) or read only memory (ROM), erasable programmable read only memory (EPROM) or other machine-readable medium as, for example, instructions for execution by a processor, controller, or other processing device. Similarly, the memory in the system may be volatile memory, such as Dynamic Random Access Memory (DRAM) or Static Random Access Memory (SRAM), or non-volatile memory such as NAND Flash or other types of non-volatile memory, or may be combinations of different types of volatile and non-volatile memory. When instructions implement the logic, the instructions may be part of a single program, separate programs, implemented in an application programming interface (API), in libraries such as Dynamic Link Libraries (DLLs), or distributed across multiple memories and processors. The system  102  may test input sentences other than requirement statements. 
     While various embodiments have been described, it will be apparent to those of ordinary skill in the art that many more embodiments and implementations are possible. For example, a method for testing a requirement statement may be provided. The method may include obtaining a requirement statement and storing the requirement statement in a memory. The method may further include submitting the requirement statement to a grammatical parser executed by a processor to obtain parser outputs characterizing the requirement statement. The method may further include applying a test artifact ruleset with the processor to the parser outputs to determine a test artifact applicable to the requirement statement. 
     In some cases, applying the test artifact ruleset includes applying a testability ruleset with the processor to the parser outputs to determine a test artifact that indicates whether the requirement statement is testable. Additionally or alternatively, it may be that applying the test artifact ruleset includes applying an ambiguity ruleset with the processor to the parser outputs to determine a test artifact that indicates whether the requirement statement is ambiguous with respect to testability. Additionally or alternatively, applying the test artifact ruleset may include applying an intent ruleset with the processor to the parser outputs to determine a test artifact that indicates an intent characteristic of the requirement statement. Additionally or alternatively, applying the test artifact ruleset may include applying a category ruleset with the processor to the parser outputs to determine a test artifact that indicates a category characteristic of the requirement statement. Additionally or alternatively, applying the test artifact ruleset may include applying a data ruleset with the processor to the parser outputs to determine a test artifact that indicates a data characteristic of the requirement statement. Additionally or alternatively, the method may further include executing a pre-processor on the requirement statement prior to submitting the requirement statement to the grammatical parser. 
     According to another aspect, a computer program product including computer-readable instructions may be provided. The instructions, when loaded and executed on a computer system, may cause the computer system to perform operations according to the steps (aspect and/or embodiments) discussed above. 
     According to yet another aspect, a requirement statement analysis system may be provided. The system may include a processor and a memory in communication with the processor. The memory may include a requirement statement and grammatical parser logic. The memory may further include analysis logic operable to, when executed by the processor obtain the requirement statement and store the requirement statement in the memory. When executed, the analysis logic may be further operable to submit the requirement statement to the grammatical parser logic and obtain parser outputs characterizing the requirement statement. The analysis logic may be further operable to apply a test artifact ruleset to the parser outputs to determine a test artifact applicable to the requirement statement. 
     In some cases the test artifact ruleset may include a testability ruleset configured to determine, as the test artifact, whether the requirement statement is testable. Additionally or alternatively, the test artifact ruleset may include an ambiguity ruleset configured to determine, as the test artifact, whether the requirement statement is ambiguous with regard to testability. Additionally or alternatively, the test artifact ruleset may include an intent ruleset configured to determine, as the test artifact, an intent characteristic of the requirement statement. Additionally or alternatively, the test artifact ruleset may include a category ruleset configured to determine, as the test artifact, a category characteristic of the requirement statement. Additionally or alternatively, the test artifact ruleset may include a data ruleset with the processor to the parser outputs to determine a test artifact that indicates a data characteristic of the requirement statement. Also, the analysis logic may be further operable to execute a pre-processor on the requirement statement prior to submitting the requirement statement to the grammatical parser. 
     It should be understood that various modifications to the disclosed examples and embodiments may be made. In particular, elements of one example may be combined and used in other examples to form new examples. Accordingly, the implementations are not to be restricted except in light of the attached claims and their equivalents.