[Git][java-team/wildfly-common][master] 3 commits: New upstream version 1.4.0

Markus Koschany gitlab at salsa.debian.org
Tue May 15 13:56:26 BST 2018


Markus Koschany pushed to branch master at Debian Java Maintainers / wildfly-common


Commits:
15f73065 by Markus Koschany at 2018-05-15T14:51:48+02:00
New upstream version 1.4.0
- - - - -
679229ee by Markus Koschany at 2018-05-15T14:51:52+02:00
Update upstream source from tag 'upstream/1.4.0'

Update to upstream version '1.4.0'
with Debian dir fd2a13c2133a9efe0c2705fa51a8b3e6f1505946
- - - - -
39597b3b by Markus Koschany at 2018-05-15T14:53:15+02:00
Update changelog

- - - - -


7 changed files:

- debian/changelog
- pom.xml
- src/main/java/org/wildfly/common/_private/CommonMessages.java
- src/main/java/org/wildfly/common/function/Functions.java
- src/main/java/org/wildfly/common/math/HashMath.java
- src/main/java/org/wildfly/common/net/Inet.java
- src/test/java/org/wildfly/common/math/HashMathTestCase.java


Changes:

=====================================
debian/changelog
=====================================
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+wildfly-common (1.4.0-1) unstable; urgency=medium
+
+  * New upstream version 1.4.0.
+
+ -- Markus Koschany <apo at debian.org>  Tue, 15 May 2018 14:53:05 +0200
+
 wildfly-common (1.3.2-1) unstable; urgency=medium
 
   * New upstream version 1.3.2.


=====================================
pom.xml
=====================================
--- a/pom.xml
+++ b/pom.xml
@@ -25,7 +25,7 @@
 
     <groupId>org.wildfly.common</groupId>
     <artifactId>wildfly-common</artifactId>
-    <version>1.3.2.Final</version>
+    <version>1.4.0.Final</version>
 
     <parent>
         <groupId>org.jboss</groupId>
@@ -197,6 +197,9 @@
                 <configuration>
                     <archive>
                         <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+                        <manifestEntries>
+                            <Multi-Release>true</Multi-Release>
+                        </manifestEntries>
                     </archive>
                 </configuration>
             </plugin>


=====================================
src/main/java/org/wildfly/common/_private/CommonMessages.java
=====================================
--- a/src/main/java/org/wildfly/common/_private/CommonMessages.java
+++ b/src/main/java/org/wildfly/common/_private/CommonMessages.java
@@ -80,6 +80,9 @@ public interface CommonMessages {
     @Message(id = 12, value = "Invalid address length of %d; must be 4 or 16")
     IllegalArgumentException invalidAddressBytes(int length);
 
+    @Message(id = 13, value = "Invalid address string \"%s\"")
+    IllegalArgumentException invalidAddress(String address);
+
     // execution path validation
 
     @Message(id = 100, value = "Method \"%s\" of class \"%s\" is not implemented")


=====================================
src/main/java/org/wildfly/common/function/Functions.java
=====================================
--- a/src/main/java/org/wildfly/common/function/Functions.java
+++ b/src/main/java/org/wildfly/common/function/Functions.java
@@ -277,6 +277,54 @@ public final class Functions {
         return new ExceptionConsumerRunnable<T, E>(consumer, param);
     }
 
+    /**
+     * Get a consumer which discards the values it is given.
+     *
+     * @param <T> the parameter type
+     * @return the discarding consumer
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> Consumer<T> discardingConsumer() {
+        return DiscardingConsumer.INSTANCE;
+    }
+
+    /**
+     * Get a consumer which discards the values it is given.
+     *
+     * @param <T> the parameter type
+     * @param <E> the exception type
+     * @return the discarding consumer
+     */
+    @SuppressWarnings("unchecked")
+    public static <T, E extends Exception> ExceptionConsumer<T, E> discardingExceptionConsumer() {
+        return DiscardingConsumer.INSTANCE;
+    }
+
+    /**
+     * Get a consumer which discards the values it is given.
+     *
+     * @param <T> the first parameter type
+     * @param <U> the second parameter type
+     * @return the discarding consumer
+     */
+    @SuppressWarnings("unchecked")
+    public static <T, U> BiConsumer<T, U> discardingBiConsumer() {
+        return DiscardingBiConsumer.INSTANCE;
+    }
+
+    /**
+     * Get a consumer which discards the values it is given.
+     *
+     * @param <T> the first parameter type
+     * @param <U> the second parameter type
+     * @param <E> the exception type
+     * @return the discarding consumer
+     */
+    @SuppressWarnings("unchecked")
+    public static <T, U, E extends Exception> ExceptionBiConsumer<T, U, E> discardingExceptionBiConsumer() {
+        return DiscardingBiConsumer.INSTANCE;
+    }
+
     static class RunnableConsumer implements Consumer<Runnable> {
         static final Consumer<Runnable> INSTANCE = new RunnableConsumer();
 
@@ -512,4 +560,24 @@ public final class Functions {
             return String.format("%s(%s)", consumer, param);
         }
     }
+
+    static class DiscardingConsumer<T, E extends Exception> implements Consumer<T>, ExceptionConsumer<T, E> {
+        static final DiscardingConsumer INSTANCE = new DiscardingConsumer();
+
+        private DiscardingConsumer() {
+        }
+
+        public void accept(final T t) {
+        }
+    }
+
+    static class DiscardingBiConsumer<T, U, E extends Exception> implements BiConsumer<T, U>, ExceptionBiConsumer<T, U, E> {
+        static final DiscardingBiConsumer INSTANCE = new DiscardingBiConsumer();
+
+        private DiscardingBiConsumer() {
+        }
+
+        public void accept(final T t, final U u) {
+        }
+    }
 }


