import com.google.common.collect.Maps;
import org.apache.commons.lang.StringUtils;
-import org.codehaus.stax2.XMLInputFactory2;
import org.codehaus.staxmate.SMInputFactory;
import org.codehaus.staxmate.in.SMHierarchicCursor;
import org.codehaus.staxmate.in.SMInputCursor;
}
private SMInputFactory initStax() {
- XMLInputFactory xmlFactory = XMLInputFactory2.newInstance();
+ XMLInputFactory xmlFactory = XMLInputFactory.newInstance();
xmlFactory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
xmlFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.FALSE);
xmlFactory.setProperty(XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
*/
package org.sonar.plugins.core.sensors;
+import org.sonar.api.resources.Resource;
+
import org.junit.Test;
import static org.mockito.Matchers.anyDouble;
import static org.mockito.Matchers.eq;
@Test
public void shouldNotSaveBranchCoverageIfMissingConditions() {
Project resource = mock(Project.class);
- when(resource.getScope()).thenReturn(Project.SCOPE_SET);
- when(resource.getQualifier()).thenReturn(Project.QUALIFIER_SUBVIEW);
+ when(resource.getScope()).thenReturn(Resource.SCOPE_SET);
+ when(resource.getQualifier()).thenReturn(Resource.QUALIFIER_SUBVIEW);
DecoratorContext context = mockContext(null, null);
new BranchCoverageDecorator().decorate(resource, context);
@Test
public void shouldSaveBranchCoverage() {
Project resource = mock(Project.class);
- when(resource.getScope()).thenReturn(Project.SCOPE_SET);
- when(resource.getQualifier()).thenReturn(Project.QUALIFIER_PROJECT);
+ when(resource.getScope()).thenReturn(Resource.SCOPE_SET);
+ when(resource.getQualifier()).thenReturn(Resource.QUALIFIER_PROJECT);
DecoratorContext context = mockContext(20, 15);
profile = mock(RulesProfile.class);
decorator = new CheckAlertThresholds(profile);
project = mock(Resource.class);
- when(project.getQualifier()).thenReturn(Project.QUALIFIER_PROJECT);
+ when(project.getQualifier()).thenReturn(Resource.QUALIFIER_PROJECT);
}
@Test
@Test
public void checkRootProjectsOnly() {
- when(project.getQualifier()).thenReturn(Project.QUALIFIER_FILE);
+ when(project.getQualifier()).thenReturn(Resource.QUALIFIER_FILE);
when(profile.getAlerts()).thenReturn(Arrays.asList(
new Alert(null, CoreMetrics.CLASSES, Alert.OPERATOR_GREATER, null, "20"),
new Alert(null, CoreMetrics.COVERAGE, Alert.OPERATOR_GREATER, null, "35.0")));
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
+
+import org.sonar.api.resources.Resource;
+
import org.junit.Before;
import org.junit.Test;
import static org.mockito.Mockito.*;
@Before
public void before() {
project = mock(Project.class);
- when(project.getScope()).thenReturn(Project.SCOPE_SET);
+ when(project.getScope()).thenReturn(Resource.SCOPE_SET);
}
@Test
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
+
+import org.sonar.api.resources.Resource;
+
import org.junit.Before;
import org.junit.Test;
import static org.mockito.Mockito.*;
@Before
public void before() {
project = mock(Project.class);
- when(project.getScope()).thenReturn(Project.SCOPE_SET);
+ when(project.getScope()).thenReturn(Resource.SCOPE_SET);
}
@Test
*/
package org.sonar.plugins.findbugs;
+import edu.umd.cs.findbugs.Priorities;
+
import com.google.common.collect.Lists;
import edu.umd.cs.findbugs.*;
import edu.umd.cs.findbugs.config.UserPreferences;
engine.setProject(project);
XMLBugReporter xmlBugReporter = new XMLBugReporter(project);
- xmlBugReporter.setPriorityThreshold(Detector.LOW_PRIORITY);
+ xmlBugReporter.setPriorityThreshold(Priorities.LOW_PRIORITY);
xmlBugReporter.setAddMessages(true);
File xmlReport = configuration.getTargetXMLReport();
*/
package org.sonar.batch;
+import org.mockito.Matchers;
+
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
import org.sonar.api.batch.SonarIndex;
import org.sonar.api.measures.Measure;
import org.sonar.api.measures.Metric;
fileLineMeasures.save();
ArgumentCaptor<Measure> measureCaptor = ArgumentCaptor.forClass(Measure.class);
- verify(index).addMeasure(Mockito.eq(resource), measureCaptor.capture());
+ verify(index).addMeasure(Matchers.eq(resource), measureCaptor.capture());
Measure measure = measureCaptor.getValue();
assertThat(measure.getMetricKey(), is("hits"));
assertThat(measure.getPersistenceMode(), is(PersistenceMode.DATABASE));
fileLineMeasures.setIntValue("branches", 3, 4);
fileLineMeasures.save();
- verify(index, times(3)).addMeasure(Mockito.eq(resource), Mockito.any(Measure.class));
+ verify(index, times(3)).addMeasure(Matchers.eq(resource), Matchers.any(Measure.class));
}
@Test(expected = UnsupportedOperationException.class)
fileLineMeasures.setIntValue("hits", 1, 2);
fileLineMeasures.save();
fileLineMeasures.save();
- verify(index).addMeasure(Mockito.eq(resource), Mockito.any(Measure.class));
+ verify(index).addMeasure(Matchers.eq(resource), Matchers.any(Measure.class));
fileLineMeasures.setIntValue("hits", 1, 2);
}
@Test
public void shouldLoadIntValues() {
- when(index.getMeasure(Mockito.any(Resource.class), Mockito.any(Metric.class)))
+ when(index.getMeasure(Matchers.any(Resource.class), Matchers.any(Metric.class)))
.thenReturn(new Measure("hits").setData("1=2;3=4"));
assertThat(fileLineMeasures.getIntValue("hits", 1), is(2));
@Test
public void shouldLoadStringValues() {
- when(index.getMeasure(Mockito.any(Resource.class), Mockito.any(Metric.class)))
+ when(index.getMeasure(Matchers.any(Resource.class), Matchers.any(Metric.class)))
.thenReturn(new Measure("author").setData("1=simon;3=evgeny"));
assertThat(fileLineMeasures.getStringValue("author", 1), is("simon"));
@Test
public void shouldNotSaveAfterLoad() {
- when(index.getMeasure(Mockito.any(Resource.class), Mockito.any(Metric.class)))
+ when(index.getMeasure(Matchers.any(Resource.class), Matchers.any(Metric.class)))
.thenReturn(new Measure("author").setData("1=simon;3=evgeny"));
fileLineMeasures.getStringValue("author", 1);
fileLineMeasures.save();
- verify(index, never()).addMeasure(Mockito.eq(resource), Mockito.any(Measure.class));
+ verify(index, never()).addMeasure(Matchers.eq(resource), Matchers.any(Measure.class));
}
@Test(expected = UnsupportedOperationException.class)
public void shouldNotModifyAfterLoad() {
- when(index.getMeasure(Mockito.any(Resource.class), Mockito.any(Metric.class)))
+ when(index.getMeasure(Matchers.any(Resource.class), Matchers.any(Metric.class)))
.thenReturn(new Measure("author").setData("1=simon;3=evgeny"));
fileLineMeasures.getStringValue("author", 1);
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.Mockito;
import org.sonar.duplications.statement.matcher.AnyTokenMatcher;
import org.sonar.duplications.statement.matcher.TokenMatcher;
import org.sonar.duplications.token.Token;
assertThat(channel.consume(tokenQueue, output), is(false));
ArgumentCaptor<List> matchedTokenList = ArgumentCaptor.forClass(List.class);
- verify(matcher).matchToken(Mockito.eq(tokenQueue), matchedTokenList.capture());
+ verify(matcher).matchToken(Matchers.eq(tokenQueue), matchedTokenList.capture());
verifyNoMoreInteractions(matcher);
verify(tokenQueue).pushForward(matchedTokenList.getValue());
verifyNoMoreInteractions(tokenQueue);
List<Statement> output = mock(List.class);
assertThat(channel.consume(tokenQueue, output), is(true));
- verify(matcher).matchToken(Mockito.eq(tokenQueue), Mockito.anyList());
+ verify(matcher).matchToken(Matchers.eq(tokenQueue), Matchers.anyList());
verifyNoMoreInteractions(matcher);
ArgumentCaptor<Statement> statement = ArgumentCaptor.forClass(Statement.class);
verify(output).add(statement.capture());
List<Statement> output = mock(List.class);
assertThat(channel.consume(tokenQueue, output), is(true));
- verify(matcher).matchToken(Mockito.eq(tokenQueue), Mockito.anyList());
+ verify(matcher).matchToken(Matchers.eq(tokenQueue), Matchers.anyList());
verifyNoMoreInteractions(matcher);
- verify(output).add(Mockito.any(Statement.class));
+ verify(output).add(Matchers.any(Statement.class));
verifyNoMoreInteractions(output);
}
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.CharEncoding;
import org.apache.commons.lang.StringUtils;
-import org.codehaus.stax2.XMLInputFactory2;
import org.codehaus.staxmate.SMInputFactory;
import org.codehaus.staxmate.in.SMHierarchicCursor;
import org.codehaus.staxmate.in.SMInputCursor;
}
public List<Rule> parse(Reader reader) {
- XMLInputFactory xmlFactory = XMLInputFactory2.newInstance();
+ XMLInputFactory xmlFactory = XMLInputFactory.newInstance();
xmlFactory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
xmlFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.FALSE);
// just so it won't try to load DTD in if there's DOCTYPE
import com.ctc.wstx.stax.WstxInputFactory;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
-import org.codehaus.stax2.XMLInputFactory2;
import org.codehaus.staxmate.SMInputFactory;
import org.codehaus.staxmate.in.SMHierarchicCursor;
*/
public StaxParser(XmlStreamHandler streamHandler, boolean isoControlCharsAwareParser) {
this.streamHandler = streamHandler;
- XMLInputFactory xmlFactory = XMLInputFactory2.newInstance();
+ XMLInputFactory xmlFactory = XMLInputFactory.newInstance();
if (xmlFactory instanceof WstxInputFactory) {
WstxInputFactory wstxInputfactory = (WstxInputFactory) xmlFactory;
wstxInputfactory.configureForLowMemUsage();
import org.junit.Test;
import org.sonar.api.test.MavenTestUtils;
-import java.util.Collection;
-
import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertThat;