Improve code quality

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/rule/OneQuickFixPerLineSensor.java

 import org.sonar.api.batch.fs.FileSystem;
 import org.sonar.api.batch.fs.InputFile;
 import org.sonar.api.batch.fs.InputFile.Type;
-import org.sonar.api.batch.rule.Severity;
 import org.sonar.api.batch.sensor.Sensor;
 import org.sonar.api.batch.sensor.SensorContext;
 import org.sonar.api.batch.sensor.SensorDescriptor;
 import org.sonar.api.batch.sensor.issue.NewIssue;
 import org.sonar.api.rule.RuleKey;
-import org.sonar.api.utils.Version;
 import org.sonar.xoo.Xoo;
 import org.sonar.xoo.Xoo2;
 

plugins/sonar-xoo-plugin/src/test/java/org/sonar/xoo/rule/OneQuickFixPerLineSensorTest.java

 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
-import org.sonar.api.SonarEdition;
-import org.sonar.api.SonarQubeSide;
 import org.sonar.api.batch.fs.internal.DefaultInputFile;
 import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
-import org.sonar.api.batch.rule.Severity;
 import org.sonar.api.batch.sensor.internal.DefaultSensorDescriptor;
 import org.sonar.api.batch.sensor.internal.SensorContextTester;
 import org.sonar.api.batch.sensor.issue.Issue;
-import org.sonar.api.config.internal.MapSettings;
-import org.sonar.api.internal.SonarRuntimeImpl;
-import org.sonar.api.utils.Version;
 import org.sonar.xoo.Xoo;
 
 import java.io.IOException;

server/sonar-alm-client/src/test/java/org/sonar/alm/client/bitbucket/bitbucketcloud/BitbucketCloudRestClientTest.java

 
     RepositoryList repositoryList = underTest.searchRepos("user:apppwd", "", null, 1, 100);
     assertThat(repositoryList.getNext()).isNull();
-    assertThat(repositoryList.getPage()).isEqualTo(1);
+    assertThat(repositoryList.getPage()).isOne();
     assertThat(repositoryList.getPagelen()).isEqualTo(100);
     assertThat(repositoryList.getValues())
       .hasSize(1)

server/sonar-alm-client/src/test/java/org/sonar/alm/client/bitbucketserver/BitbucketServerRestClientTest.java

       .setBody("this is not a json payload"));
 
     String serverUrl = server.url("/").toString();
-    assertThatThrownBy(() -> {
-      underTest.validateUrl(serverUrl);
-    })
+    assertThatThrownBy(() -> underTest.validateUrl(serverUrl))
       .isInstanceOf(IllegalArgumentException.class)
       .hasMessage("Unable to contact Bitbucket server, got an unexpected response");
   }

server/sonar-alm-client/src/test/java/org/sonar/alm/client/gitlab/GitlabHttpClientTest.java

 
     ProjectList projectList = underTest.searchProjects(gitlabUrl, "pat", "example", 1, 10);
 
-    assertThat(projectList.getPageNumber()).isEqualTo(1);
+    assertThat(projectList.getPageNumber()).isOne();
     assertThat(projectList.getPageSize()).isEqualTo(10);
     assertThat(projectList.getTotal()).isEqualTo(3);
 
 
     ProjectList projectList = underTest.searchProjects(gitlabUrl, "pat", "example", 1, 10);
 
-    assertThat(projectList.getPageNumber()).isEqualTo(1);
+    assertThat(projectList.getPageNumber()).isOne();
     assertThat(projectList.getPageSize()).isEqualTo(10);
     assertThat(projectList.getTotal()).isNull();
 
 
     ProjectList projectList = underTest.searchProjects(gitlabUrl, "pat", "example", 1, 10);
 
-    assertThat(projectList.getPageNumber()).isEqualTo(1);
-    assertThat(projectList.getPageSize()).isEqualTo(1);
+    assertThat(projectList.getPageNumber()).isOne();
+    assertThat(projectList.getPageSize()).isOne();
     assertThat(projectList.getTotal()).isEqualTo(2);
 
     assertThat(projectList.getProjects()).hasSize(1);

server/sonar-auth-bitbucket/src/main/java/org/sonar/auth/bitbucket/BitbucketSettings.java

 import org.sonar.api.config.PropertyDefinition;
 import org.sonar.api.server.ServerSide;
 
-import static java.lang.String.format;
-
 @ServerSide
 public class BitbucketSettings {
 

server/sonar-auth-bitbucket/src/main/java/org/sonar/auth/bitbucket/UserIdentityFactory.java

 import org.sonar.api.server.ServerSide;
 import org.sonar.api.server.authentication.UserIdentity;
 
-import static java.lang.String.format;
-
 @ServerSide
 public class UserIdentityFactory {
 

server/sonar-auth-gitlab/src/test/java/org/sonar/auth/gitlab/GsonGroupTest.java

       "}]");
 
     assertThat(groups).isNotNull();
-    assertThat(groups.size()).isEqualTo(1);
+    assertThat(groups.size()).isOne();
     assertThat(groups.get(0).getFullPath()).isEqualTo("my-awesome-group/my-project");
   }
 }

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapSearchTest.java

     assertThat(search.toString()).isEqualTo("LdapSearch{baseDn=dc=example,dc=org, scope=subtree, request=(objectClass={0}), parameters=[inetOrgPerson], attributes=[objectClass]}");
     assertThat(enumerationToArrayList(search.find()).size()).isEqualTo(3);
 
-    assertThatThrownBy(() -> search.findUnique())
+    assertThatThrownBy(search::findUnique)
       .isInstanceOf(NamingException.class)
       .hasMessage("Non unique result for " + search.toString());
+
   }
 
   @Test
     assertThat(search.getRequest()).isEqualTo("(objectClass={0})");
     assertThat(search.getParameters()).isEqualTo(new String[] {"inetOrgPerson"});
     assertThat(search.getReturningAttributes()).isEqualTo(new String[] {"cn"});
-    assertThat(search.toString()).isEqualTo("LdapSearch{baseDn=dc=example,dc=org, scope=onelevel, request=(objectClass={0}), parameters=[inetOrgPerson], attributes=[cn]}");
+    assertThat(search).hasToString("LdapSearch{baseDn=dc=example,dc=org, scope=onelevel, request=(objectClass={0}), parameters=[inetOrgPerson], attributes=[cn]}");
     assertThat(enumerationToArrayList(search.find()).size()).isZero();
     assertThat(search.findUnique()).isNull();
   }
     assertThat(search.getRequest()).isEqualTo("(objectClass={0})");
     assertThat(search.getParameters()).isEqualTo(new String[] {"uidObject"});
     assertThat(search.getReturningAttributes()).isEqualTo(new String[] {"uid"});
-    assertThat(search.toString()).isEqualTo(
+    assertThat(search).hasToString(
       "LdapSearch{baseDn=cn=bind,ou=users,dc=example,dc=org, scope=object, request=(objectClass={0}), parameters=[uidObject], attributes=[uid]}");
-    assertThat(enumerationToArrayList(search.find()).size()).isEqualTo(1);
+    assertThat(enumerationToArrayList(search.find())).hasSize(1);
     assertThat(search.findUnique()).isNotNull();
   }
 

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapSettingsManagerTest.java

   public void testContextFactoriesWithSingleLdap() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
       generateSingleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
-    assertThat(settingsManager.getContextFactories().size()).isEqualTo(1);
+    assertThat(settingsManager.getContextFactories()).hasSize(1);
   }
 
   /**
   public void testContextFactoriesWithMultipleLdap() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
       generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
-    assertThat(settingsManager.getContextFactories().size()).isEqualTo(2);
+    assertThat(settingsManager.getContextFactories()).hasSize(2);
     // We do it twice to make sure the settings keep the same.
-    assertThat(settingsManager.getContextFactories().size()).isEqualTo(2);
+    assertThat(settingsManager.getContextFactories()).hasSize(2);
   }
 
   @Test
     when(ldapAutodiscovery.getLdapServers("example.org")).thenReturn(Arrays.asList(ldap1, ldap2));
     LdapSettingsManager settingsManager = new LdapSettingsManager(
       generateAutodiscoverSettings().asConfig(), ldapAutodiscovery);
-    assertThat(settingsManager.getContextFactories().size()).isEqualTo(2);
+    assertThat(settingsManager.getContextFactories()).hasSize(2);
   }
 
   @Test
   public void testUserMappings() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
       generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
-    assertThat(settingsManager.getUserMappings().size()).isEqualTo(2);
+    assertThat(settingsManager.getUserMappings()).hasSize(2);
     // We do it twice to make sure the settings keep the same.
-    assertThat(settingsManager.getUserMappings().size()).isEqualTo(2);
+    assertThat(settingsManager.getUserMappings()).hasSize(2);
   }
 
   /**
   public void testGroupMappings() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
       generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
-    assertThat(settingsManager.getGroupMappings().size()).isEqualTo(2);
+    assertThat(settingsManager.getGroupMappings()).hasSize(2);
     // We do it twice to make sure the settings keep the same.
-    assertThat(settingsManager.getGroupMappings().size()).isEqualTo(2);
+    assertThat(settingsManager.getGroupMappings()).hasSize(2);
   }
 
   /**

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapUserMappingTest.java

     assertThat(userMapping.getRealNameAttribute()).isEqualTo("cn");
     assertThat(userMapping.getEmailAttribute()).isEqualTo("mail");
 
-    assertThat(userMapping.toString()).isEqualTo("LdapUserMapping{" +
+    assertThat(userMapping).hasToString("LdapUserMapping{" +
       "baseDn=null," +
       " request=(&(objectClass=inetOrgPerson)(uid={0}))," +
       " realNameAttribute=cn," +
     assertThat(search.getParameters()).isEqualTo(new String[] {"tester"});
     assertThat(search.getReturningAttributes()).isNull();
 
-    assertThat(userMapping.toString()).isEqualTo("LdapUserMapping{" +
+    assertThat(userMapping).hasToString("LdapUserMapping{" +
       "baseDn=cn=users," +
       " request=(&(objectClass=user)(sAMAccountName={0}))," +
       " realNameAttribute=cn," +

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapUsersProviderTest.java

 
     details = usersProvider.getUserDetails("without_email");
     assertThat(details.getName()).isEqualTo("Without Email");
-    assertThat(details.getEmail()).isEqualTo("");
+    assertThat(details.getEmail()).isEmpty();
 
     details = usersProvider.getUserDetails("notfound");
     assertThat(details).isNull();

server/sonar-auth-saml/src/test/java/org/sonar/auth/saml/SamlSettingsTest.java

   public void return_user_email_attribute() {
     settings.setProperty("sonar.auth.saml.user.email", "userEmail");
 
-    assertThat(underTest.getUserEmail().get()).isEqualTo("userEmail");
+    assertThat(underTest.getUserEmail()).contains("userEmail");
   }
 
   @Test
   public void return_group_name_attribute() {
     settings.setProperty("sonar.auth.saml.group.name", "groupName");
 
-    assertThat(underTest.getGroupName().get()).isEqualTo("groupName");
+    assertThat(underTest.getGroupName()).contains("groupName");
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/measure/MeasureComputersHolderImpl.java

  */
 package org.sonar.ce.task.projectanalysis.measure;
 