=====================================
src/main/java/org/wildfly/common/math/HashMath.java
=====================================
--- a/src/main/java/org/wildfly/common/math/HashMath.java
+++ b/src/main/java/org/wildfly/common/math/HashMath.java
@@ -18,6 +18,8 @@
 
 package org.wildfly.common.math;
 
+import org.wildfly.common.Assert;
+
 /**
  * Routines which are useful for hashcode computation, among other things.
  *
@@ -31,6 +33,18 @@ public final class HashMath {
     }
 
     /**
+     * Round the given value up to the next positive power of two.
+     *
+     * @param value the value (must not be negative and must be less than or equal to {@code 2^31})
+     * @return the rounded power of two value
+     */
+    public static int roundToPowerOfTwo(int value) {
+        Assert.checkMinimumParameter("value", 0, value);
+        Assert.checkMaximumParameter("value", 0x4000_0000, value);
+        return value <= 1 ? value : Integer.highestOneBit(value - 1) << 1;
+    }
+
+    /**
      * A hash function which combines an accumulated hash with a next hash such that {@code f(f(k, p2, b), p1, a) ≠ₙ f(f(k, p1, a), p2, b)}.
      * This function is suitable for object chains whose order affects the overall equality of the hash code.
      * <p>


=====================================
src/main/java/org/wildfly/common/net/Inet.java
=====================================
--- a/src/main/java/org/wildfly/common/net/Inet.java
+++ b/src/main/java/org/wildfly/common/net/Inet.java
@@ -20,12 +20,14 @@ package org.wildfly.common.net;
 
 import static java.security.AccessController.doPrivileged;
 
+import java.lang.reflect.Array;
 import java.net.Inet4Address;
 import java.net.Inet6Address;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.NetworkInterface;
 import java.net.SocketException;
+import java.net.URI;
 import java.net.UnknownHostException;
 import java.nio.ByteBuffer;
 import java.security.PrivilegedAction;
@@ -98,6 +100,51 @@ public final class Inet {
     }
 
     /**
+     * Get a string representation of the given address which is suitable for use as the host component of a URL.
+     *
+     * @param inetAddress the address (must not be {@code null})
+     * @param useHostNameIfPresent {@code true} to preserve the host name string in the address, {@code false} to always give
+     *     an IP address string
+     * @return the string representation (not {@code null})
+     */
+    public static String toURLString(InetAddress inetAddress, boolean useHostNameIfPresent) {
+        Assert.checkNotNullParam("inetAddress", inetAddress);
+        if (useHostNameIfPresent) {
+            final String hostName = getHostNameIfResolved(inetAddress);
+            if (hostName != null) {
+                if (inetAddress instanceof Inet6Address && isInet6Address(hostName)) {
+                    return "[" + hostName + "]";
+                } else {
+                    // return it even if it's an IP address or whatever
+                    return hostName;
+                }
+            }
+        }
+        if (inetAddress instanceof Inet6Address) {
+            return "[" + toOptimalString(inetAddress) + "]";
+        } else {
+            return toOptimalString(inetAddress);
+        }
+    }
+
+    /**
+     * Get a string representation of the given address bytes which is suitable for use as the host component of a URL.
+     *
+     * @param addressBytes the address bytes (must not be {@code null})
+     * @return the string representation (not {@code null})
+     */
+    public static String toURLString(byte[] addressBytes) {
+        Assert.checkNotNullParam("addressBytes", addressBytes);
+        if (addressBytes.length == 4) {
+            return (addressBytes[0] & 0xff) + "." + (addressBytes[1] & 0xff) + "." + (addressBytes[2] & 0xff) + "." + (addressBytes[3] & 0xff);
+        } else if (addressBytes.length == 16) {
+            return "[" + toOptimalStringV6(addressBytes) + "]";
+        } else {
+            throw CommonMessages.msg.invalidAddressBytes(addressBytes.length);
+        }
+    }
+
+    /**
      * Get the IPv6 equivalent of the given address.  If the address is IPv4 then it is returned as a compatibility
      * address.
      *
@@ -140,6 +187,142 @@ public final class Inet {
     }
 
     /**
+     * Get a resolved socket address from the given URI.
+     *
+     * @param uri the URI (must not be {@code null})
+     * @param defaultPort the default port to use if none is given (must be in the range {@code 1 ≤ n ≤ 65535}
+     * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+     * @return the socket address, or {@code null} if the URI does not have a host component
+     * @throws UnknownHostException if address resolution failed
+     */
+    public static InetSocketAddress getResolved(URI uri, int defaultPort, Class<? extends InetAddress> addressType) throws UnknownHostException {
+        Assert.checkNotNullParam("uri", uri);
+        Assert.checkMinimumParameter("defaultPort", 1, defaultPort);
+        Assert.checkMaximumParameter("defaultPort", 65535, defaultPort);
+        Assert.checkNotNullParam("addressType", addressType);
+        final String uriHost = uri.getHost();
+        if (uriHost == null) {
+            return null;
+        }
+        final InetAddress resolved = getAddressByNameAndType(uriHost, addressType);
+        final int uriPort = uri.getPort();
+        return uriPort != - 1 ? new InetSocketAddress(resolved, uriPort) : new InetSocketAddress(resolved, defaultPort);
+    }
+
+    /**
+     * Get the resolved socket address from the given URI.
+     *
+     * @param uri the URI (must not be {@code null})
+     * @param defaultPort the default port to use if none is given (must be in the range {@code 1 ≤ n ≤ 65535}
+     * @return the socket address, or {@code null} if the URI does not have a host component
+     * @throws UnknownHostException if address resolution failed
+     */
+    public static InetSocketAddress getResolved(URI uri, int defaultPort) throws UnknownHostException {
+        return getResolved(uri, defaultPort, InetAddress.class);
+    }
+
+    /**
+     * Get a copy of the given socket address, but with a resolved address component.
+     *
+     * @param address the (possibly unresolved) address (must not be {@code null})
+     * @return the resolved address (not {@code null})
+     * @throws UnknownHostException if address resolution failed
+     */
+    public static InetSocketAddress getResolved(InetSocketAddress address) throws UnknownHostException {
+        return getResolved(address, InetAddress.class);
+    }
+
+    /**
+     * Get a copy of the given socket address, but with a resolved address component of the given type.
+     *
+     * @param address the (possibly unresolved) address (must not be {@code null})
+     * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+     * @return the resolved address (not {@code null})
+     * @throws UnknownHostException if address resolution failed, or if no addresses of the given type were found, or
+     *     if the given address was already resolved but is not of the given address type
+     */
+    public static InetSocketAddress getResolved(InetSocketAddress address, Class<? extends InetAddress> addressType) throws UnknownHostException {
+        Assert.checkNotNullParam("address", address);
+        Assert.checkNotNullParam("addressType", addressType);
+        if (! address.isUnresolved()) {
+            if (! addressType.isInstance(address.getAddress())) {
+                // the address part does not match
+                throw new UnknownHostException(address.getHostString());
+            }
+            return address;
+        }
+        return new InetSocketAddress(getAddressByNameAndType(address.getHostString(), addressType), address.getPort());
+    }
+
+    /**
+     * Resolve the given host name, returning the first answer with the given address type.
+     *
+     * @param hostName the host name to resolve (must not be {@code null})
+     * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+     * @param <T> the type of the {@code InetAddress} to search for
+     * @return the resolved address (not {@code null})
+     * @throws UnknownHostException if address resolution failed or if no addresses of the given type were found
+     */
+    public static <T extends InetAddress> T getAddressByNameAndType(String hostName, Class<T> addressType) throws UnknownHostException {
+        Assert.checkNotNullParam("hostName", hostName);
+        Assert.checkNotNullParam("addressType", addressType);
+        if (addressType == InetAddress.class) {
+            return addressType.cast(InetAddress.getByName(hostName));
+        }
+        for (InetAddress inetAddress : InetAddress.getAllByName(hostName)) {
+            if (addressType.isInstance(inetAddress)) {
+                return addressType.cast(inetAddress);
+            }
+        }
+        // no i18n here because this is a "standard" exception
+        throw new UnknownHostException(hostName);
+    }
+
+    /**
+     * Resolve the given host name, returning all answers with the given address type.
+     *
+     * @param hostName the host name to resolve (must not be {@code null})
+     * @param addressType the class of the {@code InetAddress} to search for (must not be {@code null})
+     * @param <T> the type of the {@code InetAddress} to search for
+     * @return the resolved addresses (not {@code null})
+     * @throws UnknownHostException if address resolution failed or if no addresses of the given type were found
+     */
+    @SuppressWarnings("unchecked")
+    public static <T extends InetAddress> T[] getAllAddressesByNameAndType(String hostName, Class<T> addressType) throws UnknownHostException {
+        Assert.checkNotNullParam("hostName", hostName);
+        Assert.checkNotNullParam("addressType", addressType);
+        if (addressType == InetAddress.class) {
+            // safe because T == InetAddress
+            return (T[]) InetAddress.getAllByName(hostName);
+        }
+        final InetAddress[] addresses = InetAddress.getAllByName(hostName);
+        final int length = addresses.length;
+        int count = 0;
+        for (InetAddress inetAddress : addresses) {
+            if (addressType.isInstance(inetAddress)) {
+                count ++;
+            }
+        }
+        if (count == 0) {
+            // no i18n here because this is a "standard" exception
+            throw new UnknownHostException(hostName);
+        }
+        final T[] newArray = (T[]) Array.newInstance(addressType, count);
+        if (count == length) {
+            //noinspection SuspiciousSystemArraycopy
+            System.arraycopy(addresses, 0, newArray, 0, length);
+        } else {
+            int idx = 0;
+            for (InetAddress inetAddress : addresses) {
+                if (addressType.isInstance(inetAddress)) {
+                    newArray[idx] = addressType.cast(inetAddress);
+                }
+            }
+        }
+        return newArray;
+    }
+
+    /**
      * Get an IPv4 address from four integer segments.  Each segment must be between 0 and 255.
      *
      * @param s1 the first segment
@@ -238,37 +421,77 @@ public final class Inet {
     /**
      * Parse an IPv6 address into an {@code Inet6Address} object.
      *
-     * @param string the address to parse
+     * @param address the address to parse
      * @return the parsed address, or {@code null} if the address is not valid
      */
