<artifactId>jetty-server</artifactId>
<version>${jetty.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-core</artifactId>
+ <version>1.3</version>
+ </dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-all</artifactId>
<artifactId>assertj-guava</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <!-- TODO to be removed -->
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-all</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
*/
package org.sonar.ce.queue;
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.sonar.ce.container.ComputeEngineStatus.Status.STARTED;
-import static org.sonar.ce.container.ComputeEngineStatus.Status.STOPPING;
-
+import com.google.common.collect.ImmutableSet;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.List;
import java.util.Optional;
import java.util.Random;
-
import javax.annotation.Nullable;
-
-import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.server.organization.DefaultOrganization;
import org.sonar.server.organization.DefaultOrganizationProvider;
-import com.google.common.collect.ImmutableSet;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.sonar.ce.container.ComputeEngineStatus.Status.STARTED;
+import static org.sonar.ce.container.ComputeEngineStatus.Status.STOPPING;
public class InternalCeQueueImplTest {
CeQueueDto queueDto = db.getDbClient().ceQueueDao().selectByUuid(db.getSession(), task.getUuid()).get();
expectedException.expect(IllegalStateException.class);
- expectedException.expectMessage(Matchers.startsWith("Task is in progress and can't be canceled"));
+ expectedException.expectMessage("Task is in progress and can't be canceled");
underTest.cancel(db.getSession(), queueDto);
}
<artifactId>assertj-core</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <!-- TODO to be removed -->
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-all</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-guava</artifactId>
import org.junit.Test;
import org.sonar.db.rule.RuleMapper;
-import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertThat;
public class MyBatisTest {
assertThat(dbTester.countRowsOfTable(dbSession, "ANALYSIS_PROPERTIES")).isEqualTo(propertyDtos.size());
List<AnalysisPropertyDto> result = underTest.selectBySnapshotUuid(dbSession, snapshotUuid);
- assertThat(result).containsExactlyInAnyOrder((AnalysisPropertyDto[]) propertyDtos.toArray());
+ assertThat(result).containsExactlyInAnyOrder(propertyDtos.toArray(new AnalysisPropertyDto[0]));
}
private AnalysisPropertyDto insertAnalysisPropertyDto(int valueLength) {
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
public class PurgeableAnalysisDtoTest {
@Rule
public void testEquals() {
PurgeableAnalysisDto dto1 = new PurgeableAnalysisDto().setAnalysisUuid("u3");
PurgeableAnalysisDto dto2 = new PurgeableAnalysisDto().setAnalysisUuid("u4");
- assertThat(dto1.equals(dto2), is(false));
- assertThat(dto2.equals(dto1), is(false));
- assertThat(dto1.equals(dto1), is(true));
- assertThat(dto1.equals(new PurgeableAnalysisDto().setAnalysisUuid("u3")), is(true));
- assertThat(dto1.equals("bi_bop_a_lou_la"), is(false));
- assertThat(dto1.equals(null), is(false));
+ assertThat(dto1.equals(dto2)).isFalse();
+ assertThat(dto2.equals(dto1)).isFalse();
+ assertThat(dto1.equals(dto1)).isTrue();
+ assertThat(dto1.equals(new PurgeableAnalysisDto().setAnalysisUuid("u3"))).isTrue();
+ assertThat(dto1.equals("bi_bop_a_lou_la")).isFalse();
+ assertThat(dto1.equals(null)).isFalse();
}
@Test
public void testHasCode() {
PurgeableAnalysisDto dto = new PurgeableAnalysisDto().setAnalysisUuid("u3");
- assertThat(dto.hashCode(), is(dto.hashCode()));
+ assertThat(dto.hashCode()).isEqualTo(dto.hashCode());
// no uuid => NPE
dto = new PurgeableAnalysisDto();
@Test
public void testToString() {
PurgeableAnalysisDto dto = new PurgeableAnalysisDto().setAnalysisUuid("u3");
- assertThat(dto.toString().length(), greaterThan(0));
+ assertThat(dto.toString()).isNotEmpty();
}
}
if (projectUuids.isEmpty()) {
sql = StringUtils.replace(SQL_TEMPLATE, "{projectsCondition}", "");
} else {
- sql = StringUtils.replace(SQL_TEMPLATE, "{projectsCondition}", " AND (" + repeat("projects.uuid = ?", " or ", projectUuids.size()) + ")");
+ sql = StringUtils.replace(SQL_TEMPLATE, "{projectsCondition}", " AND projects.uuid in (" + repeat("?", ", ", projectUuids.size()) + ")");
}
PreparedStatement stmt = dbClient.getMyBatis().newScrollingSelectStatement(session, sql);
int index = 1;
import org.hamcrest.MatcherAssert;
import org.junit.Assert;
-import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
package org.sonar.server.issue;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
+import java.util.HashMap;
import java.util.Map;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.mockito.Matchers;
+import org.mockito.Mockito;
import org.sonar.core.issue.DefaultIssue;
-import org.sonar.core.issue.IssueChangeContext;
-import static com.google.common.collect.Maps.newHashMap;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class AddTagsActionTest {
- private AddTagsAction action;
-
- private IssueFieldsSetter issueUpdater = mock(IssueFieldsSetter.class);
-
@Rule
public ExpectedException throwable = ExpectedException.none();
- @Before
- public void before() {
- action = new AddTagsAction(issueUpdater);
- }
+ private IssueFieldsSetter issueUpdater = new IssueFieldsSetter();
+ private AddTagsAction underTest = new AddTagsAction(issueUpdater);
@Test
@SuppressWarnings("unchecked")
public void should_execute() {
- Map<String, Object> properties = newHashMap();
+ Map<String, Object> properties = new HashMap<>();
properties.put("tags", "tag2,tag3");
DefaultIssue issue = mock(DefaultIssue.class);
when(issue.tags()).thenReturn(ImmutableSet.of("tag1", "tag3"));
- Action.Context context = mock(Action.Context.class);
+ Action.Context context = mock(Action.Context.class, Mockito.RETURNS_DEEP_STUBS);
when(context.issue()).thenReturn(issue);
- action.execute(properties, context);
- verify(issueUpdater).setTags(eq(issue),
- (Collection<String>) Matchers.argThat(org.hamcrest.Matchers.containsInAnyOrder("tag1", "tag2", "tag3")),
- any(IssueChangeContext.class));
+ underTest.execute(properties, context);
+ verify(issue).setTags(ImmutableSet.of("tag1", "tag2", "tag3"));
}
@Test
throwable.expect(IllegalArgumentException.class);
throwable.expectMessage("Tag 'th ag' is invalid. Rule tags accept only the characters: a-z, 0-9, '+', '-', '#', '.'");
- Map<String, Object> properties = newHashMap();
+ Map<String, Object> properties = new HashMap<>();
properties.put("tags", "th ag");
DefaultIssue issue = mock(DefaultIssue.class);
Action.Context context = mock(Action.Context.class);
when(context.issue()).thenReturn(issue);
- action.execute(properties, context);
+ underTest.execute(properties, context);
}
}
package org.sonar.server.issue;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
import java.util.Map;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
-import org.mockito.Matchers;
+import org.mockito.Mockito;
import org.sonar.core.issue.DefaultIssue;
-import org.sonar.core.issue.IssueChangeContext;
import static com.google.common.collect.Maps.newHashMap;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class RemoveTagsActionTest {
- private RemoveTagsAction action;
-
- private IssueFieldsSetter issueUpdater = mock(IssueFieldsSetter.class);
-
@Rule
public ExpectedException throwable = ExpectedException.none();
- @Before
- public void before() {
- action = new RemoveTagsAction(issueUpdater);
- }
+ private IssueFieldsSetter issueUpdater = new IssueFieldsSetter();
+ private RemoveTagsAction action = new RemoveTagsAction(issueUpdater);
@Test
@SuppressWarnings("unchecked")
DefaultIssue issue = mock(DefaultIssue.class);
when(issue.tags()).thenReturn(ImmutableSet.of("tag1", "tag3"));
- Action.Context context = mock(Action.Context.class);
+ Action.Context context = mock(Action.Context.class, Mockito.RETURNS_DEEP_STUBS);
when(context.issue()).thenReturn(issue);
action.execute(properties, context);
- verify(issueUpdater).setTags(eq(issue),
- (Collection<String>) Matchers.argThat(org.hamcrest.Matchers.containsInAnyOrder("tag1")),
- any(IssueChangeContext.class));
+ verify(issue).setTags(ImmutableSet.of("tag1"));
}
@Test
import org.sonar.api.notifications.Notification;
import org.sonar.api.notifications.NotificationChannel;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import org.sonar.api.notifications.Notification;
import org.sonar.plugins.emailnotifications.api.EmailMessage;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.sonar.api.utils.System2;
import org.sonar.db.DbTester;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
-import org.mockito.Mockito;
+import org.sonar.core.platform.ComponentContainer;
import org.sonar.db.DBSessions;
import org.sonar.server.authentication.UserSessionInitializer;
import org.sonar.server.organization.DefaultOrganizationCache;
public class UserSessionFilterTest {
private UserSessionInitializer userSessionInitializer = mock(UserSessionInitializer.class);
- private Platform platform = mock(Platform.class, Mockito.RETURNS_DEEP_STUBS);
+ private ComponentContainer container = new ComponentContainer();
+ private Platform platform = mock(Platform.class);
private HttpServletRequest request = mock(HttpServletRequest.class);
private HttpServletResponse response = mock(HttpServletResponse.class);
private FilterChain chain = mock(FilterChain.class);
@Before
public void setUp() {
- when(platform.getContainer().getComponentByType(DBSessions.class)).thenReturn(dbSessions);
- when(platform.getContainer().getComponentByType(ThreadLocalSettings.class)).thenReturn(settings);
- when(platform.getContainer().getComponentByType(DefaultOrganizationCache.class)).thenReturn(defaultOrganizationCache);
+ container.add(dbSessions, settings, defaultOrganizationCache);
+ when(platform.getContainer()).thenReturn(container);
}
@Test
@Test
public void does_nothing_when_not_initialized() throws Exception {
- mockNoUserSessionInitializer();
-
underTest.doFilter(request, response, chain);
verify(chain).doFilter(request, response);
@Test
public void doFilter_loads_and_unloads_settings() throws Exception {
- mockNoUserSessionInitializer();
-
underTest.doFilter(request, response, chain);
InOrder inOrder = inOrder(settings);
@Test
public void doFilter_unloads_Settings_even_if_chain_throws_exception() throws Exception {
- mockNoUserSessionInitializer();
RuntimeException thrown = mockChainDoFilterError();
try {
@Test
public void doFilter_enables_and_disables_caching_in_DbSessions() throws Exception {
- mockNoUserSessionInitializer();
-
underTest.doFilter(request, response, chain);
InOrder inOrder = inOrder(dbSessions);
@Test
public void doFilter_disables_caching_in_DbSessions_even_if_chain_throws_exception() throws Exception {
- mockNoUserSessionInitializer();
RuntimeException thrown = mockChainDoFilterError();
try {
@Test
public void doFilter_unloads_Settings_even_if_DefaultOrganizationCache_unload_fails() throws Exception {
- mockNoUserSessionInitializer();
RuntimeException thrown = new RuntimeException("Faking DefaultOrganizationCache.unload failing");
doThrow(thrown)
.when(defaultOrganizationCache)
@Test
public void doFilter_loads_and_unloads_DefaultOrganizationCache() throws Exception {
- mockNoUserSessionInitializer();
-
underTest.doFilter(request, response, chain);
InOrder inOrder = inOrder(defaultOrganizationCache);
@Test
public void doFilter_unloads_DefaultOrganizationCache_even_if_chain_throws_exception() throws Exception {
- mockNoUserSessionInitializer();
RuntimeException thrown = mockChainDoFilterError();
try {
@Test
public void doFilter_unloads_DefaultOrganizationCache_even_if_Settings_unload_fails() throws Exception {
- mockNoUserSessionInitializer();
RuntimeException thrown = new RuntimeException("Faking Settings.unload failing");
doThrow(thrown)
.when(settings)
// do not fail
}
- private void mockNoUserSessionInitializer() {
- when(platform.getContainer().getComponentByType(UserSessionInitializer.class)).thenReturn(null);
- }
-
private void mockUserSessionInitializer(boolean value) {
- when(platform.getContainer().getComponentByType(UserSessionInitializer.class)).thenReturn(userSessionInitializer);
+ container.add(userSessionInitializer);
when(userSessionInitializer.initUserSession(request, response)).thenReturn(value);
}
private RuntimeException mockUserSessionInitializerRemoveUserSessionFailing() {
- when(platform.getContainer().getComponentByType(UserSessionInitializer.class)).thenReturn(userSessionInitializer);
+ container.add(userSessionInitializer);
RuntimeException thrown = new RuntimeException("Faking UserSessionInitializer.removeUserSession failing");
doThrow(thrown)
.when(userSessionInitializer)
<artifactId>assertj-core</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-all</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
import org.junit.Before;
import org.junit.Test;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.sameInstance;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;
public class TokenEntryTest {
*/
package org.sonar.duplications.block;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-
import java.util.List;
-
import org.junit.Test;
import org.sonar.duplications.statement.Statement;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
public class BlockChunkerTest extends BlockChunkerTestCase {
@Override
import org.junit.Test;
import org.sonar.duplications.statement.Statement;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.sameInstance;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;
/**
import org.junit.Test;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.sameInstance;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;
public class BlockTest {
*/
package org.sonar.duplications.block;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import org.junit.Test;
import org.sonar.duplications.index.CloneGroup;
import org.sonar.duplications.index.ClonePart;
-import static org.hamcrest.Matchers.hasItem;
+import static org.hamcrest.CoreMatchers.hasItem;
public class CloneGroupMatcher extends TypeSafeMatcher<CloneGroup> {
*/
package org.sonar.duplications.detector;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;
import java.util.Comparator;
import org.sonar.duplications.junit.TestNamePrinter;
import static org.hamcrest.CoreMatchers.hasItem;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.sameInstance;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.spy;
import org.junit.Test;
import org.sonar.duplications.block.Block;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
public class BlocksGroupTest {
import java.util.Arrays;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.*;
import java.util.Collections;
import java.util.List;
-import static org.hamcrest.Matchers.sameInstance;
+import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.sonar.duplications.detector.CloneGroupMatcher.hasCloneGroup;
*/
package org.sonar.duplications.index;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import java.util.Arrays;
import java.util.Iterator;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.sameInstance;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;
public class PackedMemoryCloneIndexTest {
import java.util.Arrays;
import java.util.List;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
public class PmdBlockChunkerTest {
import org.junit.Before;
import org.junit.Test;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
public class TokenizerBridgeTest {
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.joining;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
/**
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import org.apache.commons.io.IOUtils;
-import org.hamcrest.Matcher;
-import org.hamcrest.Matchers;
import org.junit.Test;
import org.sonar.duplications.DuplicationsTestUtil;
import org.sonar.duplications.token.Token;
import org.sonar.duplications.token.TokenChunker;
import org.sonar.duplications.token.TokenQueue;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
public class JavaTokenProducerTest {
+ private static final Token NUMERIC_LITTERAL = new Token("$NUMBER", 1, 0);
+ private static final Token STRING_LITTERAL = new Token("$CHARS", 1, 0);
private final TokenChunker chunker = JavaTokenProducer.build();
/**
*/
@Test
public void shouldIgnoreWhitespaces() {
- assertThat(chunk(" \t\f\n\r"), isTokens());
+ assertThat(chunk(" \t\f\n\r")).isEmpty();
}
/**
*/
@Test
public void shouldIgnoreEndOfLineComment() {
- assertThat(chunk("// This is a comment"), isTokens());
- assertThat(chunk("// This is a comment \n and_this_is_not"), isTokens(new Token("and_this_is_not", 2, 1)));
+ assertThat(chunk("// This is a comment")).isEmpty();
+ assertThat(chunk("// This is a comment \n and_this_is_not")).containsExactly(new Token("and_this_is_not", 2, 1));
}
@Test
public void shouldIgnoreTraditionalComment() {
- assertThat(chunk("/* This is a comment \n and the second line */"), isTokens());
- assertThat(chunk("/** This is a javadoc \n and the second line */"), isTokens());
- assertThat(chunk("/* this \n comment /* \n // /** ends \n here: */"), isTokens());
+ assertThat(chunk("/* This is a comment \n and the second line */")).isEmpty();
+ assertThat(chunk("/** This is a javadoc \n and the second line */")).isEmpty();
+ assertThat(chunk("/* this \n comment /* \n // /** ends \n here: */")).isEmpty();
}
/**
*/
@Test
public void shouldPreserveIdentifiers() {
- assertThat(chunk("String"), isTokens(new Token("String", 1, 0)));
- assertThat(chunk("i3"), isTokens(new Token("i3", 1, 0)));
- assertThat(chunk("MAX_VALUE"), isTokens(new Token("MAX_VALUE", 1, 0)));
- assertThat(chunk("isLetterOrDigit"), isTokens(new Token("isLetterOrDigit", 1, 0)));
+ assertThat(chunk("String")).containsExactly(new Token("String", 1, 0));
+ assertThat(chunk("i3")).containsExactly(new Token("i3", 1, 0));
+ assertThat(chunk("MAX_VALUE")).containsExactly(new Token("MAX_VALUE", 1, 0));
+ assertThat(chunk("isLetterOrDigit")).containsExactly(new Token("isLetterOrDigit", 1, 0));
- assertThat(chunk("_"), isTokens(new Token("_", 1, 0)));
- assertThat(chunk("_123_"), isTokens(new Token("_123_", 1, 0)));
- assertThat(chunk("_Field"), isTokens(new Token("_Field", 1, 0)));
- assertThat(chunk("_Field5"), isTokens(new Token("_Field5", 1, 0)));
+ assertThat(chunk("_")).containsExactly(new Token("_", 1, 0));
+ assertThat(chunk("_123_")).containsExactly(new Token("_123_", 1, 0));
+ assertThat(chunk("_Field")).containsExactly(new Token("_Field", 1, 0));
+ assertThat(chunk("_Field5")).containsExactly(new Token("_Field5", 1, 0));
- assertThat(chunk("$"), isTokens(new Token("$", 1, 0)));
- assertThat(chunk("$field"), isTokens(new Token("$field", 1, 0)));
+ assertThat(chunk("$")).containsExactly(new Token("$", 1, 0));
+ assertThat(chunk("$field")).containsExactly(new Token("$field", 1, 0));
- assertThat(chunk("i2j"), isTokens(new Token("i2j", 1, 0)));
- assertThat(chunk("from1to4"), isTokens(new Token("from1to4", 1, 0)));
+ assertThat(chunk("i2j")).containsExactly(new Token("i2j", 1, 0));
+ assertThat(chunk("from1to4")).containsExactly(new Token("from1to4", 1, 0));
- assertThat("identifier with unicode", chunk("αβγ"), isTokens(new Token("αβγ", 1, 0)));
+ // identifier with unicode
+ assertThat(chunk("αβγ")).containsExactly(new Token("αβγ", 1, 0));
}
/**
*/
@Test
public void shouldPreserverKeywords() {
- assertThat(chunk("private static final"), isTokens(new Token("private", 1, 0), new Token("static", 1, 8), new Token("final", 1, 15)));
+ assertThat(chunk("private static final")).containsExactly(
+ new Token("private", 1, 0),
+ new Token("static", 1, 8),
+ new Token("final", 1, 15));
}
/**
*/
@Test
public void shouldNormalizeDecimalIntegerLiteral() {
- assertThat(chunk("543"), isNumericLiteral());
- assertThat(chunk("543l"), isNumericLiteral());
- assertThat(chunk("543L"), isNumericLiteral());
+ assertThat(chunk("543")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("543l")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("543L")).containsExactly(NUMERIC_LITTERAL);
}
@Test
public void shouldNormalizeOctalIntegerLiteral() {
- assertThat(chunk("077"), isNumericLiteral());
- assertThat(chunk("077l"), isNumericLiteral());
- assertThat(chunk("077L"), isNumericLiteral());
+ assertThat(chunk("077")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("077l")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("077L")).containsExactly(NUMERIC_LITTERAL);
}
@Test
public void shouldNormalizeHexIntegerLiteral() {
- assertThat(chunk("0xFF"), isNumericLiteral());
- assertThat(chunk("0xFFl"), isNumericLiteral());
- assertThat(chunk("0xFFL"), isNumericLiteral());
+ assertThat(chunk("0xFF")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xFFl")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xFFL")).containsExactly(NUMERIC_LITTERAL);
- assertThat(chunk("0XFF"), isNumericLiteral());
- assertThat(chunk("0XFFl"), isNumericLiteral());
- assertThat(chunk("0XFFL"), isNumericLiteral());
+ assertThat(chunk("0XFF")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XFFl")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XFFL")).containsExactly(NUMERIC_LITTERAL);
}
/**
*/
@Test
public void shouldNormalizeBinaryIntegerLiteral() {
- assertThat(chunk("0b10"), isNumericLiteral());
- assertThat(chunk("0b10l"), isNumericLiteral());
- assertThat(chunk("0b10L"), isNumericLiteral());
+ assertThat(chunk("0b10")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0b10l")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0b10L")).containsExactly(NUMERIC_LITTERAL);
- assertThat(chunk("0B10"), isNumericLiteral());
- assertThat(chunk("0B10l"), isNumericLiteral());
- assertThat(chunk("0B10L"), isNumericLiteral());
+ assertThat(chunk("0B10")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0B10l")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0B10L")).containsExactly(NUMERIC_LITTERAL);
}
/**
@Test
public void shouldNormalizeDecimalFloatingPointLiteral() {
// with dot at the end
- assertThat(chunk("1234."), isNumericLiteral());
- assertThat(chunk("1234.E1"), isNumericLiteral());
- assertThat(chunk("1234.e+1"), isNumericLiteral());
- assertThat(chunk("1234.E-1"), isNumericLiteral());
- assertThat(chunk("1234.f"), isNumericLiteral());
+ assertThat(chunk("1234.")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234.E1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234.e+1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234.E-1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234.f")).containsExactly(NUMERIC_LITTERAL);
// with dot between
- assertThat(chunk("12.34"), isNumericLiteral());
- assertThat(chunk("12.34E1"), isNumericLiteral());
- assertThat(chunk("12.34e+1"), isNumericLiteral());
- assertThat(chunk("12.34E-1"), isNumericLiteral());
+ assertThat(chunk("12.34")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("12.34E1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("12.34e+1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("12.34E-1")).containsExactly(NUMERIC_LITTERAL);
- assertThat(chunk("12.34f"), isNumericLiteral());
- assertThat(chunk("12.34E1F"), isNumericLiteral());
- assertThat(chunk("12.34E+1d"), isNumericLiteral());
- assertThat(chunk("12.34e-1D"), isNumericLiteral());
+ assertThat(chunk("12.34f")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("12.34E1F")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("12.34E+1d")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("12.34e-1D")).containsExactly(NUMERIC_LITTERAL);
// with dot at the beginning
- assertThat(chunk(".1234"), isNumericLiteral());
- assertThat(chunk(".1234e1"), isNumericLiteral());
- assertThat(chunk(".1234E+1"), isNumericLiteral());
- assertThat(chunk(".1234E-1"), isNumericLiteral());
+ assertThat(chunk(".1234")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk(".1234e1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk(".1234E+1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk(".1234E-1")).containsExactly(NUMERIC_LITTERAL);
- assertThat(chunk(".1234f"), isNumericLiteral());
- assertThat(chunk(".1234E1F"), isNumericLiteral());
- assertThat(chunk(".1234e+1d"), isNumericLiteral());
- assertThat(chunk(".1234E-1D"), isNumericLiteral());
+ assertThat(chunk(".1234f")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk(".1234E1F")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk(".1234e+1d")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk(".1234E-1D")).containsExactly(NUMERIC_LITTERAL);
// without dot
- assertThat(chunk("1234e1"), isNumericLiteral());
- assertThat(chunk("1234E+1"), isNumericLiteral());
- assertThat(chunk("1234E-1"), isNumericLiteral());
+ assertThat(chunk("1234e1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234E+1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234E-1")).containsExactly(NUMERIC_LITTERAL);
- assertThat(chunk("1234E1f"), isNumericLiteral());
- assertThat(chunk("1234e+1d"), isNumericLiteral());
- assertThat(chunk("1234E-1D"), isNumericLiteral());
+ assertThat(chunk("1234E1f")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234e+1d")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1234E-1D")).containsExactly(NUMERIC_LITTERAL);
}
@Test
public void shouldNormalizeHexadecimalFloatingPointLiteral() {
// with dot at the end
- assertThat(chunk("0xAF."), isNumericLiteral());
- assertThat(chunk("0XAF.P1"), isNumericLiteral());
- assertThat(chunk("0xAF.p+1"), isNumericLiteral());
- assertThat(chunk("0XAF.p-1"), isNumericLiteral());
- assertThat(chunk("0xAF.f"), isNumericLiteral());
+ assertThat(chunk("0xAF.")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XAF.P1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xAF.p+1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XAF.p-1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xAF.f")).containsExactly(NUMERIC_LITTERAL);
// with dot between
- assertThat(chunk("0XAF.BC"), isNumericLiteral());
- assertThat(chunk("0xAF.BCP1"), isNumericLiteral());
- assertThat(chunk("0XAF.BCp+1"), isNumericLiteral());
- assertThat(chunk("0xAF.BCP-1"), isNumericLiteral());
+ assertThat(chunk("0XAF.BC")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xAF.BCP1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XAF.BCp+1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xAF.BCP-1")).containsExactly(NUMERIC_LITTERAL);
- assertThat(chunk("0xAF.BCf"), isNumericLiteral());
- assertThat(chunk("0xAF.BCp1F"), isNumericLiteral());
- assertThat(chunk("0XAF.BCP+1d"), isNumericLiteral());
- assertThat(chunk("0XAF.BCp-1D"), isNumericLiteral());
+ assertThat(chunk("0xAF.BCf")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xAF.BCp1F")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XAF.BCP+1d")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XAF.BCp-1D")).containsExactly(NUMERIC_LITTERAL);
// without dot
- assertThat(chunk("0xAFp1"), isNumericLiteral());
- assertThat(chunk("0XAFp+1"), isNumericLiteral());
- assertThat(chunk("0xAFp-1"), isNumericLiteral());
+ assertThat(chunk("0xAFp1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XAFp+1")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xAFp-1")).containsExactly(NUMERIC_LITTERAL);
- assertThat(chunk("0XAFp1f"), isNumericLiteral());
- assertThat(chunk("0xAFp+1d"), isNumericLiteral());
- assertThat(chunk("0XAFp-1D"), isNumericLiteral());
+ assertThat(chunk("0XAFp1f")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xAFp+1d")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0XAFp-1D")).containsExactly(NUMERIC_LITTERAL);
}
/**
*/
@Test
public void shouldNormalizeNumericLiteralsWithUnderscores() {
- assertThat(chunk("54_3L"), isNumericLiteral());
- assertThat(chunk("07_7L"), isNumericLiteral());
- assertThat(chunk("0b1_0L"), isNumericLiteral());
- assertThat(chunk("0xF_FL"), isNumericLiteral());
-
- assertThat(chunk("1_234."), isNumericLiteral());
- assertThat(chunk("1_2.3_4"), isNumericLiteral());
- assertThat(chunk(".1_234"), isNumericLiteral());
- assertThat(chunk("1_234e1_0"), isNumericLiteral());
-
- assertThat(chunk("0xA_F."), isNumericLiteral());
- assertThat(chunk("0xA_F.B_C"), isNumericLiteral());
- assertThat(chunk("0x1.ffff_ffff_ffff_fP1_023"), isNumericLiteral());
+ assertThat(chunk("54_3L")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("07_7L")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0b1_0L")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xF_FL")).containsExactly(NUMERIC_LITTERAL);
+
+ assertThat(chunk("1_234.")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1_2.3_4")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk(".1_234")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("1_234e1_0")).containsExactly(NUMERIC_LITTERAL);
+
+ assertThat(chunk("0xA_F.")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0xA_F.B_C")).containsExactly(NUMERIC_LITTERAL);
+ assertThat(chunk("0x1.ffff_ffff_ffff_fP1_023")).containsExactly(NUMERIC_LITTERAL);
}
/**
*/
@Test
public void shouldPreserveBooleanLiterals() {
- assertThat(chunk("true false"), isTokens(new Token("true", 1, 0), new Token("false", 1, 5)));
+ assertThat(chunk("true false")).containsExactly(new Token("true", 1, 0), new Token("false", 1, 5));
}
/**
*/
@Test
public void shouldNormalizeCharacterLiterals() {
- assertThat("single character", chunk("'a'"), isStringLiteral());
- assertThat("escaped LF", chunk("'\\n'"), isStringLiteral());
- assertThat("escaped quote", chunk("'\\''"), isStringLiteral());
- assertThat("octal escape", chunk("'\\177'"), isStringLiteral());
- assertThat("unicode escape", chunk("'\\u03a9'"), isStringLiteral());
+ // single character
+ assertThat(chunk("'a'")).containsExactly(STRING_LITTERAL);
+ // escaped LF
+ assertThat(chunk("'\\n'")).containsExactly(STRING_LITTERAL);
+ // escaped quote
+ assertThat(chunk("'\\''")).containsExactly(STRING_LITTERAL);
+ // octal escape
+ assertThat(chunk("'\\177'")).containsExactly(STRING_LITTERAL);
+ // unicode escape
+ assertThat(chunk("'\\u03a9'")).containsExactly(STRING_LITTERAL);
}
/**
*/
@Test
public void shouldNormalizeStringLiterals() {
- assertThat("regular string", chunk("\"string\""), isStringLiteral());
- assertThat("empty string", chunk("\"\""), isStringLiteral());
- assertThat("escaped LF", chunk("\"\\n\""), isStringLiteral());
- assertThat("escaped double quotes", chunk("\"string, which contains \\\"escaped double quotes\\\"\""), isStringLiteral());
- assertThat("octal escape", chunk("\"string \\177\""), isStringLiteral());
- assertThat("unicode escape", chunk("\"string \\u03a9\""), isStringLiteral());
+ // regular string
+ assertThat(chunk("\"string\"")).containsExactly(STRING_LITTERAL);
+ // empty string
+ assertThat(chunk("\"\"")).containsExactly(STRING_LITTERAL);
+ // escaped LF
+ assertThat(chunk("\"\\n\"")).containsExactly(STRING_LITTERAL);
+ // escaped double quotes
+ assertThat(chunk("\"string, which contains \\\"escaped double quotes\\\"\"")).containsExactly(STRING_LITTERAL);
+ // octal escape
+ assertThat(chunk("\"string \\177\"")).containsExactly(STRING_LITTERAL);
+ // unicode escape
+ assertThat(chunk("\"string \\u03a9\"")).containsExactly(STRING_LITTERAL);
}
/**
*/
@Test
public void shouldPreserverNullLiteral() {
- assertThat(chunk("null"), isTokens(new Token("null", 1, 0)));
+ assertThat(chunk("null")).containsExactly(new Token("null", 1, 0));
}
/**
*/
@Test
public void shouldPreserveSeparators() {
- assertThat(chunk("(){}[];,."), isTokens(
+ assertThat(chunk("(){}[];,.")).containsExactly(
new Token("(", 1, 0), new Token(")", 1, 1),
new Token("{", 1, 2), new Token("}", 1, 3),
new Token("[", 1, 4), new Token("]", 1, 5),
new Token(";", 1, 6), new Token(",", 1, 7),
- new Token(".", 1, 8)));
+ new Token(".", 1, 8));
}
/**
*/
@Test
public void shouldPreserveOperators() {
- assertThat(chunk("+="), isTokens(new Token("+", 1, 0), new Token("=", 1, 1)));
- assertThat(chunk("--"), isTokens(new Token("-", 1, 0), new Token("-", 1, 1)));
+ assertThat(chunk("+=")).containsExactly(new Token("+", 1, 0), new Token("=", 1, 1));
+ assertThat(chunk("--")).containsExactly(new Token("-", 1, 0), new Token("-", 1, 1));
}
@Test
public void realExamples() {
File testFile = DuplicationsTestUtil.findFile("/java/MessageResources.java");
- assertThat(chunk(testFile).size(), Matchers.greaterThan(0));
+ assertThat(chunk(testFile)).isNotEmpty();
testFile = DuplicationsTestUtil.findFile("/java/RequestUtils.java");
- assertThat(chunk(testFile).size(), Matchers.greaterThan(0));
+ assertThat(chunk(testFile)).isNotEmpty();
}
private TokenQueue chunk(File file) {
}
}
- private static Matcher<List<Token>> isNumericLiteral() {
- return isTokens(new Token("$NUMBER", 1, 0));
- }
-
- private static Matcher<List<Token>> isStringLiteral() {
- return isTokens(new Token("$CHARS", 1, 0));
- }
-
- /**
- * @return matcher for list of tokens
- */
- private static Matcher<List<Token>> isTokens(Token... tokens) {
- return is(Arrays.asList(tokens));
- }
-
private List<Token> chunk(String sourceCode) {
List<Token> target = new ArrayList<>();
chunker.chunk(sourceCode).forEach(target::add);
*/
package org.sonar.duplications.statement;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyListOf;
*/
package org.sonar.duplications.statement;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-import org.mockito.Matchers;
-
import java.util.Arrays;
import java.util.List;
-
import org.junit.Test;
import org.mockito.ArgumentCaptor;
+import org.mockito.Matchers;
import org.sonar.duplications.statement.matcher.AnyTokenMatcher;
import org.sonar.duplications.statement.matcher.TokenMatcher;
import org.sonar.duplications.token.Token;
import org.sonar.duplications.token.TokenQueue;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
public class StatementChannelTest {
@Test(expected = IllegalArgumentException.class)
*/
package org.sonar.duplications.statement;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import java.util.ArrayList;
*/
package org.sonar.duplications.statement;
-import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.CoreMatchers.instanceOf;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
*/
package org.sonar.duplications.statement.matcher;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
*/
package org.sonar.duplications.statement.matcher;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
*/
package org.sonar.duplications.statement.matcher;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import org.sonar.duplications.token.Token;
import org.sonar.duplications.token.TokenQueue;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.spy;
*/
package org.sonar.duplications.statement.matcher;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
*/
package org.sonar.duplications.statement.matcher;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
*/
package org.sonar.duplications.token;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
*/
package org.sonar.duplications.token;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import java.util.ArrayList;
import static org.junit.Assert.assertThat;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.not;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
public class TokenTest {
*/
package org.sonar.duplications.utils;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import java.util.Arrays;
*/
package net.sourceforge.pmd.cpd.fork;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;
import java.nio.charset.Charset;
+++ /dev/null
-/*
- * SonarQube
- * Copyright (C) 2009-2017 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.api.test;
-
-import org.apache.commons.lang.ObjectUtils;
-import org.mockito.ArgumentMatcher;
-import org.sonar.api.resources.Resource;
-
-public class IsResource extends ArgumentMatcher<Resource> {
-
- private String scope;
- private String qualifier;
- private String key;
-
- public IsResource(String scope, String qualifier) {
- this.scope = scope;
- this.qualifier = qualifier;
- }
-
- public IsResource(String scope, String qualifier, String key) {
- this(scope, qualifier);
- this.key = key;
- }
-
- @Override
- public boolean matches(Object o) {
- Resource r = (Resource) o;
- return ObjectUtils.equals(r.getScope(), scope) && ObjectUtils.equals(r.getQualifier(), qualifier) && r.getKey().equals(key);
- }
-}
verify(logger).info(eq("{}..."), eq("Cycle analysis"));
profiler.stop();
- verify(logger).info(eq("{} done: {} ms"), eq("Cycle analysis"), anyInt());
+ verify(logger).info(eq("{} done: {} ms"), eq("Cycle analysis"), anyLong());
}
@Test
profiler.stop();
profiler.stop();
verify(logger, times(1)).info(anyString(), anyString()); // start() executes log() with 1 parameter
- verify(logger, times(1)).info(anyString(), anyString(), anyInt()); // stop() executes log() with 3 parameters
+ verify(logger, times(1)).info(anyString(), anyString(), anyLong()); // stop() executes log() with 3 parameters
}
@Test
profiler.start("New task");
profiler.stop();
profiler.stop();
- verify(logger, never()).info(eq("{} done: {} ms"), eq("Cycle analysis"), anyInt());
- verify(logger, times(1)).info(eq("{} done: {} ms"), eq("New task"), anyInt());
+ verify(logger, never()).info(eq("{} done: {} ms"), eq("Cycle analysis"), anyLong());
+ verify(logger, times(1)).info(eq("{} done: {} ms"), eq("New task"), anyLong());
}
}
<artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-all</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>sonar-plugin-api</artifactId>
public boolean accept(FilterableIssue issue, IssueFilterChain chain) {
if (hasMatchFor(issue)) {
return false;
- } else {
- return chain.accept(issue);
}
+ return chain.accept(issue);
}
private boolean hasMatchFor(FilterableIssue issue) {
@CheckForNull
private static String getSonarProfile(AnalysisProperties props) {
- String profile = null;
- if (props.properties().containsKey(ModuleQProfiles.SONAR_PROFILE_PROP)) {
- profile = props.property(ModuleQProfiles.SONAR_PROFILE_PROP);
+ String profile = props.property(ModuleQProfiles.SONAR_PROFILE_PROP);
+ if (profile != null) {
LOG.warn("Ability to set quality profile from command line using '" + ModuleQProfiles.SONAR_PROFILE_PROP
+ "' is deprecated and will be dropped in a future SonarQube version. Please configure quality profile used by your project on SonarQube server.");
}
import org.sonar.scanner.scan.measure.MeasureCache;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
*/
package org.sonar.scanner.issue.ignore;
-import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mockito;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.scan.issue.filter.FilterableIssue;
import org.sonar.api.scan.issue.filter.IssueFilterChain;
public class IgnoreIssuesFilterTest {
- private PatternMatcher exclusionPatternMatcher;
- private IgnoreIssuesFilter ignoreFilter;
- private FilterableIssue issue;
- private IssueFilterChain chain;
-
- @Before
- public void init() {
- exclusionPatternMatcher = mock(PatternMatcher.class);
- issue = mock(FilterableIssue.class);
- chain = mock(IssueFilterChain.class);
- when(chain.accept(issue)).thenReturn(true);
-
- ignoreFilter = new IgnoreIssuesFilter(exclusionPatternMatcher);
- }
+ private PatternMatcher exclusionPatternMatcher = mock(PatternMatcher.class);
+ private FilterableIssue issue = mock(FilterableIssue.class, Mockito.RETURNS_DEEP_STUBS);
+ private IssueFilterChain chain = mock(IssueFilterChain.class);
+ private IgnoreIssuesFilter underTest = new IgnoreIssuesFilter(exclusionPatternMatcher);
@Test
public void shouldPassToChainIfMatcherHasNoPatternForIssue() {
- when(exclusionPatternMatcher.getMatchingPattern(anyString(), any(RuleKey.class), any(Integer.class))).thenReturn(null);
-
- assertThat(ignoreFilter.accept(issue, chain)).isTrue();
+ when(exclusionPatternMatcher.getMatchingPattern(anyString(), any(RuleKey.class), any(Integer.class)))
+ .thenReturn(null);
+ when(chain.accept(issue)).thenReturn(true);
+ assertThat(underTest.accept(issue, chain)).isTrue();
}
@Test
- public void shouldAcceptOrRefuseIfMatcherHasPatternForIssue() {
- when(exclusionPatternMatcher.getMatchingPattern(anyString(), any(RuleKey.class), any(Integer.class))).thenReturn(mock(IssuePattern.class));
+ public void shouldRejectIfPatternMatches() {
+ IssuePattern pattern = mock(IssuePattern.class);
+ when(exclusionPatternMatcher.getMatchingPattern(anyString(), any(RuleKey.class), any(Integer.class)))
+ .thenReturn(pattern);
- assertThat(ignoreFilter.accept(issue, chain)).isFalse();
+ assertThat(underTest.accept(issue, chain)).isFalse();
}
+
}
import java.util.Collections;
import java.util.Map;
+import org.hamcrest.CoreMatchers;
import org.hamcrest.Description;
-import org.hamcrest.Matchers;
import org.hamcrest.TypeSafeMatcher;
import org.junit.BeforeClass;
import org.junit.Rule;
loader.withCause = false;
thrown.expect(MessageException.class);
thrown.expectMessage("Error loading settings");
- thrown.expectCause(Matchers.nullValue(Throwable.class));
+ thrown.expectCause(CoreMatchers.nullValue(Throwable.class));
batch.start();
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isNull;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
@Test
public void testProvide() {
- when(loader.load(eq("project"), isNull(String.class))).thenReturn(response);
+ when(loader.load("project", null)).thenReturn(response);
ModuleQProfiles qps = qualityProfileProvider.provide(key, loader, projectRepo, props);
assertResponse(qps);
- verify(loader).load(eq("project"), isNull(String.class));
+ verify(loader).load("project", null);
verifyNoMoreInteractions(loader);
}
public void testProjectDoesntExist() {
when(projectRepo.exists()).thenReturn(false);
when(loader.loadDefault(anyString())).thenReturn(response);
+ when(props.property(ModuleQProfiles.SONAR_PROFILE_PROP)).thenReturn("profile");
ModuleQProfiles qps = qualityProfileProvider.provide(key, loader, projectRepo, props);
assertResponse(qps);
}
private void assertResponse(ModuleQProfiles qps) {
- assertThat(qps.findAll()).hasSize(1);
assertThat(qps.findAll()).extracting("key").containsExactly("profile");
}
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class ModuleInputComponentStoreTest {
@Rule
public void should_find_module_components_with_non_global_strategy() {
InputComponentStore inputComponentStore = mock(InputComponentStore.class);
SensorStrategy strategy = new SensorStrategy();
- ModuleInputComponentStore store = new ModuleInputComponentStore(mock(InputModule.class), inputComponentStore, strategy);
+ InputModule module = mock(InputModule.class);
+ when(module.key()).thenReturn("foo");
+ ModuleInputComponentStore store = new ModuleInputComponentStore(module, inputComponentStore, strategy);
store.inputFiles();
- verify(inputComponentStore).filesByModule(any(String.class));
+ verify(inputComponentStore).filesByModule("foo");
String relativePath = "somepath";
store.inputFile(relativePath);
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-core</artifactId>
+ </dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<scope>provided</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-all</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
import java.util.SortedMap;
import static junit.framework.TestCase.fail;
-import static org.hamcrest.Matchers.*;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.Assert.*;
public class BundleSynchronizedMatcherTest {
import java.io.File;
-import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
<artifactId>assertj-core</artifactId>
</dependency>
<dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-all</artifactId>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-guava</artifactId>
</dependency>
<dependency>
<groupId>com.googlecode.json-simple</groupId>
validation.mustHaveComments(SRC_DIR);
validation.mustHaveComplexity(SRC_DIR);
validation.mustHaveIssues(SRC_DIR + "/HasIssues.js");
- validation.mustHaveMeasuresGreaterThan(SRC_DIR + "/Person.js", 0, "coverage");
+ validation.mustHaveMeasuresGreaterThanOrEquals(SRC_DIR + "/Person.js", 0, "coverage");
}
}
import com.google.common.base.Joiner;
import com.google.gson.Gson;
import com.sonar.orchestrator.Orchestrator;
-import org.sonarqube.tests.plugins.Project;
import java.io.File;
import java.util.List;
import java.util.Map;
-import org.hamcrest.Matchers;
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeMatcher;
import org.junit.rules.ErrorCollector;
+import org.sonarqube.tests.plugins.Project;
import org.sonarqube.ws.client.GetRequest;
import org.sonarqube.ws.client.WsResponse;
import static java.util.Arrays.asList;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
import static util.ItUtils.getMeasuresAsDoubleByMetricKey;
import static util.ItUtils.newAdminWsClient;
public void mustHaveIssues(String path) {
// TODO use the WS api/issues
- mustHaveMeasuresGreaterThan(path, 1, "violations");
+ mustHaveMeasuresGreaterThanOrEquals(path, 1, "violations");
}
public void mustHaveComments(String path) {
- mustHaveMeasuresGreaterThan(path, 0, "comment_lines", "comment_lines_density");
+ mustHaveMeasuresGreaterThanOrEquals(path, 0, "comment_lines", "comment_lines_density");
}
public void mustHaveComplexity(String path) {
- mustHaveMeasuresGreaterThan(path, 0, "complexity");
+ mustHaveMeasuresGreaterThanOrEquals(path, 0, "complexity");
}
public void mustHaveSize(String path) {
- mustHaveMeasuresGreaterThan(path, 0, "ncloc", "lines");
+ mustHaveMeasuresGreaterThanOrEquals(path, 0, "ncloc", "lines");
}
- public void mustHaveMeasuresGreaterThan(String path, int min, String... metricKeys) {
+ public void mustHaveMeasuresGreaterThanOrEquals(String path, int min, String... metricKeys) {
for (String filePath : toFiles(path)) {
fileMustHaveMeasures(filePath, metricKeys, min);
}
Double measure = measures.get(metricKey);
errorCollector.checkThat("Measure " + metricKey + " is set on file " + filePath, measure, notNullValue());
if (measure != null) {
- errorCollector.checkThat("Measure " + metricKey + " is positive on file " + filePath, measure.intValue(), Matchers.greaterThanOrEqualTo(min));
+ errorCollector.checkThat("Measure " + metricKey + " is positive on file " + filePath, measure.intValue(), new TypeSafeMatcher<Integer>() {
+ @Override
+ protected boolean matchesSafely(Integer item) {
+ return item >= min;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText(metricKey).appendValue(min);
+ }
+ });
}
}
}
errorCollector.checkThat("Source is set on file " + filePath, response.isSuccessful(), is(true));
Sources source = Sources.parse(response.content());
if (source != null) {
- errorCollector.checkThat("Source is empty on file " + filePath, source.getSources().size(), Matchers.greaterThanOrEqualTo(minLines));
+ errorCollector.checkThat("Source is empty on file " + filePath, source.getSources().size(), new TypeSafeMatcher<Integer>() {
+ @Override
+ protected boolean matchesSafely(Integer item) {
+ return item >= minLines;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendValue(minLines);
+ }
+ });
}
}
}
private static Stream<Measure> getStreamMeasures(Orchestrator orchestrator, String componentKey, String... metricKeys) {
return newWsClient(orchestrator).measures().component(new ComponentWsRequest()
- .setComponentKey(componentKey)
+ .setComponent(componentKey)
.setMetricKeys(asList(metricKeys)))
.getComponent().getMeasuresList()
.stream();
projects / sonarqube.git / commitdiff