-import com.google.common.base.Predicates;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 import javax.annotation.CheckForNull;
 import org.sonar.ce.task.projectanalysis.api.measurecomputer.MeasureComputerWrapper;
 
 import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.FluentIterable.from;
 import static java.util.Objects.requireNonNull;
 
 public class MeasureComputersHolderImpl implements MutableMeasureComputersHolder {
   public void setMeasureComputers(Iterable<MeasureComputerWrapper> measureComputers) {
     requireNonNull(measureComputers, "Measure computers cannot be null");
     checkState(this.measureComputers == null, "Measure computers have already been initialized");
-    this.measureComputers = from(measureComputers).filter(Predicates.notNull()).toList();
+    this.measureComputers = StreamSupport.stream(measureComputers.spliterator(), false).filter(Objects::nonNull).collect(Collectors.toList());
   }
 }

server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/qualitygate/EvaluationResultTextConverterImpl.java

  */
 package org.sonar.ce.task.projectanalysis.qualitygate;
 
-import com.google.common.collect.ImmutableMap;
 import java.util.Locale;
 import java.util.Map;
 import javax.annotation.CheckForNull;
 import static java.util.Objects.requireNonNull;
 
 public final class EvaluationResultTextConverterImpl implements EvaluationResultTextConverter {
-  private static final Map<Condition.Operator, String> OPERATOR_LABELS = ImmutableMap.of(
+  private static final Map<Condition.Operator, String> OPERATOR_LABELS = Map.of(
     Condition.Operator.GREATER_THAN, ">",
     Condition.Operator.LESS_THAN, "<");
 

server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/source/linereader/SymbolsLineReader.java

 
 public class SymbolsLineReader implements LineReader {
 
-  private static final Logger LOG = Loggers.get(HighlightingLineReader.class);
+  private static final Logger LOG = Loggers.get(SymbolsLineReader.class);
 
   private final Component file;
   private final RangeOffsetConverter rangeOffsetConverter;

server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/step/PersistAnalysisPropertiesStep.java

  */
 package org.sonar.ce.task.projectanalysis.step;
 
-import com.google.common.collect.ImmutableSet;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 public class PersistAnalysisPropertiesStep implements ComputationStep {
 
   private static final String SONAR_PULL_REQUEST = "sonar.pullrequest.";
-  private static final Set<String> ANALYSIS_PROPERTIES_TO_PERSIST = ImmutableSet.of(SONAR_ANALYSIS_DETECTEDSCM, SONAR_ANALYSIS_DETECTEDCI);
+  private static final Set<String> ANALYSIS_PROPERTIES_TO_PERSIST = Set.of(SONAR_ANALYSIS_DETECTEDSCM, SONAR_ANALYSIS_DETECTEDCI);
 
   private final DbClient dbClient;
   private final AnalysisMetadataHolder analysisMetadataHolder;

server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/step/PersistLiveMeasuresStep.java

   /**
    * List of metrics that should not be persisted on file measure.
    */
-  private static final Set<String> NOT_TO_PERSIST_ON_FILE_METRIC_KEYS = unmodifiableSet(new HashSet<>(asList(
-    FILE_COMPLEXITY_DISTRIBUTION_KEY,
-    FUNCTION_COMPLEXITY_DISTRIBUTION_KEY)));
+  private static final Set<String> NOT_TO_PERSIST_ON_FILE_METRIC_KEYS = Set.of(FILE_COMPLEXITY_DISTRIBUTION_KEY, FUNCTION_COMPLEXITY_DISTRIBUTION_KEY);
 
   private final DbClient dbClient;
   private final MetricRepository metricRepository;

server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/step/PersistProjectLinksStep.java

  */
 package org.sonar.ce.task.projectanalysis.step;
 
-import com.google.common.collect.ImmutableMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import static com.google.common.base.Preconditions.checkArgument;
 
 public class PersistProjectLinksStep implements ComputationStep {
-  private static final Map<ComponentLinkType, String> typesConverter = ImmutableMap.of(
+  private static final Map<ComponentLinkType, String> typesConverter = Map.of(
     ComponentLinkType.HOME, ProjectLinkDto.TYPE_HOME_PAGE,
     ComponentLinkType.SCM, ProjectLinkDto.TYPE_SOURCES,
     ComponentLinkType.CI, ProjectLinkDto.TYPE_CI,

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/analysis/AnalysisImplTest.java

 
 public class AnalysisImplTest {
 
-
   private static final long ID = 10;
   private static final String UUID = "uuid ";
   private static final long CREATED_AT = 123456789L;
       .setUuid(UUID)
       .setCreatedAt(CREATED_AT)
       .build().toString())
-        .isEqualTo("Analysis{uuid='uuid ', createdAt=123456789}");
+      .isEqualTo("Analysis{uuid='uuid ', createdAt=123456789}");
   }
 
   @Test
       .setCreatedAt(CREATED_AT)
       .build();
 
-    assertThat(analysis).isEqualTo(analysis);
-    assertThat(analysis).isEqualTo(sameAnalysis);
-    assertThat(analysis).isNotEqualTo(otherAnalysis);
-    assertThat(analysis).isNotEqualTo(null);
-
-    assertThat(analysis.hashCode()).isEqualTo(analysis.hashCode());
-    assertThat(analysis.hashCode()).isEqualTo(sameAnalysis.hashCode());
+    assertThat(analysis)
+      .isEqualTo(analysis)
+      .isEqualTo(sameAnalysis)
+      .isNotEqualTo(otherAnalysis)
+      .isNotNull()
+      .hasSameHashCodeAs(analysis.hashCode())
+      .hasSameHashCodeAs(sameAnalysis.hashCode());
     assertThat(analysis.hashCode()).isNotEqualTo(otherAnalysis.hashCode());
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/analysis/AnalysisMetadataHolderImplTest.java

 
     underTest.setCrossProjectDuplicationEnabled(true);
 
-    assertThat(underTest.isCrossProjectDuplicationEnabled()).isEqualTo(true);
+    assertThat(underTest.isCrossProjectDuplicationEnabled()).isTrue();
   }
 
   @Test
 
     underTest.setCrossProjectDuplicationEnabled(false);
 
-    assertThat(underTest.isCrossProjectDuplicationEnabled()).isEqualTo(false);
+    assertThat(underTest.isCrossProjectDuplicationEnabled()).isFalse();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/analysis/ScannerPluginTest.java

   public void verify_toString() {
     ScannerPlugin plugin = new ScannerPlugin("key", "base", 12345L);
 
-    assertThat(plugin.toString()).isEqualTo("ScannerPlugin{key='key', basePluginKey='base', updatedAt='12345'}");
+    assertThat(plugin).hasToString("ScannerPlugin{key='key', basePluginKey='base', updatedAt='12345'}");
   }
 
   @Test
   public void equals_is_based_on_key_only() {
     ScannerPlugin plugin = new ScannerPlugin("key", "base", 12345L);
 
-    assertThat(plugin).isEqualTo(plugin);
-    assertThat(plugin).isEqualTo(new ScannerPlugin("key", null, 45678L));
-    assertThat(plugin).isNotEqualTo(new ScannerPlugin("key2", "base", 12345L));
-    assertThat(plugin).isNotEqualTo(null);
-    assertThat(plugin).isNotEqualTo("toto");
+    assertThat(plugin)
+      .isEqualTo(plugin)
+      .isEqualTo(new ScannerPlugin("key", null, 45678L))
+      .isNotEqualTo(new ScannerPlugin("key2", "base", 12345L))
+      .isNotNull()
+      .isNotEqualTo("toto");
   }
 
   @Test
   public void hashcode_is_based_on_key_only() {
     ScannerPlugin plugin = new ScannerPlugin("key", "base", 12345L);
 
-    assertThat(plugin.hashCode()).isEqualTo("key".hashCode());
+    assertThat(plugin).hasSameHashCodeAs("key");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/measurecomputer/ComponentImplTest.java

     ComponentImpl sameComponent = new ComponentImpl("Project1", Component.Type.PROJECT, null);
     ComponentImpl anotherComponent = new ComponentImpl("Project2", Component.Type.PROJECT, null);
 
-    assertThat(component).isEqualTo(component);
-    assertThat(component).isEqualTo(sameComponent);
-    assertThat(component).isNotEqualTo(anotherComponent);
-    assertThat(component).isNotEqualTo(null);
-
-    assertThat(component.hashCode()).isEqualTo(component.hashCode());
-    assertThat(component.hashCode()).isEqualTo(sameComponent.hashCode());
+    assertThat(component)
+      .isEqualTo(component)
+      .isEqualTo(sameComponent)
+      .isNotEqualTo(anotherComponent)
+      .isNotNull()
+      .hasSameHashCodeAs(component)
+      .hasSameHashCodeAs(sameComponent);
     assertThat(component.hashCode()).isNotEqualTo(anotherComponent.hashCode());
   }
 
   @Test
   public void test_to_string() {
-    assertThat(new ComponentImpl("File", Component.Type.FILE, new ComponentImpl.FileAttributesImpl("xoo", true)).toString())
-      .isEqualTo("ComponentImpl{key=File, type='FILE', fileAttributes=FileAttributesImpl{languageKey='xoo', unitTest=true}}");
+    assertThat(new ComponentImpl("File", Component.Type.FILE, new ComponentImpl.FileAttributesImpl("xoo", true)))
+      .hasToString("ComponentImpl{key=File, type='FILE', fileAttributes=FileAttributesImpl{languageKey='xoo', unitTest=true}}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/measurecomputer/MeasureComputerContextImplTest.java

       .setSeverity("MAJOR")
       .setStatus("CLOSED")
       .setResolution("FIXED")
-      .setEffort(Duration.create(10l));
+      .setEffort(Duration.create(10L));
 
     MeasureComputerContextImpl underTest = newContext(PROJECT_REF, Arrays.asList(issue));
 
     assertThat(result.severity()).isEqualTo("MAJOR");
     assertThat(result.status()).isEqualTo("CLOSED");
     assertThat(result.resolution()).isEqualTo("FIXED");
-    assertThat(result.effort()).isEqualTo(Duration.create(10l));
+    assertThat(result.effort()).isEqualTo(Duration.create(10L));
   }
 
   private MeasureComputerContextImpl newContext(int componentRef) {

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/measurecomputer/MeasureComputerDefinitionImplTest.java

     assertThat(computer).isEqualTo(computer)
       .isEqualTo(sameComputer)
       .isNotEqualTo(anotherComputer)
-      .isNotEqualTo(null);
+      .isNotNull();
 
     assertThat(computer)
       .hasSameHashCodeAs(computer)

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/measurecomputer/MeasureImplTest.java

   @Test
   public void get_int_value() {
     MeasureImpl measure = new MeasureImpl(Measure.newMeasureBuilder().create(1));
-    assertThat(measure.getIntValue()).isEqualTo(1);
+    assertThat(measure.getIntValue()).isOne();
   }
 
   @Test
   @Test
   public void get_long_value() {
     MeasureImpl measure = new MeasureImpl(Measure.newMeasureBuilder().create(1L));
-    assertThat(measure.getLongValue()).isEqualTo(1L);
+    assertThat(measure.getLongValue()).isOne();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/posttask/CeTaskImplTest.java

 
   @Test
   public void verify_toString() {
-    assertThat(new CeTaskImpl(SOME_ID, CeTask.Status.SUCCESS).toString()).isEqualTo("CeTaskImpl{id='some id', status=SUCCESS}");
+    assertThat(new CeTaskImpl(SOME_ID, CeTask.Status.SUCCESS)).hasToString("CeTaskImpl{id='some id', status=SUCCESS}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/posttask/ConditionImplTest.java

 
   @Test
   public void toString_ConditionImpl_of_type_different_from_NO_VALUE() {
-    assertThat(builder.build().toString())
-      .isEqualTo(
+    assertThat(builder.build())
+      .hasToString(
         "ConditionImpl{status=OK, metricKey='metricKey', operator=GREATER_THAN, errorThreshold='error threshold', value='value'}");
   }
 
     builder.setStatus(QualityGate.EvaluationStatus.NO_VALUE)
       .setValue(null);
 
-    assertThat(builder.build().toString())
-      .isEqualTo(
+    assertThat(builder.build())
+      .hasToString(
         "ConditionImpl{status=NO_VALUE, metricKey='metricKey', operator=GREATER_THAN, errorThreshold='error threshold', value='null'}");
   }
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/posttask/ProjectImplTest.java

 
   @Test
   public void verify_toString() {
-    assertThat(new ProjectImpl(SOME_UUID, SOME_KEY, SOME_NAME).toString())
-      .isEqualTo("ProjectImpl{uuid='some uuid', key='some key', name='some name'}");
+    assertThat(new ProjectImpl(SOME_UUID, SOME_KEY, SOME_NAME))
+      .hasToString("ProjectImpl{uuid='some uuid', key='some key', name='some name'}");
 
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/api/posttask/QualityGateImplTest.java

   public void verify_toString() {
     when(condition.toString()).thenReturn("{Condition}");
 
-    assertThat(underTest.toString())
-      .isEqualTo("QualityGateImpl{id='some id', name='some name', status=OK, conditions=[{Condition}]}");
+    assertThat(underTest)
+      .hasToString("QualityGateImpl{id='some id', name='some name', status=OK, conditions=[{Condition}]}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/component/CallRecorderPathAwareVisitor.java

  */
 package org.sonar.ce.task.projectanalysis.component;
 
-import com.google.common.base.Function;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.NoSuchElementException;
-import javax.annotation.Nonnull;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.FluentIterable.from;
 
 class CallRecorderPathAwareVisitor extends PathAwareVisitorAdapter<Integer> {
   final List<PathAwareCallRecord> callsRecords = new ArrayList<>();
   }
 
   private static List<Integer> toValueList(Path<Integer> path) {
-    return from(path.getCurrentPath()).transform(new Function<PathElement<Integer>, Integer>() {
-      @Nonnull
-      @Override
-      public Integer apply(@Nonnull PathElement<Integer> input) {
-        return input.getElement();
-      }
-    }).toList();
+    return StreamSupport.stream(path.getCurrentPath().spliterator(), false).map(PathElement::getElement).collect(Collectors.toList());
   }
 
   private static Integer getParent(Path<Integer> path) {

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/component/ComponentImplTest.java

   public void hashCode_is_hashcode_of_uuid() {
     ComponentImpl.Builder builder = buildSimpleComponent(FILE, "1").setUuid(UUID);
 
-    assertThat(builder.build().hashCode()).isEqualTo(builder.build().hashCode());
-    assertThat(builder.build().hashCode()).isEqualTo(buildSimpleComponent(FILE, "2").setUuid(UUID).build().hashCode());
-    assertThat(builder.build().hashCode()).isEqualTo(UUID.hashCode());
+    assertThat(builder.build()).hasSameHashCodeAs(builder.build().hashCode());
+    assertThat(builder.build()).hasSameHashCodeAs(buildSimpleComponent(FILE, "2").setUuid(UUID).build().hashCode());
+    assertThat(builder.build()).hasSameHashCodeAs(UUID.hashCode());
   }
 
   private static ComponentImpl.Builder buildSimpleComponent(Component.Type type, String dbKey) {

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/component/ComponentTreeBuilderTest.java

     Component root = call(project);
     Component dir = root.getChildren().iterator().next();
     Component file = dir.getChildren().iterator().next();
-    assertThat(file.getFileAttributes().getLines()).isEqualTo(1);
+    assertThat(file.getFileAttributes().getLines()).isOne();
     assertThat(file.getFileAttributes().getLanguageKey()).isNull();
     assertThat(file.getFileAttributes().isUnitTest()).isFalse();
   }
     Component root = call(project);
     Component dir = root.getChildren().iterator().next();
     Component file = dir.getChildren().iterator().next();
-    assertThat(file.getFileAttributes().getLines()).isEqualTo(1);
+    assertThat(file.getFileAttributes().getLines()).isOne();
     assertThat(file.getFileAttributes().getLanguageKey()).isEqualTo("js");
     assertThat(file.getFileAttributes().isUnitTest()).isTrue();
   }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/component/FileAttributesTest.java

 
   @Test
   public void test_toString() {
-    assertThat(new FileAttributes(true, "java", 10).toString()).isEqualTo("FileAttributes{languageKey='java', unitTest=true, lines=10}");
-    assertThat(new FileAttributes(false, null, 1).toString()).isEqualTo("FileAttributes{languageKey='null', unitTest=false, lines=1}");
+    assertThat(new FileAttributes(true, "java", 10)).hasToString("FileAttributes{languageKey='java', unitTest=true, lines=10}");
+    assertThat(new FileAttributes(false, null, 1)).hasToString("FileAttributes{languageKey='null', unitTest=false, lines=1}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/container/ProjectAnalysisTaskContainerPopulatorTest.java

 package org.sonar.ce.task.projectanalysis.container;
 
 import com.google.common.base.Function;
-import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableList;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import org.sonar.core.platform.ComponentContainer;
 import org.sonar.core.util.stream.MoreCollectors;
 
-import static com.google.common.collect.FluentIterable.from;
 import static com.google.common.collect.Sets.difference;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
     @Override
     public <T> List<T> getComponentsByType(final Class<T> type) {
-      return from(added)
-        .filter(new Predicate<Object>() {
-          @Override
-          public boolean apply(@Nonnull Object input) {
-            return input.getClass().getSimpleName().contains(type.getSimpleName());
-          }
-        }).transform(new Function<Object, T>() {
-          @Override
-          @Nonnull
-          public T apply(@Nonnull Object input) {
-            return (T) input;
-          }
-        }).toList();
+      return added.stream()
+        .filter(input -> input.getClass().getSimpleName().contains(type.getSimpleName()))
+        .map(input -> (T) input)
+        .collect(Collectors.toList());
     }
   }
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/duplication/CrossProjectDuplicateTest.java

   @Test
   public void hashcode_depends_on_file_and_TextBlock() {
     TextBlock textBlock = new TextBlock(1, 2);
-    assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode()).isEqualTo(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode());
+    assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock)).hasSameHashCodeAs(new CrossProjectDuplicate(FILE_KEY_1, textBlock));
 
     assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode()).isNotEqualTo(new CrossProjectDuplicate(FILE_KEY_2, textBlock).hashCode());
     assertThat(new CrossProjectDuplicate(FILE_KEY_1, textBlock).hashCode()).isNotEqualTo(new CrossProjectDuplicate(FILE_KEY_2, new TextBlock(1, 1)).hashCode());
 
   @Test
   public void verify_toString() {
-    assertThat(new CrossProjectDuplicate(FILE_KEY_1, new TextBlock(1, 2)).toString()).isEqualTo("CrossProjectDuplicate{fileKey='file key 1', textBlock=TextBlock{start=1, end=2}}");
+    assertThat(new CrossProjectDuplicate(FILE_KEY_1, new TextBlock(1, 2))).hasToString("CrossProjectDuplicate{fileKey='file key 1', textBlock=TextBlock{start=1, end=2}}");
   }
 
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/duplication/DuplicationRepositoryRule.java

  */
 package org.sonar.ce.task.projectanalysis.duplication;
 
-import com.google.common.base.Function;
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.Multimap;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.stream.Collectors;
 import javax.annotation.CheckForNull;
-import javax.annotation.Nonnull;
 import org.junit.rules.ExternalResource;
 import org.sonar.ce.task.projectanalysis.component.Component;
 import org.sonar.ce.task.projectanalysis.component.ComponentProvider;
 import org.sonar.ce.task.projectanalysis.component.TreeRootHolderRule;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.FluentIterable.from;
 import static java.util.Objects.requireNonNull;
 
 public class DuplicationRepositoryRule extends ExternalResource implements DuplicationRepository {
       component,
       new Duplication(
         original,
-        from(Arrays.asList(duplicates)).transform(TextBlockToInnerDuplicate.INSTANCE).toList()));
+        Arrays.stream(duplicates).map(InnerDuplicate::new).collect(Collectors.toList())));
 
     return this;
   }
     requireNonNull(this.componentProvider, "Methods with component reference can not be used unless a TreeRootHolder has been provided when instantiating the rule");
     this.componentProvider.ensureInitialized();
   }
-
-  private enum TextBlockToInnerDuplicate implements Function<TextBlock, Duplicate> {
-    INSTANCE;
-
-    @Override
-    @Nonnull
-    public Duplicate apply(@Nonnull TextBlock input) {
-      return new InnerDuplicate(input);
-    }
-  }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/duplication/DuplicationTest.java

   public void hashcode_is_based_on_original_only() {
     Duplication duplication = new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_1)));
 
-    assertThat(duplication.hashCode()).isEqualTo(new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_1))).hashCode());
+    assertThat(duplication).hasSameHashCodeAs(new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_1))));
     assertThat(duplication.hashCode()).isNotEqualTo(new Duplication(SOME_ORIGINAL_TEXTBLOCK, Arrays.asList(new InnerDuplicate(TEXT_BLOCK_2))).hashCode());
     assertThat(duplication.hashCode()).isNotEqualTo(new Duplication(TEXT_BLOCK_1, Arrays.asList(new InnerDuplicate(SOME_ORIGINAL_TEXTBLOCK))).hashCode());
   }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/duplication/InProjectDuplicateTest.java

   @Test
   public void hashcode_depends_on_file_and_TextBlock() {
     TextBlock textBlock = new TextBlock(1, 2);
-    assertThat(new InProjectDuplicate(FILE_1, textBlock).hashCode()).isEqualTo(new InProjectDuplicate(FILE_1, textBlock).hashCode());
+    assertThat(new InProjectDuplicate(FILE_1, textBlock)).hasSameHashCodeAs(new InProjectDuplicate(FILE_1, textBlock));
 
     assertThat(new InProjectDuplicate(FILE_1, textBlock).hashCode()).isNotEqualTo(new InProjectDuplicate(FILE_2, textBlock).hashCode());
     assertThat(new InProjectDuplicate(FILE_1, textBlock).hashCode()).isNotEqualTo(new InProjectDuplicate(FILE_2, new TextBlock(1, 1)).hashCode());

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/duplication/InnerDuplicateTest.java

   @Test
   public void hashcode_is_TextBlock_hashcode() {
     TextBlock textBlock = new TextBlock(1, 2);
-    assertThat(new InnerDuplicate(textBlock).hashCode()).isEqualTo(textBlock.hashCode());
+    assertThat(new InnerDuplicate(textBlock)).hasSameHashCodeAs(textBlock);
   }
 
   @Test
   public void verify_toString() {
-    assertThat(new InnerDuplicate(new TextBlock(1, 2)).toString()).isEqualTo("InnerDuplicate{textBlock=TextBlock{start=1, end=2}}");
+    assertThat(new InnerDuplicate(new TextBlock(1, 2))).hasToString("InnerDuplicate{textBlock=TextBlock{start=1, end=2}}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/duplication/TextBlockTest.java

 
   @Test
   public void hashcode_is_based__on_start_and_end() {
-    assertThat(new TextBlock(15, 15).hashCode()).isEqualTo(new TextBlock(15, 15).hashCode());
-    assertThat(new TextBlock(15, 300).hashCode()).isEqualTo(new TextBlock(15, 300).hashCode());
+    assertThat(new TextBlock(15, 15)).hasSameHashCodeAs(new TextBlock(15, 15));
+    assertThat(new TextBlock(15, 300)).hasSameHashCodeAs(new TextBlock(15, 300));
     assertThat(new TextBlock(15, 300).hashCode()).isNotEqualTo(new TextBlock(15, 15).hashCode());
   }
 
 
   @Test
   public void verify_toString() {
-    assertThat(new TextBlock(13, 400).toString()).isEqualTo("TextBlock{start=13, end=400}");
+    assertThat(new TextBlock(13, 400)).hasToString("TextBlock{start=13, end=400}");
 
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/event/EventTest.java

   @Test
   public void same_name_and_category_make_equal_events() {
     Event source = Event.createAlert(SOME_NAME, null, null);
-    assertThat(source).isEqualTo(Event.createAlert(SOME_NAME, null, null));
-    assertThat(source).isEqualTo(source);
-    assertThat(source).isNotEqualTo(null);
+    assertThat(source)
+      .isEqualTo(Event.createAlert(SOME_NAME, null, null))
+      .isEqualTo(source)
+      .isNotNull();
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/filemove/FileMoveDetectionStepTest.java

 
     assertThat(movedFilesRepository.getComponentsWithOriginal()).isEmpty();
     assertThat(scoreMatrixDumper.scoreMatrix.getMaxScore())
-      .isGreaterThan(0)
+      .isPositive()
       .isLessThan(MIN_REQUIRED_SCORE);
     assertThat(addedFileRepository.getComponents()).contains(file2);
     verifyStatistics(context, 1, 1, 1, 0);

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/filemove/MatchTest.java

 
   @Test
   public void toString_prints_both_properties() {
-    assertThat(underTest.toString()).isEqualTo("{key=>reportKey}");
+    assertThat(underTest).hasToString("{key=>reportKey}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/formula/counter/LongValueTest.java

 
   private static void verifyUnsetVariationValue(LongValue variationValue) {
     assertThat(variationValue.isSet()).isFalse();
-    assertThat(variationValue.getValue()).isEqualTo(0L);
+    assertThat(variationValue.getValue()).isZero();
   }
 
   private static void verifySetVariationValue(LongValue variationValue, long expected) {

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/formula/coverage/CoverageUtilsTest.java

 
   @Test
   public void getLongMeasureValue_returns_0_if_measure_does_not_exist() {
-    assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isEqualTo(0L);
+    assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isZero();
   }
 
   @Test
   public void getLongMeasureValue_returns_0_if_measure_is_NO_VALUE() {
     fileAggregateContext.put(SOME_METRIC_KEY, newMeasureBuilder().createNoValue());
 
-    assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isEqualTo(0L);
+    assertThat(getLongMeasureValue(fileAggregateContext, SOME_METRIC_KEY)).isZero();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/issue/DebtCalculatorTest.java

   public void copy_effort_for_external_issues() {
     issue.setGap(null);
     issue.setIsFromExternalRuleEngine(true);
-    issue.setEffort(Duration.create(20l));
+    issue.setEffort(Duration.create(20L));
     rule.setFunction(null);
 
-    assertThat(underTest.calculate(issue).toMinutes()).isEqualTo(20l);
+    assertThat(underTest.calculate(issue).toMinutes()).isEqualTo(20L);
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/issue/NewAdHocRuleTest.java

     NewAdHocRule adHocRule2 = new NewAdHocRule(ScannerReport.ExternalIssue.newBuilder().setEngineId("eslint").setRuleId("no-cond-assign").build());
     NewAdHocRule anotherAdHocRule = new NewAdHocRule(ScannerReport.ExternalIssue.newBuilder().setEngineId("eslint").setRuleId("another").build());
 
-    assertThat(adHocRule1).isEqualTo(adHocRule1);
-    assertThat(adHocRule1).isEqualTo(adHocRule2);
-    assertThat(adHocRule1).isNotEqualTo(null);
-    assertThat(adHocRule1).isNotEqualTo(anotherAdHocRule);
-
-    assertThat(adHocRule1.hashCode()).isEqualTo(adHocRule1.hashCode());
-    assertThat(adHocRule1.hashCode()).isEqualTo(adHocRule2.hashCode());
+    assertThat(adHocRule1)
+      .isEqualTo(adHocRule1)
+      .isEqualTo(adHocRule2)
+      .isNotNull()
+      .isNotEqualTo(anotherAdHocRule)
+      .hasSameHashCodeAs(adHocRule1)
+      .hasSameHashCodeAs(adHocRule2);
     assertThat(adHocRule1.hashCode()).isNotEqualTo(anotherAdHocRule.hashCode());
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/issue/TrackerRawInputFactoryTest.java

       .setEngineId("eslint")
       .setRuleId("S001")
       .setSeverity(Constants.Severity.BLOCKER)
-      .setEffort(20l)
+      .setEffort(20L)
       .setType(issueType)
       .build();
     reportReader.putExternalIssues(FILE.getReportAttributes().getRef(), asList(reportIssue));
     assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("external_eslint", "S001"));
     assertThat(issue.severity()).isEqualTo(Severity.BLOCKER);
     assertThat(issue.line()).isEqualTo(2);
-    assertThat(issue.effort()).isEqualTo(Duration.create(20l));
+    assertThat(issue.effort()).isEqualTo(Duration.create(20L));
     assertThat(issue.message()).isEqualTo("the message");
     assertThat(issue.type()).isEqualTo(expectedRuleType);
 
     assertThat(issue.ruleKey()).isEqualTo(RuleKey.of("external_eslint", "S001"));
     assertThat(issue.severity()).isEqualTo(Severity.BLOCKER);
     assertThat(issue.line()).isEqualTo(2);
-    assertThat(issue.effort()).isEqualTo(Duration.create(0l));
+    assertThat(issue.effort()).isEqualTo(Duration.create(0L));
     assertThat(issue.message()).isEqualTo("the message");
     assertThat(issue.type()).isEqualTo(expectedRuleType);
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/issue/filter/IssuePatternTest.java

   public void test_to_string() {
     IssuePattern pattern = new IssuePattern("*", "checkstyle:*");
 
-    assertThat(pattern.toString()).isEqualTo(
+    assertThat(pattern).hasToString(
       "IssuePattern{componentPattern=*, rulePattern=checkstyle:*}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/language/HandleUnanalyzedLanguagesStepTest.java

       "1 unanalyzed C++ file was detected in this project during the last analysis. C++ cannot be analyzed with your current SonarQube edition. Please" +
         " consider <a target=\"_blank\" href=\"https://www.sonarqube.org/trial-request/developer-edition/?referrer=sonarqube-cpp\">upgrading to Developer" +
         " Edition</a> to find Bugs, Code Smells, Vulnerabilities and Security Hotspots in this file.");
-    assertThat(measureRepository.getAddedRawMeasure(PROJECT_REF, UNANALYZED_CPP_KEY).get().getIntValue()).isEqualTo(1);
+    assertThat(measureRepository.getAddedRawMeasure(PROJECT_REF, UNANALYZED_CPP_KEY).get().getIntValue()).isOne();
     assertThat(measureRepository.getAddedRawMeasure(PROJECT_REF, UNANALYZED_C_KEY)).isEmpty();
   }
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/language/LanguageRepositoryImplTest.java

 
   @Test
   public void find_on_empty_LanguageRepository_returns_absent() {
-    assertThat(new LanguageRepositoryImpl().find(ANY_KEY).isPresent()).isFalse();
+    assertThat(new LanguageRepositoryImpl().find(ANY_KEY)).isEmpty();
   }
 
   @Test
   public void find_by_key_returns_the_same_object() {
     LanguageRepositoryImpl languageRepository = new LanguageRepositoryImpl(SOME_LANGUAGE);
     Optional<Language> language = languageRepository.find(SOME_LANGUAGE_KEY);
-    assertThat(language.isPresent()).isTrue();
+    assertThat(language).isPresent();
     assertThat(language.get()).isSameAs(SOME_LANGUAGE);
   }
 
   public void find_by_other_key_returns_absent() {
     LanguageRepositoryImpl languageRepository = new LanguageRepositoryImpl(SOME_LANGUAGE);
     Optional<Language> language = languageRepository.find(ANY_KEY);
-    assertThat(language.isPresent()).isFalse();
+    assertThat(language).isEmpty();
   }
 
   private static Language createLanguage(final String key, final String nameSuffix) {

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/measure/BatchMeasureToMeasureTest.java

   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Int_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_INT_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
 
     Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_INT_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT);
     assertThat(measure.get().getIntValue()).isEqualTo(10);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Long_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   @Test
   public void toMeasure_returns_long_part_of_value_in_dto_for_Long_Metric() {
-    Optional<Measure> measure = underTest.toMeasure(ScannerReport.Measure.newBuilder().setLongValue(LongValue.newBuilder().setValue(15l)).build(), SOME_LONG_METRIC);
+    Optional<Measure> measure = underTest.toMeasure(ScannerReport.Measure.newBuilder().setLongValue(LongValue.newBuilder().setValue(15L)).build(), SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG);
     assertThat(measure.get().getLongValue()).isEqualTo(15);
   }
   @Test
   public void toMeasure_maps_data_and_alert_properties_in_dto_for_Long_Metric() {
     ScannerReport.Measure batchMeasure = ScannerReport.Measure.newBuilder()
-      .setLongValue(LongValue.newBuilder().setValue(10l).setData(SOME_DATA))
+      .setLongValue(LongValue.newBuilder().setValue(10L).setData(SOME_DATA))
       .build();
 
     Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG);
     assertThat(measure.get().getLongValue()).isEqualTo(10);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Double_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_DOUBLE_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
 
     Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_DOUBLE_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.DOUBLE);
     assertThat(measure.get().getDoubleValue()).isEqualTo(10.6395d);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Boolean_metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   private void verify_toMeasure_returns_false_value_if_dto_has_invalid_value_for_Boolean_metric(boolean expected) {
     Optional<Measure> measure = underTest.toMeasure(ScannerReport.Measure.newBuilder().setBooleanValue(BoolValue.newBuilder().setValue(expected)).build(), SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN);
     assertThat(measure.get().getBooleanValue()).isEqualTo(expected);
   }
 
     Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN);
     assertThat(measure.get().getBooleanValue()).isTrue();
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_String_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_BATCH_MEASURE, SOME_STRING_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
 
     Optional<Measure> measure = underTest.toMeasure(batchMeasure, SOME_STRING_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.STRING);
     assertThat(measure.get().getStringValue()).isEqualTo(SOME_DATA);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/measure/LiveMeasureDtoToMeasureTest.java

   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Int_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_INT_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   public void toMeasure_returns_int_part_of_value_in_dto_for_Int_Metric() {
     Optional<Measure> measure = underTest.toMeasure(new LiveMeasureDto().setValue(1.5d), SOME_INT_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT);
-    assertThat(measure.get().getIntValue()).isEqualTo(1);
+    assertThat(measure.get().getIntValue()).isOne();
   }
 
   @Test
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Long_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   public void toMeasure_returns_long_part_of_value_in_dto_for_Long_Metric() {
     Optional<Measure> measure = underTest.toMeasure(new LiveMeasureDto().setValue(1.5d), SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG);
-    assertThat(measure.get().getLongValue()).isEqualTo(1);
+    assertThat(measure.get().getLongValue()).isOne();
   }
 
   @Test
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Double_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_DOUBLE_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Boolean_metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   public void toMeasure_returns_false_value_if_dto_has_invalid_value_for_Boolean_metric() {
     Optional<Measure> measure = underTest.toMeasure(new LiveMeasureDto().setValue(1.987d), SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN);
     assertThat(measure.get().getBooleanValue()).isFalse();
   }
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_String_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_STRING_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   @Test
   @UseDataProvider("all_types_LiveMeasureDtos")
   public void toMeasure_creates_MeasureVariation_and_maps_the_right_one(LiveMeasureDto builder, Metric metric) {
-    assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isEqualTo(1);
+    assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isOne();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/measure/MapBasedRawMeasureRepositoryTest.java

 
   private static final List<Measure> MEASURES = ImmutableList.of(
     Measure.newMeasureBuilder().create(1),
-    Measure.newMeasureBuilder().create(1l),
+    Measure.newMeasureBuilder().create(1L),
     Measure.newMeasureBuilder().create(1d, 1),
     Measure.newMeasureBuilder().create(true),
     Measure.newMeasureBuilder().create(false),

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/measure/MeasureDtoToMeasureTest.java

   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Int_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_INT_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   public void toMeasure_returns_int_part_of_value_in_dto_for_Int_Metric() {
     Optional<Measure> measure = underTest.toMeasure(new MeasureDto().setValue(1.5d), SOME_INT_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT);
-    assertThat(measure.get().getIntValue()).isEqualTo(1);
+    assertThat(measure.get().getIntValue()).isOne();
   }
 
   @Test
 
     Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_INT_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.INT);
     assertThat(measure.get().getIntValue()).isEqualTo(10);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Long_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   public void toMeasure_returns_long_part_of_value_in_dto_for_Long_Metric() {
     Optional<Measure> measure = underTest.toMeasure(new MeasureDto().setValue(1.5d), SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG);
-    assertThat(measure.get().getLongValue()).isEqualTo(1);
+    assertThat(measure.get().getLongValue()).isOne();
   }
 
   @Test
 
     Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_LONG_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.LONG);
     assertThat(measure.get().getLongValue()).isEqualTo(10);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Double_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_DOUBLE_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
 
     Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_DOUBLE_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.DOUBLE);
     assertThat(measure.get().getDoubleValue()).isEqualTo(10.6395d);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_Boolean_metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
   public void toMeasure_returns_false_value_if_dto_has_invalid_value_for_Boolean_metric() {
     Optional<Measure> measure = underTest.toMeasure(new MeasureDto().setValue(1.987d), SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN);
     assertThat(measure.get().getBooleanValue()).isFalse();
   }
 
     Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_BOOLEAN_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.BOOLEAN);
     assertThat(measure.get().getBooleanValue()).isTrue();
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   public void toMeasure_returns_no_value_if_dto_has_no_value_for_String_Metric() {
     Optional<Measure> measure = underTest.toMeasure(EMPTY_MEASURE_DTO, SOME_STRING_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.NO_VALUE);
   }
 
 
     Optional<Measure> measure = underTest.toMeasure(measureDto, SOME_STRING_METRIC);
 
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getValueType()).isEqualTo(Measure.ValueType.STRING);
     assertThat(measure.get().getStringValue()).isEqualTo(SOME_DATA);
     assertThat(measure.get().getData()).isEqualTo(SOME_DATA);
   @Test
   @UseDataProvider("all_types_MeasureDtos")
   public void toMeasure_creates_MeasureVariation_and_maps_the_right_one(MeasureDto builder, Metric metric) {
-    assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isEqualTo(1);
+    assertThat(underTest.toMeasure(builder.setVariation(1d), metric).get().getVariation()).isOne();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/measure/MeasureRepositoryImplTest.java

 
   private static final List<Measure> MEASURES = ImmutableList.of(
     Measure.newMeasureBuilder().create(1),
-    Measure.newMeasureBuilder().create(1l),
+    Measure.newMeasureBuilder().create(1L),
     Measure.newMeasureBuilder().create(1d, 1),
     Measure.newMeasureBuilder().create(true),
     Measure.newMeasureBuilder().create(false),
   }
 
   private Measure getSomeMeasureByValueType(final Metric.MetricType metricType) {
-    return from(MEASURES).filter(input -> input.getValueType() == metricType.getValueType()).first().get();
+    return MEASURES.stream().filter(input -> input.getValueType() == metricType.getValueType()).findFirst().get();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/measure/MeasureTest.java

 public class MeasureTest {
 
   private static final Measure INT_MEASURE = newMeasureBuilder().create(1);
-  private static final Measure LONG_MEASURE = newMeasureBuilder().create(1l);
+  private static final Measure LONG_MEASURE = newMeasureBuilder().create(1L);
   private static final Measure DOUBLE_MEASURE = newMeasureBuilder().create(1d, 1);
   private static final Measure STRING_MEASURE = newMeasureBuilder().create("some_sT ring");
   private static final Measure TRUE_MEASURE = newMeasureBuilder().create(true);
 
   @Test
   public void getIntValue_returns_value_for_INT_value_type() {
-    assertThat(INT_MEASURE.getIntValue()).isEqualTo(1);
+    assertThat(INT_MEASURE.getIntValue()).isOne();
   }
 
   @Test
 
   @Test
   public void getLongValue_returns_value_for_LONG_value_type() {
-    assertThat(LONG_MEASURE.getLongValue()).isEqualTo(1);
+    assertThat(LONG_MEASURE.getLongValue()).isOne();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/measure/QualityGateStatusTest.java

       assertThat(status).isEqualTo(new QualityGateStatus(level, null));
       assertThat(status).isNotEqualTo(new QualityGateStatus(level, "bar"));
       assertThat(status).isNotEqualTo(new QualityGateStatus(level, ""));
-      assertThat(status).isNotEqualTo(null);
+      assertThat(status).isNotNull();
     }
   }
 
   @Test
   public void verify_toString() {
-    assertThat(new QualityGateStatus(Measure.Level.OK, "foo").toString()).isEqualTo("QualityGateStatus{status=OK, text=foo}");
+    assertThat(new QualityGateStatus(Measure.Level.OK, "foo")).hasToString("QualityGateStatus{status=OK, text=foo}");
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/period/PeriodTest.java

   public void equals_is_done_on_all_fields() {
     Period period = new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034400000L);
 
-    assertThat(period).isEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034400000L));
-
-    assertThat(period).isNotEqualTo(null);
-    assertThat(period).isNotEqualTo("sdsd");
-    assertThat(period).isNotEqualTo(new Period(NewCodePeriodType.PREVIOUS_VERSION.name(), "2.3", 1420034400000L));
-    assertThat(period).isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.4", 1420034400000L));
-    assertThat(period).isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034410000L));
+    assertThat(period)
+      .isEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034400000L))
+      .isNotNull()
+      .isNotEqualTo("sdsd")
+      .isNotEqualTo(new Period(NewCodePeriodType.PREVIOUS_VERSION.name(), "2.3", 1420034400000L))
+      .isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.4", 1420034400000L))
+      .isNotEqualTo(new Period(NewCodePeriodType.NUMBER_OF_DAYS.name(), "2.3", 1420034410000L));
 
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/qualitygate/ConditionEvaluatorTest.java

   @Test
   public void getLevel_throws_IEA_if_error_threshold_is_not_parsable_long() {
     Metric metric = createMetric(WORK_DUR);
-    Measure measure = newMeasureBuilder().create(60l, null);
+    Measure measure = newMeasureBuilder().create(60L, null);
 
     assertThatThrownBy(() -> underTest.evaluate(createCondition(metric, LESS_THAN, "polop"), measure))
       .isInstanceOf(IllegalArgumentException.class)

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/qualitygate/ConditionStatusTest.java

 
   @Test
   public void verify_toString() {
-    assertThat(ConditionStatus.create(OK, SOME_VALUE).toString()).isEqualTo("ConditionStatus{status=OK, value='value'}");
-    assertThat(ConditionStatus.NO_VALUE_STATUS.toString()).isEqualTo("ConditionStatus{status=NO_VALUE, value='null'}");
+    assertThat(ConditionStatus.create(OK, SOME_VALUE)).hasToString("ConditionStatus{status=OK, value='value'}");
+    assertThat(ConditionStatus.NO_VALUE_STATUS).hasToString("ConditionStatus{status=NO_VALUE, value='null'}");
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/qualitymodel/NewMaintainabilityMeasuresVisitorTest.java

   private static final double[] RATING_GRID = new double[] {0.1, 0.2, 0.5, 1};
 
   private static final String LANGUAGE_1_KEY = "language 1 key";
-  private static final long LANGUAGE_1_DEV_COST = 30l;
+  private static final long LANGUAGE_1_DEV_COST = 30L;
   private static final int ROOT_REF = 1;
   private static final int LANGUAGE_1_FILE_REF = 11111;
   private static final Offset<Double> VARIATION_COMPARISON_OFFSET = Offset.offset(0.01);

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/qualitymodel/NewReliabilityAndSecurityRatingMeasuresVisitorTest.java

 
 public class NewReliabilityAndSecurityRatingMeasuresVisitorTest {
 
-  private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323l;
-  private static final Date DEFAULT_ISSUE_CREATION_DATE = new Date(1000l);
+  private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323L;
+  private static final Date DEFAULT_ISSUE_CREATION_DATE = new Date(1000L);
   private static final Date BEFORE_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC - 5000L);
   private static final Date AFTER_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC + 5000L);
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/qualitymodel/NewSecurityReviewMeasuresVisitorTest.java

 
   private static final Offset<Double> VARIATION_COMPARISON_OFFSET = Offset.offset(0.01);
 
-  private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323l;
-  private static final Date DEFAULT_CREATION_DATE = new Date(1000l);
+  private static final long LEAK_PERIOD_SNAPSHOT_IN_MILLISEC = 12323L;
+  private static final Date DEFAULT_CREATION_DATE = new Date(1000L);
   private static final Date BEFORE_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC - 5000L);
   private static final Date AFTER_LEAK_PERIOD_DATE = new Date(LEAK_PERIOD_SNAPSHOT_IN_MILLISEC + 5000L);
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/qualitymodel/ReliabilityAndSecurityRatingMeasuresVisitorTest.java

       .setKey(Uuids.create())
       .setSeverity(severity)
       .setType(type)
-      .setCreationDate(new Date(1000l));
+      .setCreationDate(new Date(1000L));
   }
 
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/qualityprofile/ActiveRulesHolderImplTest.java

   public void get_inactive_rule() {
     underTest.set(Collections.emptyList());
     Optional<ActiveRule> activeRule = underTest.get(RULE_KEY);
-    assertThat(activeRule.isPresent()).isFalse();
+    assertThat(activeRule).isEmpty();
   }
 
   @Test
     underTest.set(asList(new ActiveRule(RULE_KEY, Severity.BLOCKER, Collections.emptyMap(), SOME_DATE, PLUGIN_KEY, QP_KEY)));
 
     Optional<ActiveRule> activeRule = underTest.get(RULE_KEY);
-    assertThat(activeRule.isPresent()).isTrue();
+    assertThat(activeRule).isPresent();
     assertThat(activeRule.get().getRuleKey()).isEqualTo(RULE_KEY);
     assertThat(activeRule.get().getSeverity()).isEqualTo(Severity.BLOCKER);
   }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/scm/ChangesetTest.java

 
 public class ChangesetTest {
 
-
   @Test
   public void create_changeset() {
     Changeset underTest = Changeset.newChangesetBuilder()
       .setRevision("rev-1")
       .build();
 
-    assertThat(underTest.toString()).isEqualTo("Changeset{revision='rev-1', author='john', date=123456789}");
+    assertThat(underTest).hasToString("Changeset{revision='rev-1', author='john', date=123456789}");
   }
 
   @Test
       .setRevision("rev-2")
       .build();
 
-    assertThat(changeset).isEqualTo(changeset);
-    assertThat(changeset).isEqualTo(sameChangeset);
-    assertThat(changeset).isNotEqualTo(anotherChangesetWithSameRevision);
-    assertThat(changeset).isNotEqualTo(anotherChangeset);
-
-    assertThat(changeset.hashCode()).isEqualTo(changeset.hashCode());
-    assertThat(changeset.hashCode()).isEqualTo(sameChangeset.hashCode());
-    assertThat(changeset.hashCode()).isNotEqualTo(anotherChangesetWithSameRevision.hashCode());
-    assertThat(changeset.hashCode()).isNotEqualTo(anotherChangeset.hashCode());
+    assertThat(changeset)
+      .isEqualTo(changeset)
+      .isEqualTo(sameChangeset)
+      .isNotEqualTo(anotherChangesetWithSameRevision)
+      .isNotEqualTo(anotherChangeset)
+      .hasSameHashCodeAs(changeset)
+      .hasSameHashCodeAs(sameChangeset);
+    assertThat(changeset.hashCode())
+      .isNotEqualTo(anotherChangesetWithSameRevision.hashCode())
+      .isNotEqualTo(anotherChangeset.hashCode());
   }
 }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/scm/ScmInfoImplTest.java

   public void test_to_string() {
     ScmInfo scmInfo = createScmInfoWithTwoChangestOnFourLines();
 
-    assertThat(scmInfo.toString()).isEqualTo("ScmInfoImpl{" +
+    assertThat(scmInfo).hasToString("ScmInfoImpl{" +
       "latestChangeset=Changeset{revision='rev-2', author='henry', date=1234567810}, " +
       "lineChangesets={" +
       "1=Changeset{revision='rev-1', author='john', date=123456789}, " +

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/source/LastCommitVisitorTest.java

     underTest.visit(file);
 
     Optional<Measure> measure = measureRepository.getAddedRawMeasure(FILE_1_REF, LAST_COMMIT_DATE_KEY);
-    assertThat(measure.isPresent()).isFalse();
+    assertThat(measure).isEmpty();
   }
 
   private void assertDate(int componentRef, long expectedDate) {
     Optional<Measure> measure = measureRepository.getAddedRawMeasure(componentRef, LAST_COMMIT_DATE_KEY);
-    assertThat(measure.isPresent()).isTrue();
+    assertThat(measure).isPresent();
     assertThat(measure.get().getLongValue()).isEqualTo(expectedDate);
   }
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/source/PersistFileSourcesStepTest.java

 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getProjectUuid()).isEqualTo(PROJECT_UUID);
     assertThat(fileSourceDto.getFileUuid()).isEqualTo(FILE1_UUID);
 
     DbFileSources.Data data = fileSourceDto.getSourceData();
     assertThat(data.getLinesCount()).isEqualTo(2);
-    assertThat(data.getLines(0).getLine()).isEqualTo(1);
+    assertThat(data.getLines(0).getLine()).isOne();
     assertThat(data.getLines(0).getSource()).isEqualTo("line1");
     assertThat(data.getLines(1).getLine()).isEqualTo(2);
     assertThat(data.getLines(1).getSource()).isEqualTo("line2");
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getLineHashes()).containsExactly("137f72c3708c6bd0de00a0e5a69c699b", "e6251bcf1a7dc3ba5e7933e325bbe605");
     assertThat(fileSourceDto.getSrcHash()).isEqualTo("ee5a58024a155466b43bc559d953e018");
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData);
     verify(fileSourceDataWarnings).commitWarnings();
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData);
     assertThat(fileSourceDto.getRevision()).isNull();
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
 
     DbFileSources.Data data = fileSourceDto.getSourceData();
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     DbFileSources.Data data = fileSourceDto.getSourceData();
     assertThat(data).isEqualTo(dbData);
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData);
     verify(fileSourceDataWarnings).commitWarnings();
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getSourceData()).isEqualTo(dbData);
     verify(fileSourceDataWarnings).commitWarnings();
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getSrcHash()).isEqualTo("sourceHash");
     assertThat(fileSourceDto.getLineHashes()).isEqualTo(Collections.singletonList("lineHash"));
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getCreatedAt()).isEqualTo(past);
     assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW);
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getCreatedAt()).isEqualTo(PAST);
     assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW);
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("file_sources")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("file_sources")).isOne();
     FileSourceDto fileSourceDto = dbClient.fileSourceDao().selectByFileUuid(session, FILE1_UUID);
     assertThat(fileSourceDto.getCreatedAt()).isEqualTo(PAST);
     assertThat(fileSourceDto.getUpdatedAt()).isEqualTo(NOW);

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/source/ReportIteratorTest.java

   @Test
   public void read_report() {
     underTest = new ReportIterator<>(file, ScannerReport.LineCoverage.parser());
-    assertThat(underTest.next().getLine()).isEqualTo(1);
+    assertThat(underTest.next().getLine()).isOne();
   }
 
   @Test
   public void do_not_fail_when_calling_has_next_with_iterator_already_closed() {
     underTest = new ReportIterator<>(file, ScannerReport.LineCoverage.parser());
-    assertThat(underTest.next().getLine()).isEqualTo(1);
+    assertThat(underTest.next().getLine()).isOne();
     assertThat(underTest.hasNext()).isFalse();
 
     underTest.close();

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/source/SignificantCodeRepositoryTest.java

     assertThat(underTest.getRangesPerLine(component)).isNotEmpty();
     LineRange[] lines = underTest.getRangesPerLine(component).get();
     assertThat(lines).hasSize(1);
-    assertThat(lines[0].startOffset()).isEqualTo(1);
+    assertThat(lines[0].startOffset()).isOne();
     assertThat(lines[0].endOffset()).isEqualTo(2);
   }
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/source/linereader/CoverageLineReaderTest.java

     DbFileSources.Line.Builder lineBuilder = DbFileSources.Data.newBuilder().addLinesBuilder().setLine(1);
     assertThat(computeCoverageLine.read(lineBuilder)).isEmpty();
 