-    public static Inet6Address parseInet6Address(String string) {
-        final byte[] bytes = parseInet6AddressToBytes(string);
+    public static Inet6Address parseInet6Address(String address) {
+        return parseInet6Address(address, null);
+    }
+
+    /**
+     * Parse an IPv6 address into an {@code Inet6Address} object.
+     *
+     * @param address the address to parse (must not be {@code null})
+     * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+     *      the address
+     * @return the parsed address, or {@code null} if the address is not valid
+     */
+    public static Inet6Address parseInet6Address(String address, String hostName) {
+        final byte[] bytes = parseInet6AddressToBytes(address);
         if (bytes == null) {
             return null;
         }
         int scopeId = 0;
-        Inet6Address address;
+        Inet6Address inetAddress;
         try {
-            address = Inet6Address.getByAddress(string, bytes, 0);
+            inetAddress = Inet6Address.getByAddress(hostName == null ? toOptimalStringV6(bytes) : hostName, bytes, 0);
         } catch (UnknownHostException e) {
             // not possible
             throw new IllegalStateException(e);
         }
-        final int pctIdx = string.indexOf('%');
+        final int pctIdx = address.indexOf('%');
         if (pctIdx != -1) {
-            scopeId = getScopeId(string.substring(pctIdx + 1), address);
+            scopeId = getScopeId(address.substring(pctIdx + 1), inetAddress);
             if (scopeId == 0) {
                 // address not valid after all...
                 return null;
             }
             try {
-                address = Inet6Address.getByAddress(string, bytes, scopeId);
+                inetAddress = Inet6Address.getByAddress(hostName == null ? toOptimalStringV6(bytes) : hostName, bytes, scopeId);
             } catch (UnknownHostException e) {
                 // not possible
                 throw new IllegalStateException(e);
             }
         }
-        return address;
+        return inetAddress;
+    }
+
+    /**
+     * Parse an IPv6 address into an {@code Inet6Address} object, throwing an exception on failure.
+     *
+     * @param address the address to parse
+     * @return the parsed address (not {@code null})
+     * @throws IllegalArgumentException if the address is not valid
+     */
+    public static Inet6Address parseInet6AddressOrFail(String address) {
+        final Inet6Address result = parseInet6Address(address, null);
+        if (result == null) throw CommonMessages.msg.invalidAddress(address);
+        return result;
+    }
+
+    /**
+     * Parse an IPv6 address into an {@code Inet6Address} object.
+     *
+     * @param address the address to parse (must not be {@code null})
+     * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+     *      the address
+     * @return the parsed address (not {@code null})
+     * @throws IllegalArgumentException if the address is not valid
+     */
+    public static Inet6Address parseInet6AddressOrFail(String address, String hostName) {
+        final Inet6Address result = parseInet6Address(address, hostName);
+        if (result == null) throw CommonMessages.msg.invalidAddress(address);
+        return result;
     }
 
     /**
@@ -288,12 +511,24 @@ public final class Inet {
      * @return the parsed address, or {@code null} if the address is not valid
      */
     public static Inet4Address parseInet4Address(String address) {
+        return parseInet4Address(address, null);
+    }
+
+    /**
+     * Parse an IPv4 address into an {@code Inet4Address} object.
+     *
+     * @param address the address to parse
+     * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+     *      the address
+     * @return the parsed address, or {@code null} if the address is not valid
+     */
+    public static Inet4Address parseInet4Address(String address, String hostName) {
         final byte[] bytes = parseInet4AddressToBytes(address);
         if (bytes == null) {
             return null;
         }
         try {
-            return (Inet4Address) Inet4Address.getByAddress(address, bytes);
+            return (Inet4Address) Inet4Address.getByAddress(hostName == null ? toOptimalString(bytes) : hostName, bytes);
         } catch (UnknownHostException e) {
             // not possible
             throw new IllegalStateException(e);
@@ -301,21 +536,89 @@ public final class Inet {
     }
 
     /**
+     * Parse an IPv4 address into an {@code Inet4Address} object, throwing an exception on failure.
+     *
+     * @param address the address to parse
+     * @return the parsed address (not {@code null})
+     * @throws IllegalArgumentException if the address is not valid
+     */
+    public static Inet4Address parseInet4AddressOrFail(String address) {
+        final Inet4Address result = parseInet4Address(address, null);
+        if (result == null) throw CommonMessages.msg.invalidAddress(address);
+        return result;
+    }
+
+    /**
+     * Parse an IPv4 address into an {@code Inet4Address} object.
+     *
+     * @param address the address to parse (must not be {@code null})
+     * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+     *      the address
+     * @return the parsed address (not {@code null})
+     * @throws IllegalArgumentException if the address is not valid
+     */
+    public static Inet4Address parseInet4AddressOrFail(String address, String hostName) {
+        final Inet4Address result = parseInet4Address(address, hostName);
+        if (result == null) throw CommonMessages.msg.invalidAddress(address);
+        return result;
+    }
+
+    /**
      * Parse an IP address into an {@code InetAddress} object.
      *
      * @param address the address to parse
      * @return the parsed address, or {@code null} if the address is not valid
      */
     public static InetAddress parseInetAddress(String address) {
+        return parseInetAddress(address, null);
+    }
+
+    /**
+     * Parse an IP address into an {@code InetAddress} object.
+     *
+     * @param address the address to parse
+     * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+     *      the address
+     * @return the parsed address, or {@code null} if the address is not valid
+     */
+    public static InetAddress parseInetAddress(String address, String hostName) {
         // simple heuristic
         if (address.indexOf(':') != -1) {
-            return parseInet6Address(address);
+            return parseInet6Address(address, hostName);
         } else {
-            return parseInet4Address(address);
+            return parseInet4Address(address, hostName);
         }
     }
 
     /**
+     * Parse an IP address into an {@code InetAddress} object, throwing an exception on failure.
+     *
+     * @param address the address to parse
+     * @return the parsed address (not {@code null})
+     * @throws IllegalArgumentException if the address is not valid
+     */
+    public static InetAddress parseInetAddressOrFail(String address) {
+        final InetAddress result = parseInetAddress(address, null);
+        if (result == null) throw CommonMessages.msg.invalidAddress(address);
+        return result;
+    }
+
+    /**
+     * Parse an IP address into an {@code InetAddress} object.
+     *
+     * @param address the address to parse (must not be {@code null})
+     * @param hostName the host name to use in the resultant object, or {@code null} to use the string representation of
+     *      the address
+     * @return the parsed address (not {@code null})
+     * @throws IllegalArgumentException if the address is not valid
+     */
+    public static InetAddress parseInetAddressOrFail(String address, String hostName) {
+        final InetAddress result = parseInetAddress(address, hostName);
+        if (result == null) throw CommonMessages.msg.invalidAddress(address);
+        return result;
+    }
+
+    /**
      * Parse a CIDR address into a {@code CidrAddress} object.
      *
      * @param address the address to parse


=====================================
src/test/java/org/wildfly/common/math/HashMathTestCase.java
=====================================
--- a/src/test/java/org/wildfly/common/math/HashMathTestCase.java
+++ b/src/test/java/org/wildfly/common/math/HashMathTestCase.java
@@ -19,14 +19,33 @@
 package org.wildfly.common.math;
 
 import static org.junit.Assert.*;
-import static org.wildfly.common.math.HashMath.multiHashOrdered;
-import static org.wildfly.common.math.HashMath.multiHashUnordered;
+import static org.wildfly.common.math.HashMath.*;
 
 import org.junit.Test;
 
 public class HashMathTestCase {
 
     @Test
+    public void testPowerOfTwo() {
+        assertEquals(0, roundToPowerOfTwo(0));
+        assertEquals(1, roundToPowerOfTwo(1));
+        assertEquals(4, roundToPowerOfTwo(3));
+        assertEquals(4, roundToPowerOfTwo(4));
+        assertEquals(8, roundToPowerOfTwo(5));
+        assertEquals(8, roundToPowerOfTwo(7));
+        assertEquals(8, roundToPowerOfTwo(8));
+        assertEquals(128, roundToPowerOfTwo(128));
+        assertEquals(256, roundToPowerOfTwo(129));
+        assertEquals(256, roundToPowerOfTwo(200));
+        assertEquals(256, roundToPowerOfTwo(255));
+        assertEquals(256, roundToPowerOfTwo(256));
+        assertEquals(0x2000_0000, roundToPowerOfTwo(0x2000_0000));
+        assertEquals(0x4000_0000, roundToPowerOfTwo(0x2000_0001));
+        assertEquals(0x4000_0000, roundToPowerOfTwo(0x3FFF_FFFF));
+        assertEquals(0x4000_0000, roundToPowerOfTwo(0x4000_0000));
+    }
+
+    @Test
     public void testOrderedCommutative() {
         final int ab = multiHashOrdered(multiHashOrdered(1234, 65537, 13), 16633, 5342);
         final int ba = multiHashOrdered(multiHashOrdered(1234, 16633, 5342), 65537, 13);



View it on GitLab: https://salsa.debian.org/java-team/wildfly-common/compare/b0d17c0d1475320def5d4b0edecd7d8cd5b9f553...39597b3bbadc0fea2e53e48ace4df65777da0a94

---
View it on GitLab: https://salsa.debian.org/java-team/wildfly-common/compare/b0d17c0d1475320def5d4b0edecd7d8cd5b9f553...39597b3bbadc0fea2e53e48ace4df65777da0a94
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/pkg-java-commits/attachments/20180515/9a5e9579/attachment.html>


More information about the pkg-java-commits mailing list