KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > tools > verifier > tests > ejb > entity > cmp > CmpFields


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 package com.sun.enterprise.tools.verifier.tests.ejb.entity.cmp;
24
25 import com.sun.enterprise.tools.verifier.tests.ejb.EjbTest;
26 import java.lang.reflect.Field JavaDoc;
27 import java.util.*;
28 import com.sun.enterprise.deployment.*;
29 import com.sun.enterprise.tools.verifier.*;
30 import com.sun.enterprise.tools.verifier.tests.ejb.RmiIIOPUtils;
31 import com.sun.enterprise.tools.verifier.tests.ejb.EjbCheck;
32 import java.lang.ClassLoader JavaDoc;
33 import com.sun.enterprise.tools.verifier.tests.*;
34
35 /**
36  * Container-managed fields valid type test.
37  *
38  * The Bean Provider must ensure that the Java types assigned to the
39  * container-managed fields are one of the following: Java primitive types,
40  * Java serializable types, or references to enterprise beans' remote or home
41  * interfaces.
42  *
43  */

44 public class CmpFields extends EjbTest implements EjbCheck {
45
46
47     /**
48      * Container-managed fields valid type test.
49      *
50      * The Bean Provider must ensure that the Java types assigned to the
51      * container-managed fields are one of the following: Java primitive types,
52      * Java serializable types, or references to enterprise beans' remote or home
53      * interfaces.
54      *
55      * @param descriptor the Enterprise Java Bean deployment descriptor
56      *
57      * @return <code>Result</code> the results for this assertion
58      */

59     public Result check(EjbDescriptor descriptor) {
60
61     Result result = getInitializedResult();
62     ComponentNameConstructor compName = getVerifierContext().getComponentNameConstructor();
63
64     if (descriptor instanceof EjbEntityDescriptor) {
65         String JavaDoc persistentType =
66         ((EjbEntityDescriptor)descriptor).getPersistenceType();
67         if (EjbEntityDescriptor.CONTAINER_PERSISTENCE.equals(persistentType)) {
68                 
69                 // this test apply only to 1.x cmp beans, in 2.x fields are virtual fields only
70
if (EjbCMPEntityDescriptor.CMP_1_1 != ((EjbCMPEntityDescriptor) descriptor).getCMPVersion()) {
71             result.addNaDetails(smh.getLocalString
72                        ("tests.componentNameConstructor",
73                     "For [ {0} ]",
74                     new Object JavaDoc[] {compName.toString()}));
75                 result.notApplicable(smh.getLocalString
76                  ("com.sun.enterprise.tools.verifier.tests.ejb.entity.cmp2.CMPTest.notApplicable3",
77                   "Test do not apply to this cmp-version of container managed persistence EJBs"));
78                 return result;
79                 }
80                 
81         Context context = getVerifierContext();
82         ClassLoader JavaDoc jcl = context.getClassLoader();
83         // RULE: container-managed fields are one of the following:
84
// Java primitive types, Java serializable types, or references
85
// to enterprise beans' remote or home interfaces.
86
Set persistentFields =
87             ((EjbCMPEntityDescriptor)descriptor).getPersistenceDescriptor().getCMPFields();
88         Iterator iterator = persistentFields.iterator();
89         
90         Descriptor persistentField;
91         Field JavaDoc field;
92         boolean oneFailed = false;
93         while (iterator.hasNext()) {
94             persistentField = (Descriptor)iterator.next();
95             boolean foundField = false;
96             try {
97             Class JavaDoc c = Class.forName(descriptor.getEjbClassName(), false, getVerifierContext().getClassLoader());
98             // start do while loop here....
99
do {
100                 try {
101                     Field JavaDoc f = c.getDeclaredField(persistentField.getName());
102                     foundField = true;
103                     Class JavaDoc persistentFieldClassType = f.getType();
104
105                 if(descriptor.getHomeClassName() != null && !"".equals(descriptor.getHomeClassName()) &&
106                    descriptor.getRemoteClassName() != null && !"".equals(descriptor.getRemoteClassName())) {
107                     if (RmiIIOPUtils.isPersistentFieldTypeValid(persistentFieldClassType,descriptor.getHomeClassName(),descriptor.getRemoteClassName())) {
108                     result.addGoodDetails(smh.getLocalString
109                                   ("tests.componentNameConstructor",
110                                    "For [ {0} ]",
111                                    new Object JavaDoc[] {compName.toString()}));
112                     result.addGoodDetails(smh.getLocalString
113                     (getClass().getName() + ".passed",
114                     "Valid type assigned to container managed field [ {0} ] found in bean [ {1} ]",
115                     new Object JavaDoc[] {((Descriptor)persistentField).getName(),c.getName()}));
116                     } else {
117                     oneFailed = true;
118                     result.addErrorDetails(smh.getLocalString
119                                    ("tests.componentNameConstructor",
120                                 "For [ {0} ]",
121                                 new Object JavaDoc[] {compName.toString()}));
122                     result.addErrorDetails(smh.getLocalString
123                        (getClass().getName() + ".failed",
124                        "Error: Invalid type assigned to container managed field [ {0} ] found in bean [ {1} ]",
125                         new Object JavaDoc[] {((Descriptor)persistentField).getName(),c.getName()}));
126                     }
127                 }
128                 
129                 if(descriptor.getLocalHomeClassName() != null && !"".equals(descriptor.getLocalHomeClassName()) && descriptor.getLocalClassName() != null && !"".equals(descriptor.getLocalClassName())) {
130                     if (RmiIIOPUtils.isPersistentFieldTypeValid(persistentFieldClassType,descriptor.getLocalHomeClassName(),descriptor.getLocalClassName())) {
131                     result.addGoodDetails(smh.getLocalString
132                                    ("tests.componentNameConstructor",
133                                 "For [ {0} ]",
134                                 new Object JavaDoc[] {compName.toString()}));
135                     result.addGoodDetails(smh.getLocalString
136                     (getClass().getName() + ".passed",
137                     "Valid type assigned to container managed field [ {0} ] found in bean [ {1} ]",
138                     new Object JavaDoc[] {((Descriptor)persistentField).getName(),c.getName()}));
139                     } else {
140                     oneFailed = true;
141                     result.addErrorDetails(smh.getLocalString
142                                    ("tests.componentNameConstructor",
143                                 "For [ {0} ]",
144                                 new Object JavaDoc[] {compName.toString()}));
145                     result.addErrorDetails(smh.getLocalString
146                                    (getClass().getName() + ".failed",
147                                 "Error: Invalid type assigned to container managed field [ {0} ] found in bean [ {1} ]",
148                     new Object JavaDoc[] {((Descriptor)persistentField).getName(),c.getName()}));
149                     }
150                 }
151                 
152                 } catch (NoSuchFieldException JavaDoc e) {
153                 foundField = false;
154                 }
155                         } while (((c = c.getSuperclass()) != null) && (!foundField));
156                 if (!foundField) {
157                             if (!oneFailed) {
158                     oneFailed = true;
159                             }
160                 result.addErrorDetails(smh.getLocalString
161                            ("tests.componentNameConstructor",
162                             "For [ {0} ]",
163                             new Object JavaDoc[] {compName.toString()}));
164                 result.addErrorDetails(smh.getLocalString
165                            (getClass().getName() + ".failedException1",
166                             "Error: field [ {0} ] not found in class [ {1} ]",
167                             new Object JavaDoc[] {((Descriptor)persistentField).getName(),descriptor.getEjbClassName()}));
168             }
169             } catch (ClassNotFoundException JavaDoc e) {
170             Verifier.debug(e);
171             result.addErrorDetails(smh.getLocalString
172                            ("tests.componentNameConstructor",
173                         "For [ {0} ]",
174                         new Object JavaDoc[] {compName.toString()}));
175             result.failed(smh.getLocalString
176                       (getClass().getName() + ".failedException",
177                        "Error: [ {0} ] class not found.",
178                        new Object JavaDoc[] {descriptor.getEjbClassName()}));
179             }
180         }
181         if (oneFailed) {
182             result.setStatus(Result.FAILED);
183         } else {
184             result.setStatus(Result.PASSED);
185         }
186         } else { // if (BEAN_PERSISTENCE.equals(persistentType))
187
result.addNaDetails(smh.getLocalString
188                        ("tests.componentNameConstructor",
189                     "For [ {0} ]",
190                     new Object JavaDoc[] {compName.toString()}));
191         result.notApplicable(smh.getLocalString
192                      (getClass().getName() + ".notApplicable1",
193                       "Expected persistence type [ {0} ], but [ {1} ] bean has persistence type [ {2} ]",
194                       new Object JavaDoc[] {EjbEntityDescriptor.CONTAINER_PERSISTENCE,descriptor.getName(),persistentType}));
195         }
196         return result;
197     } else {
198         result.addNaDetails(smh.getLocalString
199                        ("tests.componentNameConstructor",
200                     "For [ {0} ]",
201                     new Object JavaDoc[] {compName.toString()}));
202         result.notApplicable(smh.getLocalString
203                  (getClass().getName() + ".notApplicable",
204                   "[ {0} ] expected {1} bean, but called with {2} bean.",
205                   new Object JavaDoc[] {getClass(),"Entity","Session"}));
206         return result;
207     }
208     }
209 }
210
Popular Tags