-    assertThat(lineBuilder.getLineHits()).isEqualTo(1);
+    assertThat(lineBuilder.getLineHits()).isOne();
     assertThat(lineBuilder.getConditions()).isEqualTo(10);
     assertThat(lineBuilder.getCoveredConditions()).isEqualTo(2);
   }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/ExecuteVisitorsStepTest.java

 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(measureRepository.getAddedRawMeasure(FILE_1_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(1);
-    assertThat(measureRepository.getAddedRawMeasure(FILE_2_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(1);
+    assertThat(measureRepository.getAddedRawMeasure(FILE_1_REF, TEST_METRIC_KEY).get().getIntValue()).isOne();
+    assertThat(measureRepository.getAddedRawMeasure(FILE_2_REF, TEST_METRIC_KEY).get().getIntValue()).isOne();
     assertThat(measureRepository.getAddedRawMeasure(DIRECTORY_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(2);
     assertThat(measureRepository.getAddedRawMeasure(ROOT_REF, TEST_METRIC_KEY).get().getIntValue()).isEqualTo(2);
   }

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/LoadReportAnalysisMetadataHolderStepTest.java

 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(analysisMetadataHolder.getRootComponentRef()).isEqualTo(1);
+    assertThat(analysisMetadataHolder.getRootComponentRef()).isOne();
   }
 
   @Test
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isEqualTo(true);
+    assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isTrue();
   }
 
   @Test
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isEqualTo(false);
+    assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isFalse();
   }
 
   @Test
 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isEqualTo(false);
+    assertThat(analysisMetadataHolder.isCrossProjectDuplicationEnabled()).isFalse();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/PersistAdHocRulesStepTest.java

     assertThat(reloaded.getSeverity()).isNull();
     assertThat(reloaded.getName()).isEqualTo("eslint:no-cond-assign");
 
-    assertThat(es.countDocuments(RuleIndexDefinition.TYPE_RULE)).isEqualTo(1L);
+    assertThat(es.countDocuments(RuleIndexDefinition.TYPE_RULE)).isOne();
     assertThat(es.getDocuments(RuleIndexDefinition.TYPE_RULE).iterator().next().getId()).isEqualTo(reloaded.getUuid());
   }
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/PersistCrossProjectDuplicationIndexStepTest.java

     underTest.execute(context);
 
     Map<String, Object> dto = dbTester.selectFirst("select HASH, START_LINE, END_LINE, INDEX_IN_FILE, COMPONENT_UUID, ANALYSIS_UUID from duplications_index");
-    assertThat(dto.get("HASH")).isEqualTo(CPD_TEXT_BLOCK.getHash());
-    assertThat(dto.get("START_LINE")).isEqualTo(30L);
-    assertThat(dto.get("END_LINE")).isEqualTo(45L);
-    assertThat(dto.get("INDEX_IN_FILE")).isEqualTo(0L);
-    assertThat(dto.get("COMPONENT_UUID")).isEqualTo(FILE_1.getUuid());
-    assertThat(dto.get("ANALYSIS_UUID")).isEqualTo(ANALYSIS_UUID);
+    assertThat(dto)
+      .containsEntry("HASH", CPD_TEXT_BLOCK.getHash())
+      .containsEntry("START_LINE", 30L)
+      .containsEntry("END_LINE", 45L)
+      .containsEntry("INDEX_IN_FILE", 0L)
+      .containsEntry("COMPONENT_UUID", FILE_1.getUuid())
+      .containsEntry("ANALYSIS_UUID", ANALYSIS_UUID);
     context.getStatistics().assertValue("inserts", 1);
   }
 

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/PersistEventsStepTest.java

 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "events")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "events")).isOne();
     List<EventDto> eventDtos = dbTester.getDbClient().eventDao().selectByComponentUuid(dbTester.getSession(), ROOT.getUuid());
     assertThat(eventDtos).hasSize(1);
     EventDto eventDto = eventDtos.iterator().next();

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/PersistLiveMeasuresStepTest.java

     Optional<LiveMeasureDto> persisted = dbClient.liveMeasureDao().selectMeasure(db.getSession(),
       template.getComponentUuid(), metricRepository.getByUuid(template.getMetricUuid()).getKey());
     assertThat(persisted).isPresent();
