Coverage Report

Coverage Report - jaggregate.internal.number.OperableInteger

Classes in this File

Line Coverage

Branch Coverage

Complexity

OperableInteger

100%

22/22

100%

7/7

OperableInteger$1

100%

2/2

N/A

 /*
  Copyright 2004-2008 Paul R. Holser, Jr.  All rights reserved.
  Licensed under the Academic Free License version 3.0
  */
 
 package jaggregate.internal.number;
 
 /**
  * Wrapper for an {@code int}.
  *
  * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
  * @version $Id: OperableInteger.java,v 1.1 2008/03/26 18:01:26 pholser Exp $
  */
 public class OperableInteger extends OperableNumber<Integer> {
     private static final long serialVersionUID = -1L;
 
     private static final OperableInteger ONE = new OperableInteger( 1 ) {
         private static final long serialVersionUID = -1L;
 
         @Override
         public void incrementBy( OperableNumber<Integer> increment ) {
             throw new UnsupportedOperationException();
         }
     };
 
     /**
      * Creates a wrapper for the given number.
      *
      * @param wrapped the wrapped number
      */
     public OperableInteger( Integer wrapped ) {
         super( wrapped );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isZero() {
         return unwrapped() == 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger plus( Integer addend ) {
         return new OperableInteger( unwrapped() + addend );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger plus( int addend ) {
         return new OperableInteger( unwrapped() + addend );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger minus( Integer subtrahend ) {
         return new OperableInteger( unwrapped() - subtrahend );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger times( Integer multiplier ) {
         return new OperableInteger( unwrapped() * multiplier );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger times( int multiplier ) {
         return new OperableInteger( unwrapped() * multiplier );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger dividedBy( Integer divisor ) {
         return new OperableInteger( unwrapped() / divisor );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger modulo( Integer divisor ) {
         return new OperableInteger( unwrapped() % divisor );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isPositive() {
         return unwrapped() > 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isNegative() {
         return unwrapped() < 0;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThan( Integer comparand ) {
         return unwrapped() > comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThanOrEqualTo( Integer comparand ) {
         return unwrapped() >= comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThan( Integer comparand ) {
         return unwrapped() < comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThanOrEqualTo( Integer comparand ) {
         return unwrapped() <= comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableInteger negated() {
         return new OperableInteger( -unwrapped() );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void incrementBy( OperableNumber<Integer> increment ) {
         update( unwrapped() + increment.unwrapped() );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableNumber<Integer> one() {
         return ONE;
     }
 }

1		/*
2		Copyright 2004-2008 Paul R. Holser, Jr. All rights reserved.
3		Licensed under the Academic Free License version 3.0
4		*/
5
6		package jaggregate.internal.number;
7
8		/**
9		* Wrapper for an {@code int}.
10		*
11		* @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
12		* @version $Id: OperableInteger.java,v 1.1 2008/03/26 18:01:26 pholser Exp $
13		*/
14	16389	public class OperableInteger extends OperableNumber<Integer> {
15		private static final long serialVersionUID = -1L;
16
17	1	private static final OperableInteger ONE = new OperableInteger( 1 ) {
18		private static final long serialVersionUID = -1L;
19
20		@Override
21	1717	public void incrementBy( OperableNumber<Integer> increment ) {
22	1	throw new UnsupportedOperationException();
23		}
24		};
25
26		/**
27		* Creates a wrapper for the given number.
28		*
29		* @param wrapped the wrapped number
30		*/
31		public OperableInteger( Integer wrapped ) {
32	12096	super( wrapped );
33	12096	}
34
35		/**
36		* {@inheritDoc}
37		*/
38		@Override
39		public boolean isZero() {
40	845	return unwrapped() == 0;
41		}
42
43		/**
44		* {@inheritDoc}
45		*/
46		@Override
47		public OperableInteger plus( Integer addend ) {
48	3155	return new OperableInteger( unwrapped() + addend );
49		}
50
51		/**
52		* {@inheritDoc}
53		*/
54		@Override
55		public OperableInteger plus( int addend ) {
56	668	return new OperableInteger( unwrapped() + addend );
57		}
58
59		/**
60		* {@inheritDoc}
61		*/
62		@Override
63		public OperableInteger minus( Integer subtrahend ) {
64	1336	return new OperableInteger( unwrapped() - subtrahend );
65		}
66
67		/**
68		* {@inheritDoc}
69		*/
70		@Override
71		public OperableInteger times( Integer multiplier ) {
72	668	return new OperableInteger( unwrapped() * multiplier );
73		}
74
75		/**
76		* {@inheritDoc}
77		*/
78		@Override
79		public OperableInteger times( int multiplier ) {
80	2372	return new OperableInteger( unwrapped() * multiplier );
81		}
82
83		/**
84		* {@inheritDoc}
85		*/
86		@Override
87		public OperableInteger dividedBy( Integer divisor ) {
88	1336	return new OperableInteger( unwrapped() / divisor );
89		}
90
91		/**
92		* {@inheritDoc}
93		*/
94		@Override
95		public OperableInteger modulo( Integer divisor ) {
96	79	return new OperableInteger( unwrapped() % divisor );
97		}
98
99		/**
100		* {@inheritDoc}
101		*/
102		@Override
103		public boolean isPositive() {
104	3891	return unwrapped() > 0;
105		}
106
107		/**
108		* {@inheritDoc}
109		*/
110		@Override
111		public boolean isNegative() {
112	1147	return unwrapped() < 0;
113		}
114
115		/**
116		* {@inheritDoc}
117		*/
118		@Override
119		public boolean greaterThan( Integer comparand ) {
120	3691	return unwrapped() > comparand;
121		}
122
123		/**
124		* {@inheritDoc}
125		*/
126		@Override
127		public boolean greaterThanOrEqualTo( Integer comparand ) {
128	385	return unwrapped() >= comparand;
129		}
130
131		/**
132		* {@inheritDoc}
133		*/
134		@Override
135		public boolean lessThan( Integer comparand ) {
136	3481	return unwrapped() < comparand;
137		}
138
139		/**
140		* {@inheritDoc}
141		*/
142		@Override
143		public boolean lessThanOrEqualTo( Integer comparand ) {
144	837	return unwrapped() <= comparand;
145		}
146
147		/**
148		* {@inheritDoc}
149		*/
150		@Override
151		public OperableInteger negated() {
152	97	return new OperableInteger( -unwrapped() );
153		}
154
155		/**
156		* {@inheritDoc}
157		*/
158		@Override
159		public void incrementBy( OperableNumber<Integer> increment ) {
160	914	update( unwrapped() + increment.unwrapped() );
161	914	}
162
163		/**
164		* {@inheritDoc}
165		*/
166		@Override
167		public OperableNumber<Integer> one() {
168	207	return ONE;
169		}
170		}