MapBeanReadWrapper.java

package fr.sii.ogham.core.util.bean;

import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import fr.sii.ogham.core.exception.util.InvalidPropertyException;

/**
 * Wraps a bean and exposes as a Map.
 * 
 * The Map is indexed by the property names defined in the bean and allow to
 * access the value using the Map insterface.
 * 
 * This implementation doesn't support update methods (remove, clear, put...)
 * and doesn't support access to values directly (values, containsValue).
 * 
 * This implementation delegates access to real bean properties through a
 * {@link SimpleBeanReadWrapper} instance (by default). You can
 * override this default wrapper using the constructor
 * {@link #MapBeanReadWrapper(BeanReadWrapper)}.
 * 
 * @author Aurélien Baudet
 *
 */
public class MapBeanReadWrapper implements BeanReadWrapper, Map<String, Object> {
	private final BeanReadWrapper delegate;

	/**
	 * Initializes the wrapper for the provided bean.
	 * 
	 * {@link SimpleBeanReadWrapper} is used to access bean
	 * properties.
	 * 
	 * @param bean
	 *            the bean to wrap
	 */
	public MapBeanReadWrapper(Object bean) {
		this(bean, true);
	}

	/**
	 * Initializes the wrapper for the provided bean.
	 * 
	 * {@link SimpleBeanReadWrapper} is used to access bean
	 * properties.
	 * 
	 * @param bean
	 *            the bean to wrap
	 * @param failOnMissingProperty
	 *            if false null is returned if the property doesn't exist, if
	 *            true an {@link InvalidPropertyException} is thrown if the
	 *            property doesn't exist
	 */
	public MapBeanReadWrapper(Object bean, boolean failOnMissingProperty) {
		this(new SimpleBeanReadWrapper(bean, failOnMissingProperty));
	}

	/**
	 * Point of extension by providing custom bean wrapper.
	 * 
	 * @param delegate
	 *            the bean wrapper that access bean properties
	 */
	public MapBeanReadWrapper(BeanReadWrapper delegate) {
		super();
		this.delegate = delegate;
	}

	@Override
	public int size() {
		return getProperties().size();
	}

	@Override
	public boolean isEmpty() {
		return size() == 0;
	}

	@Override
	public boolean containsKey(Object key) {
		for (String prop : getProperties()) {
			if (prop.equals(key)) {
				return true;
			}
		}
		return false;
	}

	@Override
	public boolean containsValue(Object value) {
		throw new UnsupportedOperationException("containsValue not implemented");
	}

	@Override
	public Object get(Object key) {
		if (key == null) {
			throw new IllegalArgumentException("key must not be null");
		}
		return getPropertyValue(key.toString());
	}

	@Override
	public Object put(String key, Object value) {
		throw new UnsupportedOperationException("put not implemented");
	}

	@Override
	public Object remove(Object key) {
		throw new UnsupportedOperationException("remove not implemented");
	}

	@Override
	public void putAll(Map<? extends String, ? extends Object> m) {
		throw new UnsupportedOperationException("putAll not implemented");
	}

	@Override
	public void clear() {
		throw new UnsupportedOperationException("clear not implemented");
	}

	@Override
	public Set<String> keySet() {
		return new HashSet<>(delegate.getProperties());
	}

	@Override
	public Collection<Object> values() {
		throw new UnsupportedOperationException("values not implemented");
	}

	@Override
	public Set<Entry<String, Object>> entrySet() {
		Set<Entry<String, Object>> entries = new TreeSet<>();
		for (String prop : getProperties()) {
			entries.add(new MapBeanReadWrapperEntry(delegate, prop));
		}
		return entries;
	}

	@Override
	public Object getPropertyValue(String name) {
		return delegate.getPropertyValue(name);
	}

	@Override
	public List<String> getProperties() {
		return delegate.getProperties();
	}

	@Override
	public Object getWrappedBean() {
		return delegate.getWrappedBean();
	}

	/**
	 * Specific Entry implementation that delegates to a real bean wrapper in order
	 * to access bean properties.
	 * 
	 * @author Aurélien Baudet
	 *
	 */
	public static class MapBeanReadWrapperEntry implements Entry<String, Object>, Comparable<MapBeanReadWrapperEntry> {
		private final BeanReadWrapper delegate;
		private final String key;

		public MapBeanReadWrapperEntry(BeanReadWrapper delegate, String key) {
			super();
			this.delegate = delegate;
			this.key = key;
		}

		@Override
		public String getKey() {
			return key;
		}

		@Override
		public Object getValue() {
			return delegate.getPropertyValue(key);
		}

		@Override
		public Object setValue(Object value) {
			throw new UnsupportedOperationException("entry.setValue not implemented");
		}

		@Override
		public int compareTo(MapBeanReadWrapperEntry o) {
			return key.compareTo(o.getKey());
		}

		@Override
		public int hashCode() {
			int prime = 31;
			int result = 1;
			result = prime * result + ((key == null) ? 0 : key.hashCode());
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj) {
				return true;
			}
			if (obj == null) {
				return false;
			}
			if (obj.getClass() != getClass()) {
				return false;
			}
			MapBeanReadWrapperEntry other = (MapBeanReadWrapperEntry) obj;
			if (key == null) {
				if (other.key != null) {
					return false;
				}
			} else if (!key.equals(other.key)) {
				return false;
			}
			return true;
		}
	}
}































Active mutators

org.pitest.mutationtest.engine.gregor.mutators.BooleanFalseReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.BooleanTrueReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.ConditionalsBoundaryMutator
org.pitest.mutationtest.engine.gregor.mutators.EmptyObjectReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.IncrementsMutator
org.pitest.mutationtest.engine.gregor.mutators.InvertNegsMutator
org.pitest.mutationtest.engine.gregor.mutators.MathMutator
org.pitest.mutationtest.engine.gregor.mutators.NegateConditionalsMutator
org.pitest.mutationtest.engine.gregor.mutators.NullReturnValsMutator
org.pitest.mutationtest.engine.gregor.mutators.PrimitiveReturnsMutator
org.pitest.mutationtest.engine.gregor.mutators.VoidMethodCallMutator

Tests examined

Report generated by PIT OGHAM

1		package fr.sii.ogham.core.util.bean;
2
3		import java.util.Collection;
4		import java.util.HashSet;
5		import java.util.List;
6		import java.util.Map;
7		import java.util.Set;
8		import java.util.TreeSet;
9
10		import fr.sii.ogham.core.exception.util.InvalidPropertyException;
11
12		/**
13		* Wraps a bean and exposes as a Map.
14		*
15		* The Map is indexed by the property names defined in the bean and allow to
16		* access the value using the Map insterface.
17		*
18		* This implementation doesn't support update methods (remove, clear, put...)
19		* and doesn't support access to values directly (values, containsValue).
20		*
21		* This implementation delegates access to real bean properties through a
22		* {@link SimpleBeanReadWrapper} instance (by default). You can
23		* override this default wrapper using the constructor
24		* {@link #MapBeanReadWrapper(BeanReadWrapper)}.
25		*
26		* @author Aurélien Baudet
27		*
28		*/
29		public class MapBeanReadWrapper implements BeanReadWrapper, Map<String, Object> {
30		private final BeanReadWrapper delegate;
31
32		/**
33		* Initializes the wrapper for the provided bean.
34		*
35		* {@link SimpleBeanReadWrapper} is used to access bean
36		* properties.
37		*
38		* @param bean
39		* the bean to wrap
40		*/

MapBeanReadWrapper.java

Mutations

Active mutators

Tests examined