-    assertThat(persisted.get().getValue()).isEqualTo((double) expectedValue);
+    assertThat(persisted.get().getValue()).isEqualTo(expectedValue);
   }
 
   private void assertThatMeasureHasValue(String componentUuid, Metric metric, int expectedValue) {
     Optional<LiveMeasureDto> persisted = dbClient.liveMeasureDao().selectMeasure(db.getSession(),
       componentUuid, metric.getKey());
     assertThat(persisted).isPresent();
-    assertThat(persisted.get().getValue()).isEqualTo((double) expectedValue);
+    assertThat(persisted.get().getValue()).isEqualTo(expectedValue);
   }
 
   private void assertThatMeasureDoesNotExist(LiveMeasureDto template) {

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/PersistMeasuresStepTest.java

     TestComputationStepContext context = execute();
 
     // project and dir measures are persisted, but not file measures
-    assertThat(db.countRowsOfTable("project_measures")).isEqualTo(1);
+    assertThat(db.countRowsOfTable("project_measures")).isOne();
     assertThat(selectMeasure("project-uuid", STRING_METRIC).get().getData()).isEqualTo("project-value");
     assertThatMeasuresAreNotPersisted("dir-uuid");
     assertThatMeasuresAreNotPersisted("file-uuid");

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/PersistProjectLinksStepTest.java

 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(db.countRowsOfTable("project_links")).isEqualTo(1);
+    assertThat(db.countRowsOfTable("project_links")).isOne();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/ReportPersistAnalysisStepTest.java

 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("snapshots")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("snapshots")).isOne();
 
     SnapshotDto projectSnapshot = getUnprocessedSnapshot(projectDto.uuid());
     assertThat(projectSnapshot.getUuid()).isEqualTo(ANALYSIS_UUID);

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/step/ViewsPersistAnalysisStepTest.java

 
     underTest.execute(new TestComputationStepContext());
 
