Coverage Report

Coverage Report - org.truth0.AbstractVerb

Classes in this File

Line Coverage

Branch Coverage

Complexity

AbstractVerb

100%

10/10

N/A

AbstractVerb$DelegatedVerb

100%

4/4

N/A

 package org.truth0;
 
 import org.truth0.subjects.Subject;
 import org.truth0.subjects.SubjectFactory;
 
 import com.google.common.annotations.GwtCompatible;
 import com.google.common.annotations.GwtIncompatible;
 
 @GwtCompatible
 public class AbstractVerb {
 
   private final FailureStrategy failureStrategy;
 
   public AbstractVerb(FailureStrategy failureStrategy) {
     this.failureStrategy = failureStrategy;
   }
 
   protected FailureStrategy getFailureStrategy() {
     return failureStrategy;
   }
 
         /**
          * Triggers the failure strategy with an empty failure message
          */
         public void fail() {
                 failureStrategy.fail("");
         }
 
         /**
          * Triggers the failure strategy with the given failure message
          */
         public void fail(String message) {
                 failureStrategy.fail(message);
         }
 
   /**
    * The recommended method of extension of Truth to new types, which is
    * documented in {@link DelegationTest }.
    *
    * @see DelegationTest
    * @param factory a SubjectFactory<S, T> implementation
    * @returns A custom verb for the type returned by the SubjectFactory
    */
   public <S extends Subject<S,T>, T, SF extends SubjectFactory<S, T>>
       DelegatedVerb<S, T> about(SF factory) {
       return new DelegatedVerb<S, T>(getFailureStrategy(), factory);
   }
 
   /**
    * A special Verb implementation which wraps a SubjectFactory
    */
   public static class DelegatedVerb<S extends Subject<S,T>, T>
       extends AbstractVerb {
 
     private final SubjectFactory<S, T> factory;
 
     public DelegatedVerb(FailureStrategy fs, SubjectFactory<S, T> factory) {
       super(fs);
       this.factory = factory;
     }
 
     public S that(T target) {
       return factory.getSubject(getFailureStrategy(), target);
     }
   }
 
   @GwtIncompatible("org.truth0.IteratingVerb")
   public <T> IteratingVerb<T> in(Iterable<T> data) {
     return new IteratingVerb<T>(data, getFailureStrategy());
   }
 
 }
 

1		package org.truth0;
2
3		import org.truth0.subjects.Subject;
4		import org.truth0.subjects.SubjectFactory;
5
6		import com.google.common.annotations.GwtCompatible;
7		import com.google.common.annotations.GwtIncompatible;
8
9		@GwtCompatible
10		public class AbstractVerb {
11
12		private final FailureStrategy failureStrategy;
13
14	48	public AbstractVerb(FailureStrategy failureStrategy) {
15	48	this.failureStrategy = failureStrategy;
16	48	}
17
18		protected FailureStrategy getFailureStrategy() {
19	374	return failureStrategy;
20		}
21
22		/**
23		* Triggers the failure strategy with an empty failure message
24		*/
25		public void fail() {
26	1	failureStrategy.fail("");
27	1	}
28
29		/**
30		* Triggers the failure strategy with the given failure message
31		*/
32		public void fail(String message) {
33	2	failureStrategy.fail(message);
34	2	}
35
36		/**
37		* The recommended method of extension of Truth to new types, which is
38		* documented in {@link DelegationTest }.
39		*
40		* @see DelegationTest
41		* @param factory a SubjectFactory<S, T> implementation
42		* @returns A custom verb for the type returned by the SubjectFactory
43		*/
44		public <S extends Subject<S,T>, T, SF extends SubjectFactory<S, T>>
45		DelegatedVerb<S, T> about(SF factory) {
46	3	return new DelegatedVerb<S, T>(getFailureStrategy(), factory);
47		}
48
49		/**
50		* A special Verb implementation which wraps a SubjectFactory
51		*/
52		public static class DelegatedVerb<S extends Subject<S,T>, T>
53		extends AbstractVerb {
54
55		private final SubjectFactory<S, T> factory;
56
57		public DelegatedVerb(FailureStrategy fs, SubjectFactory<S, T> factory) {
58	3	super(fs);
59	3	this.factory = factory;
60	3	}
61
62		public S that(T target) {
63	3	return factory.getSubject(getFailureStrategy(), target);
64		}
65		}
66
67		@GwtIncompatible("org.truth0.IteratingVerb")
68		public <T> IteratingVerb<T> in(Iterable<T> data) {
69	4	return new IteratingVerb<T>(data, getFailureStrategy());
70		}
71
72		}
73