Clover Coverage Report - KS LUM 1.1.1-SNAPSHOT (Aggregated)
Coverage timestamp: Wed Apr 20 2011 05:50:45 EST
Overview   Package   File
    FRAMES   NO FRAMES     
383   932   117   3.39
8   747   0.31   113
113     1.04  
1    
 
  TestStatementServiceConfiguration       Line # 21 383 0% 117 4 99.2% 0.99206346
 
  (109)
 
1    package org.kuali.student.lum.statement.service.impl;
2   
3    import java.util.List;
4   
5    import org.junit.Assert;
6    import org.junit.Test;
7    import org.kuali.student.common.test.spring.AbstractTransactionalDaoTest;
8    import org.kuali.student.common.test.spring.Dao;
9    import org.kuali.student.common.test.spring.PersistenceFileLocation;
10    import org.kuali.student.core.exceptions.DoesNotExistException;
11    import org.kuali.student.core.statement.dao.StatementDao;
12    import org.kuali.student.core.statement.entity.NlUsageType;
13    import org.kuali.student.core.statement.entity.OrderedReqComponentType;
14    import org.kuali.student.core.statement.entity.OrderedStatementType;
15    import org.kuali.student.core.statement.entity.ReqComponentFieldType;
16    import org.kuali.student.core.statement.entity.ReqComponentType;
17    import org.kuali.student.core.statement.entity.ReqComponentTypeNLTemplate;
18    import org.kuali.student.core.statement.entity.StatementType;
19   
20    @PersistenceFileLocation("classpath:META-INF/statement-persistence.xml")
 