-    assertThat(dbTester.countRowsOfTable("snapshots")).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable("snapshots")).isOne();
 
     SnapshotDto viewSnapshot = getUnprocessedSnapshot(viewDto.uuid());
     assertThat(viewSnapshot.getUuid()).isEqualTo(ANALYSIS_UUID);

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectexport/ProjectExportComputationStepsTest.java

 
   @Test
   public void count_step_classes() {
-    assertThat(copyOf(underTest.orderedStepClasses()).size()).isEqualTo(20);
+    assertThat(copyOf(underTest.orderedStepClasses())).hasSize(20);
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectexport/analysis/ExportAnalysesStepTest.java

 
   private static void assertAnalysis(ProjectDump.Analysis analysis, ComponentDto component, SnapshotDto dto) {
     assertThat(analysis.getUuid()).isEqualTo(dto.getUuid());
-    assertThat(analysis.getComponentRef()).isEqualTo(1);
+    assertThat(analysis.getComponentRef()).isOne();
     assertThat(analysis.getDate()).isEqualTo(dto.getCreatedAt());
     assertThat(analysis.getProjectVersion()).isEqualTo(defaultString(dto.getProjectVersion()));
     assertThat(analysis.getBuildString()).isEqualTo(defaultString(dto.getBuildString()));

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectexport/steps/ExportEventsStepTest.java

     assertThat(event.getDescription()).isEqualTo("desc");
     assertThat(event.getDate()).isEqualTo(IN_THE_PAST);
     assertThat(event.getAnalysisUuid()).isEqualTo(snapshot.getUuid());
-    assertThat(event.getComponentRef()).isEqualTo(1);
+    assertThat(event.getComponentRef()).isOne();
   }
 
   @Test

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectexport/steps/ExportMetricsStepTest.java

  */
 package org.sonar.ce.task.projectexport.steps;
 
-import com.google.common.base.Predicate;
 import com.sonarsource.governance.projectdump.protobuf.ProjectDump;
 import java.util.List;
+import java.util.function.Predicate;
 import javax.annotation.Nonnull;
 import org.junit.Before;
 import org.junit.Rule;
 import org.sonar.db.DbTester;
 import org.sonar.db.metric.MetricDto;
 
-import static com.google.common.collect.FluentIterable.from;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
     assertThat(logTester.logs(LoggerLevel.DEBUG)).contains("2 metrics exported");
     List<ProjectDump.Metric> exportedMetrics = dumpWriter.getWrittenMessagesOf(DumpElement.METRICS);
 
-    ProjectDump.Metric ncloc = from(exportedMetrics).firstMatch(new HasMetricRefPredicate(0)).get();
+    ProjectDump.Metric ncloc = exportedMetrics.stream().filter(input -> input.getRef() == 0).findAny().orElseThrow();
     assertThat(ncloc.getRef()).isZero();
     assertThat(ncloc.getKey()).isEqualTo("ncloc");
     assertThat(ncloc.getName()).isEqualTo("Lines of code");
 
-    ProjectDump.Metric coverage = from(exportedMetrics).firstMatch(new HasMetricRefPredicate(1)).get();
-    assertThat(coverage.getRef()).isEqualTo(1);
+    ProjectDump.Metric coverage = exportedMetrics.stream().filter(input -> input.getRef() == 1).findAny().orElseThrow();
+    assertThat(coverage.getRef()).isOne();
     assertThat(coverage.getKey()).isEqualTo("coverage");
     assertThat(coverage.getName()).isEqualTo("Coverage");
   }
   public void test_getDescription() {
     assertThat(underTest.getDescription()).isEqualTo("Export metrics");
   }
