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