21    public class TestStatementServiceConfiguration extends AbstractTransactionalDaoTest {
22    @Dao(value = "org.kuali.student.core.statement.dao.impl.StatementDaoImpl", testSqlFile = "classpath:ks-statement.sql")
23    public StatementDao dao;
24   
 
25  11 toggle private boolean containsStatementType(List<OrderedStatementType> typeList, String id) {
26  11 for(OrderedStatementType type : typeList) {
27  22 if(type.getChildStatementType().getId().equals(id)) {
28  11 return true;
29    }
30    }
31  0 return false;
32    }
33   
 
34  1 toggle @Test
35    public void testStatementTypeCount() {
36  1 List<StatementType> statementTypes = this.dao.find(StatementType.class);
37  1 Assert.assertEquals(15, statementTypes.size());
38    }
39   
 
40  1 toggle @Test
41    public void testValidStatementSubTypesForCourse() throws DoesNotExistException {
42  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course");
43  1 List<OrderedStatementType> subTypes = statementType.getAllowedStatementTypes();
44  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.enrollmentEligibility"));
45  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.creditConstraints"));
46    }
47   
 
48  1 toggle @Test
49    public void testValidStatementSubTypesForEnrollmentEligibility() throws DoesNotExistException {
50  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.enrollmentEligibility");
51  1 List<OrderedStatementType> subTypes = statementType.getAllowedStatementTypes();
52  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.academicReadiness.studentEligibilityPrereq"));
53  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.academicReadiness.coreq"));
54  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.recommendedPreparation"));
55  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.academicReadiness.antireq"));
56    }
57   
 
58  1 toggle @Test
59    public void testValidStatementSubTypesForCreditConstraints() throws DoesNotExistException {
60  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.creditConstraints");
61  1 List<OrderedStatementType> subTypes = statementType.getAllowedStatementTypes();
62  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.credit.restriction"));
63  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.course.credit.repeatable"));
64    }
65   
 
66  1 toggle @Test
67    public void testValidStatementSubTypesForProgram() throws DoesNotExistException {
68  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program");
69  1 List<OrderedStatementType> subTypes = statementType.getAllowedStatementTypes();
70  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.program.entrance"));
71  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.program.satisfactoryProgress"));
72  1 Assert.assertTrue(containsStatementType(subTypes, "kuali.statement.type.program.completion"));
73    }
74   
 
75  1 toggle @Test
76    public void testStatementSubTypesForCourseStatementType() throws DoesNotExistException {
77  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course");
78  1 Assert.assertEquals(2, statementType.getAllowedStatementTypes().size());
79    }
80   
 
81  1 toggle @Test
82    public void testStatementSubTypesForProgramStatementType() throws DoesNotExistException {
83  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program");
84  1 Assert.assertEquals(3, statementType.getAllowedStatementTypes().size());
85    }
86   
 
87  1 toggle @Test
88    public void testReqComponentTypeCount() {
89  1 List<ReqComponentType> reqComponentTypes = this.dao.find(ReqComponentType.class);
90  1 Assert.assertEquals(42, reqComponentTypes.size());
91    }
92   
 
93  1 toggle @Test
94    public void testReqComponentFieldTypeCount() {
95  1 List<ReqComponentFieldType> reqComponentFieldTypes = this.dao.find(ReqComponentFieldType.class);
96  1 Assert.assertEquals(18, reqComponentFieldTypes.size());
97    }
98   
 
99  1 toggle @Test
100    public void testReqComponentTypeNLTemplateCount() {
101  1 List<ReqComponentTypeNLTemplate> reqComponentTypeNLTemplates = this.dao.find(ReqComponentTypeNLTemplate.class);
102  1 Assert.assertEquals(168, reqComponentTypeNLTemplates.size());
103    }
104   
 
105  1 toggle @Test
106    public void testNlUsageTypeCount() {
107  1 List<NlUsageType> nlUsageTypes = this.dao.find(NlUsageType.class);
108  1 Assert.assertEquals(5, nlUsageTypes.size());
109    }
110   
 
111  5 toggle private boolean containsNlUsageType(List<NlUsageType> typeList, String id) {
112  5 for(NlUsageType type : typeList) {
113  15 if(type.getId().equals(id)) {
114  5 return true;
115    }
116    }
117  0 return false;
118    }
119   
 
120  1 toggle @Test
121    public void testValidNlUsageTypes() {
122  1 List<NlUsageType> nlUsageTypes = this.dao.find(NlUsageType.class);
123  1 Assert.assertTrue(containsNlUsageType(nlUsageTypes, "KUALI.CATALOG"));
124  1 Assert.assertTrue(containsNlUsageType(nlUsageTypes, "KUALI.RULE"));
125  1 Assert.assertTrue(containsNlUsageType(nlUsageTypes, "KUALI.RULE.PREVIEW"));
126  1 Assert.assertTrue(containsNlUsageType(nlUsageTypes, "KUALI.RULE.EXAMPLE"));
127  1 Assert.assertTrue(containsNlUsageType(nlUsageTypes, "KUALI.RULE.COMPOSITION"));
128    }
129   
 
130  65 toggle private boolean containsReqComponentType(List<OrderedReqComponentType> typeList, String id) {
131  65 for(OrderedReqComponentType type : typeList) {
132  418 if(type.getReqComponentType().getId().equals(id)) {
133  65 return true;
134    }
135    }
136  0 return false;
137    }
138   
 
139  1 toggle @Test
140    public void testReqComponentTypesForAntireqType() throws DoesNotExistException {
141  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.antireq");
142  1 Assert.assertEquals(5, statementType.getAllowedReqComponentTypes().size());
143    }
144   
 
145  1 toggle @Test
146    public void testValidReqComponentTypesForAntireqType() throws DoesNotExistException {
147  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.antireq");
148  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
149  1 Assert.assertEquals("kuali.reqComponent.type.course.notcompleted", types.get(0).getReqComponentType().getId());
150  1 Assert.assertEquals("kuali.reqComponent.type.course.courseset.completed.none", types.get(1).getReqComponentType().getId());
151  1 Assert.assertEquals("kuali.reqComponent.type.course.courseset.credits.completed.none", types.get(2).getReqComponentType().getId());
152  1 Assert.assertEquals("kuali.reqComponent.type.course.courseset.credits.completed.max", types.get(3).getReqComponentType().getId());
153  1 Assert.assertEquals("kuali.reqComponent.type.course.test.score.max", types.get(4).getReqComponentType().getId());
154    }
155   
 
156  1 toggle @Test
157    public void testReqComponentTypesForPrereqType() throws DoesNotExistException {
158  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.prereq");
159  1 Assert.assertEquals(13, statementType.getAllowedReqComponentTypes().size());
160    }
161   
 
162  1 toggle @Test
163    public void testValidReqComponentTypesForPrereqType() throws DoesNotExistException {
164  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.prereq");
165  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
166  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.completed.all"));
167  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.completed.nof"));
168  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.credits.completed.nof"));
169  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.gpa.min"));
170  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.grade.min"));
171  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.grade.max"));
172  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.permission.org.required"));
173  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.permission.instructor.required"));
174  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.test.score.min"));
175  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.nof.grade.min"));
176  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.admitted.org.duration"));
177  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.org.credits.completed.min"));
178    }
179   
 
180  1 toggle @Test
181    public void testReqComponentTypesForCoreqType() throws DoesNotExistException {
182  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.coreq");
183  1 Assert.assertEquals(2, statementType.getAllowedReqComponentTypes().size());
184    }
185   
 
186  1 toggle @Test
187    public void testValidReqComponentTypesForCoreqType() throws DoesNotExistException {
188  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.coreq");
189  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
190    //Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.courseList.coreq.all"));
191    //Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.courseList.coreq.oneof"));
192  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.enrolled.nof"));
193  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.enrolled"));
194    }
195   
 
196  1 toggle @Test
197    public void testReqComponentTypesForStudentEligibilityType() throws DoesNotExistException {
198  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.studentEligibility");
199  1 Assert.assertEquals(4, statementType.getAllowedReqComponentTypes().size());
200    }
201   
 
202  1 toggle @Test
203    public void testValidReqComponentTypesForStudentEligibilityType() throws DoesNotExistException {
204  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.studentEligibilityPrereq");
205  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
206    //Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.programList.enroll.oneof"));
207    //Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.programList.enroll.none"));
208  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.notadmitted.org.duration"));
209  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.org.program.admitted"));
210  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.notadmitted"));
211  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.admitted"));
212    }
213   
 
214  1 toggle @Test
215    public void testReqComponentTypesForStudentEligibilityPreReqType() throws DoesNotExistException {
216  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.studentEligibilityPrereq");
217  1 Assert.assertEquals(17, statementType.getAllowedReqComponentTypes().size());
218    }
219   
 
220  1 toggle @Test
221    public void testValidReqComponentTypesForStudentEligibilityPreReqType() throws DoesNotExistException {
222  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.academicReadiness.studentEligibilityPrereq");
223  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
224    //Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.programList.enroll.oneof"));
225    //Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.programList.enroll.none"));
226  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.notadmitted.org.duration"));
227  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.org.program.admitted"));
228  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.notadmitted"));
229  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.admitted"));
230  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.completed"));
231  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.completed.all"));
232  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.completed.nof"));
233  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.credits.completed.nof"));
234  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.gpa.min"));
235  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.grade.min"));
236  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.grade.max"));
237  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.permission.org.required"));
238  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.permission.instructor.required"));
239  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.test.score.min"));
240  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.nof.grade.min"));
241  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.program.admitted.org.duration"));
242  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.org.credits.completed.min"));
243    }
244   
 
245  1 toggle @Test
246    public void testReqComponentTypesForRepeatableForCreditType() throws DoesNotExistException {
247  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.credit.repeatable");
248  1 Assert.assertEquals(1, statementType.getAllowedReqComponentTypes().size());
249    }
250   
 
251  1 toggle @Test
252    public void testValidReqComponentTypesForRepeatableForCreditType() throws DoesNotExistException {
253  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.credit.repeatable");
254  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
255  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.credits.repeat.max"));
256    }
257   
 
258  1 toggle @Test
259    public void testReqComponentTypesForRecommendedPreparationType() throws DoesNotExistException {
260  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.recommendedPreparation");
261  1 Assert.assertEquals(2, statementType.getAllowedReqComponentTypes().size());
262    }
263   
 
264  1 toggle @Test
265    public void testValidReqComponentTypesForRecommendedPreparationType() throws DoesNotExistException {
266  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.recommendedPreparation");
267  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
268  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.org.credits.completed.min"));
269  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.completed"));
270    }
271   
 
272  1 toggle @Test
273    public void testReqComponentTypesForCoursesThatRestrictCreditType() throws DoesNotExistException {
274  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.credit.restriction");
275  1 Assert.assertEquals(2, statementType.getAllowedReqComponentTypes().size());
276    }
277   
 
278  1 toggle @Test
279    public void testValidReqComponentTypesForCoursesThatRestrictCreditType() throws DoesNotExistException {
280  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.course.credit.restriction");
281  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
282  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.completed.none"));
283  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.notcompleted"));
284    }
285   
 
286  1 toggle @Test
287    public void testReqComponentTypesForProgramSatisfactoryProgressType() throws DoesNotExistException {
288  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program.satisfactoryProgress");
289  1 Assert.assertEquals(7, statementType.getAllowedReqComponentTypes().size());
290    }
291   
 
292  1 toggle @Test
293    public void testValidReqComponentTypesForProgramSatisfactoryProgressType() throws DoesNotExistException {
294  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program.satisfactoryProgress");
295  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
296  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.admitted.credits"));
297  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.credits.max"));
298  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.completion.duration"));
299  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.candidate.status.duration"));
300  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.nof.grade.min"));
301  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.cumulative.gpa.min"));
302  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.duration.gpa.min"));
303    }
304   
 
305  1 toggle @Test
306    public void testReqComponentTypesForProgramEntranceType() throws DoesNotExistException {
307  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program.entrance");
308  1 Assert.assertEquals(19, statementType.getAllowedReqComponentTypes().size());
309    }
310   
 
311  1 toggle @Test
312    public void testValidReqComponentTypesForProgramEntranceType() throws DoesNotExistException {
313  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program.entrance");
314  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
315  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.programset.completed.nof"));
316  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.programset.notcompleted.nof"));
317  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.programset.completed.all"));
318  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.programset.coursecompleted.nof"));
319  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.gpa.min"));
320  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.test.score.min"));
321  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.admitted.credits"));
322  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.minor.admitted.classstanding"));
323    }
324   
 
325  1 toggle @Test
326    public void testReqComponentTypesForProgramCompletionType() throws DoesNotExistException {
327  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program.completion");
328  1 Assert.assertEquals(18, statementType.getAllowedReqComponentTypes().size());
329    }
330   
 
331  1 toggle @Test
332    public void testValidReqComponentTypesForProgramCompletionType() throws DoesNotExistException {
333  1 StatementType statementType = this.dao.fetch(StatementType.class, "kuali.statement.type.program.completion");
334  1 List<OrderedReqComponentType> types = statementType.getAllowedReqComponentTypes();
335  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.programset.completed.nof"));
336  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.programset.completed.all"));
337  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.programset.coursecompleted.nof"));
338  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.course.courseset.gpa.min"));
339  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.credits.min"));
340  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.residence.credits.final"));
341  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.enrolled.credits.final"));
342  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.completion.duration.afterentry"));
343  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.minors.nof"));
344  1 Assert.assertTrue(containsReqComponentType(types, "kuali.reqComponent.type.program.cumulative.gpa.min"));
345    }
346   
 
347  64 toggle private boolean containsReqComponentFieldType(List<ReqComponentFieldType> typeList, String id) {
348  64 for(ReqComponentFieldType type : typeList) {
349  105 if(type.getId().equals(id)) {
350  64 return true;
351    }
352    }
353  0 return false;
354    }
355   
 
356  1 toggle @Test
357    public void testReqComponentFieldTypeCountForReqComponentType_course_courseset_completed_none() throws DoesNotExistException {
358  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.completed.none");
359  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
360    }
361   
 
362  1 toggle @Test
363    public void testReqComponentFieldTypeForReqComponentType_course_courseset_completed_none() throws DoesNotExistException {
364  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.completed.none");
365  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
366  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
367    }
368   
 
369  1 toggle @Test
370    public void testReqComponentFieldTypeCountForReqComponentType_reqCompFieldType_cluSet_id() throws DoesNotExistException {
371  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.completed.all");
372  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
373    }
374   
 
375  1 toggle @Test
376    public void testReqComponentFieldTypeForReqComponentType_reqCompFieldType_cluSet_id() throws DoesNotExistException {
377  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.completed.all");
378  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
379  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
380    }
381   
 
382  1 toggle @Test
383    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_completed_nof() throws DoesNotExistException {
384  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.completed.nof");
385  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
386    }
387   
 
388  1 toggle @Test
389    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_completed_nof() throws DoesNotExistException {
390  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.completed.nof");
391  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
392  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
393  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
394    }
395   
 
396  1 toggle @Test
397    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_enrolled_nof() throws DoesNotExistException {
398  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.enrolled.nof");
399  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
400    }
401   
 
402  1 toggle @Test
403    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_enrolled_nof() throws DoesNotExistException {
404  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.enrolled.nof");
405  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
406  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
407  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
408    }
409   
 
410  1 toggle @Test
411    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_credits_completed_nof() throws DoesNotExistException {
412  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.credits.completed.nof");
413  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
414    }
415   
 
416  1 toggle @Test
417    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_credits_completed_nof() throws DoesNotExistException {
418  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.credits.completed.nof");
419  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
420  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
421  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
422    }
423   
 
424  1 toggle @Test
425    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_credits_completed_none() throws DoesNotExistException {
426  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.credits.completed.none");
427  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
428    }
429   
 
430  1 toggle @Test
431    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_credits_completed_none() throws DoesNotExistException {
432  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.credits.completed.none");
433  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
434  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
435  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
436    }
437   
 
438  1 toggle @Test
439    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_credits_completed_max() throws DoesNotExistException {
440  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.credits.completed.max");
441  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
442    }
443   
 
444  1 toggle @Test
445    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_credits_completed_max() throws DoesNotExistException {
446  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.credits.completed.max");
447  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
448  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
449  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
450    }
451   
 
452  1 toggle @Test
453    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_gpa_min() throws DoesNotExistException {
454  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.gpa.min");
455  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
456    }
457   
 
458  1 toggle @Test
459    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_gpa_min() throws DoesNotExistException {
460  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.gpa.min");
461  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
462  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
463  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.gpa"));
464    }
465   
466    /*@Test
467    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_courseList_coreq_all() throws DoesNotExistException {
468    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.courseList.coreq.all");
469    Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
470    }
471   
472    @Test
473    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_courseList_coreq_all() throws DoesNotExistException {
474    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.courseList.coreq.all");
475    List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
476    Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.cluSet.id"));
477    }
478   
479    @Test
480    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_courseList_coreq_oneof() throws DoesNotExistException {
481    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.courseList.coreq.oneof");
482    Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
483    }
484   
485    @Test
486    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_courseList_coreq_oneof() throws DoesNotExistException {
487    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.courseList.coreq.oneof");
488    List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
489    Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.cluSet.id"));
490    }
491   
492    @Test
493    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_programList_enroll_oneof() throws DoesNotExistException {
494    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.programList.enroll.oneof");
495    Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
496    }
497   
498    @Test
499    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_programList_enroll_oneof() throws DoesNotExistException {
500    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.programList.enroll.oneof");
501    List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
502    Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.cluSet.id"));
503    }
504   
505    @Test
506    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_programList_enroll_none() throws DoesNotExistException {
507    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.programList.enroll.none");
508    Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
509    }
510   
511    @Test
512    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_programList_enroll_none() throws DoesNotExistException {
513    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.programList.enroll.none");
514    List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
515    Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.cluSet.id"));
516    }*/
517   
 
518  1 toggle @Test
519    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_grade_min() throws DoesNotExistException {
520  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.grade.min");
521  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
522    }
523   
 
524  1 toggle @Test
525    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_grade_min() throws DoesNotExistException {
526  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.grade.min");
527  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
528  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
529  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.grade.id"));
530    }
531   
 
532  1 toggle @Test
533    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_grade_max() throws DoesNotExistException {
534  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.grade.max");
535  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
536    }
537   
 
538  1 toggle @Test
539    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_grade_max() throws DoesNotExistException {
540  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.grade.max");
541  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
542  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
543  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.grade.id"));
544    }
545   
 
546  1 toggle @Test
547    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_permission_org_required() throws DoesNotExistException {
548  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.permission.org.required");
549  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
550    }
551   
 
552  1 toggle @Test
553    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_permission_org_required() throws DoesNotExistException {
554  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.permission.org.required");
555  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
556  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.org.id"));
557    }
558   
 
559  1 toggle @Test
560    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_permission_instructor_required() throws DoesNotExistException {
561  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.permission.instructor.required");
562  1 Assert.assertEquals(0, reqComponentType.getReqCompFieldTypes().size());
563    }
564   
565    /*@Test
566    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_permission_instructor_required() throws DoesNotExistException {
567    ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.permission.instructor.required");
568    List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
569    Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.person.id"));
570    }*/
571   
 
572  1 toggle @Test
573    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_test_score_min() throws DoesNotExistException {
574  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.test.score.min");
575  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
576    }
577   
 
578  1 toggle @Test
579    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_test_score_min() throws DoesNotExistException {
580  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.test.score.min");
581  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
582  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.test.cluSet.id"));
583  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.test.score"));
584    }
585   
 
586  1 toggle @Test
587    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_test_score_max() throws DoesNotExistException {
588  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.test.score.max");
589  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
590    }
591   
 
592  1 toggle @Test
593    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_test_score_max() throws DoesNotExistException {
594  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.test.score.max");
595  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
596  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.test.cluSet.id"));
597  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.test.score"));
598    }
599   
 
600  1 toggle @Test
601    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_course_courseset_nof_grade_min() throws DoesNotExistException {
602  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.nof.grade.min");
603  1 Assert.assertEquals(3, reqComponentType.getReqCompFieldTypes().size());
604    }
605   
 
606  1 toggle @Test
607    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_course_courseset_nof_grade_min() throws DoesNotExistException {
608  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.courseset.nof.grade.min");
609  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
610  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
611  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.cluSet.id"));
612  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.grade.id"));
613    }
614   
 
615  1 toggle @Test
616    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_program_admitted_org_duration() throws DoesNotExistException {
617  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.admitted.org.duration");
618  1 Assert.assertEquals(5, reqComponentType.getReqCompFieldTypes().size());
619    }
620   
 
621  1 toggle @Test
622    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_program_admitted_org_duration() throws DoesNotExistException {
623  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.admitted.org.duration");
624  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
625  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
626  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
627  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.org.id"));
628  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.duration"));
629  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.durationType.id"));
630    }
631   
 
632  1 toggle @Test
633    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_program_notadmitted_org_duration() throws DoesNotExistException {
634  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.notadmitted.org.duration");
635  1 Assert.assertEquals(5, reqComponentType.getReqCompFieldTypes().size());
636    }
637   
 
638  1 toggle @Test
639    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_program_notadmitted_org_duration() throws DoesNotExistException {
640  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.notadmitted.org.duration");
641  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
642  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
643  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
644  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.org.id"));
645  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.duration"));
646  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.durationType.id"));
647    }
648   
 
649  1 toggle @Test
650    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_org_program_admitted() throws DoesNotExistException {
651  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.org.program.admitted");
652  1 Assert.assertEquals(0, reqComponentType.getReqCompFieldTypes().size());
653    }
654   
 
655  1 toggle @Test
656    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_program_notadmitted() throws DoesNotExistException {
657  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.notadmitted");
658  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
659    }
660   
 
661  1 toggle @Test
662    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_program_notadmitted() throws DoesNotExistException {
663  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.notadmitted");
664  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
665  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
666    }
667   
 
668  1 toggle @Test
669    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_program_admitted() throws DoesNotExistException {
670  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.admitted");
671  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
672    }
673   
 
674  1 toggle @Test
675    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_program_admitted() throws DoesNotExistException {
676  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.program.admitted");
677  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
678  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
679    }
680   
 
681  1 toggle @Test
682    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_credits_repeat_max() throws DoesNotExistException {
683  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.credits.repeat.max");
684  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
685    }
686   
 
687  1 toggle @Test
688    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_credits_repeat_max() throws DoesNotExistException {
689  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.credits.repeat.max");
690  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
691  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
692    }
693   
 
694  1 toggle @Test
695    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_org_credits_completed_min() throws DoesNotExistException {
696  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.org.credits.completed.min");
697  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
698    }
699   
 
700  1 toggle @Test
701    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_org_credits_completed_min() throws DoesNotExistException {
702  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.org.credits.completed.min");
703  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
704  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
705  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.org.id"));
706    }
707   
708   
709    /* Programs */
710   
711   
 
712  1 toggle @Test
713    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_programset_completed_nof() throws DoesNotExistException {
714  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.completed.nof");
715  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
716    }
717   
 
718  1 toggle @Test
719    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_programset_completed_nof() throws DoesNotExistException {
720  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.completed.nof");
721  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
722  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
723  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
724    }
725   
 
726  1 toggle @Test
727    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_programset_notcompleted_nof() throws DoesNotExistException {
728  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.notcompleted.nof");
729  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
730    }
731   
 
732  1 toggle @Test
733    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_programset_notcompleted_nof() throws DoesNotExistException {
734  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.notcompleted.nof");
735  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
736  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
737    }
738   
 
739  1 toggle @Test
740    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_programset_completed_all() throws DoesNotExistException {
741  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.completed.all");
742  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
743    }
744   
 
745  1 toggle @Test
746    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_programset_completed_all() throws DoesNotExistException {
747  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.completed.all");
748  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
749  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
750    }
751   
 
752  1 toggle @Test
753    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_programset_coursecompleted_nof() throws DoesNotExistException {
754  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.coursecompleted.nof");
755  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
756    }
757   
 
758  1 toggle @Test
759    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_programset_coursecompleted_nof() throws DoesNotExistException {
760  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.programset.coursecompleted.nof");
761  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
762  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
763  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.cluSet.id"));
764    }
765   
 
766  1 toggle @Test
767    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_admitted_credits() throws DoesNotExistException {
768  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.admitted.credits");
769  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
770    }
771   
 
772  1 toggle @Test
773    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_admitted_credits() throws DoesNotExistException {
774  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.admitted.credits");
775  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
776  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
777    }
778   
 
779  1 toggle @Test
780    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_credits_min() throws DoesNotExistException {
781  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.credits.min");
782  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
783    }
784   
 
785  1 toggle @Test
786    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_credits_min() throws DoesNotExistException {
787  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.credits.min");
788  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
789  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
790    }
791   
 
792  1 toggle @Test
793    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_credits_max() throws DoesNotExistException {
794  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.credits.max");
795  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
796    }
797   
 
798  1 toggle @Test
799    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_credits_max() throws DoesNotExistException {
800  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.credits.max");
801  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
802  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
803    }
804   
 
805  1 toggle @Test
806    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_completion_duration() throws DoesNotExistException {
807  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.completion.duration");
808  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
809    }
810   
 
811  1 toggle @Test
812    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_completion_duration() throws DoesNotExistException {
813  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.completion.duration");
814  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
815  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.duration"));
816  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.durationType.id"));
817    }
818   
 
819  1 toggle @Test
820    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_candidate_status_duration() throws DoesNotExistException {
821  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.candidate.status.duration");
822  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
823    }
824   
 
825  1 toggle @Test
826    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_candidate_status_duration() throws DoesNotExistException {
827  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.candidate.status.duration");
828  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
829  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.duration"));
830  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.durationType.id"));
831    }
832   
 
833  1 toggle @Test
834    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqCompType_program_completion_duration_afterentry() throws DoesNotExistException {
835  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.completion.duration.afterentry");
836  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
837    }
838   
 
839  1 toggle @Test
840    public void testReqComponentFieldTypeForReqComponentType_kuali_reqCompType_program_completion_duration_afterentry() throws DoesNotExistException {
841  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.completion.duration.afterentry");
842  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
843  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.duration"));
844  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.durationType.id"));
845    }
846   
 
847  1 toggle @Test
848    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_program_residence_credits_final() throws DoesNotExistException {
849  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.residence.credits.final");
850  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
851    }
852   
 
853  1 toggle @Test
854    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_program_residence_credits_final() throws DoesNotExistException {
855  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.residence.credits.final");
856  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
857  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.clu.id"));
858  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
859    }
860   
 
861  1 toggle @Test
862    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_program_enrolled_credits_final() throws DoesNotExistException {
863  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.enrolled.credits.final");
864  1 Assert.assertEquals(2, reqComponentType.getReqCompFieldTypes().size());
865    }
866   
 
867  1 toggle @Test
868    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_program_enrolled_credits_final() throws DoesNotExistException {
869  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.enrolled.credits.final");
870  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
871  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.program.clu.id"));
872  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
873    }
874   
 
875  1 toggle @Test
876    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_program_minors_nof() throws DoesNotExistException {
877  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.minors.nof");
878  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
879    }
880   
 
881  1 toggle @Test
882    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_program_minors_nof() throws DoesNotExistException {
883  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.minors.nof");
884  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
885  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.value.positive.integer"));
886    }
887   
 
888  1 toggle @Test
889    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_program_minor_admitted_classstanding() throws DoesNotExistException {
890  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.program.minor.admitted.classstanding");
891  1 Assert.assertEquals(0, reqComponentType.getReqCompFieldTypes().size());
892    }
893   
 
894  1 toggle @Test
895    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_completed() throws DoesNotExistException {
896  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.completed");
897  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
898    }
899   
 
900  1 toggle @Test
901    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_completed() throws DoesNotExistException {
902  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.completed");
903  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
904  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.clu.id"));
905    }
906   
 
907  1 toggle @Test
908    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_enrolled() throws DoesNotExistException {
909  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.enrolled");
910  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
911    }
912   
 
913  1 toggle @Test
914    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_enrolled() throws DoesNotExistException {
915  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.enrolled");
916  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
917  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.clu.id"));
918    }
919   
 
920  1 toggle @Test
921    public void testReqComponentFieldTypeCountForReqComponentType_kuali_reqComponent_type_course_notcompleted() throws DoesNotExistException {
922  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.notcompleted");
923  1 Assert.assertEquals(1, reqComponentType.getReqCompFieldTypes().size());
924    }
925   
 
926  1 toggle @Test
927    public void testReqComponentFieldTypeForReqComponentType_kuali_reqComponent_type_course_notcompleted() throws DoesNotExistException {
928  1 ReqComponentType reqComponentType = this.dao.fetch(ReqComponentType.class, "kuali.reqComponent.type.course.notcompleted");
929  1 List<ReqComponentFieldType> types = reqComponentType.getReqCompFieldTypes();
930  1 Assert.assertTrue(containsReqComponentFieldType(types, "kuali.reqComponent.field.type.course.clu.id"));
931    }
932    }
 
CloverReport generated by Clover Code Coverage v3.0.2
Wed Apr 20 2011 05:52:19 EST.		   Clover: Open Source License registered to University of Arizona.