Result


1   /*
2    * The contents of this file are subject to the terms 
3    * of the Common Development and Distribution License 
4    * (the License).  You may not use this file except in
5    * compliance with the License.
6    * 
7    * You can obtain a copy of the license at 
8    * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9    * glassfish/bootstrap/legal/CDDLv1.0.txt.
10   * See the License for the specific language governing 
11   * permissions and limitations under the License.
12   * 
13   * When distributing Covered Code, include this CDDL 
14   * Header Notice in each file and include the License file 
15   * at glassfish/bootstrap/legal/CDDLv1.0.txt.  
16   * If applicable, add the following below the CDDL Header, 
17   * with the fields enclosed by brackets [] replaced by
18   * you own identifying information: 
19   * "Portions Copyrighted [year] [name of copyright owner]"
20   * 
21   * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22   */
23  
24  package com.sun.enterprise.tools.verifier;
25  
26  import java.util.Vector  ;
27  import java.util.logging.Level  ;
28  import java.util.logging.Logger  ;
29  
30  import com.sun.enterprise.logging.LogDomains;
31  
32  public class Result {
33  
34      public static final int PASSED = 0;
35      public static final int FAILED = 1;
36      public static final int WARNING = 2;
37      public static final int NOT_APPLICABLE = 3;
38      public static final int NOT_RUN = 4;
39      public static final int NOT_IMPLEMENTED = 5;
40      private int status = NOT_RUN;
41  
42      public static final String   APP = "application"; // NOI18N
43      public static final String   EJB = "ejb"; // NOI18N
44      public static final String   WEB = "web"; // NOI18N
45      public static final String   APPCLIENT = "appclient"; // NOI18N
46      public static final String   CONNECTOR = "connector"; // NOI18N
47      public static final String   WEBSERVICE = "webservice"; // NOI18N
48      public static final String   WEBSERVICE_CLIENT = "webservice_client"; // NOI18N
49  
50      private String   moduleName;
51  
52      private String   componentName;
53      private String   assertion;
54      private String   testName;
55      private Vector  <String  > errorDetails = new Vector  <String  >();
56      private Vector  <String  > goodDetails = new Vector  <String  >();
57      private Vector  <String  > warningDetails = new Vector  <String  >();
58      private Vector  <String  > naDetails = new Vector  <String  >();
59      boolean debug = Verifier.isDebug();
60  
61      private Logger   logger = LogDomains.getLogger(
62              LogDomains.AVK_VERIFIER_LOGGER);
63  
64      /**
65       * Result Constructor
66       */
67      public Result() {
68      }
69  
70  
71      /**
72       * Initialize the Result object
73       *
74       * @param c Class of the current test/assertion
75       * @param compName
76       */
77      public void init(Class   c, String   version, String   compName) {
78          setComponentName(compName);
79          StringBuffer   assertion = new StringBuffer  (
80                  StringManagerHelper.getLocalStringsManager().getLocalString(
81                          (c.getName() + ".assertion"), "")); // NOI18N
82          String   key = ".specMappingInfo_"+version; // NOI18N
83          StringBuffer   specMappingInfo = new StringBuffer  (
84                  StringManagerHelper.getLocalStringsManager().getLocalString(
85                          (c.getName() + key), ""));
86          // if specMappingInfo_<version> is unavailable then try just specMappingInfo
87          if(specMappingInfo == null || specMappingInfo.length() == 0) {
88              key = c.getName() + ".specMappingInfo";
89              specMappingInfo = new StringBuffer  (StringManagerHelper.getLocalStringsManager().getLocalString(key, ""));
90          }
91          String    prefix = StringManagerHelper.getLocalStringsManager().getLocalString(
92                  (getClass().getName() + ".prefix"), ""); // NOI18N
93          String    suffix = StringManagerHelper.getLocalStringsManager().getLocalString(
94                  (getClass().getName() + ".suffix"), ""); // NOI18N
95  
96          if (specMappingInfo.length()!=0 && specMappingInfo!=null)
97              setAssertion(assertion.append(" ").append(prefix+" ").append(specMappingInfo).append(" "+suffix).toString()); // NOI18N
98          else
99              setAssertion(assertion.toString());
100         String   this_package = "com.sun.enterprise.tools.verifier."; // NOI18N
101         setTestName(c.getName().substring(this_package.length()));
102     }
103 
104     /**
105      * Store passed info
106      *
107      * @param detail Details of passed test
108      */
109     public void passed(String   detail) {
110         setStatus(PASSED);
111         addGoodDetails(detail);
112     }
113 
114     /**
115      * Store warning info
116      *
117      * @param detail Details of warning test
118      */
119     public void warning(String   detail) {
120         setStatus(WARNING);
121         addWarningDetails(detail);
122     }
123 
124     /**
125      * Store Not Applicable info
126      *
127      * @param detail Details of not applicable test
128      */
129     public void notApplicable(String   detail) {
130         setStatus(NOT_APPLICABLE);
131         addNaDetails(detail);
132     }
133 
134     /**
135      * Store Failed info
136      *
137      * @param detail Details of failed test
138      */
139     public void failed(String   detail) {
140         setStatus(FAILED);
141         addErrorDetails(detail);
142     }
143 
144     /**
145      * Retrieve Not Applicable details
146      *
147      * @return <code>Vector</code> not applicable details
148      */
149     public Vector   getNaDetails() {
150         if(naDetails.isEmpty()){
151             Vector  <String  > result = new Vector  <String  >();
152             result.add(StringManagerHelper.getLocalStringsManager()
153                     .getLocalString("tests.componentNameConstructor", // NOI18N
154                             "For [ {0} ]", // NOI18N
155                             new Object  []{getComponentName()}));
156             result.add(StringManagerHelper.getLocalStringsManager()
157                     .getLocalString(getClass().getName() + ".defaultNADetails", //NOI18N
158                             "Test is not applicable.")); // NOI18N
159             logger.fine("Returning default NADetails."); // NOI18N
160             return result;
161         }
162         return naDetails;
163     }
164 
165     /**
166      * Retrieve Warning details
167      *
168      * @return <code>Vector</code> warning details
169      */
170     public Vector   getWarningDetails() {
171         return warningDetails;
172     }
173 
174     /**
175      * Retrieve Not Applicable details
176      *
177      * @param s not applicable details
178      */
179     public void addNaDetails(String   s) {
180         naDetails.addElement(s);
181         logger.log(Level.FINE, s);
182     }
183 
184     /**
185      * Retrieve Good details
186      *
187      * @return <code>Vector</code> good details
188      */
189     public Vector   getGoodDetails() {
190         if(goodDetails.isEmpty()){
191             Vector  <String  > result = new Vector  <String  >();
192             result.add(StringManagerHelper.getLocalStringsManager()
193                     .getLocalString("tests.componentNameConstructor", // NOI18N
194                             "For [ {0} ]", // NOI18N
195                             new Object  []{getComponentName()}));
196             result.add(StringManagerHelper.getLocalStringsManager()
197                     .getLocalString(getClass().getName() + ".defaultGoodDetails", //NOI18N
198                             "There were no errors reported.")); // NOI18N
199             logger.fine("Returning default GoodDetails."); // NOI18N
200             return result;
201         }
202         return goodDetails;
203     }
204 
205     /**
206      * Fill in Good details
207      *
208      * @param s good detail string
209      */
210     public void addGoodDetails(String   s) {
211         goodDetails.addElement(s);
212         logger.log(Level.FINE, s);
213     }
214 
215     /**
216      * Fill in Warning details
217      *
218      * @param s warning detail string
219      */
220     public void addWarningDetails(String   s) {
221         warningDetails.addElement(s);
222         logger.log(Level.FINE, s);
223     }
224 
225     /**
226      * Retrieve Error details
227      *
228      * @return <code>Vector</code> error details
229      */
230     public Vector   getErrorDetails() {
231         return errorDetails;
232     }
233 
234     /**
235      * Fill in Error details
236      *
237      * @param s error detail string
238      */
239     public void addErrorDetails(String   s) {
240         errorDetails.addElement(s);
241         logger.log(Level.FINE, s);
242     }
243 
244     /**
245      * Retrieve test result status
246      *
247      * @return <code>int</code> test result status
248      */
249     public int getStatus() {
250         return status;
251     }
252 
253     /**
254      * Set test result status
255      *
256      * @param s test result status
257      */
258     public void setStatus(int s) {
259         status = s;
260     }
261 
262     /**
263      * Retrieve assertion
264      *
265      * @return <code>String</code> assertion string
266      */
267     public String   getAssertion() {
268         return assertion;
269     }
270 
271     /**
272      * Set assertion
273      *
274      * @param s assertion string
275      */
276     public void setAssertion(String   s) {
277         assertion = s;
278     }
279 
280     /**
281      * Retrieve component/module name
282      *
283      * @return <code>String</code> component/module name
284      */
285     public String   getComponentName() {
286         return componentName;
287     }
288 
289     /**
290      * Set component/module name
291      *
292      * @param s component/module name
293      */
294     public void setComponentName(String   s) {
295         componentName = s;
296     }
297 
298     /**
299      * Retrieve test name
300      *
301      * @return <code>String</code> test name
302      */
303     public String   getTestName() {
304         return testName;
305     }
306 
307     /**
308      * Set test name
309      *
310      * @param s test name
311      */
312     public void setTestName(String   s) {
313         testName = s;
314     }
315 
316     public void setModuleName(String   name) {
317         moduleName = name;
318     }
319 
320     public String   getModuleName() {
321         return moduleName;
322     }
323 
324 } // Result class
325
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags