Coverage Report

Coverage Report - org.truth0.subjects.MapSubject

Classes in this File

Line Coverage

Branch Coverage

Complexity

MapSubject

100%

21/21

100%

12/12

MapSubject$1

100%

5/5

87%

7/8

MapSubject$WithValue

N/A

 /*
  * Copyright (c) 2011 David Saff
  * Copyright (c) 2011 Christian Gruber
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.truth0.subjects;
 
 import java.util.Arrays;
 import java.util.Map;
 
 import org.truth0.FailureStrategy;
 
 import com.google.common.annotations.GwtCompatible;
 
 /**
  * @author Christian Gruber (cgruber@israfil.net)
  */
 @GwtCompatible
 public class MapSubject<S extends MapSubject<S, K, V, M>, K, V, M extends Map<K, V>> extends Subject<S, M> {
 
   public MapSubject(FailureStrategy failureStrategy, M map) {
     super(failureStrategy, map);
   }
 
   /**
    * Attests that the subject holds no objects, or fails.
    */
   public void isEmpty() {
     if (!getSubject().isEmpty()) {
       fail("is empty");
     }
   }
 
   /**
    * Attests that the subject holds one or more objects, or fails
    */
   public void isNotEmpty() {
     if (getSubject().isEmpty()) {
       fail("is not empty");
     }
   }
 
   /**
    * Attests that the subject contains the provided key or fails.
    */
   public WithValue<V> hasKey(final K key) {
     if (!getSubject().containsKey(key)) {
       fail("has key", key);
     }
     return new WithValue<V>() {
       @Override public void withValue(V expected) {
         V actual = getSubject().get(key);
         if ((actual == null && expected != null) ||
             !(actual == expected || actual.equals(expected))) {
           fail("has key/value pair", Arrays.asList(key, expected),
               "actually has key/value pair", Arrays.asList(key, actual));
         }
       }
     };
   }
 
   public void lacksKey(K key) {
     if (getSubject().containsKey(key)) {
       fail("lacks key", key);
     }
   }
 
   public void hasValue(V key) {
     if (!getSubject().containsValue(key)) {
       fail("has value", key);
     }
   }
 
   public void lacksValue(V key) {
     if (getSubject().containsValue(key)) {
       fail("lacks value", key);
     }
   }
 
   public interface WithValue<V> {
     void withValue(V value);
   }
 
   @SuppressWarnings({ "unchecked", "rawtypes" })
   public static <K, V, M extends Map<K, V>> MapSubject<? extends MapSubject<?, K, V, M>, K, V, M> create(
       FailureStrategy failureStrategy, Map<K, V> map) {
     return new MapSubject(failureStrategy, map);
   }
 
 }

1		/*
2		* Copyright (c) 2011 David Saff
3		* Copyright (c) 2011 Christian Gruber
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.truth0.subjects;
18
19		import java.util.Arrays;
20		import java.util.Map;
21
22		import org.truth0.FailureStrategy;
23
24		import com.google.common.annotations.GwtCompatible;
25
26		/**
27		* @author Christian Gruber (cgruber@israfil.net)
28		*/
29		@GwtCompatible
30		public class MapSubject<S extends MapSubject<S, K, V, M>, K, V, M extends Map<K, V>> extends Subject<S, M> {
31
32		public MapSubject(FailureStrategy failureStrategy, M map) {
33	19	super(failureStrategy, map);
34	19	}
35
36		/**
37		* Attests that the subject holds no objects, or fails.
38		*/
39		public void isEmpty() {
40	2	if (!getSubject().isEmpty()) {
41	1	fail("is empty");
42		}
43	1	}
44
45		/**
46		* Attests that the subject holds one or more objects, or fails
47		*/
48		public void isNotEmpty() {
49	2	if (getSubject().isEmpty()) {
50	1	fail("is not empty");
51		}
52	1	}
53
54		/**
55		* Attests that the subject contains the provided key or fails.
56		*/
57		public WithValue<V> hasKey(final K key) {
58	8	if (!getSubject().containsKey(key)) {
59	2	fail("has key", key);
60		}
61	6	return new WithValue<V>() {
62		@Override public void withValue(V expected) {
63	5	V actual = getSubject().get(key);
64	5	if ((actual == null && expected != null) \|\|
65		!(actual == expected \|\| actual.equals(expected))) {
66	3	fail("has key/value pair", Arrays.asList(key, expected),
67		"actually has key/value pair", Arrays.asList(key, actual));
68		}
69	2	}
70		};
71		}
72
73		public void lacksKey(K key) {
74	2	if (getSubject().containsKey(key)) {
75	1	fail("lacks key", key);
76		}
77	1	}
78
79		public void hasValue(V key) {
80	3	if (!getSubject().containsValue(key)) {
81	1	fail("has value", key);
82		}
83	2	}
84
85		public void lacksValue(V key) {
86	2	if (getSubject().containsValue(key)) {
87	1	fail("lacks value", key);
88		}
89	1	}
90
91		public interface WithValue<V> {
92		void withValue(V value);
93		}
94
95		@SuppressWarnings({ "unchecked", "rawtypes" })
96		public static <K, V, M extends Map<K, V>> MapSubject<? extends MapSubject<?, K, V, M>, K, V, M> create(
97		FailureStrategy failureStrategy, Map<K, V> map) {
98	19	return new MapSubject(failureStrategy, map);
99		}
100
101		}