001 /*
002 * Created on Oct 25, 2010
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
005 * the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
010 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
011 * specific language governing permissions and limitations under the License.
012 *
013 * Copyright @2010-2011 the original author or authors.
014 */
015 package org.fest.assertions.api;
016
017 import java.util.Comparator;
018
019 import org.fest.assertions.core.FloatingPointNumberAssert;
020 import org.fest.assertions.data.Offset;
021 import org.fest.assertions.internal.Doubles;
022 import org.fest.util.ComparatorBasedComparisonStrategy;
023 import org.fest.util.VisibleForTesting;
024
025 /**
026 * Assertion methods for doubles.
027 * <p>
028 * To create an instance of this class, invoke <code>{@link Assertions#assertThat(Double)}</code> or
029 * <code>{@link Assertions#assertThat(double)}</code>.
030 * </p>
031 *
032 * @author Yvonne Wang
033 * @author David DIDIER
034 * @author Alex Ruiz
035 * @author Ansgar Konermann
036 * @author Joel Costigliola
037 */
038 public class DoubleAssert extends AbstractComparableAssert<DoubleAssert, Double> implements
039 FloatingPointNumberAssert<Double> {
040
041 @VisibleForTesting
042 Doubles doubles = Doubles.instance();
043
044 protected DoubleAssert(Double actual) {
045 super(actual, DoubleAssert.class);
046 }
047
048 /** {@inheritDoc} */
049 public DoubleAssert isNaN() {
050 doubles.assertIsNaN(info, actual);
051 return this;
052 }
053
054 /** {@inheritDoc} */
055 public DoubleAssert isNotNaN() {
056 doubles.assertIsNotNaN(info, actual);
057 return this;
058 }
059
060 /** {@inheritDoc} */
061 public DoubleAssert isZero() {
062 doubles.assertIsZero(info, actual);
063 return this;
064 }
065
066 /** {@inheritDoc} */
067 public DoubleAssert isNotZero() {
068 doubles.assertIsNotZero(info, actual);
069 return this;
070 }
071
072 /** {@inheritDoc} */
073 public DoubleAssert isPositive() {
074 doubles.assertIsPositive(info, actual);
075 return this;
076 }
077
078 /** {@inheritDoc} */
079 public DoubleAssert isNegative() {
080 doubles.assertIsNegative(info, actual);
081 return this;
082 }
083
084 /**
085 * Verifies that the actual value is equal to the given one.
086 * @param expected the given value to compare the actual value to.
087 * @return {@code this} assertion object.
088 * @throws AssertionError if the actual value is {@code null}.
089 * @throws AssertionError if the actual value is not equal to the given one.
090 */
091 public DoubleAssert isEqualTo(double expected) {
092 doubles.assertEqual(info, actual, expected);
093 return this;
094 }
095
096 /** {@inheritDoc} */
097 public DoubleAssert isEqualTo(Double expected, Offset<Double> offset) {
098 doubles.assertEqual(info, actual, expected, offset);
099 return this;
100 }
101
102 /**
103 * Verifies that the actual value is equal to the given one, within a positive offset.
104 * @param expected the given value to compare the actual value to.
105 * @param offset the given positive offset.
106 * @return {@code this} assertion object.
107 * @throws NullPointerException if the given offset is {@code null}.
108 * @throws AssertionError if the actual value is {@code null}.
109 * @throws AssertionError if the actual value is not equal to the given one.
110 */
111 public DoubleAssert isEqualTo(double expected, Offset<Double> offset) {
112 doubles.assertEqual(info, actual, expected, offset);
113 return this;
114 }
115
116 /**
117 * Verifies that the actual value is not equal to the given one.
118 * @param other the given value to compare the actual value to.
119 * @return {@code this} assertion object.
120 * @throws AssertionError if the actual value is {@code null}.
121 * @throws AssertionError if the actual value is equal to the given one.
122 */
123 public DoubleAssert isNotEqualTo(double other) {
124 doubles.assertNotEqual(info, actual, other);
125 return this;
126 }
127
128 /**
129 * Verifies that the actual value is less than the given one.
130 * @param other the given value to compare the actual value to.
131 * @return {@code this} assertion object.
132 * @throws AssertionError if the actual value is {@code null}.
133 * @throws AssertionError if the actual value is equal to or greater than the given one.
134 */
135 public DoubleAssert isLessThan(double other) {
136 doubles.assertLessThan(info, actual, other);
137 return this;
138 }
139
140 /**
141 * Verifies that the actual value is less than or equal to the given one.
142 * @param other the given value to compare the actual value to.
143 * @return {@code this} assertion object.
144 * @throws AssertionError if the actual value is {@code null}.
145 * @throws AssertionError if the actual value is greater than the given one.
146 */
147 public DoubleAssert isLessThanOrEqualTo(double other) {
148 doubles.assertLessThanOrEqualTo(info, actual, other);
149 return this;
150 }
151
152 /**
153 * Verifies that the actual value is greater than the given one.
154 * @param other the given value to compare the actual value to.
155 * @return {@code this} assertion object.
156 * @throws AssertionError if the actual value is {@code null}.
157 * @throws AssertionError if the actual value is equal to or less than the given one.
158 */
159 public DoubleAssert isGreaterThan(double other) {
160 doubles.assertGreaterThan(info, actual, other);
161 return this;
162 }
163
164 /**
165 * Verifies that the actual value is greater than or equal to the given one.
166 * @param other the given value to compare the actual value to.
167 * @return {@code this} assertion object.
168 * @throws AssertionError if the actual value is {@code null}.
169 * @throws AssertionError if the actual value is less than the given one.
170 */
171 public DoubleAssert isGreaterThanOrEqualTo(double other) {
172 doubles.assertGreaterThanOrEqualTo(info, actual, other);
173 return this;
174 }
175
176 @Override
177 public DoubleAssert usingComparator(Comparator<?> customComparator) {
178 super.usingComparator(customComparator);
179 this.doubles = new Doubles(new ComparatorBasedComparisonStrategy(customComparator));
180 return myself;
181 }
182
183 @Override
184 public DoubleAssert usingDefaultComparator() {
185 super.usingDefaultComparator();
186 this.doubles = Doubles.instance();
187 return myself;
188 }
189 }