Excavator: Upgrades Baseline to the latest version

.baseline/checkstyle/checkstyle.xml

@@ -127,6 +127,11 @@
             <property name="illegalPkgs" value="junit.framework"/>
             <message key="import.illegal" value="Use JUnit 4-style (org.junit.*) test classes and assertions instead of JUnit 3 (junit.framework.*)."/>
         </module>
+        <module name="IllegalImport"> <!-- Only relevant for pre-Java 11 because javafx is gone completely in Java 11 -->
+            <property name="id" value="BanJavafx"/>
+            <property name="illegalPkgs" value="javafx"/>
+            <message key="import.illegal" value="Must not import javafx classes because some OpenJDK builds do not include javafx."/>
+        </module>
         <module name="IllegalImport"> <!-- Java Coding Guidelines: Import the canonical package -->
             <property name="illegalPkgs" value="org.elasticsearch.common.base, com.clearspring.analytics.util, org.spark_project.guava"/>
             <message key="import.illegal" value="Must not import repackaged classes."/>
@@ -417,6 +422,7 @@
             <property name="allowEmptyMethods" value="true"/>
             <property name="allowEmptyTypes" value="true"/>
             <property name="allowEmptyLoops" value="true"/>
+            <property name="allowEmptyLambdas" value="true"/>
             <property name="ignoreEnhancedForColon" value="false"/>
             <message key="ws.notFollowed" value="WhitespaceAround: ''{0}'' is not followed by whitespace. Empty blocks may only be represented as '{}' when not part of a multi-block statement (4.1.3)"/>
             <message key="ws.notPreceded" value="WhitespaceAround: ''{0}'' is not preceded with whitespace."/>
@@ -430,7 +436,7 @@
         </module>
         <module name="CyclomaticComplexity"/> <!-- Java Coding Guidelines: Reduce Cyclomatic Complexity -->
         <module name="DesignForExtension"> <!-- Java Coding Guidelines: Design for extension -->
-            <property name="ignoredAnnotations" value="Test, Before, BeforeEach, After, AfterEach, BeforeClass, BeforeAll, AfterClass, AfterAll"/>
+            <property name="ignoredAnnotations" value="ParameterizedTest, Test, Before, BeforeEach, After, AfterEach, BeforeClass, BeforeAll, AfterClass, AfterAll"/>
         </module>
         <module name="JavadocMethod"> <!-- Java Style Guide: Where Javadoc is used -->
             <property name="scope" value="public"/>

build.gradle

@@ -29,7 +29,7 @@ buildscript {
         classpath 'com.netflix.nebula:gradle-info-plugin:5.0.3'
         classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
         classpath 'com.netflix.nebula:nebula-publishing-plugin:13.5.1'
-        classpath 'com.palantir.baseline:gradle-baseline-java:0.51.1'
+        classpath 'com.palantir.baseline:gradle-baseline-java:2.6.0'
         classpath 'com.palantir.gradle.conjure:gradle-conjure:4.13.1'
         classpath 'com.palantir.gradle.gitversion:gradle-git-version:0.12.2'
         classpath 'gradle.plugin.org.inferred:gradle-processors:3.1.0'

conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java

@@ -72,6 +72,7 @@
 import com.palantir.conjure.spec.UnionDefinition;
 import com.palantir.conjure.visitor.DealiasingTypeVisitor;
 import com.palantir.conjure.visitor.TypeDefinitionVisitor;
+import com.palantir.logsafe.exceptions.SafeIllegalArgumentException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -97,7 +98,7 @@ public static String parsePackageOrElseThrow(
             Optional<String> defaultPackage) {
         String packageName = conjurePackage
                 .map(p -> p.name())
-                .orElseGet(() -> defaultPackage.orElseThrow(() -> new IllegalArgumentException(
+                .orElseGet(() -> defaultPackage.orElseThrow(() -> new SafeIllegalArgumentException(
                         // TODO(rfink): Better errors: Can we provide context on where exactly no package was provided?
                         "Must provide default conjure package or "
                                 + "explicit conjure package for every object and service")));
@@ -373,7 +374,7 @@ private static Optional<AuthType> parseAuthType(
             case NONE:
                 return Optional.empty();
             default:
-                throw new IllegalArgumentException("Unrecognized auth type.");
+                throw new SafeIllegalArgumentException("Unrecognized auth type.");
         }
     }
 
@@ -415,14 +416,14 @@ private static ParameterType parseParameterType(
                     return ParameterType.body(BodyParameterType.of());
                 }
             case HEADER:
-                String headerParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get());
+                String headerParamId = argumentDef.paramId().map(id -> id.name()).orElseGet(() -> argName.get());
                 return ParameterType.header(HeaderParameterType.of(ParameterId.of(headerParamId)));
             case PATH:
                 return ParameterType.path(PathParameterType.of());
             case BODY:
                 return ParameterType.body(BodyParameterType.of());
             case QUERY:
-                String queryParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get());
+                String queryParamId = argumentDef.paramId().map(id -> id.name()).orElseGet(() -> argName.get());
                 return ParameterType.query(QueryParameterType.of(ParameterId.of(queryParamId)));
             default:
                 throw new IllegalArgumentException("Unknown parameter type: " + argumentDef.paramType());

conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java

@@ -39,6 +39,7 @@
 import com.palantir.conjure.visitor.ParameterTypeVisitor;
 import com.palantir.conjure.visitor.TypeDefinitionVisitor;
 import com.palantir.conjure.visitor.TypeVisitor;
+import com.palantir.logsafe.exceptions.SafeRuntimeException;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
@@ -306,17 +307,17 @@ public Boolean visitMap(MapType value) {
                         // DealiasingTypeVisitor above
                         @Override
                         public Boolean visitReference(TypeName value) {
-                            throw new RuntimeException("Unexpected type when validating query parameters");
+                            throw new SafeRuntimeException("Unexpected type when validating query parameters");
                         }
 
                         @Override
                         public Boolean visitExternal(ExternalReference value) {
-                            throw new RuntimeException("Unexpected type when validating query parameters");
+                            throw new SafeRuntimeException("Unexpected type when validating query parameters");
                         }
 
                         @Override
                         public Boolean visitUnknown(String unknownType) {
-                            throw new RuntimeException("Unexpected type when validating query parameters");
+                            throw new SafeRuntimeException("Unexpected type when validating query parameters");
                         }
                     }));
         }

conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java

@@ -74,7 +74,7 @@ private static boolean isValidJavaIdentifier(String key) {
         @Override
         public void validate(UnionDefinition definition) {
             definition.getUnion().stream().forEach(fieldDef -> {
-                        Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldDef.getFieldName().get()),
+                        com.palantir.logsafe.Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldDef.getFieldName().get()),
                                 "Union member key must not be empty");
                         Preconditions.checkArgument(isValidJavaIdentifier(fieldDef.getFieldName().get()),
                                 "Union member key must be a valid Java identifier: %s",

conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java

@@ -16,12 +16,12 @@
 
 package com.palantir.conjure.parser.services;
 
-import static com.google.common.base.Preconditions.checkArgument;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonValue;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.palantir.conjure.defs.ConjureImmutablesStyle;
+import com.palantir.logsafe.Preconditions;
 import java.util.Locale;
 import org.immutables.value.Value;
 
@@ -81,7 +81,7 @@ static AuthDefinition fromString(String value) {
                 id = "NONE";
                 break;
             case COOKIE:
-                checkArgument(parts.length == 2, "Cookie authorization type must include a cookie name");
+                Preconditions.checkArgument(parts.length == 2, "Cookie authorization type must include a cookie name");
                 id = parts[1];
                 break;
             default:

conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java

@@ -29,6 +29,7 @@
 import com.palantir.conjure.parser.types.complex.UnionTypeDefinition;
 import com.palantir.conjure.parser.types.names.ConjurePackage;
 import com.palantir.conjure.parser.types.reference.AliasTypeDefinition;
+import com.palantir.logsafe.exceptions.SafeIllegalArgumentException;
 import java.io.IOException;
 import java.util.Optional;
 
@@ -57,7 +58,7 @@ public BaseObjectTypeDefinition deserialize(JsonParser parser, DeserializationCo
             } else if (tree.get("namespace") != null) {
                 return ErrorTypeDefinition.fromJson(parser, tree);
             } else {
-                throw new IllegalArgumentException(
+                throw new SafeIllegalArgumentException(
                         "Unrecognized definition, types must have either fields, values or an alias defined.");
             }
         }

conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java

@@ -69,7 +69,7 @@ public ConjureSpecTest(TestCaseDefinition testCaseDef) {
     @Test
     public void testConjureSpec() {
         // test positive cases
-        testCaseDef.positive().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> {
+        testCaseDef.positive().orElseGet(() -> new TreeMap<>()).entrySet().stream().forEach(entry -> {
             String testName = String.format("positive case %s", entry.getKey());
             String yml = getYmlAsString(testName, entry.getValue().conjure());
             try {
@@ -80,7 +80,7 @@ public void testConjureSpec() {
         });
 
         // test negative cases
-        testCaseDef.negative().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> {
+        testCaseDef.negative().orElseGet(() -> new TreeMap<>()).entrySet().stream().forEach(entry -> {
             String testName = String.format("negative case %s", entry.getKey());
             String yml = getYmlAsString(testName, entry.getValue().conjure());
             try {

conjure-core/src/test/java/com/palantir/parsec/tests/TestUnitParsers.java

@@ -16,8 +16,7 @@
 
 package com.palantir.parsec.tests;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import com.palantir.parsec.ParseException;
 import com.palantir.parsec.Parser;
@@ -42,20 +41,18 @@ public final class TestUnitParsers {
 
     @Test
     public void testQuotedStringParser() throws ParseException {
-        assertEquals("Test 123", new QuotedStringParser(false).parse(new StringParserState("\"Test 123\"")));
-        assertEquals("Test \"123",
-                new QuotedStringParser(false).parse(new StringParserState("\"Test \\\"123\"")));
-        assertEquals("Test 123", new QuotedStringParser(false).parse(new StringParserState("\"Test \n\n123\"")));
-        assertEquals("Test \n\n123",
-                new QuotedStringParser(true).parse(new StringParserState("\"Test \n\n123\"")));
+        assertThat(new QuotedStringParser(false).parse(new StringParserState("\"Test 123\""))).isEqualTo("Test 123");
+        assertThat(new QuotedStringParser(false).parse(new StringParserState("\"Test \\\"123\""))).isEqualTo("Test \"123");
+        assertThat(new QuotedStringParser(false).parse(new StringParserState("\"Test \n\n123\""))).isEqualTo("Test 123");
+        assertThat(new QuotedStringParser(true).parse(new StringParserState("\"Test \n\n123\""))).isEqualTo("Test \n\n123");
     }
 
     @Test
     public void testRawStringParser() {
-        assertEquals("a:b123", new RawStringParser().parse(new StringParserState("a:b123")));
-        assertNull(new RawStringParser().parse(new StringParserState(" a:b123")));
-        assertEquals("ab123", new RawStringParser().parse(new StringParserState("ab123 ")));
-        assertEquals("ab123", new RawStringParser().parse(new StringParserState("ab123\n")));
+        assertThat(new RawStringParser().parse(new StringParserState("a:b123"))).isEqualTo("a:b123");
+        assertThat(new RawStringParser().parse(new StringParserState(" a:b123"))).isNull();
+        assertThat(new RawStringParser().parse(new StringParserState("ab123 "))).isEqualTo("ab123");
+        assertThat(new RawStringParser().parse(new StringParserState("ab123\n"))).isEqualTo("ab123");
     }
 
     @Test
@@ -65,54 +62,50 @@ public void testDispatchingParser() throws ParseException {
         map.put("dir1", new RawStringParser());
         map.put("dir2", new QuotedStringParser());
 
-        assertEquals("def", new DispatchingParser<String>(map, Parsers.whitespace())
-                .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n")));
-        assertEquals("def", new DispatchingParser<String>(map, Parsers.whitespace())
-                .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n")));
+        assertThat(new DispatchingParser<String>(map, Parsers.whitespace())
+                .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))).isEqualTo("def");
+        assertThat(new DispatchingParser<String>(map, Parsers.whitespace())
+                .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))).isEqualTo("def");
     }
 
     @Test
     public void testExpectantParser() {
-        assertEquals(ExpectationResult.CORRECT,
-                new ExpectantParser("abcdef").parse(new StringParserState("abcdef")));
-        assertEquals(ExpectationResult.INCORRECT,
-                new ExpectantParser("abcdef").parse(new StringParserState("abcde")));
-        assertEquals(ExpectationResult.INCORRECT,
-                new ExpectantParser("abcdef").parse(new StringParserState("abcdeg")));
+        assertThat(new ExpectantParser("abcdef").parse(new StringParserState("abcdef"))).isEqualTo(ExpectationResult.CORRECT);
+        assertThat(new ExpectantParser("abcdef").parse(new StringParserState("abcde"))).isEqualTo(ExpectationResult.INCORRECT);
+        assertThat(new ExpectantParser("abcdef").parse(new StringParserState("abcdeg"))).isEqualTo(ExpectationResult.INCORRECT);
     }
 
     @Test
     public void testBetweenParser() throws ParseException {
-        assertEquals("abcdef",
-                new BetweenParser<String>(new ExpectantParser("{"),
+        assertThat(new BetweenParser<String>(new ExpectantParser("{"),
                         Parsers.prefix(Parsers.whitespace(), new RawStringParser()),
                         Parsers.prefix(Parsers.whitespace(), new ExpectantParser("}")))
-                        .parse(new StringParserState("{ abcdef }")));
+                        .parse(new StringParserState("{ abcdef }"))).isEqualTo("abcdef");
     }
 
     @Test
     public void testListParser() throws ParseException {
         List<String> list = new ArrayList<>();
         list.add("abc");
         list.add("def");
-        assertEquals(list, new ListParser<>(new QuotedStringParser(), Parsers.whitespace())
-                .parse(new StringParserState("\"abc\" \"def\"")));
+        assertThat(new ListParser<>(new QuotedStringParser(), Parsers.whitespace())
+                .parse(new StringParserState("\"abc\" \"def\""))).isEqualTo(list);
     }
 
     @Test
     public void testMapParser() throws ParseException {
         Map<String, String> map = new HashMap<String, String>();
         map.put("abc", "def");
-        assertEquals(map, new MapParser<String, String>(new RawStringParser(),
+        assertThat(new MapParser<String, String>(new RawStringParser(),
                 Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.whitespace()).parse(
-                new StringParserState("abc def")));
-        assertEquals(map, new MapParser<String, String>(Parsers.prefix(Parsers.whitespace(), new RawStringParser()),
+                new StringParserState("abc def"))).isEqualTo(map);
+        assertThat(new MapParser<String, String>(Parsers.prefix(Parsers.whitespace(), new RawStringParser()),
                 Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.whitespace()).parse(
-                new StringParserState(" abc def")));
+                new StringParserState(" abc def"))).isEqualTo(map);
         map.put("ghi", "jkl");
-        assertEquals(map, new MapParser<String, String>(Parsers.prefix(Parsers.whitespace(), new RawStringParser()),
+        assertThat(new MapParser<String, String>(Parsers.prefix(Parsers.whitespace(), new RawStringParser()),
                 Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.whitespace()).parse(
-                new StringParserState("abc def  ghi jkl")));
+                new StringParserState("abc def  ghi jkl"))).isEqualTo(map);
     }
 
     @Test
@@ -129,12 +122,12 @@ public void testMapParserBuiltup() throws ParseException {
         MapParser<String, String> mapParser2 =
                 new MapParser<String, String>(whitespaceStringParser, whitespaceStringParser, Parsers.whitespace());
 
-        assertEquals(map, mapParser1.parse(new StringParserState("abc def")));
-        assertEquals(map, mapParser2.parse(new StringParserState(" abc def")));
+        assertThat(mapParser1.parse(new StringParserState("abc def"))).isEqualTo(map);
+        assertThat(mapParser2.parse(new StringParserState(" abc def"))).isEqualTo(map);
 
         map.put("ghi", "jkl");
 
-        assertEquals(map, mapParser2.parse(new StringParserState("abc def  ghi jkl")));
+        assertThat(mapParser2.parse(new StringParserState("abc def  ghi jkl"))).isEqualTo(map);
     }
 
     @Test
@@ -151,10 +144,8 @@ public String getDescription() {
             }
         });
 
-        assertEquals("abcdef",
-                Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("abcdef")));
-        assertEquals("abcdef",
-                Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("\"abcdef\"")));
+        assertThat(Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("abcdef"))).isEqualTo("abcdef");
+        assertThat(Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("\"abcdef\""))).isEqualTo("abcdef");
     }
 
     private static final Parser<String> rsp = Parsers.prefix(Parsers.whitespace(), new RawStringParser());
@@ -164,28 +155,28 @@ public String getDescription() {
     public void testGingerlyBooleanFalse() throws ParseException {
         StringParserState state = new StringParserState("false 123");
 
-        assertEquals(Boolean.FALSE, Parsers.gingerly(bp).parse(state));
-        assertEquals("123", rsp.parse(state));
+        assertThat(Parsers.gingerly(bp).parse(state)).isEqualTo(Boolean.FALSE);
+        assertThat(rsp.parse(state)).isEqualTo("123");
     }
 
     @Test
     public void testGingerlyBooleanTrue() throws ParseException {
         StringParserState state = new StringParserState("true 123");
 
-        assertEquals(Boolean.TRUE, Parsers.gingerly(bp).parse(state));
-        assertEquals("123", rsp.parse(state));
+        assertThat(Parsers.gingerly(bp).parse(state)).isEqualTo(Boolean.TRUE);
+        assertThat(rsp.parse(state)).isEqualTo("123");
     }
 
     @Test
     public void testEofParser() throws ParseException {
-        assertEquals(ExpectationResult.CORRECT, Parsers.eof(new ExpectantParser("abc"))
-                .parse(new StringParserState("abc")));
+        assertThat(Parsers.eof(new ExpectantParser("abc"))
+                .parse(new StringParserState("abc"))).isEqualTo(ExpectationResult.CORRECT);
     }
 
     @Test
     public void testEofParserFails() throws ParseException {
-        assertNull(Parsers.eof(new ExpectantParser("abc"))
-                .parse(new StringParserState("abcdef")));
+        assertThat(Parsers.eof(new ExpectantParser("abc"))
+                .parse(new StringParserState("abcdef"))).isNull();
     }
 
 }