-
-  private static class HasMetricRefPredicate implements Predicate<ProjectDump.Metric> {
-    private final int ref;
-
-    HasMetricRefPredicate(int ref) {
-      this.ref = ref;
-    }
-
-    @Override
-    public boolean apply(@Nonnull ProjectDump.Metric input) {
-      return input.getRef() == ref;
-    }
-  }
 }

server/sonar-ce-task-projectanalysis/src/testFixtures/java/org/sonar/ce/task/projectanalysis/measure/MeasureAssert.java

     return new MeasureAssert(actual == null ? null : actual.orElse(null));
   }
 
-  public MeasureAssert hasValueType(Measure.ValueType expected) {
-    isNotNull();
-
-    if (actual.getValueType() != expected) {
-      failWithMessage("Expected ValueType of Measure to be <%s> but was <%s>", expected, actual.getValueType());
-    }
-
-    return this;
-  }
-
   public MeasureAssert hasValue(int expected) {
     isNotNull();
 

server/sonar-ce-task-projectanalysis/src/testFixtures/java/org/sonar/ce/task/projectanalysis/measure/MeasureRepositoryRule.java

   @Override
   public Map<String, Measure> getRawMeasures(Component component) {
     return filterKeys(rawMeasures, hasComponentRef(component)).entrySet().stream()
-      .collect(Collectors.toMap(k -> k.getKey().getMetricKey(), e -> e.getValue()));
+      .collect(Collectors.toMap(k -> k.getKey().getMetricKey(), Map.Entry::getValue));
   }
 
   private HasComponentRefPredicate hasComponentRef(Component component) {

server/sonar-ce-task/src/test/java/org/sonar/ce/task/CeTaskComponentTest.java

     String somethingElse = randomAlphabetic(5);
     CeTask.Component underTest = new CeTask.Component(uuid, key, name);
 
-    assertThat(underTest).isEqualTo(underTest);
-    assertThat(underTest).isEqualTo(new CeTask.Component(uuid, key, name));
-    assertThat(underTest).isNotEqualTo(null);
-    assertThat(underTest).isNotEqualTo(new Object());
-    assertThat(underTest).isNotEqualTo(new CeTask.Component(somethingElse, key, name));
-    assertThat(underTest).isNotEqualTo(new CeTask.Component(uuid, somethingElse, name));
-    assertThat(underTest).isNotEqualTo(new CeTask.Component(uuid, key, somethingElse));
-    assertThat(underTest).isNotEqualTo(new CeTask.Component(uuid, key, null));
+    assertThat(underTest)
+      .isEqualTo(underTest)
+      .isEqualTo(new CeTask.Component(uuid, key, name))
+      .isNotNull()
+      .isNotEqualTo(new Object())
+      .isNotEqualTo(new CeTask.Component(somethingElse, key, name))
+      .isNotEqualTo(new CeTask.Component(uuid, somethingElse, name))
+      .isNotEqualTo(new CeTask.Component(uuid, key, somethingElse))
+      .isNotEqualTo(new CeTask.Component(uuid, key, null));
   }
 
   @Test
     String somethingElse = randomAlphabetic(5);
     CeTask.Component underTest = new CeTask.Component(uuid, key, name);
 
-    assertThat(underTest.hashCode()).isEqualTo(underTest.hashCode());
-    assertThat(underTest.hashCode()).isEqualTo(new CeTask.Component(uuid, key, name).hashCode());
-    assertThat(underTest.hashCode()).isNotEqualTo(new Object().hashCode());
-    assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(somethingElse, key, name).hashCode());
-    assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(uuid, somethingElse, name).hashCode());
-    assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(uuid, key, somethingElse).hashCode());
-    assertThat(underTest.hashCode()).isNotEqualTo(new CeTask.Component(uuid, key, null).hashCode());
+    assertThat(underTest)
+      .hasSameHashCodeAs(underTest)
+      .hasSameHashCodeAs(new CeTask.Component(uuid, key, name));
+    assertThat(underTest.hashCode())
+      .isNotEqualTo(new Object().hashCode())
+      .isNotEqualTo(new CeTask.Component(somethingElse, key, name).hashCode())
+      .isNotEqualTo(new CeTask.Component(uuid, somethingElse, name).hashCode())
+      .isNotEqualTo(new CeTask.Component(uuid, key, somethingElse).hashCode())
+      .isNotEqualTo(new CeTask.Component(uuid, key, null).hashCode());
   }
 
   @DataProvider

