1 /* 2 * Copyright (C) 2008 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.primitives; 18 19 import static com.google.common.truth.Truth.assertThat; 20 import static com.google.common.truth.Truth.assertWithMessage; 21 import static java.lang.Float.NaN; 22 23 import com.google.common.annotations.GwtCompatible; 24 import com.google.common.annotations.GwtIncompatible; 25 import com.google.common.annotations.J2ktIncompatible; 26 import com.google.common.base.Converter; 27 import com.google.common.collect.ImmutableList; 28 import com.google.common.collect.testing.Helpers; 29 import com.google.common.testing.NullPointerTester; 30 import com.google.common.testing.SerializableTester; 31 import java.util.Arrays; 32 import java.util.Collection; 33 import java.util.Collections; 34 import java.util.Comparator; 35 import java.util.List; 36 import junit.framework.TestCase; 37 import org.checkerframework.checker.nullness.qual.Nullable; 38 39 /** 40 * Unit test for {@link Floats}. 41 * 42 * @author Kevin Bourrillion 43 */ 44 @ElementTypesAreNonnullByDefault 45 @GwtCompatible(emulated = true) 46 public class FloatsTest extends TestCase { 47 private static final float[] EMPTY = {}; 48 private static final float[] ARRAY1 = {(float) 1}; 49 private static final float[] ARRAY234 = {(float) 2, (float) 3, (float) 4}; 50 51 private static final float LEAST = Float.NEGATIVE_INFINITY; 52 private static final float GREATEST = Float.POSITIVE_INFINITY; 53 54 private static final float[] NUMBERS = 55 new float[] { 56 LEAST, 57 -Float.MAX_VALUE, 58 -1f, 59 -0f, 60 0f, 61 1f, 62 Float.MAX_VALUE, 63 GREATEST, 64 Float.MIN_NORMAL, 65 -Float.MIN_NORMAL, 66 Float.MIN_VALUE, 67 -Float.MIN_VALUE, 68 Integer.MIN_VALUE, 69 Integer.MAX_VALUE, 70 Long.MIN_VALUE, 71 Long.MAX_VALUE 72 }; 73 74 private static final float[] VALUES = Floats.concat(NUMBERS, new float[] {NaN}); 75 testHashCode()76 public void testHashCode() { 77 for (float value : VALUES) { 78 assertThat(Floats.hashCode(value)).isEqualTo(((Float) value).hashCode()); 79 } 80 } 81 testIsFinite()82 public void testIsFinite() { 83 for (float value : NUMBERS) { 84 assertThat(Floats.isFinite(value)) 85 .isEqualTo(!(Float.isInfinite(value) || Float.isNaN(value))); 86 } 87 } 88 testCompare()89 public void testCompare() { 90 for (float x : VALUES) { 91 for (float y : VALUES) { 92 // note: spec requires only that the sign is the same 93 assertWithMessage(x + ", " + y) 94 .that(Floats.compare(x, y)) 95 .isEqualTo(Float.valueOf(x).compareTo(y)); 96 } 97 } 98 } 99 testContains()100 public void testContains() { 101 assertThat(Floats.contains(EMPTY, (float) 1)).isFalse(); 102 assertThat(Floats.contains(ARRAY1, (float) 2)).isFalse(); 103 assertThat(Floats.contains(ARRAY234, (float) 1)).isFalse(); 104 assertThat(Floats.contains(new float[] {(float) -1}, (float) -1)).isTrue(); 105 assertThat(Floats.contains(ARRAY234, (float) 2)).isTrue(); 106 assertThat(Floats.contains(ARRAY234, (float) 3)).isTrue(); 107 assertThat(Floats.contains(ARRAY234, (float) 4)).isTrue(); 108 109 for (float value : NUMBERS) { 110 assertWithMessage("" + value).that(Floats.contains(new float[] {5f, value}, value)).isTrue(); 111 } 112 assertThat(Floats.contains(new float[] {5f, NaN}, NaN)).isFalse(); 113 } 114 testIndexOf()115 public void testIndexOf() { 116 assertThat(Floats.indexOf(EMPTY, (float) 1)).isEqualTo(-1); 117 assertThat(Floats.indexOf(ARRAY1, (float) 2)).isEqualTo(-1); 118 assertThat(Floats.indexOf(ARRAY234, (float) 1)).isEqualTo(-1); 119 assertThat(Floats.indexOf(new float[] {(float) -1}, (float) -1)).isEqualTo(0); 120 assertThat(Floats.indexOf(ARRAY234, (float) 2)).isEqualTo(0); 121 assertThat(Floats.indexOf(ARRAY234, (float) 3)).isEqualTo(1); 122 assertThat(Floats.indexOf(ARRAY234, (float) 4)).isEqualTo(2); 123 assertThat(Floats.indexOf(new float[] {(float) 2, (float) 3, (float) 2, (float) 3}, (float) 3)) 124 .isEqualTo(1); 125 126 for (float value : NUMBERS) { 127 assertWithMessage("" + value) 128 .that(Floats.indexOf(new float[] {5f, value}, value)) 129 .isEqualTo(1); 130 } 131 assertThat(Floats.indexOf(new float[] {5f, NaN}, NaN)).isEqualTo(-1); 132 } 133 testIndexOf_arrayTarget()134 public void testIndexOf_arrayTarget() { 135 assertThat(Floats.indexOf(EMPTY, EMPTY)).isEqualTo(0); 136 assertThat(Floats.indexOf(ARRAY234, EMPTY)).isEqualTo(0); 137 assertThat(Floats.indexOf(EMPTY, ARRAY234)).isEqualTo(-1); 138 assertThat(Floats.indexOf(ARRAY234, ARRAY1)).isEqualTo(-1); 139 assertThat(Floats.indexOf(ARRAY1, ARRAY234)).isEqualTo(-1); 140 assertThat(Floats.indexOf(ARRAY1, ARRAY1)).isEqualTo(0); 141 assertThat(Floats.indexOf(ARRAY234, ARRAY234)).isEqualTo(0); 142 assertThat(Floats.indexOf(ARRAY234, new float[] {(float) 2, (float) 3})).isEqualTo(0); 143 assertThat(Floats.indexOf(ARRAY234, new float[] {(float) 3, (float) 4})).isEqualTo(1); 144 assertThat(Floats.indexOf(ARRAY234, new float[] {(float) 3})).isEqualTo(1); 145 assertThat(Floats.indexOf(ARRAY234, new float[] {(float) 4})).isEqualTo(2); 146 assertThat( 147 Floats.indexOf( 148 new float[] {(float) 2, (float) 3, (float) 3, (float) 3, (float) 3}, 149 new float[] {(float) 3})) 150 .isEqualTo(1); 151 assertThat( 152 Floats.indexOf( 153 new float[] { 154 (float) 2, (float) 3, (float) 2, (float) 3, (float) 4, (float) 2, (float) 3 155 }, 156 new float[] {(float) 2, (float) 3, (float) 4})) 157 .isEqualTo(2); 158 assertThat( 159 Floats.indexOf( 160 new float[] { 161 (float) 2, (float) 2, (float) 3, (float) 4, (float) 2, (float) 3, (float) 4 162 }, 163 new float[] {(float) 2, (float) 3, (float) 4})) 164 .isEqualTo(1); 165 assertThat( 166 Floats.indexOf( 167 new float[] {(float) 4, (float) 3, (float) 2}, 168 new float[] {(float) 2, (float) 3, (float) 4})) 169 .isEqualTo(-1); 170 171 for (float value : NUMBERS) { 172 assertWithMessage("" + value) 173 .that(Floats.indexOf(new float[] {5f, value, value, 5f}, new float[] {value, value})) 174 .isEqualTo(1); 175 } 176 assertThat(Floats.indexOf(new float[] {5f, NaN, NaN, 5f}, new float[] {NaN, NaN})) 177 .isEqualTo(-1); 178 } 179 testLastIndexOf()180 public void testLastIndexOf() { 181 assertThat(Floats.lastIndexOf(EMPTY, (float) 1)).isEqualTo(-1); 182 assertThat(Floats.lastIndexOf(ARRAY1, (float) 2)).isEqualTo(-1); 183 assertThat(Floats.lastIndexOf(ARRAY234, (float) 1)).isEqualTo(-1); 184 assertThat(Floats.lastIndexOf(new float[] {(float) -1}, (float) -1)).isEqualTo(0); 185 assertThat(Floats.lastIndexOf(ARRAY234, (float) 2)).isEqualTo(0); 186 assertThat(Floats.lastIndexOf(ARRAY234, (float) 3)).isEqualTo(1); 187 assertThat(Floats.lastIndexOf(ARRAY234, (float) 4)).isEqualTo(2); 188 assertThat( 189 Floats.lastIndexOf(new float[] {(float) 2, (float) 3, (float) 2, (float) 3}, (float) 3)) 190 .isEqualTo(3); 191 192 for (float value : NUMBERS) { 193 assertWithMessage("" + value) 194 .that(Floats.lastIndexOf(new float[] {value, 5f}, value)) 195 .isEqualTo(0); 196 } 197 assertThat(Floats.lastIndexOf(new float[] {NaN, 5f}, NaN)).isEqualTo(-1); 198 } 199 200 @J2ktIncompatible 201 @GwtIncompatible testMax_noArgs()202 public void testMax_noArgs() { 203 try { 204 Floats.max(); 205 fail(); 206 } catch (IllegalArgumentException expected) { 207 } 208 } 209 testMax()210 public void testMax() { 211 assertThat(Floats.max(GREATEST)).isEqualTo(GREATEST); 212 assertThat(Floats.max(LEAST)).isEqualTo(LEAST); 213 assertThat( 214 Floats.max((float) 8, (float) 6, (float) 7, (float) 5, (float) 3, (float) 0, (float) 9)) 215 .isEqualTo((float) 9); 216 217 assertThat(Floats.max(-0f, 0f)).isEqualTo(0f); 218 assertThat(Floats.max(0f, -0f)).isEqualTo(0f); 219 assertThat(Floats.max(NUMBERS)).isEqualTo(GREATEST); 220 assertThat(Float.isNaN(Floats.max(VALUES))).isTrue(); 221 } 222 223 @J2ktIncompatible 224 @GwtIncompatible testMin_noArgs()225 public void testMin_noArgs() { 226 try { 227 Floats.min(); 228 fail(); 229 } catch (IllegalArgumentException expected) { 230 } 231 } 232 testMin()233 public void testMin() { 234 assertThat(Floats.min(LEAST)).isEqualTo(LEAST); 235 assertThat(Floats.min(GREATEST)).isEqualTo(GREATEST); 236 assertThat( 237 Floats.min((float) 8, (float) 6, (float) 7, (float) 5, (float) 3, (float) 0, (float) 9)) 238 .isEqualTo((float) 0); 239 240 assertThat(Floats.min(-0f, 0f)).isEqualTo(-0f); 241 assertThat(Floats.min(0f, -0f)).isEqualTo(-0f); 242 assertThat(Floats.min(NUMBERS)).isEqualTo(LEAST); 243 assertThat(Float.isNaN(Floats.min(VALUES))).isTrue(); 244 } 245 testConstrainToRange()246 public void testConstrainToRange() { 247 assertThat(Floats.constrainToRange((float) 1, (float) 0, (float) 5)).isEqualTo((float) 1); 248 assertThat(Floats.constrainToRange((float) 1, (float) 1, (float) 5)).isEqualTo((float) 1); 249 assertThat(Floats.constrainToRange((float) 1, (float) 3, (float) 5)).isEqualTo((float) 3); 250 assertThat(Floats.constrainToRange((float) 0, (float) -5, (float) -1)).isEqualTo((float) -1); 251 assertThat(Floats.constrainToRange((float) 5, (float) 2, (float) 2)).isEqualTo((float) 2); 252 try { 253 Floats.constrainToRange((float) 1, (float) 3, (float) 2); 254 fail(); 255 } catch (IllegalArgumentException expected) { 256 } 257 } 258 testConcat()259 public void testConcat() { 260 assertThat(Floats.concat()).isEqualTo(EMPTY); 261 assertThat(Floats.concat(EMPTY)).isEqualTo(EMPTY); 262 assertThat(Floats.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY); 263 assertThat(Floats.concat(ARRAY1)).isEqualTo(ARRAY1); 264 assertThat(Floats.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1); 265 assertThat(Floats.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1); 266 assertThat(Floats.concat(ARRAY1, ARRAY1, ARRAY1)) 267 .isEqualTo(new float[] {(float) 1, (float) 1, (float) 1}); 268 assertThat(Floats.concat(ARRAY1, ARRAY234)) 269 .isEqualTo(new float[] {(float) 1, (float) 2, (float) 3, (float) 4}); 270 } 271 testEnsureCapacity()272 public void testEnsureCapacity() { 273 assertThat(Floats.ensureCapacity(EMPTY, 0, 1)).isSameInstanceAs(EMPTY); 274 assertThat(Floats.ensureCapacity(ARRAY1, 0, 1)).isSameInstanceAs(ARRAY1); 275 assertThat(Floats.ensureCapacity(ARRAY1, 1, 1)).isSameInstanceAs(ARRAY1); 276 assertThat( 277 Arrays.equals( 278 new float[] {(float) 1, (float) 0, (float) 0}, Floats.ensureCapacity(ARRAY1, 2, 1))) 279 .isTrue(); 280 } 281 testEnsureCapacity_fail()282 public void testEnsureCapacity_fail() { 283 try { 284 Floats.ensureCapacity(ARRAY1, -1, 1); 285 fail(); 286 } catch (IllegalArgumentException expected) { 287 } 288 try { 289 // notice that this should even fail when no growth was needed 290 Floats.ensureCapacity(ARRAY1, 1, -1); 291 fail(); 292 } catch (IllegalArgumentException expected) { 293 } 294 } 295 296 @J2ktIncompatible 297 @GwtIncompatible // Float.toString returns different value in GWT. testJoin()298 public void testJoin() { 299 assertThat(Floats.join(",", EMPTY)).isEmpty(); 300 assertThat(Floats.join(",", ARRAY1)).isEqualTo("1.0"); 301 assertThat(Floats.join(",", (float) 1, (float) 2)).isEqualTo("1.0,2.0"); 302 assertThat(Floats.join("", (float) 1, (float) 2, (float) 3)).isEqualTo("1.02.03.0"); 303 } 304 testLexicographicalComparator()305 public void testLexicographicalComparator() { 306 List<float[]> ordered = 307 Arrays.asList( 308 new float[] {}, 309 new float[] {LEAST}, 310 new float[] {LEAST, LEAST}, 311 new float[] {LEAST, (float) 1}, 312 new float[] {(float) 1}, 313 new float[] {(float) 1, LEAST}, 314 new float[] {GREATEST, Float.MAX_VALUE}, 315 new float[] {GREATEST, GREATEST}, 316 new float[] {GREATEST, GREATEST, GREATEST}); 317 318 Comparator<float[]> comparator = Floats.lexicographicalComparator(); 319 Helpers.testComparator(comparator, ordered); 320 } 321 322 @J2ktIncompatible 323 @GwtIncompatible // SerializableTester testLexicographicalComparatorSerializable()324 public void testLexicographicalComparatorSerializable() { 325 Comparator<float[]> comparator = Floats.lexicographicalComparator(); 326 assertThat(SerializableTester.reserialize(comparator)).isSameInstanceAs(comparator); 327 } 328 testReverse()329 public void testReverse() { 330 testReverse(new float[] {}, new float[] {}); 331 testReverse(new float[] {1}, new float[] {1}); 332 testReverse(new float[] {1, 2}, new float[] {2, 1}); 333 testReverse(new float[] {3, 1, 1}, new float[] {1, 1, 3}); 334 testReverse(new float[] {-1, 1, -2, 2}, new float[] {2, -2, 1, -1}); 335 } 336 testReverse(float[] input, float[] expectedOutput)337 private static void testReverse(float[] input, float[] expectedOutput) { 338 input = Arrays.copyOf(input, input.length); 339 Floats.reverse(input); 340 assertThat(input).isEqualTo(expectedOutput); 341 } 342 testReverse( float[] input, int fromIndex, int toIndex, float[] expectedOutput)343 private static void testReverse( 344 float[] input, int fromIndex, int toIndex, float[] expectedOutput) { 345 input = Arrays.copyOf(input, input.length); 346 Floats.reverse(input, fromIndex, toIndex); 347 assertThat(input).isEqualTo(expectedOutput); 348 } 349 testReverseIndexed()350 public void testReverseIndexed() { 351 testReverse(new float[] {}, 0, 0, new float[] {}); 352 testReverse(new float[] {1}, 0, 1, new float[] {1}); 353 testReverse(new float[] {1, 2}, 0, 2, new float[] {2, 1}); 354 testReverse(new float[] {3, 1, 1}, 0, 2, new float[] {1, 3, 1}); 355 testReverse(new float[] {3, 1, 1}, 0, 1, new float[] {3, 1, 1}); 356 testReverse(new float[] {-1, 1, -2, 2}, 1, 3, new float[] {-1, -2, 1, 2}); 357 } 358 testRotate(float[] input, int distance, float[] expectedOutput)359 private static void testRotate(float[] input, int distance, float[] expectedOutput) { 360 input = Arrays.copyOf(input, input.length); 361 Floats.rotate(input, distance); 362 assertThat(input).isEqualTo(expectedOutput); 363 } 364 testRotate( float[] input, int distance, int fromIndex, int toIndex, float[] expectedOutput)365 private static void testRotate( 366 float[] input, int distance, int fromIndex, int toIndex, float[] expectedOutput) { 367 input = Arrays.copyOf(input, input.length); 368 Floats.rotate(input, distance, fromIndex, toIndex); 369 assertThat(input).isEqualTo(expectedOutput); 370 } 371 testRotate()372 public void testRotate() { 373 testRotate(new float[] {}, -1, new float[] {}); 374 testRotate(new float[] {}, 0, new float[] {}); 375 testRotate(new float[] {}, 1, new float[] {}); 376 377 testRotate(new float[] {1}, -2, new float[] {1}); 378 testRotate(new float[] {1}, -1, new float[] {1}); 379 testRotate(new float[] {1}, 0, new float[] {1}); 380 testRotate(new float[] {1}, 1, new float[] {1}); 381 testRotate(new float[] {1}, 2, new float[] {1}); 382 383 testRotate(new float[] {1, 2}, -3, new float[] {2, 1}); 384 testRotate(new float[] {1, 2}, -1, new float[] {2, 1}); 385 testRotate(new float[] {1, 2}, -2, new float[] {1, 2}); 386 testRotate(new float[] {1, 2}, 0, new float[] {1, 2}); 387 testRotate(new float[] {1, 2}, 1, new float[] {2, 1}); 388 testRotate(new float[] {1, 2}, 2, new float[] {1, 2}); 389 testRotate(new float[] {1, 2}, 3, new float[] {2, 1}); 390 391 testRotate(new float[] {1, 2, 3}, -5, new float[] {3, 1, 2}); 392 testRotate(new float[] {1, 2, 3}, -4, new float[] {2, 3, 1}); 393 testRotate(new float[] {1, 2, 3}, -3, new float[] {1, 2, 3}); 394 testRotate(new float[] {1, 2, 3}, -2, new float[] {3, 1, 2}); 395 testRotate(new float[] {1, 2, 3}, -1, new float[] {2, 3, 1}); 396 testRotate(new float[] {1, 2, 3}, 0, new float[] {1, 2, 3}); 397 testRotate(new float[] {1, 2, 3}, 1, new float[] {3, 1, 2}); 398 testRotate(new float[] {1, 2, 3}, 2, new float[] {2, 3, 1}); 399 testRotate(new float[] {1, 2, 3}, 3, new float[] {1, 2, 3}); 400 testRotate(new float[] {1, 2, 3}, 4, new float[] {3, 1, 2}); 401 testRotate(new float[] {1, 2, 3}, 5, new float[] {2, 3, 1}); 402 403 testRotate(new float[] {1, 2, 3, 4}, -9, new float[] {2, 3, 4, 1}); 404 testRotate(new float[] {1, 2, 3, 4}, -5, new float[] {2, 3, 4, 1}); 405 testRotate(new float[] {1, 2, 3, 4}, -1, new float[] {2, 3, 4, 1}); 406 testRotate(new float[] {1, 2, 3, 4}, 0, new float[] {1, 2, 3, 4}); 407 testRotate(new float[] {1, 2, 3, 4}, 1, new float[] {4, 1, 2, 3}); 408 testRotate(new float[] {1, 2, 3, 4}, 5, new float[] {4, 1, 2, 3}); 409 testRotate(new float[] {1, 2, 3, 4}, 9, new float[] {4, 1, 2, 3}); 410 411 testRotate(new float[] {1, 2, 3, 4, 5}, -6, new float[] {2, 3, 4, 5, 1}); 412 testRotate(new float[] {1, 2, 3, 4, 5}, -4, new float[] {5, 1, 2, 3, 4}); 413 testRotate(new float[] {1, 2, 3, 4, 5}, -3, new float[] {4, 5, 1, 2, 3}); 414 testRotate(new float[] {1, 2, 3, 4, 5}, -1, new float[] {2, 3, 4, 5, 1}); 415 testRotate(new float[] {1, 2, 3, 4, 5}, 0, new float[] {1, 2, 3, 4, 5}); 416 testRotate(new float[] {1, 2, 3, 4, 5}, 1, new float[] {5, 1, 2, 3, 4}); 417 testRotate(new float[] {1, 2, 3, 4, 5}, 3, new float[] {3, 4, 5, 1, 2}); 418 testRotate(new float[] {1, 2, 3, 4, 5}, 4, new float[] {2, 3, 4, 5, 1}); 419 testRotate(new float[] {1, 2, 3, 4, 5}, 6, new float[] {5, 1, 2, 3, 4}); 420 } 421 testRotateIndexed()422 public void testRotateIndexed() { 423 testRotate(new float[] {}, 0, 0, 0, new float[] {}); 424 425 testRotate(new float[] {1}, 0, 0, 1, new float[] {1}); 426 testRotate(new float[] {1}, 1, 0, 1, new float[] {1}); 427 testRotate(new float[] {1}, 1, 1, 1, new float[] {1}); 428 429 // Rotate the central 5 elements, leaving the ends as-is 430 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -6, 1, 6, new float[] {0, 2, 3, 4, 5, 1, 6}); 431 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -1, 1, 6, new float[] {0, 2, 3, 4, 5, 1, 6}); 432 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 0, 1, 6, new float[] {0, 1, 2, 3, 4, 5, 6}); 433 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 5, 1, 6, new float[] {0, 1, 2, 3, 4, 5, 6}); 434 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 14, 1, 6, new float[] {0, 2, 3, 4, 5, 1, 6}); 435 436 // Rotate the first three elements 437 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -2, 0, 3, new float[] {2, 0, 1, 3, 4, 5, 6}); 438 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -1, 0, 3, new float[] {1, 2, 0, 3, 4, 5, 6}); 439 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 0, 0, 3, new float[] {0, 1, 2, 3, 4, 5, 6}); 440 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 1, 0, 3, new float[] {2, 0, 1, 3, 4, 5, 6}); 441 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 2, 0, 3, new float[] {1, 2, 0, 3, 4, 5, 6}); 442 443 // Rotate the last four elements 444 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -6, 3, 7, new float[] {0, 1, 2, 5, 6, 3, 4}); 445 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -5, 3, 7, new float[] {0, 1, 2, 4, 5, 6, 3}); 446 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -4, 3, 7, new float[] {0, 1, 2, 3, 4, 5, 6}); 447 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -3, 3, 7, new float[] {0, 1, 2, 6, 3, 4, 5}); 448 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -2, 3, 7, new float[] {0, 1, 2, 5, 6, 3, 4}); 449 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, -1, 3, 7, new float[] {0, 1, 2, 4, 5, 6, 3}); 450 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 0, 3, 7, new float[] {0, 1, 2, 3, 4, 5, 6}); 451 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 1, 3, 7, new float[] {0, 1, 2, 6, 3, 4, 5}); 452 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 2, 3, 7, new float[] {0, 1, 2, 5, 6, 3, 4}); 453 testRotate(new float[] {0, 1, 2, 3, 4, 5, 6}, 3, 3, 7, new float[] {0, 1, 2, 4, 5, 6, 3}); 454 } 455 testSortDescending()456 public void testSortDescending() { 457 testSortDescending(new float[] {}, new float[] {}); 458 testSortDescending(new float[] {1}, new float[] {1}); 459 testSortDescending(new float[] {1, 2}, new float[] {2, 1}); 460 testSortDescending(new float[] {1, 3, 1}, new float[] {3, 1, 1}); 461 testSortDescending(new float[] {-1, 1, -2, 2}, new float[] {2, 1, -1, -2}); 462 testSortDescending( 463 new float[] {-1, 1, Float.NaN, -2, -0f, 0, 2}, 464 new float[] {Float.NaN, 2, 1, 0, -0f, -1, -2}); 465 } 466 testSortDescending(float[] input, float[] expectedOutput)467 private static void testSortDescending(float[] input, float[] expectedOutput) { 468 input = Arrays.copyOf(input, input.length); 469 Floats.sortDescending(input); 470 for (int i = 0; i < input.length; i++) { 471 assertThat(input[i]).isEqualTo(expectedOutput[i]); 472 } 473 } 474 testSortDescending( float[] input, int fromIndex, int toIndex, float[] expectedOutput)475 private static void testSortDescending( 476 float[] input, int fromIndex, int toIndex, float[] expectedOutput) { 477 input = Arrays.copyOf(input, input.length); 478 Floats.sortDescending(input, fromIndex, toIndex); 479 for (int i = 0; i < input.length; i++) { 480 assertThat(input[i]).isEqualTo(expectedOutput[i]); 481 } 482 } 483 testSortDescendingIndexed()484 public void testSortDescendingIndexed() { 485 testSortDescending(new float[] {}, 0, 0, new float[] {}); 486 testSortDescending(new float[] {1}, 0, 1, new float[] {1}); 487 testSortDescending(new float[] {1, 2}, 0, 2, new float[] {2, 1}); 488 testSortDescending(new float[] {1, 3, 1}, 0, 2, new float[] {3, 1, 1}); 489 testSortDescending(new float[] {1, 3, 1}, 0, 1, new float[] {1, 3, 1}); 490 testSortDescending(new float[] {-1, -2, 1, 2}, 1, 3, new float[] {-1, 1, -2, 2}); 491 testSortDescending( 492 new float[] {-1, 1, Float.NaN, -2, 2}, 1, 4, new float[] {-1, Float.NaN, 1, -2, 2}); 493 } 494 495 @J2ktIncompatible 496 @GwtIncompatible // SerializableTester testStringConverterSerialization()497 public void testStringConverterSerialization() { 498 SerializableTester.reserializeAndAssert(Floats.stringConverter()); 499 } 500 testToArray()501 public void testToArray() { 502 // need explicit type parameter to avoid javac warning!? 503 List<Float> none = Arrays.<Float>asList(); 504 assertThat(Floats.toArray(none)).isEqualTo(EMPTY); 505 506 List<Float> one = Arrays.asList((float) 1); 507 assertThat(Floats.toArray(one)).isEqualTo(ARRAY1); 508 509 float[] array = {(float) 0, (float) 1, (float) 3}; 510 511 List<Float> three = Arrays.asList((float) 0, (float) 1, (float) 3); 512 assertThat(Floats.toArray(three)).isEqualTo(array); 513 514 assertThat(Floats.toArray(Floats.asList(array))).isEqualTo(array); 515 } 516 testToArray_threadSafe()517 public void testToArray_threadSafe() { 518 for (int delta : new int[] {+1, 0, -1}) { 519 for (int i = 0; i < VALUES.length; i++) { 520 List<Float> list = Floats.asList(VALUES).subList(0, i); 521 Collection<Float> misleadingSize = Helpers.misleadingSizeCollection(delta); 522 misleadingSize.addAll(list); 523 float[] arr = Floats.toArray(misleadingSize); 524 assertThat(arr.length).isEqualTo(i); 525 for (int j = 0; j < i; j++) { 526 assertThat(arr[j]).isEqualTo(VALUES[j]); 527 } 528 } 529 } 530 } 531 testToArray_withNull()532 public void testToArray_withNull() { 533 List<@Nullable Float> list = Arrays.asList((float) 0, (float) 1, null); 534 try { 535 Floats.toArray(list); 536 fail(); 537 } catch (NullPointerException expected) { 538 } 539 } 540 testToArray_withConversion()541 public void testToArray_withConversion() { 542 float[] array = {(float) 0, (float) 1, (float) 2}; 543 544 List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2); 545 List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2); 546 List<Integer> ints = Arrays.asList(0, 1, 2); 547 List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2); 548 List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2); 549 List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2); 550 551 assertThat(Floats.toArray(bytes)).isEqualTo(array); 552 assertThat(Floats.toArray(shorts)).isEqualTo(array); 553 assertThat(Floats.toArray(ints)).isEqualTo(array); 554 assertThat(Floats.toArray(floats)).isEqualTo(array); 555 assertThat(Floats.toArray(longs)).isEqualTo(array); 556 assertThat(Floats.toArray(doubles)).isEqualTo(array); 557 } 558 559 @J2ktIncompatible // b/285319375 testAsList_isAView()560 public void testAsList_isAView() { 561 float[] array = {(float) 0, (float) 1}; 562 List<Float> list = Floats.asList(array); 563 list.set(0, (float) 2); 564 assertThat(array).isEqualTo(new float[] {(float) 2, (float) 1}); 565 array[1] = (float) 3; 566 assertThat(list).containsExactly((float) 2, (float) 3).inOrder(); 567 } 568 testAsList_toArray_roundTrip()569 public void testAsList_toArray_roundTrip() { 570 float[] array = {(float) 0, (float) 1, (float) 2}; 571 List<Float> list = Floats.asList(array); 572 float[] newArray = Floats.toArray(list); 573 574 // Make sure it returned a copy 575 list.set(0, (float) 4); 576 assertThat(newArray).isEqualTo(new float[] {(float) 0, (float) 1, (float) 2}); 577 newArray[1] = (float) 5; 578 assertThat((float) list.get(1)).isEqualTo((float) 1); 579 } 580 581 // This test stems from a real bug found by andrewk testAsList_subList_toArray_roundTrip()582 public void testAsList_subList_toArray_roundTrip() { 583 float[] array = {(float) 0, (float) 1, (float) 2, (float) 3}; 584 List<Float> list = Floats.asList(array); 585 assertThat(Floats.toArray(list.subList(1, 3))).isEqualTo(new float[] {(float) 1, (float) 2}); 586 assertThat(Floats.toArray(list.subList(2, 2))).isEmpty(); 587 } 588 testAsListEmpty()589 public void testAsListEmpty() { 590 assertThat(Floats.asList(EMPTY)).isSameInstanceAs(Collections.emptyList()); 591 } 592 593 /** 594 * A reference implementation for {@code tryParse} that just catches the exception from {@link 595 * Float#valueOf}. 596 */ referenceTryParse(String input)597 private static @Nullable Float referenceTryParse(String input) { 598 if (input.trim().length() < input.length()) { 599 return null; 600 } 601 try { 602 return Float.valueOf(input); 603 } catch (NumberFormatException e) { 604 return null; 605 } 606 } 607 608 @J2ktIncompatible 609 @GwtIncompatible // Floats.tryParse checkTryParse(String input)610 private static void checkTryParse(String input) { 611 assertThat(Floats.tryParse(input)).isEqualTo(referenceTryParse(input)); 612 } 613 614 @J2ktIncompatible 615 @GwtIncompatible // Floats.tryParse checkTryParse(float expected, String input)616 private static void checkTryParse(float expected, String input) { 617 assertThat(Floats.tryParse(input)).isEqualTo(Float.valueOf(expected)); 618 } 619 620 @J2ktIncompatible 621 @GwtIncompatible // Floats.tryParse testTryParseHex()622 public void testTryParseHex() { 623 for (String signChar : ImmutableList.of("", "+", "-")) { 624 for (String hexPrefix : ImmutableList.of("0x", "0X")) { 625 for (String iPart : ImmutableList.of("", "0", "1", "F", "f", "c4", "CE")) { 626 for (String fPart : ImmutableList.of("", ".", ".F", ".52", ".a")) { 627 for (String expMarker : ImmutableList.of("p", "P")) { 628 for (String exponent : ImmutableList.of("0", "-5", "+20", "52")) { 629 for (String typePart : ImmutableList.of("", "D", "F", "d", "f")) { 630 checkTryParse( 631 signChar + hexPrefix + iPart + fPart + expMarker + exponent + typePart); 632 } 633 } 634 } 635 } 636 } 637 } 638 } 639 } 640 641 @AndroidIncompatible // slow 642 @J2ktIncompatible 643 @GwtIncompatible // Floats.tryParse testTryParseAllCodePoints()644 public void testTryParseAllCodePoints() { 645 // Exercise non-ASCII digit test cases and the like. 646 char[] tmp = new char[2]; 647 for (int i = Character.MIN_CODE_POINT; i < Character.MAX_CODE_POINT; i++) { 648 Character.toChars(i, tmp, 0); 649 checkTryParse(String.copyValueOf(tmp, 0, Character.charCount(i))); 650 } 651 } 652 653 @J2ktIncompatible 654 @GwtIncompatible // Floats.tryParse testTryParseOfToStringIsOriginal()655 public void testTryParseOfToStringIsOriginal() { 656 for (float f : NUMBERS) { 657 checkTryParse(f, Float.toString(f)); 658 } 659 } 660 661 @J2ktIncompatible 662 @GwtIncompatible // Floats.tryParse testTryParseOfToHexStringIsOriginal()663 public void testTryParseOfToHexStringIsOriginal() { 664 for (float f : NUMBERS) { 665 checkTryParse(f, Float.toHexString(f)); 666 } 667 } 668 669 @J2ktIncompatible 670 @GwtIncompatible // Floats.tryParse testTryParseNaN()671 public void testTryParseNaN() { 672 checkTryParse("NaN"); 673 checkTryParse("+NaN"); 674 checkTryParse("-NaN"); 675 } 676 677 @J2ktIncompatible 678 @GwtIncompatible // Floats.tryParse testTryParseInfinity()679 public void testTryParseInfinity() { 680 checkTryParse(Float.POSITIVE_INFINITY, "Infinity"); 681 checkTryParse(Float.POSITIVE_INFINITY, "+Infinity"); 682 checkTryParse(Float.NEGATIVE_INFINITY, "-Infinity"); 683 } 684 685 private static final String[] BAD_TRY_PARSE_INPUTS = { 686 "", 687 "+-", 688 "+-0", 689 " 5", 690 "32 ", 691 " 55 ", 692 "infinity", 693 "POSITIVE_INFINITY", 694 "0x9A", 695 "0x9A.bE-5", 696 ".", 697 ".e5", 698 "NaNd", 699 "InfinityF" 700 }; 701 702 @J2ktIncompatible 703 @GwtIncompatible // Floats.tryParse testTryParseFailures()704 public void testTryParseFailures() { 705 for (String badInput : BAD_TRY_PARSE_INPUTS) { 706 assertThat(Floats.tryParse(badInput)).isEqualTo(referenceTryParse(badInput)); 707 assertThat(Floats.tryParse(badInput)).isNull(); 708 } 709 } 710 711 @J2ktIncompatible 712 @GwtIncompatible // NullPointerTester testNulls()713 public void testNulls() { 714 new NullPointerTester().testAllPublicStaticMethods(Floats.class); 715 } 716 717 @J2ktIncompatible 718 @GwtIncompatible // Float.toString returns different value in GWT. testStringConverter_convert()719 public void testStringConverter_convert() { 720 Converter<String, Float> converter = Floats.stringConverter(); 721 assertThat(converter.convert("1.0")).isEqualTo((Float) 1.0f); 722 assertThat(converter.convert("0.0")).isEqualTo((Float) 0.0f); 723 assertThat(converter.convert("-1.0")).isEqualTo((Float) (-1.0f)); 724 assertThat(converter.convert("1")).isEqualTo((Float) 1.0f); 725 assertThat(converter.convert("0")).isEqualTo((Float) 0.0f); 726 assertThat(converter.convert("-1")).isEqualTo((Float) (-1.0f)); 727 assertThat(converter.convert("1e6")).isEqualTo((Float) 1e6f); 728 assertThat(converter.convert("1e-6")).isEqualTo((Float) 1e-6f); 729 } 730 testStringConverter_convertError()731 public void testStringConverter_convertError() { 732 try { 733 Floats.stringConverter().convert("notanumber"); 734 fail(); 735 } catch (NumberFormatException expected) { 736 } 737 } 738 testStringConverter_nullConversions()739 public void testStringConverter_nullConversions() { 740 assertThat(Floats.stringConverter().convert(null)).isNull(); 741 assertThat(Floats.stringConverter().reverse().convert(null)).isNull(); 742 } 743 744 @J2ktIncompatible 745 @GwtIncompatible // Float.toString returns different value in GWT. testStringConverter_reverse()746 public void testStringConverter_reverse() { 747 Converter<String, Float> converter = Floats.stringConverter(); 748 assertThat(converter.reverse().convert(1.0f)).isEqualTo("1.0"); 749 assertThat(converter.reverse().convert(0.0f)).isEqualTo("0.0"); 750 assertThat(converter.reverse().convert(-1.0f)).isEqualTo("-1.0"); 751 assertThat(converter.reverse().convert(1e6f)).isEqualTo("1000000.0"); 752 assertThat(converter.reverse().convert(1e-6f)).isEqualTo("1.0E-6"); 753 } 754 755 @J2ktIncompatible 756 @GwtIncompatible // NullPointerTester testStringConverter_nullPointerTester()757 public void testStringConverter_nullPointerTester() throws Exception { 758 NullPointerTester tester = new NullPointerTester(); 759 tester.testAllPublicInstanceMethods(Floats.stringConverter()); 760 } 761 762 @J2ktIncompatible 763 @GwtIncompatible testTryParse_withNullNoGwt()764 public void testTryParse_withNullNoGwt() { 765 assertThat(Floats.tryParse("null")).isNull(); 766 try { 767 Floats.tryParse(null); 768 fail("Expected NPE"); 769 } catch (NullPointerException expected) { 770 } 771 } 772 } 773