1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.geometry.core;
18
19 import java.util.regex.Pattern;
20
21 import org.junit.jupiter.api.Assertions;
22 import org.junit.jupiter.api.function.Executable;
23
24 /** Class containing various geometry-related test utilities.
25 */
26 public final class GeometryTestUtils {
27
28 /** Utility class; no instantiation. */
29 private GeometryTestUtils() {}
30
31 /** Asserts that the given value is positive infinity.
32 * @param value
33 */
34 public static void assertPositiveInfinity(final double value) {
35 final String msg = "Expected value to be positive infinity but was " + value;
36 Assertions.assertTrue(Double.isInfinite(value), msg);
37 Assertions.assertTrue(value > 0, msg);
38 }
39
40 /** Asserts that the given value is negative infinity..
41 * @param value
42 */
43 public static void assertNegativeInfinity(final double value) {
44 final String msg = "Expected value to be negative infinity but was " + value;
45 Assertions.assertTrue(Double.isInfinite(value), msg);
46 Assertions.assertTrue(value < 0, msg);
47 }
48
49 /** Asserts that the Executable throws an exception matching the given type and message.
50 * @param executable the Executable instance
51 * @param exceptionType the expected exception type
52 * @param message the expected exception message; may be null
53 */
54 public static <T extends Throwable> void assertThrowsWithMessage(final Executable executable,
55 final Class<T> exceptionType, final String message) {
56 Assertions.assertEquals(message, Assertions.assertThrows(exceptionType, executable).getMessage());
57 }
58
59 /** Asserts that the Executable throws an exception of the given type with a non-null message matching
60 * the specified regex pattern.
61 * @param executable the Executable instance
62 * @param exceptionType the expected exception type
63 * @param pattern regex pattern to match
64 */
65 public static <T extends Throwable> void assertThrowsWithMessage(final Executable executable,
66 final Class<T> exceptionType, final Pattern pattern) {
67 final String message = Assertions.assertThrows(exceptionType, executable).getMessage();
68 Assertions.assertTrue(pattern.matcher(message).matches(),
69 "Expected exception message to match /" + pattern + "/ but was [" + message + "]");
70 }
71
72 /** Assert that a string contains a given substring value.
73 * @param substr
74 * @param actual
75 */
76 public static void assertContains(final String substr, final String actual) {
77 final String msg = "Expected string to contain [" + substr + "] but was [" + actual + "]";
78 Assertions.assertTrue(actual.contains(substr), msg);
79 }
80
81 /** Assert that the {@code equals} method of the argument meets the following requirements:
82 * <ol>
83 * <li>{@code obj} is not equal to null</li>
84 * <li>{@code obj} is not equal to an instance of a supertype ({@code java.lang.Object})</li>
85 * <li>{@code obj} is equal to itself</li>
86 * </ol>
87 * @param obj object to test the {@code equals} method of
88 */
89 public static void assertSimpleEqualsCases(final Object obj) {
90 // Use the JUnit boolean assertions here to ensure that the equals methods are actually
91 // invoked and no assertion shortcuts are taken
92
93 Assertions.assertFalse(obj.equals(null), "Object should not equal null");
94
95 if (obj.getClass().getSuperclass() != null) {
96 Assertions.assertFalse(obj.equals(new Object()), "Object should not equal an instance of different type");
97 }
98
99 Assertions.assertTrue(obj.equals(obj), "Object should equal itself");
100 }
101 }