server/sonar-ce-task/src/test/java/org/sonar/ce/task/CeTaskTest.java

     assertThat(task1.equals(task1)).isTrue();
     assertThat(task1.equals(task1bis)).isTrue();
     assertThat(task1.equals(task2)).isFalse();
-    assertThat(task1.hashCode()).isEqualTo(task1.hashCode());
-    assertThat(task1.hashCode()).isEqualTo(task1bis.hashCode());
+    assertThat(task1)
+      .hasSameHashCodeAs(task1)
+      .hasSameHashCodeAs(task1bis);
   }
 
   @Test
     CeTask.User user2 = new CeTask.User("UUID_2", null);
     CeTask.User user1_diff_login = new CeTask.User("UUID_1", "LOGIN");
 
-    assertThat(user1).isEqualTo(user1);
-    assertThat(user1).isEqualTo(user1bis);
-    assertThat(user1).isNotEqualTo(user2);
     assertThat(user1.equals(null)).isFalse();
-    assertThat(user1.hashCode()).isEqualTo(user1.hashCode());
-    assertThat(user1.hashCode()).isEqualTo(user1bis.hashCode());
-    assertThat(user1.hashCode()).isEqualTo(user1_diff_login.hashCode());
+    assertThat(user1)
+      .isEqualTo(user1)
+      .isEqualTo(user1bis)
+      .isNotEqualTo(user2)
+      .hasSameHashCodeAs(user1)
+      .hasSameHashCodeAs(user1bis)
+      .hasSameHashCodeAs(user1_diff_login);
   }
 }

