suggestions

Author: smiklosovic

src/java/org/apache/cassandra/auth/AuthConfig.java

@@ -85,7 +85,7 @@ public static void applyAuth()
         IRoleManager roleManager = authInstantiate(conf.role_manager, CassandraRoleManager.class);
 
         if (authenticator instanceof PasswordAuthenticator && !(roleManager instanceof CassandraRoleManager))
-            throw new ConfigurationException(authenticator.getClass().getName() + " requires CassandraRoleManager", false);
+            throw new ConfigurationException(authenticator.getClass().getName() + " requires " + CassandraRoleManager.class.getName(), false);
 
         DatabaseDescriptor.setRoleManager(roleManager);
 

src/java/org/apache/cassandra/config/ParameterizedClass.java

@@ -19,10 +19,10 @@
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import com.google.common.base.Objects;
@@ -96,23 +96,18 @@ static public <K> K newInstance(ParameterizedClass parameterizedClass, List<Stri
         {
             Constructor<?>[] declaredConstructors = providerClass.getDeclaredConstructors();
 
-            Constructor mapConstructor = Arrays.stream(declaredConstructors)
-                                               .filter(c ->
-                                                       c.getParameterTypes().length == 1 && c.getParameterTypes()[0].equals(Map.class))
-                                               .findFirst()
-                                               .orElse(null);
+            Constructor<?> mapConstructor = filterConstructor(declaredConstructors, c -> c.getParameterTypes().length == 1 && c.getParameterTypes()[0].equals(Map.class));
+
             if (mapConstructor != null)
                 return (K) mapConstructor.newInstance(parameterizedClass.parameters);
 
             // Falls-back to no-arg constructor if no parameters are present
             if (parameterizedClass.parameters == null || parameterizedClass.parameters.isEmpty())
             {
-                Constructor emptyConstructor = Arrays.stream(declaredConstructors)
-                                                     .filter(c -> c.getParameterTypes().length == 0)
-                                                     .findFirst()
-                                                     .orElse(null);
-                if (emptyConstructor != null)
-                    return (K) emptyConstructor.newInstance();
+                Constructor<?> noArgsConstructor = filterConstructor(declaredConstructors, c -> c.getParameterTypes().length == 0);
+
+                if (noArgsConstructor != null)
+                    return (K) noArgsConstructor.newInstance();
             }
 
             throw new ConfigurationException("No valid constructor found for class " + parameterizedClass.class_name);
@@ -129,6 +124,15 @@ static public <K> K newInstance(ParameterizedClass parameterizedClass, List<Stri
         }
     }
 
+    static private Constructor<?> filterConstructor(Constructor<?>[] declaredConstructors, Predicate<Constructor<?>> filter)
+    {
+        for (Constructor<?> constructor : declaredConstructors)
+            if (filter.test(constructor))
+                return constructor;
+
+        return null;
+    }
+
     @Override
     public boolean equals(Object that)
     {

test/unit/org/apache/cassandra/config/ParameterizedClassTest.java

@@ -21,36 +21,24 @@
 import java.util.List;
 import java.util.Map;
 
-import org.junit.Rule;
 import org.junit.Test;
 
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
 import org.apache.cassandra.auth.AllowAllAuthorizer;
 import org.apache.cassandra.auth.IAuthorizer;
 import org.apache.cassandra.exceptions.ConfigurationException;
-import org.junit.rules.ExpectedException;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 
 public class ParameterizedClassTest
 {
-    @Rule
-    public ExpectedException exceptionRule = ExpectedException.none();
-
     @Test
     public void newInstance_NonExistentClass_FailsWithConfigurationException()
     {
-        exceptionRule.expect(ConfigurationException.class);
-
-        String expectedError = "Unable to find class NonExistentClass in packages [\"org.apache.cassandra.config\"]";
-        exceptionRule.expectMessage(expectedError);
-
-        ParameterizedClass parameterizedClass = new ParameterizedClass("NonExistentClass");
-        ParameterizedClass.newInstance(parameterizedClass, List.of("org.apache.cassandra.config"));
-        fail();
+        assertThatThrownBy(() -> ParameterizedClass.newInstance(new ParameterizedClass("NonExistentClass"), List.of("org.apache.cassandra.config")))
+        .hasMessage("Unable to find class NonExistentClass in packages [\"org.apache.cassandra.config\"]")
+        .isInstanceOf(ConfigurationException.class);
     }
 
     @Test
@@ -64,14 +52,9 @@ public void newInstance_WithSingleEmptyConstructor_UsesEmptyConstructor()
     @Test
     public void newInstance_SingleEmptyConstructorWithParameters_FailsWithConfigurationException()
     {
-        exceptionRule.expect(ConfigurationException.class);
-        exceptionRule.expectMessage(startsWith("No valid constructor found for class"));
-
-        Map<String, String> parameters = Map.of("key", "value");
-        ParameterizedClass parameterizedClass = new ParameterizedClass(AllowAllAuthorizer.class.getName(), parameters);
-
-        ParameterizedClass.newInstance(parameterizedClass, null);
-        fail();
+        assertThatThrownBy(() -> ParameterizedClass.newInstance(new ParameterizedClass(AllowAllAuthorizer.class.getName(), Map.of("key", "value")), null))
+        .hasMessageStartingWith("No valid constructor found for class")
+        .isInstanceOf(ConfigurationException.class);
     }
 
     @Test
@@ -86,14 +69,10 @@ public void newInstance_WithValidConstructors_FavorsMapConstructor()
     @Test
     public void newInstance_WithConstructorException_PreservesOriginalFailure()
     {
-        exceptionRule.expect(ConfigurationException.class);
-        exceptionRule.expectMessage(startsWith("Failed to instantiate class"));
-        exceptionRule.expectMessage(containsString("Simulated failure"));
-
-        Map <String, String> parameters = Map.of("fail", "true");
-        ParameterizedClass parameterizedClass = new ParameterizedClass(ParameterizedClassExample.class.getName(), parameters);
-
-        ParameterizedClass.newInstance(parameterizedClass, null);
-        fail();
+        assertThatThrownBy(() -> ParameterizedClass.newInstance(new ParameterizedClass(ParameterizedClassExample.class.getName(),
+                                                                                       Map.of("fail", "true")), null))
+        .hasMessageContaining("Simulated failure")
+        .hasMessageStartingWith("Failed to instantiate class")
+        .isInstanceOf(ConfigurationException.class);
     }
 }