Coverage Report

Coverage Report - jaggregate.internal.number.OperableLong

Classes in this File

Line Coverage

Branch Coverage

Complexity

OperableLong

100%

22/22

100%

7/7

OperableLong$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 a {@code long}.
  *
  * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
  * @version $Id: OperableLong.java,v 1.1 2008/03/26 18:01:25 pholser Exp $
  */
 public class OperableLong extends OperableNumber<Long> {
     private static final long serialVersionUID = -1L;
 
     private static final OperableLong ONE = new OperableLong( 1L ) {
         private static final long serialVersionUID = -1L;
 
         @Override
         public void incrementBy( OperableNumber<Long> increment ) {
             throw new UnsupportedOperationException();
         }
     };
 
     /**
      * Creates a wrapper for the given number.
      *
      * @param wrapped the wrapped number
      */
     public OperableLong( Long wrapped ) {
         super( wrapped );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isZero() {
         return unwrapped() == 0L;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong plus( Long addend ) {
         return new OperableLong( unwrapped() + addend );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong plus( int addend ) {
         return new OperableLong( unwrapped() + addend );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong minus( Long subtrahend ) {
         return new OperableLong( unwrapped() - subtrahend );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong times( Long multiplier ) {
         return new OperableLong( unwrapped() * multiplier );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong times( int multiplier ) {
         return new OperableLong( unwrapped() * multiplier );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong dividedBy( Long divisor ) {
         return new OperableLong( unwrapped() / divisor );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong modulo( Long divisor ) {
         return new OperableLong( unwrapped() % divisor );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isPositive() {
         return unwrapped() > 0L;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean isNegative() {
         return unwrapped() < 0L;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThan( Long comparand ) {
         return unwrapped() > comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean greaterThanOrEqualTo( Long comparand ) {
         return unwrapped() >= comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThan( Long comparand ) {
         return unwrapped() < comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean lessThanOrEqualTo( Long comparand ) {
         return unwrapped() <= comparand;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableLong negated() {
         return new OperableLong( -unwrapped() );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void incrementBy( OperableNumber<Long> increment ) {
         update( unwrapped() + increment.unwrapped() );
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public OperableNumber<Long> 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 a {@code long}.
10		*
11		* @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>
12		* @version $Id: OperableLong.java,v 1.1 2008/03/26 18:01:25 pholser Exp $
13		*/
14	11041	public class OperableLong extends OperableNumber<Long> {
15		private static final long serialVersionUID = -1L;
16
17	1	private static final OperableLong ONE = new OperableLong( 1L ) {
18		private static final long serialVersionUID = -1L;
19
20		@Override
21	204	public void incrementBy( OperableNumber<Long> 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 OperableLong( Long wrapped ) {
32	8629	super( wrapped );
33	8629	}
34
35		/**
36		* {@inheritDoc}
37		*/
38		@Override
39		public boolean isZero() {
40	809	return unwrapped() == 0L;
41		}
42
43		/**
44		* {@inheritDoc}
45		*/
46		@Override
47		public OperableLong plus( Long addend ) {
48	1595	return new OperableLong( unwrapped() + addend );
49		}
50
51		/**
52		* {@inheritDoc}
53		*/
54		@Override
55		public OperableLong plus( int addend ) {
56	633	return new OperableLong( unwrapped() + addend );
57		}
58
59		/**
60		* {@inheritDoc}
61		*/
62		@Override
63		public OperableLong minus( Long subtrahend ) {
64	1266	return new OperableLong( unwrapped() - subtrahend );
65		}
66
67		/**
68		* {@inheritDoc}
69		*/
70		@Override
71		public OperableLong times( Long multiplier ) {
72	633	return new OperableLong( unwrapped() * multiplier );
73		}
74
75		/**
76		* {@inheritDoc}
77		*/
78		@Override
79		public OperableLong times( int multiplier ) {
80	847	return new OperableLong( unwrapped() * multiplier );
81		}
82
83		/**
84		* {@inheritDoc}
85		*/
86		@Override
87		public OperableLong dividedBy( Long divisor ) {
88	1266	return new OperableLong( unwrapped() / divisor );
89		}
90
91		/**
92		* {@inheritDoc}
93		*/
94		@Override
95		public OperableLong modulo( Long divisor ) {
96	79	return new OperableLong( unwrapped() % divisor );
97		}
98
99		/**
100		* {@inheritDoc}
101		*/
102		@Override
103		public boolean isPositive() {
104	2239	return unwrapped() > 0L;
105		}
106
107		/**
108		* {@inheritDoc}
109		*/
110		@Override
111		public boolean isNegative() {
112	1078	return unwrapped() < 0L;
113		}
114
115		/**
116		* {@inheritDoc}
117		*/
118		@Override
119		public boolean greaterThan( Long comparand ) {
120	2094	return unwrapped() > comparand;
121		}
122
123		/**
124		* {@inheritDoc}
125		*/
126		@Override
127		public boolean greaterThanOrEqualTo( Long comparand ) {
128	385	return unwrapped() >= comparand;
129		}
130
131		/**
132		* {@inheritDoc}
133		*/
134		@Override
135		public boolean lessThan( Long comparand ) {
136	1920	return unwrapped() < comparand;
137		}
138
139		/**
140		* {@inheritDoc}
141		*/
142		@Override
143		public boolean lessThanOrEqualTo( Long comparand ) {
144	429	return unwrapped() <= comparand;
145		}
146
147		/**
148		* {@inheritDoc}
149		*/
150		@Override
151		public OperableLong negated() {
152	97	return new OperableLong( -unwrapped() );
153		}
154
155		/**
156		* {@inheritDoc}
157		*/
158		@Override
159		public void incrementBy( OperableNumber<Long> increment ) {
160	596	update( unwrapped() + increment.unwrapped() );
161	596	}
162
163		/**
164		* {@inheritDoc}
165		*/
166		@Override
167		public OperableNumber<Long> one() {
168	181	return ONE;
169		}
170		}