server/sonar-ce-task/src/test/java/org/sonar/ce/task/container/TaskContainerImplTest.java

 
     assertThat(defaultStartable.startCalls).isZero();
     assertThat(defaultStartable.stopCalls).isZero();
-    assertThat(eagerStartable.startCalls).isEqualTo(1);
+    assertThat(eagerStartable.startCalls).isOne();
     assertThat(eagerStartable.stopCalls).isZero();
   }
 
 
     assertThat(defaultStartable.startCalls).isZero();
     assertThat(defaultStartable.stopCalls).isZero();
-    assertThat(eagerStartable.startCalls).isEqualTo(1);
-    assertThat(eagerStartable.stopCalls).isEqualTo(1);
+    assertThat(eagerStartable.startCalls).isOne();
+    assertThat(eagerStartable.stopCalls).isOne();
   }
 
   public static class DefaultStartable implements Startable {

server/sonar-ce-task/src/test/java/org/sonar/ce/task/log/CeTaskMessagesMessageTest.java

       .isEqualTo(new Message(text, timestamp))
       .isNotEqualTo(new Message(text + "ç", timestamp))
       .isNotEqualTo(new Message(text, timestamp + 10_999L))
-      .isNotEqualTo(null)
+      .isNotNull()
       .isNotEqualTo(new Object());
   }
 

server/sonar-ce/src/test/java/org/sonar/ce/cleaning/CeCleaningSchedulerImplTest.java

       mockedInternalCeQueue, mockCeDistributedInformation(jobLock));
 
     underTest.startScheduling();
-    assertThat(executorService.schedulerCounter).isEqualTo(1);
+    assertThat(executorService.schedulerCounter).isOne();
   }
 
   private CeConfiguration mockCeConfiguration(long cleanCeTasksInitialDelay, long cleanCeTasksDelay) {

server/sonar-ce/src/test/java/org/sonar/ce/configuration/CeConfigurationImplTest.java

 
   @Test
   public void getWorkerCount_returns_1_when_there_is_no_WorkerCountProvider() {
-    assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerCount()).isEqualTo(1);
+    assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerCount()).isOne();
   }
 
   @Test
   public void getWorkerMaxCount_returns_1_when_there_is_no_WorkerCountProvider() {
-    assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerMaxCount()).isEqualTo(1);
+    assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getWorkerMaxCount()).isOne();
   }
 
   @Test
   @Test
   public void getCleanCeTasksInitialDelay_returns_0() {
     assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION).getCleanTasksInitialDelay())
-      .isEqualTo(0L);
+      .isZero();
     workerCountProvider.set(1);
     assertThat(new CeConfigurationImpl(EMPTY_CONFIGURATION, workerCountProvider).getCleanTasksInitialDelay())
-      .isEqualTo(0L);
+      .isZero();
   }
 
   @Test

server/sonar-ce/src/test/java/org/sonar/ce/monitoring/CEQueueStatusImplConcurrentTest.java

 
     executorService.awaitTermination(1, TimeUnit.SECONDS);
 
-    assertThat(underTest.getInProgressCount()).isEqualTo(1);
+    assertThat(underTest.getInProgressCount()).isOne();
     assertThat(underTest.getErrorCount()).isEqualTo(17);
     assertThat(underTest.getSuccessCount()).isEqualTo(80);
     assertThat(underTest.getProcessingTime()).isEqualTo(177);

server/sonar-ce/src/test/java/org/sonar/ce/monitoring/CommonCEQueueStatusImplTest.java

   public void addInProgress_increases_InProgress() {
     getUnderTest().addInProgress();
 
-    assertThat(getUnderTest().getInProgressCount()).isEqualTo(1);
+    assertThat(getUnderTest().getInProgressCount()).isOne();
     assertThat(getUnderTest().getErrorCount()).isZero();
     assertThat(getUnderTest().getSuccessCount()).isZero();
     assertThat(getUnderTest().getProcessingTime()).isZero();
     getUnderTest().addError(SOME_PROCESSING_TIME);
 
     assertThat(getUnderTest().getInProgressCount()).isEqualTo(-1);
-    assertThat(getUnderTest().getErrorCount()).isEqualTo(1);
+    assertThat(getUnderTest().getErrorCount()).isOne();
     assertThat(getUnderTest().getSuccessCount()).isZero();
     assertThat(getUnderTest().getProcessingTime()).isEqualTo(SOME_PROCESSING_TIME);
   }
 
     assertThat(getUnderTest().getInProgressCount()).isEqualTo(-1);
     assertThat(getUnderTest().getErrorCount()).isZero();
-    assertThat(getUnderTest().getSuccessCount()).isEqualTo(1);
+    assertThat(getUnderTest().getSuccessCount()).isOne();
     assertThat(getUnderTest().getProcessingTime()).isEqualTo(SOME_PROCESSING_TIME);
   }
 

server/sonar-ce/src/test/java/org/sonar/ce/queue/InternalCeQueueImplTest.java

 
     // available in history
     Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid());
-    assertThat(history.isPresent()).isTrue();
+    assertThat(history).isPresent();
     assertThat(history.get().getStatus()).isEqualTo(CeActivityDto.Status.SUCCESS);
     assertThat(history.get().getIsLast()).isTrue();
     assertThat(history.get().getAnalysisUuid()).isNull();
 
     // available in history
     Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid());
-    assertThat(history.isPresent()).isTrue();
+    assertThat(history).isPresent();
     assertThat(history.get().getAnalysisUuid()).isNull();
   }
 
 
     // available in history
     Optional<CeActivityDto> history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid());
-    assertThat(history.isPresent()).isTrue();
+    assertThat(history).isPresent();
     assertThat(history.get().getAnalysisUuid()).isEqualTo("U1");
   }
 
     CeTask task = submit(CeTaskTypes.REPORT, newProjectDto("PROJECT_1"));
 
     Optional<CeTask> peek = underTest.peek(WORKER_UUID_1, true);
-    assertThat(peek.isPresent()).isTrue();
+    assertThat(peek).isPresent();
     assertThat(peek.get().getUuid()).isEqualTo(task.getUuid());
     assertThat(peek.get().getType()).isEqualTo(CeTaskTypes.REPORT);
     assertThat(peek.get().getComponent()).contains(new CeTask.Component("PROJECT_1", null, null));
 
     // no more pending tasks
     peek = underTest.peek(WORKER_UUID_2, true);
-    assertThat(peek.isPresent()).isFalse();
+    assertThat(peek).isEmpty();
   }
 
   @Test
     CeTask task = submit(CeTaskTypes.REPORT, branch);
 
     Optional<CeTask> peek = underTest.peek(WORKER_UUID_1, true);
-    assertThat(peek.isPresent()).isTrue();
+    assertThat(peek).isPresent();
     assertThat(peek.get().getUuid()).isEqualTo(task.getUuid());
     assertThat(peek.get().getType()).isEqualTo(CeTaskTypes.REPORT);
     assertThat(peek.get().getComponent()).contains(new CeTask.Component(branch.uuid(), branch.getDbKey(), branch.name()));
 
     // no more pending tasks
     peek = underTest.peek(WORKER_UUID_2, true);
-    assertThat(peek.isPresent()).isFalse();
+    assertThat(peek).isEmpty();
   }
 
   @Test
     when(computeEngineStatus.getStatus()).thenReturn(STOPPING);
 
     Optional<CeTask> peek = underTest.peek(WORKER_UUID_1, true);
-    assertThat(peek.isPresent()).isFalse();
+    assertThat(peek).isEmpty();
   }
 
   @Test
     underTest.cancel(db.getSession(), queueDto);
 
     Optional<CeActivityDto> activity = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), task.getUuid());
-    assertThat(activity.isPresent()).isTrue();
+    assertThat(activity).isPresent();
     assertThat(activity.get().getStatus()).isEqualTo(CeActivityDto.Status.CANCELED);
   }
 
     history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), pendingTask2.getUuid());
     assertThat(history.get().getStatus()).isEqualTo(CeActivityDto.Status.CANCELED);
     history = db.getDbClient().ceActivityDao().selectByUuid(db.getSession(), inProgressTask.getUuid());
-    assertThat(history.isPresent()).isFalse();
+    assertThat(history).isEmpty();
   }
 
   @Test
 
   private void verifyCeQueueDtoForTaskSubmit(CeTaskSubmit taskSubmit) {
     Optional<CeQueueDto> queueDto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), taskSubmit.getUuid());
-    assertThat(queueDto.isPresent()).isTrue();
+    assertThat(queueDto).isPresent();
     CeQueueDto dto = queueDto.get();
     assertThat(dto.getTaskType()).isEqualTo(taskSubmit.getType());
     Optional<CeTaskSubmit.Component> component = taskSubmit.getComponent();