001: /*******************************************************************************
002: * Portions created by Sebastian Thomschke are copyright (c) 2005-2007 Sebastian
003: * Thomschke.
004: *
005: * All Rights Reserved. This program and the accompanying materials
006: * are made available under the terms of the Eclipse Public License v1.0
007: * which accompanies this distribution, and is available at
008: * http://www.eclipse.org/legal/epl-v10.html
009: *
010: * Contributors:
011: * Sebastian Thomschke - initial implementation.
012: *******************************************************************************/package net.sf.oval.test.guard;
013:
014: import java.lang.reflect.Constructor;
015: import java.lang.reflect.Field;
016: import java.lang.reflect.Method;
017: import java.util.List;
018:
019: import junit.framework.TestCase;
020: import net.sf.oval.ConstraintViolation;
021: import net.sf.oval.constraint.NotNullCheck;
022: import net.sf.oval.context.ConstructorParameterContext;
023: import net.sf.oval.context.MethodParameterContext;
024: import net.sf.oval.exception.ConstraintsViolatedException;
025: import net.sf.oval.exception.InvalidConfigurationException;
026: import net.sf.oval.guard.Guard;
027: import net.sf.oval.guard.Guarded;
028:
029: /**
030: * @author Sebastian Thomschke
031: */
032: public class AddingChecksTest extends TestCase {
033: @Guarded
034: protected static class TestEntity1 {
035: protected String name;
036:
037: private TestEntity1(String name) {
038: this .name = name;
039: }
040:
041: /**
042: * @param name the name to set
043: */
044: public void setName(String name) {
045: this .name = name;
046: }
047: }
048:
049: @Guarded
050: protected static class TestEntity2 {
051: protected String name;
052:
053: private TestEntity2(String name) {
054: this .name = name;
055: }
056:
057: /**
058: * @param name the name to set
059: */
060: public void setName(String name) {
061: this .name = name;
062: }
063: }
064:
065: @Guarded()
066: protected static class TestEntity3 {
067: protected String name;
068:
069: private TestEntity3(String name) {
070: this .name = name;
071: }
072:
073: /**
074: * @param name the name to set
075: */
076: public void setName(String name) {
077: this .name = name;
078: }
079: }
080:
081: /**
082: * try to programmatically add a NotNull constraint to the setter parameter
083: */
084: public void addConstraintToMethodParameter() {
085: Guard guard = TestGuardAspect.aspectOf().getGuard();
086:
087: try {
088: Method setter = TestEntity1.class.getDeclaredMethod(
089: "setName", new Class<?>[] { String.class });
090: NotNullCheck notNullCheck = new NotNullCheck();
091: notNullCheck.setMessage("NOT_NULL");
092:
093: // testing without constraint
094: try {
095: TestEntity1 entity = new TestEntity1("blabla");
096: entity.setName(null);
097: } catch (ConstraintsViolatedException e) {
098: fail();
099: }
100:
101: // adding a constraint
102: guard.addChecks(setter, 0, notNullCheck);
103: try {
104: TestEntity1 entity = new TestEntity1("blabla");
105: entity.setName(null);
106: fail();
107: } catch (ConstraintsViolatedException e) {
108: ConstraintViolation[] violations = e
109: .getConstraintViolations();
110: assertTrue(violations.length == 1);
111: assertTrue(violations[0].getContext() instanceof MethodParameterContext);
112: assertTrue(violations[0].getMessage()
113: .equals("NOT_NULL"));
114: }
115:
116: // removing the constraint
117: guard.removeChecks(setter, 0, notNullCheck);
118: try {
119: TestEntity1 entity = new TestEntity1("blabla");
120: entity.setName(null);
121: } catch (ConstraintsViolatedException e) {
122: fail();
123: }
124: } catch (InvalidConfigurationException e) {
125: fail();
126: } catch (SecurityException e) {
127: e.printStackTrace();
128: fail();
129: } catch (NoSuchMethodException e) {
130: e.printStackTrace();
131: fail();
132: }
133: }
134:
135: /**
136: * try to programmatically add a NotNull constraint to the constructor parameter
137: */
138: public void testAddConstraintToConstructorParameter()
139: throws Exception {
140: final Guard guard = new Guard();
141: TestGuardAspect.aspectOf().setGuard(guard);
142:
143: Constructor constructor = TestEntity2.class
144: .getDeclaredConstructor(new Class<?>[] { String.class });
145: NotNullCheck notNullCheck = new NotNullCheck();
146: notNullCheck.setMessage("NOT_NULL");
147:
148: // testing without constraint
149: new TestEntity2(null);
150:
151: // adding a constraint
152: guard.addChecks(constructor, 0, notNullCheck);
153: try {
154: new TestEntity2(null);
155: fail();
156: } catch (ConstraintsViolatedException e) {
157: ConstraintViolation[] violations = e
158: .getConstraintViolations();
159: assertTrue(violations.length == 1);
160: assertTrue(violations[0].getContext() instanceof ConstructorParameterContext);
161: assertTrue(violations[0].getMessage().equals("NOT_NULL"));
162: }
163:
164: // removing the constraint
165: guard.removeChecks(constructor, 0, notNullCheck);
166:
167: new TestEntity2(null);
168: }
169:
170: /**
171: * programmatically add a NotNull constraint to the name field
172: */
173: public void testAddConstraintToField() throws Exception {
174: final Guard guard = new Guard();
175: TestGuardAspect.aspectOf().setGuard(guard);
176:
177: TestEntity3 entity = new TestEntity3(null);
178: assertEquals(0, guard.validate(entity).size());
179:
180: Field field = TestEntity3.class.getDeclaredField("name");
181: NotNullCheck notNullCheck = new NotNullCheck();
182: notNullCheck.setMessage("NOT_NULL");
183:
184: // testing without constraint
185: {
186: List<ConstraintViolation> violations = guard
187: .validate(entity);
188: assertTrue(violations.size() == 0);
189: }
190:
191: // adding a constraint
192: {
193: guard.addChecks(field, notNullCheck);
194:
195: List<ConstraintViolation> violations = TestGuardAspect
196: .aspectOf().getGuard().validate(entity);
197: assertTrue(violations.size() == 1);
198: assertTrue(violations.get(0).getMessage()
199: .equals("NOT_NULL"));
200: }
201:
202: // removing the constraint
203: {
204: guard.removeChecks(field, notNullCheck);
205:
206: List<ConstraintViolation> violations = TestGuardAspect
207: .aspectOf().getGuard().validate(entity);
208: assertTrue(violations.size() == 0);
209: }
210: }
211: }
|