oneadam There are many adams, I am one. This is my weblog.

@Test
public void shouldSetAndGetProperties() {
   assertThat(user, hasValidSettersAndGettersExcluding("fieldX", "fieldY"));
}

@Test
public void shouldSetAndGetProperties() {
   assertThat(user, hasValidSettersAndGettersFor("fieldA", "fieldB", "fieldC));
}

package com.express.testutils;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public class SetterGetterInvoker<T> {
   private static final Log LOG = LogFactory.getLog(SetterGetterInvoker.class);
 
   private T testTarget;
   private Class testClass;
   private ValueFactory valueFactory;
   private Map<String, Method> methodMap = new HashMap<String, Method>();
 
   public SetterGetterInvoker(T testTarget) {
      this.testTarget = testTarget;
      this.testClass = testTarget.getClass();
      this.valueFactory = new ValueFactory();
      for (Method method : testTarget.getClass().getMethods()) {
         methodMap.put(method.getName(), method);
      }
   }
 
   public boolean invokeSettersAndGettersFor(String[] fields) {
      return invokeSettersAndGetters(fields);
   }
 
   public boolean invokeSettersAndGettersExcluding(String[] excludedFields) {
      Field[] classFields = testClass.getDeclaredFields();
      List<String> fields = new ArrayList<String>();
      for(Field classField : classFields) {
         String fieldName = classField.getName();
         if(!in(fieldName, excludedFields) && !Modifier.isStatic(classField.getModifiers())) {
            fields.add(fieldName);
         }
      }
      return invokeSettersAndGetters(fields.toArray(new String[fields.size()]));
   }
 
   private boolean in(String field, String[] fields) {
      for(String arrayField : fields) {
         if( arrayField.equals(field)) {
            return true;
         }
      }
      return false;
   }
 
   private boolean invokeSettersAndGetters(String[] fields) {
      for (String field : fields) {
         LOG.debug("Invoking getter/setter for " + field);
         String capitalizedFieldName = Character.toUpperCase(field.charAt(0)) + field.substring(1);
         try {
            Object testValue = invokeSetter(methodMap.get("set" + capitalizedFieldName));
            Method getterMethod = methodMap.get(constructMethodName(capitalizedFieldName, testValue));
            Object result = getterMethod.invoke(testTarget);
            if (!testValue.equals(result)) {
               LOG.error("Getter result did not match set value for field:" + field);
               return false;
            }
         } catch (Exception e) {
            LOG.error("Unable to invoke both getter and setter for " + field, e);
            return false;
         }
      }
      return true;
   }
 
   private Object invokeSetter(Method method) throws Exception {
      Class<?>[] parameterTypes = method.getParameterTypes();
      if (parameterTypes.length == 1) {
         Object testValue = valueFactory.createValue(parameterTypes[0]);
         method.invoke(testTarget, testValue);
         return testValue;
      }
      return null;
   }
 
   private String constructMethodName(String capitalizedFieldName, Object testValue) {
      String base =  "get";
      if(testValue instanceof Boolean && testMethodNameDoesNotExists(base + capitalizedFieldName)) {
         return "is" + capitalizedFieldName;
      }
      return base + capitalizedFieldName;
   }
 
   private boolean testMethodNameDoesNotExists(String methodName) {
      try {
         testClass.getMethod(methodName, null);
         return false;
      } catch (NoSuchMethodException e) {
         return true;
      }
 
   }
}

package com.express.testutils;
 
 
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
 
import static org.mockito.Mockito.mock;
 
 
public class ValueFactory {
   private static final int A_NUMBER = 42;
   private static final int HALF_A_NUMBER = 21;
 
   private Map<Class<?>, Object> typeValues;
 
   public ValueFactory() {
      typeValues = new HashMap<Class<?>, Object>();
      typeValues.put(String.class, "test");
      typeValues.put(Long.class, new Long(A_NUMBER));
      typeValues.put(Long.TYPE, new Long(A_NUMBER));
      typeValues.put(Integer.class, Integer.valueOf(HALF_A_NUMBER));
      typeValues.put(Integer.TYPE, Integer.valueOf(HALF_A_NUMBER));
      typeValues.put(Boolean.class, Boolean.TRUE);
      typeValues.put(Boolean.TYPE, Boolean.TRUE);
      typeValues.put(Long[].class, new Long[0]);
      typeValues.put(Integer[].class, new Integer[0]);
      typeValues.put(String[].class, new String[0]);
      typeValues.put(Boolean[].class, new Boolean[0]);
   }
 
   public Object createValue(Class<?> type) {
      if(Modifier.isFinal(type.getModifiers())) {
         return typeValues.get(type);
      }
      return mock(type);
   }
}

package com.express.matcher;
 
import com.express.testutils.SetterGetterInvoker;
import org.hamcrest.Description;
import org.hamcrest.TypeSafeMatcher;
 
public class HasValidSettersAndGettersExcludingMatcher<T> extends TypeSafeMatcher<T> {
   private String[] fields;
 
   public HasValidSettersAndGettersExcludingMatcher(String... fields) {
      this.fields = fields;
   }
 
   @Override
   public boolean matchesSafely(T subject) {
      SetterGetterInvoker<T> setterGetterInvoker = new SetterGetterInvoker<T>(subject);
      return setterGetterInvoker.invokeSettersAndGettersExcluding(fields);
   }
 
   public void describeTo(Description description) {
      description.appendText("Unable to match setter and getter results for class fields excluding ");
      description.appendValue(fields);
   }
}

package com.express.matcher;
 
import com.express.testutils.SetterGetterInvoker;
import org.hamcrest.Description;
import org.hamcrest.TypeSafeMatcher;
 
public class HasValidSettersAndGettersForMatcher<T> extends TypeSafeMatcher<T> {
   private String[] fields;
 
   public HasValidSettersAndGettersForMatcher(String... fields) {
      this.fields = fields;
   }
 
   @Override
   public boolean matchesSafely(T subject) {
      SetterGetterInvoker<T> setterGetterInvoker = new SetterGetterInvoker<T>(subject);
      return setterGetterInvoker.invokeSettersAndGettersFor(fields);
   }
 
   public void describeTo(Description description) {
      description.appendText("Unable to match setter and getter results for class fields: ");
      description.appendValue(fields);
   }
}

package com.express.matcher;
 
import org.hamcrest.Factory;
 
public final class BeanMatchers {
   private BeanMatchers() { }
 
   @Factory
   public static <T> HasValidSettersAndGettersForMatcher hasValidSettersAndGettersFor(String... fields) {
      return new HasValidSettersAndGettersForMatcher(fields);
   }
 
   @Factory
   public static <T> HasValidSettersAndGettersExcludingMatcher hasValidSettersAndGettersExcluding(String... fields) {
      return new HasValidSettersAndGettersExcludingMatcher(fields);
   }
}