<parent>
<groupId>org.codehaus.sonar</groupId>
<artifactId>sonar</artifactId>
- <version>4.3-SNAPSHOT</version>
+ <version>4.4-SNAPSHOT</version>
<relativePath>../..</relativePath>
</parent>
<build>
<plugins>
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>native2ascii-maven-plugin</artifactId>
- <version>1.0-beta-1</version>
- <executions>
- <execution>
- <goals>
- <goal>native2ascii</goal>
- </goals>
- </execution>
- </executions>
- </plugin>
<plugin>
<groupId>org.codehaus.sonar</groupId>
<artifactId>sonar-packaging-maven-plugin</artifactId>
<artifactId>logback-core</artifactId>
</dependency>
<dependency>
- <groupId>${pom.groupId}</groupId>
+ <groupId>${project.groupId}</groupId>
<artifactId>sonar-batch-maven-compat</artifactId>
- <version>${pom.version}</version>
+ <version>${project.version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<dependencies>
<dependency>
- <groupId>${pom.groupId}</groupId>
+ <groupId>${project.groupId}</groupId>
<artifactId>sonar-batch</artifactId>
- <version>${pom.version}</version>
+ <version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.maven</groupId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.mockito</groupId>
- <artifactId>mockito-all</artifactId>
+ <groupId>org.easytesting</groupId>
+ <artifactId>fest-assert</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<artifactId>sonar-testing-harness</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-all</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-server</artifactId>
import org.sonar.batch.events.EventBus;
import org.sonar.core.measure.MeasurementFilters;
-import static org.hamcrest.number.OrderingComparisons.greaterThanOrEqualTo;
-import static org.hamcrest.number.OrderingComparisons.lessThan;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.junit.matchers.JUnitMatchers.containsString;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
profiler.start(decorator2);
profiler.stop();
- assertThat(profiler.getMessage().indexOf("Decorator1"), greaterThanOrEqualTo(0));
- assertThat(profiler.getMessage().indexOf("Decorator2"), greaterThanOrEqualTo(0));
+ assertThat(profiler.getMessage().indexOf("Decorator1")).isGreaterThanOrEqualTo(0);
+ assertThat(profiler.getMessage().indexOf("Decorator2")).isGreaterThanOrEqualTo(0);
// sequence of execution
- assertThat(profiler.getMessage().indexOf("Decorator1"), lessThan(profiler.getMessage().indexOf("Decorator2")));
+ assertThat(profiler.getMessage().indexOf("Decorator1")).isLessThan(profiler.getMessage().indexOf("Decorator2"));
}
@Test
fail("Exception has not been thrown");
} catch (SonarException e) {
- assertThat(e.getMessage(), containsString("src/org/foo/Bar.java"));
+ assertThat(e.getMessage()).contains("src/org/foo/Bar.java");
}
}
import org.junit.Test;
import org.sonar.channel.CodeReader;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.fest.assertions.Assertions.assertThat;
public class CDocTokenizerTest {
@Test
public void testRead() {
CDocTokenizer tokenizer = new CDocTokenizer("<c>", "</c>");
- assertTrue(tokenizer.consume(new CodeReader("//this is a comment"), codeBuilder));
- assertThat(codeBuilder.toString(), is("<c>//this is a comment</c>"));
+ assertThat(tokenizer.consume(new CodeReader("//this is a comment"), codeBuilder)).isTrue();
+ assertThat(codeBuilder.toString()).isEqualTo("<c>//this is a comment</c>");
- assertFalse(tokenizer.consume(new CodeReader("this is not a comment"), codeBuilder));
- assertThat(codeBuilder.toString(), is("<c>//this is a comment</c>"));
+ assertThat(tokenizer.consume(new CodeReader("this is not a comment"), codeBuilder)).isFalse();
+ assertThat(codeBuilder.toString()).isEqualTo("<c>//this is a comment</c>");
}
}
*/
package org.sonar.colorizer;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
-import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
-
import org.junit.Test;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
+
public class CaseInsensitiveKeywordsTokenizerTest {
@Test
public void hasNextToken() {
CaseInsensitiveKeywordsTokenizer tokenizer = new CaseInsensitiveKeywordsTokenizer("<k>", "</k>", "PROCEDURE");
- assertThat(highlight("procedure name", tokenizer), is("<k>procedure</k> name"));
- assertThat(highlight("Procedure name", tokenizer), is("<k>Procedure</k> name"));
- assertThat(highlight("PROCEDURE name", tokenizer), is("<k>PROCEDURE</k> name"));
+ assertThat(highlight("procedure name", tokenizer)).isEqualTo("<k>procedure</k> name");
+ assertThat(highlight("Procedure name", tokenizer)).isEqualTo("<k>Procedure</k> name");
+ assertThat(highlight("PROCEDURE name", tokenizer)).isEqualTo("<k>PROCEDURE</k> name");
}
@Test
public void testClone() {
CaseInsensitiveKeywordsTokenizer tokenizer = new CaseInsensitiveKeywordsTokenizer("<k>", "</k>", "PROCEDURE");
Tokenizer cloneTokenizer = tokenizer.clone();
- assertThat(tokenizer, is(not(cloneTokenizer)));
- assertThat(highlight("procedure name", cloneTokenizer), is("<k>procedure</k> name"));
+ assertThat(tokenizer).isNotEqualTo(cloneTokenizer);
+ assertThat(highlight("procedure name", cloneTokenizer)).isEqualTo("<k>procedure</k> name");
}
}
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsNot.not;
-import static org.hamcrest.number.OrderingComparisons.greaterThan;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
public class CodeColorizerTest {
HtmlOptions options = new HtmlOptions(true, "my-table-id", false);
String html = CodeColorizer.javaToHtml(java, options);
- assertThat(html, containsString("<table class=\"code\" id=\"my-table-id\""));
- assertThat(html, not(containsString("<style")));
+ assertThat(html).contains("<table class=\"code\" id=\"my-table-id\"");
+ assertThat(html).doesNotContain("<style");
}
@Test
@Test
public void getCss() {
- assertThat(CodeColorizer.getCss().length(), greaterThan(100));
- assertThat(CodeColorizer.getCss(), containsString(".code"));
+ assertThat(CodeColorizer.getCss().length()).isGreaterThan(100);
+ assertThat(CodeColorizer.getCss()).contains(".code");
}
@Test
}
List<Future<String>> futures = Executors.newFixedThreadPool(threadCount).invokeAll(tasks);
- assertThat(futures.size(), is(taskCount));
+ assertThat(futures).hasSize(taskCount);
// all html must be the same
String html = futures.get(0).get();
for (Future<String> future : futures) {
- assertEquals(html, future.get());
+ assertThat(html).isEqualTo(future.get());
}
}
assertHtml(html);
assertContains(html, "<pre> <span class=\"cppd\">/*</span></pre>",
-
"<pre><span class=\"cppd\"> * This method does <b>something</b></span></pre>",
-
"<pre><span class=\"cppd\"> *</span></pre>",
-
"<pre><span class=\"cppd\"> * &lt;p&gt;description&lt;/p&gt;</span></pre>",
-
"<pre><span class=\"cppd\"> */</span></pre>");
+ "<pre><span class=\"cppd\"> * This method does <b>something</b></span></pre>",
+ "<pre><span class=\"cppd\"> *</span></pre>",
+ "<pre><span class=\"cppd\"> * &lt;p&gt;description&lt;/p&gt;</span></pre>",
+ "<pre><span class=\"cppd\"> */</span></pre>");
}
/**
private void assertContains(String html, String... strings) {
for (String string : strings) {
- assertThat(html, containsString(string));
+ assertThat(html).contains(string);
}
}
}
import org.junit.Before;
import org.junit.Test;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.core.IsNull.nullValue;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
public class HtmlCodeBuilderTest {
@Test
public void testAppendCharSequence() {
builder.append("freddy < olivier");
- assertEquals("freddy < olivier", builder.toString());
+ assertThat("freddy < olivier").isEqualTo(builder.toString());
}
@Test
builder.append('p');
builder.append('a');
builder.append('>');
- assertEquals("pa>", builder.toString());
+ assertThat("pa>").isEqualTo(builder.toString());
}
@Test
public void testAppendCharSequenceIntInt() {
builder.append("freddy < olivier", 0, 2);
- assertEquals("fr", builder.toString());
+ assertThat("fr").isEqualTo(builder.toString());
}
@Test
public void testAppendWithoutTransforming() {
builder.appendWithoutTransforming("<inside>outside");
- assertEquals("<inside>outside", builder.toString());
+ assertThat("<inside>outside").isEqualTo(builder.toString());
}
@Test
public void testStatefulVariables() {
- assertThat(builder.getVariable("foo"), nullValue());
+ assertThat(builder.getVariable("foo")).isNull();
builder.setVariable("foo", "xxx");
- assertThat((String) builder.getVariable("foo"), is("xxx"));
+ assertThat((String) builder.getVariable("foo")).isEqualTo(("xxx"));
builder.setVariable("foo", "yyy");
- assertThat((String) builder.getVariable("foo"), is("yyy"));
+ assertThat((String) builder.getVariable("foo")).isEqualTo(("yyy"));
builder.setVariable("foo", null);
- assertThat(builder.getVariable("foo"), nullValue());
+ assertThat(builder.getVariable("foo")).isNull();
- assertThat((String) builder.getVariable("foo", "default"), is("default"));
+ assertThat((String) builder.getVariable("foo", "default")).isEqualTo(("default"));
}
}
*/
package org.sonar.colorizer;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.core.IsNot.not;
-import static org.hamcrest.number.OrderingComparisons.greaterThan;
-import static org.junit.Assert.assertThat;
-import static org.junit.internal.matchers.StringContains.containsString;
-
import org.junit.Test;
import org.sonar.channel.CodeReader;
+import static org.fest.assertions.Assertions.assertThat;
+
public class HtmlDecoratorTest {
@Test
HtmlCodeBuilder output = new HtmlCodeBuilder();
output.appendWithoutTransforming(decorator.getTagBeginOfFile());
- assertThat(decorator.consume(code, output), is(true));
- assertThat(decorator.consume(code, output), is(true));
- assertThat(decorator.consume(code, output), is(true));
+ assertThat(decorator.consume(code, output)).isTrue();
+ assertThat(decorator.consume(code, output)).isTrue();
+ assertThat(decorator.consume(code, output)).isTrue();
output.appendWithoutTransforming(decorator.getTagEndOfFile());
-
- assertThat(output.toString(), is(
-
"<table class=\"code\" id=\"\"><tbody>"
- + "<tr id=\"1\"><td><pre></pre></td></tr>"
- + "<tr id=\"2\"><td><pre></pre></td></tr>"
+
+ assertThat(output.toString()).isEqualTo(
+ "<table class=\"code\" id=\"\"><tbody>"
+ + "<tr id=\"1\"><td><pre></pre></td></tr>"
+ + "<tr id=\"2\"><td><pre></pre></td></tr>"
+ "<tr id=\"3\"><td><pre></pre></td></tr>"
- + "</tbody></table>"));
+ + "</tbody></table>"
+ );
}
@Test
public void getCss() {
- assertThat(HtmlDecorator.getCss().length(), greaterThan(100));
- assertThat(HtmlDecorator.getCss(), containsString(".code"));
+ assertThat(HtmlDecorator.getCss().length()).isGreaterThan(100);
+ assertThat(HtmlDecorator.getCss()).contains(".code");
}
public void assertContains(String html, String... strings) {
for (String string : strings) {
- assertThat(html, containsString(string));
+ assertThat(html).contains(string);
}
}
public void assertNotContains(String html, String... strings) {
for (String string : strings) {
- assertThat(html, not(containsString(string)));
+ assertThat(html).doesNotContain(string);
}
}
}
import java.io.StringReader;
import java.util.Arrays;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
-import static org.junit.internal.matchers.StringContains.containsString;
+import static org.fest.assertions.Assertions.assertThat;
public class HtmlRendererTest {
String html = htmlRenderer.render(new StringReader("public class Hello {"), Arrays.asList(javaKeywordTokenizer));
- assertThat(html, is("<span class='k'>public</span> <span class='k'>class</span> Hello {"));
+ assertThat(html).isEqualTo("<span class='k'>public</span> <span class='k'>class</span> Hello {");
}
@Test
String html = htmlRenderer.render(new StringReader("foo(\"<html>\");"), Arrays.asList(new LiteralTokenizer("<s>", "</s>")));
- assertThat(html, is("foo(<s>\"<html>\"</s>);"));
+ assertThat(html).isEqualTo("foo(<s>\"<html>\"</s>);");
}
@Test
String html = new HtmlRenderer().render(new FileReader(java), Arrays.asList(javaKeywordTokenizer));
- assertThat(html, containsString("<html>"));
- assertThat(html, containsString("<style"));
- assertThat(html, containsString("<table class=\"code\""));
- assertThat(html, containsString("public"));
- assertThat(html, containsString("class"));
- assertThat(html, containsString("Sample"));
- assertThat(html, containsString("</html>"));
+ assertThat(html).contains("<html>");
+ assertThat(html).contains("<style");
+ assertThat(html).contains("<table class=\"code\"");
+ assertThat(html).contains("public");
+ assertThat(html).contains("class");
+ assertThat(html).contains("Sample");
+ assertThat(html).contains("</html>");
}
}
*/
package org.sonar.colorizer;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
-
import org.junit.Test;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
+
public class JavaAnnotationTokenizerTest {
JavaAnnotationTokenizer tokenizer = new JavaAnnotationTokenizer("<a>", "</a>");
@Test
public void testHighlighting() {
- assertThat(highlight("@deprecated public", tokenizer), is("<a>@deprecated</a> public"));
- assertThat(highlight("import", tokenizer), is("import"));
+ assertThat(highlight("@deprecated public", tokenizer)).isEqualTo("<a>@deprecated</a> public");
+ assertThat(highlight("import", tokenizer)).isEqualTo("import");
}
@Test
public void testHighlightingWithProperties() {
- assertThat(highlight("@Target(ElementType.METHOD)", tokenizer), is("<a>@Target</a>(ElementType.METHOD)"));
+ assertThat(highlight("@Target(ElementType.METHOD)", tokenizer)).isEqualTo("<a>@Target</a>(ElementType.METHOD)");
}
}
*/
package org.sonar.colorizer;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
import org.junit.Test;
-import static org.junit.internal.matchers.IsCollectionContaining.hasItem;
+
+import static org.fest.assertions.Assertions.assertThat;
public class JavaKeywordsTest {
@Test
public void get() {
- assertThat(JavaKeywords.get().size(), is(53));
- assertThat(JavaKeywords.get(), hasItem("true"));
- assertThat(JavaKeywords.get(), hasItem("public"));
- assertThat(JavaKeywords.get(), hasItem("switch"));
+ assertThat(JavaKeywords.get()).hasSize(53);
+ assertThat(JavaKeywords.get()).contains("true", "public", "switch");
}
}
import org.junit.Test;
-import static junit.framework.Assert.fail;
-
-import static org.hamcrest.number.OrderingComparisons.greaterThan;
-import static org.hamcrest.number.OrderingComparisons.lessThan;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.junit.Assert.fail;
public class JavaTokenizersTest {
@Test
public void forHtml() {
- assertThat(JavaTokenizers.forHtml().size(), greaterThan(3));
+ assertThat(JavaTokenizers.forHtml().size()).isGreaterThan(3);
}
@Test
public void javadocIsDefinedBeforeCppComment() {
// just because /** must be detected before /*
- assertThat(indexOf(JavaTokenizers.forHtml(), JavadocTokenizer.class),
- lessThan(indexOf(JavaTokenizers.forHtml(), CppDocTokenizer.class)));
+ assertThat(indexOf(JavaTokenizers.forHtml(), JavadocTokenizer.class)).isLessThan(
+ indexOf(JavaTokenizers.forHtml(), CppDocTokenizer.class));
}
private Integer indexOf(List<Tokenizer> tokenizers, Class tokenizerClass) {
*/
package org.sonar.colorizer;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
-
import org.junit.Test;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
+
public class JavadocTokenizerTest {
JavadocTokenizer tokenizer = new JavadocTokenizer("<j>", "</j>");
@Test
public void testHighlighting() {
- assertThat(highlight("/**this is a javadoc*/ public ...", tokenizer), is("<j>/**this is a javadoc*/</j> public ..."));
- assertThat(highlight("//this is not a javadoc", tokenizer), is("//this is not a javadoc"));
+ assertThat(highlight("/**this is a javadoc*/ public ...", tokenizer)).isEqualTo("<j>/**this is a javadoc*/</j> public ...");
+ assertThat(highlight("//this is not a javadoc", tokenizer)).isEqualTo("//this is not a javadoc");
}
@Test
public void testHighlightingOnMultipleLines() {
- assertThat(highlight("/**this is \n a javadoc*/ private", tokenizer), is("<j>/**this is </j>\n<j> a javadoc*/</j> private"));
+ assertThat(highlight("/**this is \n a javadoc*/ private", tokenizer)).isEqualTo("<j>/**this is </j>\n<j> a javadoc*/</j> private");
}
}
*/
package org.sonar.colorizer;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
import org.junit.Test;
@Test
public void testColorizeKeywords() {
KeywordsTokenizer tokenizer = new KeywordsTokenizer("<s>", "</s>", "public", "new");
- assertThat(highlight("new()", tokenizer), is("<s>new</s>()"));
- assertThat(highlight("public new get()", tokenizer), is("<s>public</s> <s>new</s> get()"));
- assertThat(highlight("publication", tokenizer), is("publication"));
+ assertThat(highlight("new()", tokenizer)).isEqualTo("<s>new</s>()");
+ assertThat(highlight("public new get()", tokenizer)).isEqualTo("<s>public</s> <s>new</s> get()");
+ assertThat(highlight("publication", tokenizer)).isEqualTo("publication");
}
@Test
public void testUnderscoreAndDigit() {
KeywordsTokenizer tokenizer = new KeywordsTokenizer("<s>", "</s>", "_01public");
- assertThat(highlight("_01public", tokenizer), is("<s>_01public</s>"));
+ assertThat(highlight("_01public", tokenizer)).isEqualTo("<s>_01public</s>");
}
@Test
public void testCaseSensitive() {
KeywordsTokenizer tokenizer = new KeywordsTokenizer("<s>", "</s>", "public");
- assertThat(highlight("PUBLIC Public public", tokenizer), is("PUBLIC Public <s>public</s>"));
+ assertThat(highlight("PUBLIC Public public", tokenizer)).isEqualTo("PUBLIC Public <s>public</s>");
}
@Test
public void testClone() {
KeywordsTokenizer tokenizer = new KeywordsTokenizer("<s>", "</s>", "public", "[a-z]+");
KeywordsTokenizer cloneTokenizer = tokenizer.clone();
- assertThat(tokenizer, is(not(cloneTokenizer)));
- assertThat(highlight("public 1234", cloneTokenizer), is("<s>public</s> 1234"));
+ assertThat(tokenizer).isNotEqualTo(cloneTokenizer);
+ assertThat(highlight("public 1234", cloneTokenizer)).isEqualTo("<s>public</s> 1234");
}
}
*/
package org.sonar.colorizer;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
-import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
-
import org.junit.Test;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.sonar.colorizer.SyntaxHighlighterTestingHarness.highlight;
+
public class RegexpTokenizerTest {
- RegexpTokenizer tokenHighlighter;;
+ RegexpTokenizer tokenHighlighter;
+ ;
@Test
public void testHighlight() {
tokenHighlighter = new RegexpTokenizer("<r>", "</r>", "[0-9]+");
- assertThat(highlight("123, word = 435;", tokenHighlighter), is("<r>123</r>, word = <r>435</r>;"));
+ assertThat(highlight("123, word = 435;", tokenHighlighter)).isEqualTo("<r>123</r>, word = <r>435</r>;");
}
-
+
@Test
public void testClone() {
RegexpTokenizer tokenizer = new RegexpTokenizer("<r>", "</r>", "[a-z]+");
RegexpTokenizer cloneTokenizer = tokenizer.clone();
- assertThat(tokenizer, is(not(cloneTokenizer)));
- assertThat(highlight("public 1234", cloneTokenizer), is("<r>public</r> 1234"));
+ assertThat(tokenizer).isNotEqualTo(cloneTokenizer);
+ assertThat(highlight("public 1234", cloneTokenizer)).isEqualTo("<r>public</r> 1234");
}
}
*/
package org.sonar.colorizer;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-import java.util.Arrays;
-
import org.junit.Test;
import org.sonar.channel.Channel;
import org.sonar.channel.CodeReader;
+import java.util.Arrays;
+
+import static org.fest.assertions.Assertions.assertThat;
+
public class TokenizerDispatcherTest {
@Test
public void testPipeCodeTokenizer() {
TokenizerDispatcher colorization = newColorizer();
- assertThat(colorization.colorize("public void get(){"), is("public void get(){"));
+ assertThat(colorization.colorize("public void get(){")).isEqualTo("public void get(){");
}
@Test
public void testKeywordsCodeTokenizer() {
TokenizerDispatcher colorization = newColorizer(new KeywordsTokenizer("<k>", "</k>", JavaKeywords.get()));
- assertThat(colorization.colorize("public void get(){"), is("<k>public</k> <k>void</k> get(){"));
+ assertThat(colorization.colorize("public void get(){")).isEqualTo("<k>public</k> <k>void</k> get(){");
}
@Test
public void testPriorityToComment() {
TokenizerDispatcher colorization = newColorizer(new CDocTokenizer("<c>", "</c>"), new KeywordsTokenizer("<k>", "</k>", JavaKeywords
- .get()));
- assertThat(colorization.colorize("assert //public void get(){"), is("<k>assert</k> <c>//public void get(){</c>"));
+ .get()));
+ assertThat(colorization.colorize("assert //public void get(){")).isEqualTo("<k>assert</k> <c>//public void get(){</c>");
}
@Test
public void testCommentThenStringThenJavaKeywords() {
TokenizerDispatcher colorization = newColorizer(new CDocTokenizer("<c>", "</c>"), new LiteralTokenizer("<s>", "</s>"),
- new KeywordsTokenizer("<k>", "</k>", JavaKeywords.get()));
- assertThat(colorization.colorize("assert(\"message\"); //comment"), is("<k>assert</k>(<s>\"message\"</s>); <c>//comment</c>"));
+ new KeywordsTokenizer("<k>", "</k>", JavaKeywords.get()));
+ assertThat(colorization.colorize("assert(\"message\"); //comment")).isEqualTo("<k>assert</k>(<s>\"message\"</s>); <c>//comment</c>");
}
@Test(expected = IllegalStateException.class)
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>sonar-testing-harness</artifactId>
- <version>${project.version}</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
import org.junit.Test;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
public class MethodTest {
import java.util.Map;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
final Map<RulePriority, Integer> map = RuleUtils.getPriorityWeights(conf);
- assertThat(map.get(RulePriority.BLOCKER), is(10));
- assertThat(map.get(RulePriority.CRITICAL), is(5));
- assertThat(map.get(RulePriority.MAJOR), is(2));
- assertThat(map.get(RulePriority.MINOR), is(1));
- assertThat(map.get(RulePriority.INFO), is(0));
+ assertThat(map.get(RulePriority.BLOCKER)).isEqualTo(10);
+ assertThat(map.get(RulePriority.CRITICAL)).isEqualTo(5);
+ assertThat(map.get(RulePriority.MAJOR)).isEqualTo(2);
+ assertThat(map.get(RulePriority.MINOR)).isEqualTo(1);
+ assertThat(map.get(RulePriority.INFO)).isEqualTo(0);
}
@Test
final Map<RulePriority, Integer> map = RuleUtils.getPriorityWeights(conf);
- assertThat(map.get(RulePriority.BLOCKER), is(1));
- assertThat(map.get(RulePriority.CRITICAL), is(5));
- assertThat(map.get(RulePriority.MAJOR), is(1));
- assertThat(map.get(RulePriority.MINOR), is(1));
- assertThat(map.get(RulePriority.INFO), is(1));
+ assertThat(map.get(RulePriority.BLOCKER)).isEqualTo(1);
+ assertThat(map.get(RulePriority.CRITICAL)).isEqualTo(5);
+ assertThat(map.get(RulePriority.MAJOR)).isEqualTo(1);
+ assertThat(map.get(RulePriority.MINOR)).isEqualTo(1);
+ assertThat(map.get(RulePriority.INFO)).isEqualTo(1);
}
}
import org.junit.Test;
import org.sonar.duplications.index.CloneGroup;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
public class DuplicationPredicatesTest {
@Test
public void testNumberOfUnitsNotLessThan() {
Predicate<CloneGroup> predicate = DuplicationPredicates.numberOfUnitsNotLessThan(5);
- assertThat(predicate.apply(CloneGroup.builder().setLengthInUnits(6).build()), is(true));
- assertThat(predicate.apply(CloneGroup.builder().setLengthInUnits(5).build()), is(true));
- assertThat(predicate.apply(CloneGroup.builder().setLengthInUnits(4).build()), is(false));
+ assertThat(predicate.apply(CloneGroup.builder().setLengthInUnits(6).build())).isTrue();
+ assertThat(predicate.apply(CloneGroup.builder().setLengthInUnits(5).build())).isTrue();
+ assertThat(predicate.apply(CloneGroup.builder().setLengthInUnits(4).build())).isFalse();
}
}
import java.util.Collections;
import java.util.List;
-import static org.hamcrest.Matchers.*;
+import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.assertThat;
/**
import org.sonar.duplications.index.MemoryCloneIndex;
import org.sonar.duplications.junit.TestNamePrinter;
-import java.util.*;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
-import static org.hamcrest.Matchers.*;
+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.*;
+import static org.junit.matchers.JUnitMatchers.hasItem;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.sonar.duplications.detector.CloneGroupMatcher.hasCloneGroup;
public abstract class DetectorTestCase {
*/
protected static Block newBlock(String resourceId, ByteArray hash, int index) {
return Block.builder()
- .setResourceId(resourceId)
- .setBlockHash(hash)
- .setIndexInFile(index)
- .setLines(index, index + LINES_PER_BLOCK)
- .build();
+ .setResourceId(resourceId)
+ .setBlockHash(hash)
+ .setIndexInFile(index)
+ .setLines(index, index + LINES_PER_BLOCK)
+ .build();
}
protected static ClonePart newClonePart(String resourceId, int unitStart, int cloneUnitLength) {
@Test
public void exampleFromPaper() {
CloneIndex index = createIndex(
- newBlocks("y", "2 3 4 5"),
- newBlocks("z", "3 4"));
+ newBlocks("y", "2 3 4 5"),
+ newBlocks("z", "3 4"));
Block[] fileBlocks = newBlocks("x", "1 2 3 4 5 6");
List<CloneGroup> result = detect(index, fileBlocks);
assertEquals(2, result.size());
assertThat(result, hasCloneGroup(4,
- newClonePart("x", 1, 4),
- newClonePart("y", 0, 4)));
+ newClonePart("x", 1, 4),
+ newClonePart("y", 0, 4)));
assertThat(result, hasCloneGroup(2,
- newClonePart("x", 2, 2),
- newClonePart("y", 1, 2),
- newClonePart("z", 0, 2)));
+ newClonePart("x", 2, 2),
+ newClonePart("y", 1, 2),
+ newClonePart("z", 0, 2)));
}
/**
@Test
public void exampleFromPaperWithModifiedResourceIds() {
CloneIndex cloneIndex = createIndex(
- newBlocks("a", "2 3 4 5"),
- newBlocks("b", "3 4"));
+ newBlocks("a", "2 3 4 5"),
+ newBlocks("b", "3 4"));
Block[] fileBlocks = newBlocks("c", "1 2 3 4 5 6");
List<CloneGroup> clones = detect(cloneIndex, fileBlocks);
assertThat(clones.size(), is(2));
assertThat(clones, hasCloneGroup(4,
- newClonePart("c", 1, 4),
- newClonePart("a", 0, 4)));
+ newClonePart("c", 1, 4),
+ newClonePart("a", 0, 4)));
assertThat(clones, hasCloneGroup(2,
- newClonePart("c", 2, 2),
- newClonePart("a", 1, 2),
- newClonePart("b", 0, 2)));
+ newClonePart("c", 2, 2),
+ newClonePart("a", 1, 2),
+ newClonePart("b", 0, 2)));
}
/**
@Test
public void example1() {
CloneIndex index = createIndex(
- newBlocks("b", "3 4 5 6"),
- newBlocks("c", "5 6 7"));
+ newBlocks("b", "3 4 5 6"),
+ newBlocks("c", "5 6 7"));
Block[] fileBlocks = newBlocks("a", "1 2 3 4 5 6 7 8 9");
List<CloneGroup> result = detect(index, fileBlocks);
assertThat(result.size(), is(3));
assertThat(result, hasCloneGroup(4,
- newClonePart("a", 2, 4),
- newClonePart("b", 0, 4)));
+ newClonePart("a", 2, 4),
+ newClonePart("b", 0, 4)));
assertThat(result, hasCloneGroup(3,
- newClonePart("a", 4, 3),
- newClonePart("c", 0, 3)));
+ newClonePart("a", 4, 3),
+ newClonePart("c", 0, 3)));
assertThat(result, hasCloneGroup(2,
- newClonePart("a", 4, 2),
- newClonePart("b", 2, 2),
- newClonePart("c", 0, 2)));
+ newClonePart("a", 4, 2),
+ newClonePart("b", 2, 2),
+ newClonePart("c", 0, 2)));
}
/**
@Test
public void example2() {
CloneIndex index = createIndex(
- newBlocks("b", "1 2 3 4 1 2 3 4 1 2 3 4"),
- newBlocks("c", "1 2 3 4"));
+ newBlocks("b", "1 2 3 4 1 2 3 4 1 2 3 4"),
+ newBlocks("c", "1 2 3 4"));
Block[] fileBlocks = newBlocks("a", "1 2 3 5");
List<CloneGroup> result = detect(index, fileBlocks);
assertThat(result.size(), is(1));
assertThat(result, hasCloneGroup(3,
- newClonePart("a", 0, 3),
- newClonePart("b", 0, 3),
- newClonePart("b", 4, 3),
- newClonePart("b", 8, 3),
- newClonePart("c", 0, 3)));
+ newClonePart("a", 0, 3),
+ newClonePart("b", 0, 3),
+ newClonePart("b", 4, 3),
+ newClonePart("b", 8, 3),
+ newClonePart("c", 0, 3)));
}
/**
assertThat(result.size(), is(1));
assertThat(result, hasCloneGroup(2,
- newClonePart("a", 0, 2),
- newClonePart("a", 3, 2)));
+ newClonePart("a", 0, 2),
+ newClonePart("a", 3, 2)));
}
/**
@Test
public void covered() {
CloneIndex index = createIndex(
- newBlocks("b", "1 2 1 2"));
+ newBlocks("b", "1 2 1 2"));
Block[] fileBlocks = newBlocks("a", "1 2 1");
List<CloneGroup> result = detect(index, fileBlocks);
assertThat(result.size(), is(2));
assertThat(result, hasCloneGroup(3,
- newClonePart("a", 0, 3),
- newClonePart("b", 0, 3)));
+ newClonePart("a", 0, 3),
+ newClonePart("b", 0, 3)));
assertThat(result, hasCloneGroup(2,
- newClonePart("a", 0, 2),
- newClonePart("b", 0, 2),
- newClonePart("b", 2, 2)));
+ newClonePart("a", 0, 2),
+ newClonePart("b", 0, 2),
+ newClonePart("b", 2, 2)));
}
/**
@Test
public void problemWithNestedCloneGroups() {
CloneIndex index = createIndex(
- newBlocks("b", "1 2 1 2 1 2 1"));
+ newBlocks("b", "1 2 1 2 1 2 1"));
Block[] fileBlocks = newBlocks("a", "1 2 1 2 1 2");
List<CloneGroup> result = detect(index, fileBlocks);
assertThat(result.size(), is(2));
assertThat(result, hasCloneGroup(6,
- newClonePart("a", 0, 6),
- newClonePart("b", 0, 6)));
+ newClonePart("a", 0, 6),
+ newClonePart("b", 0, 6)));
assertThat(result, hasCloneGroup(5,
- newClonePart("a", 0, 5),
- newClonePart("b", 0, 5),
- newClonePart("b", 2, 5)));
+ newClonePart("a", 0, 5),
+ newClonePart("b", 0, 5),
+ newClonePart("b", 2, 5)));
}
/**
@Test
public void fileAlreadyInIndex() {
CloneIndex index = createIndex(
- newBlocks("a", "1 2 3"),
- newBlocks("b", "1 2 4"));
+ newBlocks("a", "1 2 3"),
+ newBlocks("b", "1 2 4"));
// Note about blocks with hashes "3", "4" and "5": those blocks here in order to not face another problem - with EOF (see separate test)
Block[] fileBlocks = newBlocks("a", "1 2 5");
List<CloneGroup> result = detect(index, fileBlocks);
assertThat(result.size(), is(1));
assertThat(result, hasCloneGroup(2,
- newClonePart("a", 0, 2),
- newClonePart("b", 0, 2)));
+ newClonePart("a", 0, 2),
+ newClonePart("b", 0, 2)));
}
/**
@Test
public void problemWithEndOfFile() {
CloneIndex cloneIndex = createIndex(
- newBlocks("b", "1 2 3 4"));
+ newBlocks("b", "1 2 3 4"));
Block[] fileBlocks =
- newBlocks("a", "1 2 3");
+ newBlocks("a", "1 2 3");
List<CloneGroup> clones = detect(cloneIndex, fileBlocks);
print(clones);
assertThat(clones.size(), is(1));
assertThat(clones, hasCloneGroup(3,
- newClonePart("a", 0, 3),
- newClonePart("b", 0, 3)));
+ newClonePart("a", 0, 3),
+ newClonePart("b", 0, 3)));
}
/**
public void same_lines_but_different_indexes() {
CloneIndex cloneIndex = createIndex();
Block.Builder block = Block.builder()
- .setResourceId("a")
- .setLines(0, 1);
- Block[] fileBlocks = new Block[] {
+ .setResourceId("a")
+ .setLines(0, 1);
+ Block[] fileBlocks = new Block[]{
block.setBlockHash(new ByteArray("1".getBytes())).setIndexInFile(0).build(),
block.setBlockHash(new ByteArray("2".getBytes())).setIndexInFile(1).build(),
block.setBlockHash(new ByteArray("1".getBytes())).setIndexInFile(2).build()
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.io.IOException;
import java.util.List;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
public class TokenizerBridgeTest {
import java.util.Collection;
import java.util.List;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
/**
import java.io.Reader;
import java.util.List;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.number.OrderingComparisons.greaterThan;
-import static org.junit.Assert.assertThat;
+import static org.fest.assertions.Assertions.assertThat;
public class JavaStatementBuilderTest {
@Test
public void shouldIgnoreImportStatement() {
- assertThat(chunk("import org.sonar.duplications.java;").size(), is(0));
+ assertThat(chunk("import org.sonar.duplications.java;")).isEmpty();
}
@Test
public void shouldIgnorePackageStatement() {
- assertThat(chunk("package org.sonar.duplications.java;").size(), is(0));
+ assertThat(chunk("package org.sonar.duplications.java;")).isEmpty();
}
@Test
"@Entity" +
"@Table(name = \"properties\")" +
"@Column(updatable = true, nullable = true)");
- assertThat(statements.size(), is(3));
- assertThat(statements.get(0).getValue(), is("@Entity"));
- assertThat(statements.get(1).getValue(), is("@Table(name=$CHARS)"));
- assertThat(statements.get(2).getValue(), is("@Column(updatable=true,nullable=true)"));
+ assertThat(statements).hasSize(3);
+ assertThat(statements.get(0).getValue()).isEqualTo("@Entity");
+ assertThat(statements.get(1).getValue()).isEqualTo("@Table(name=$CHARS)");
+ assertThat(statements.get(2).getValue()).isEqualTo("@Column(updatable=true,nullable=true)");
}
@Test
public void shouldHandleIf() {
List<Statement> statements = chunk("if (a > b) { something(); }");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("if(a>b)"));
- assertThat(statements.get(1).getValue(), is("something()"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("if(a>b)");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
statements = chunk("if (a > b) { something(); } else { somethingOther(); }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("if(a>b)"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("else"));
- assertThat(statements.get(3).getValue(), is("somethingOther()"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("if(a>b)");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("else");
+ assertThat(statements.get(3).getValue()).isEqualTo("somethingOther()");
statements = chunk("if (a > 0) { something(); } else if (a == 0) { somethingOther(); }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("if(a>$NUMBER)"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("elseif(a==$NUMBER)"));
- assertThat(statements.get(3).getValue(), is("somethingOther()"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("if(a>$NUMBER)");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("elseif(a==$NUMBER)");
+ assertThat(statements.get(3).getValue()).isEqualTo("somethingOther()");
}
@Test
public void shouldHandleFor() {
List<Statement> statements = chunk("for (int i = 0; i < 10; i++) { something(); }");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("for(inti=$NUMBER;i<$NUMBER;i++)"));
- assertThat(statements.get(1).getValue(), is("something()"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("for(inti=$NUMBER;i<$NUMBER;i++)");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
statements = chunk("for (Item item : items) { something(); }");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("for(Itemitem:items)"));
- assertThat(statements.get(1).getValue(), is("something()"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("for(Itemitem:items)");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
}
@Test
public void shouldHandleWhile() {
List<Statement> statements = chunk("while (i < args.length) { something(); }");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("while(i<args.length)"));
- assertThat(statements.get(1).getValue(), is("something()"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("while(i<args.length)");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
statements = chunk("while (true);");
- assertThat(statements.size(), is(1));
- assertThat(statements.get(0).getValue(), is("while(true)"));
+ assertThat(statements.size()).isEqualTo(1);
+ assertThat(statements.get(0).getValue()).isEqualTo("while(true)");
}
@Test
public void shouldHandleDoWhile() {
List<Statement> statements = chunk("do { something(); } while (true);");
- assertThat(statements.size(), is(3));
- assertThat(statements.get(0).getValue(), is("do"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("while(true)"));
+ assertThat(statements.size()).isEqualTo(3);
+ assertThat(statements.get(0).getValue()).isEqualTo("do");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("while(true)");
}
@Test
" case 2 : monthString=\"February\"; break;" +
" default: monthString=\"Invalid\";" +
"}");
- assertThat(statements.size(), is(6));
- assertThat(statements.get(0).getValue(), is("switch(month)"));
- assertThat(statements.get(1).getValue(), is("case$NUMBER:monthString=$CHARS"));
- assertThat(statements.get(2).getValue(), is("break"));
- assertThat(statements.get(3).getValue(), is("case$NUMBER:monthString=$CHARS"));
- assertThat(statements.get(4).getValue(), is("break"));
- assertThat(statements.get(5).getValue(), is("default:monthString=$CHARS"));
+ assertThat(statements.size()).isEqualTo(6);
+ assertThat(statements.get(0).getValue()).isEqualTo("switch(month)");
+ assertThat(statements.get(1).getValue()).isEqualTo("case$NUMBER:monthString=$CHARS");
+ assertThat(statements.get(2).getValue()).isEqualTo("break");
+ assertThat(statements.get(3).getValue()).isEqualTo("case$NUMBER:monthString=$CHARS");
+ assertThat(statements.get(4).getValue()).isEqualTo("break");
+ assertThat(statements.get(5).getValue()).isEqualTo("default:monthString=$CHARS");
}
/**
" case 'a': case 'b': case 'c': something(); break;" +
" case 'd': case 'e': case 'f': somethingOther(); break;" +
"}");
- assertThat(statements.size(), is(5));
- assertThat(statements.get(0).getValue(), is("switch(a)"));
- assertThat(statements.get(1).getValue(), is("case$CHARS:case$CHARS:case$CHARS:something()"));
- assertThat(statements.get(2).getValue(), is("break"));
- assertThat(statements.get(3).getValue(), is("case$CHARS:case$CHARS:case$CHARS:somethingOther()"));
- assertThat(statements.get(4).getValue(), is("break"));
+ assertThat(statements.size()).isEqualTo(5);
+ assertThat(statements.get(0).getValue()).isEqualTo("switch(a)");
+ assertThat(statements.get(1).getValue()).isEqualTo("case$CHARS:case$CHARS:case$CHARS:something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("break");
+ assertThat(statements.get(3).getValue()).isEqualTo("case$CHARS:case$CHARS:case$CHARS:somethingOther()");
+ assertThat(statements.get(4).getValue()).isEqualTo("break");
}
@Test
public void shouldHandleArray() {
List<Statement> statements = chunk("new Integer[] { 1, 2, 3, 4 };");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("newInteger[]"));
- assertThat(statements.get(1).getValue(), is("{$NUMBER,$NUMBER,$NUMBER,$NUMBER}"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("newInteger[]");
+ assertThat(statements.get(1).getValue()).isEqualTo("{$NUMBER,$NUMBER,$NUMBER,$NUMBER}");
}
/**
@Test
public void shouldHandleMultidimensionalArray() {
List<Statement> statements = chunk("new Integer[][] { { 1, 2 }, {3, 4} };");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("newInteger[][]"));
- assertThat(statements.get(1).getValue(), is("{{$NUMBER,$NUMBER},{$NUMBER,$NUMBER}}"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("newInteger[][]");
+ assertThat(statements.get(1).getValue()).isEqualTo("{{$NUMBER,$NUMBER},{$NUMBER,$NUMBER}}");
statements = chunk("new Integer[][] { null, {3, 4} };");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("newInteger[][]"));
- assertThat(statements.get(1).getValue(), is("{null,{$NUMBER,$NUMBER}}"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("newInteger[][]");
+ assertThat(statements.get(1).getValue()).isEqualTo("{null,{$NUMBER,$NUMBER}}");
}
@Test
public void shouldHandleTryCatch() {
List<Statement> statements;
statements = chunk("try { } catch (Exception e) { }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("{}"));
- assertThat(statements.get(2).getValue(), is("catch(Exceptione)"));
- assertThat(statements.get(3).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("{}");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exceptione)");
+ assertThat(statements.get(3).getValue()).isEqualTo("{}");
statements = chunk("try { something(); } catch (Exception e) { }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("catch(Exceptione)"));
- assertThat(statements.get(3).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exceptione)");
+ assertThat(statements.get(3).getValue()).isEqualTo("{}");
statements = chunk("try { something(); } catch (Exception e) { onException(); }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("catch(Exceptione)"));
- assertThat(statements.get(3).getValue(), is("onException()"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exceptione)");
+ assertThat(statements.get(3).getValue()).isEqualTo("onException()");
statements = chunk("try { something(); } catch (Exception1 e) { onException1(); } catch (Exception2 e) { onException2(); }");
- assertThat(statements.size(), is(6));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("catch(Exception1e)"));
- assertThat(statements.get(3).getValue(), is("onException1()"));
- assertThat(statements.get(4).getValue(), is("catch(Exception2e)"));
- assertThat(statements.get(5).getValue(), is("onException2()"));
+ assertThat(statements.size()).isEqualTo(6);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exception1e)");
+ assertThat(statements.get(3).getValue()).isEqualTo("onException1()");
+ assertThat(statements.get(4).getValue()).isEqualTo("catch(Exception2e)");
+ assertThat(statements.get(5).getValue()).isEqualTo("onException2()");
}
@Test
public void shouldHandleTryFinnaly() {
List<Statement> statements;
statements = chunk("try { } finally { }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("{}"));
- assertThat(statements.get(2).getValue(), is("finally"));
- assertThat(statements.get(3).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("{}");
+ assertThat(statements.get(2).getValue()).isEqualTo("finally");
+ assertThat(statements.get(3).getValue()).isEqualTo("{}");
statements = chunk("try { something(); } finally { }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("finally"));
- assertThat(statements.get(3).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("finally");
+ assertThat(statements.get(3).getValue()).isEqualTo("{}");
statements = chunk("try { something(); } finally { somethingOther(); }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("finally"));
- assertThat(statements.get(3).getValue(), is("somethingOther()"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("finally");
+ assertThat(statements.get(3).getValue()).isEqualTo("somethingOther()");
}
@Test
public void shouldHandleTryCatchFinally() {
List<Statement> statements;
statements = chunk("try { } catch (Exception e) {} finally { }");
- assertThat(statements.size(), is(6));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("{}"));
- assertThat(statements.get(2).getValue(), is("catch(Exceptione)"));
- assertThat(statements.get(3).getValue(), is("{}"));
- assertThat(statements.get(4).getValue(), is("finally"));
- assertThat(statements.get(5).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(6);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("{}");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exceptione)");
+ assertThat(statements.get(3).getValue()).isEqualTo("{}");
+ assertThat(statements.get(4).getValue()).isEqualTo("finally");
+ assertThat(statements.get(5).getValue()).isEqualTo("{}");
statements = chunk("try { something(); } catch (Exception e) { onException(); } finally { somethingOther(); }");
- assertThat(statements.size(), is(6));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("catch(Exceptione)"));
- assertThat(statements.get(3).getValue(), is("onException()"));
- assertThat(statements.get(4).getValue(), is("finally"));
- assertThat(statements.get(5).getValue(), is("somethingOther()"));
+ assertThat(statements.size()).isEqualTo(6);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exceptione)");
+ assertThat(statements.get(3).getValue()).isEqualTo("onException()");
+ assertThat(statements.get(4).getValue()).isEqualTo("finally");
+ assertThat(statements.get(5).getValue()).isEqualTo("somethingOther()");
}
/**
public void shouldHandleMultiCatch() {
List<Statement> statements;
statements = chunk("try { } catch (Exception1 | Exception2 e) { }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("{}"));
- assertThat(statements.get(2).getValue(), is("catch(Exception1|Exception2e)"));
- assertThat(statements.get(3).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("{}");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exception1|Exception2e)");
+ assertThat(statements.get(3).getValue()).isEqualTo("{}");
statements = chunk("try { something(); } catch (Exception1 | Exception2 e) { }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("catch(Exception1|Exception2e)"));
- assertThat(statements.get(3).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exception1|Exception2e)");
+ assertThat(statements.get(3).getValue()).isEqualTo("{}");
statements = chunk("try { something(); } catch (Exception1 | Exception2 e) { onException(); }");
- assertThat(statements.size(), is(4));
- assertThat(statements.get(0).getValue(), is("try"));
- assertThat(statements.get(1).getValue(), is("something()"));
- assertThat(statements.get(2).getValue(), is("catch(Exception1|Exception2e)"));
- assertThat(statements.get(3).getValue(), is("onException()"));
+ assertThat(statements.size()).isEqualTo(4);
+ assertThat(statements.get(0).getValue()).isEqualTo("try");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
+ assertThat(statements.get(2).getValue()).isEqualTo("catch(Exception1|Exception2e)");
+ assertThat(statements.get(3).getValue()).isEqualTo("onException()");
}
/**
public void shouldHandleTryWithResource() {
List<Statement> statements;
statements = chunk("try (FileInputStream in = new FileInputStream()) {}");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("try(FileInputStreamin=newFileInputStream())"));
- assertThat(statements.get(1).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("try(FileInputStreamin=newFileInputStream())");
+ assertThat(statements.get(1).getValue()).isEqualTo("{}");
statements = chunk("try (FileInputStream in = new FileInputStream(); FileOutputStream out = new FileOutputStream()) {}");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("try(FileInputStreamin=newFileInputStream();FileOutputStreamout=newFileOutputStream())"));
- assertThat(statements.get(1).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("try(FileInputStreamin=newFileInputStream();FileOutputStreamout=newFileOutputStream())");
+ assertThat(statements.get(1).getValue()).isEqualTo("{}");
statements = chunk("try (FileInputStream in = new FileInputStream(); FileOutputStream out = new FileOutputStream();) {}");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("try(FileInputStreamin=newFileInputStream();FileOutputStreamout=newFileOutputStream();)"));
- assertThat(statements.get(1).getValue(), is("{}"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("try(FileInputStreamin=newFileInputStream();FileOutputStreamout=newFileOutputStream();)");
+ assertThat(statements.get(1).getValue()).isEqualTo("{}");
statements = chunk("try (FileInputStream in = new FileInputStream()) { something(); }");
- assertThat(statements.size(), is(2));
- assertThat(statements.get(0).getValue(), is("try(FileInputStreamin=newFileInputStream())"));
- assertThat(statements.get(1).getValue(), is("something()"));
+ assertThat(statements.size()).isEqualTo(2);
+ assertThat(statements.get(0).getValue()).isEqualTo("try(FileInputStreamin=newFileInputStream())");
+ assertThat(statements.get(1).getValue()).isEqualTo("something()");
}
@Test
public void realExamples() {
- assertThat(chunk(DuplicationsTestUtil.findFile("/java/MessageResources.java")).size(), greaterThan(0));
- assertThat(chunk(DuplicationsTestUtil.findFile("/java/RequestUtils.java")).size(), greaterThan(0));
+ assertThat(chunk(DuplicationsTestUtil.findFile("/java/MessageResources.java")).size()).isGreaterThan(0);
+ assertThat(chunk(DuplicationsTestUtil.findFile("/java/RequestUtils.java")).size()).isGreaterThan(0);
}
private List<Statement> chunk(File file) {
import java.util.Arrays;
import java.util.List;
+import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.is;
-import static org.hamcrest.number.OrderingComparisons.greaterThan;
import static org.junit.Assert.assertThat;
public class JavaTokenProducerTest {
*/
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.Mockito.mock;
import static org.mockito.Mockito.spy;
*/
package org.sonar.duplications.token;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyZeroInteractions;
-
import org.junit.Test;
import org.sonar.channel.CodeReader;
+import static org.fest.assertions.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
public class BlackHoleTokenChannelTest {
@Test
TokenQueue output = mock(TokenQueue.class);
CodeReader codeReader = new CodeReader("ABCD");
- assertThat(channel.consume(codeReader, output), is(true));
- assertThat(codeReader.getLinePosition(), is(1));
- assertThat(codeReader.getColumnPosition(), is(3));
+ assertThat(channel.consume(codeReader, output)).isTrue();
+ assertThat(codeReader.getLinePosition()).isEqualTo(1);
+ assertThat(codeReader.getColumnPosition()).isEqualTo(3);
verifyZeroInteractions(output);
}
*/
package org.sonar.api.database.model;
-import org.hamcrest.core.Is;
import org.junit.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.internal.matchers.StringContains.containsString;
+import static org.fest.assertions.Assertions.assertThat;
public class UserTest {
@Test
public void testToString() {
User user = new User()
- .setEmail("super@m.an")
- .setLogin("superman")
- .setName("Superman");
- assertThat(user.toString(), containsString("super@m.an"));
- assertThat(user.toString(), containsString("superman"));
- assertThat(user.toString(), containsString("Superman"));
+ .setEmail("super@m.an")
+ .setLogin("superman")
+ .setName("Superman");
+ assertThat(user.toString()).contains("super@m.an");
+ assertThat(user.toString()).contains("superman");
+ assertThat(user.toString()).contains("Superman");
}
@Test
public void testEquals() {
User one = new User()
- .setLogin("one")
- .setName("One");
+ .setLogin("one")
+ .setName("One");
User two = new User()
- .setLogin("two")
- .setName("Two");
+ .setLogin("two")
+ .setName("Two");
- assertThat(one.equals(one), Is.is(true));
- assertThat(one.equals(new User().setLogin("one")), Is.is(true));
- assertThat(one.equals(two), Is.is(false));
+ assertThat(one.equals(one)).isTrue();
+ assertThat(one.equals(new User().setLogin("one"))).isTrue();
+ assertThat(one.equals(two)).isFalse();
- assertEquals(one.hashCode(), new User().setLogin("one").hashCode());
+ assertThat(one.hashCode()).isEqualTo(new User().setLogin("one").hashCode());
}
}
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
-import static org.junit.internal.matchers.IsCollectionContaining.hasItem;
-import static org.junit.matchers.JUnitMatchers.hasItems;
+import static org.fest.assertions.Assertions.assertThat;
public class ManifestUtilsTest {
@Rule
public TemporaryFolder tempDir = new TemporaryFolder();
- @Test
+ @Test
public void emptyManifest() throws Exception {
Manifest mf = new Manifest();
File jar = createJar(mf, "emptyManifest.jar");
URLClassLoader classloader = new URLClassLoader(FileUtils.toURLs(new File[]{jar}));
- assertThat(ManifestUtils.getPropertyValues(classloader, "foo").size(), is(0));
+ assertThat(ManifestUtils.getPropertyValues(classloader, "foo")).isEmpty();
}
@Test
URLClassLoader classloader = new URLClassLoader(FileUtils.toURLs(new File[]{jar}));
List<String> values = ManifestUtils.getPropertyValues(classloader, "foo");
- assertThat(values.size(), is(1));
- assertThat(values, hasItem("bar"));
+ assertThat(values).containsOnly("bar");
}
@Test
URLClassLoader classloader = new URLClassLoader(FileUtils.toURLs(new File[]{jar1, jar2}));
List<String> values = ManifestUtils.getPropertyValues(classloader, "foo");
- assertThat(values.size(), is(2));
- assertThat(values, hasItems("bar", "otherbar"));
+ assertThat(values).containsOnly("bar", "otherbar");
}
private File createJar(Manifest mf, String name) throws Exception {
import org.junit.Test;
import org.slf4j.Logger;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-import static org.junit.internal.matchers.IsCollectionContaining.hasItem;
-import static org.junit.internal.matchers.StringContains.containsString;
+import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
public class ValidationMessagesTest {
@Test
public void emptyMessages() {
ValidationMessages messages = ValidationMessages.create();
- assertThat(messages.hasErrors(), is(false));
- assertThat(messages.hasWarnings(), is(false));
- assertThat(messages.hasInfos(), is(false));
+ assertThat(messages.hasErrors()).isFalse();
+ assertThat(messages.hasWarnings()).isFalse();
+ assertThat(messages.hasInfos()).isFalse();
Logger logger = mock(Logger.class);
messages.log(logger);
public void addError() {
ValidationMessages messages = ValidationMessages.create();
messages.addErrorText("my error");
- assertThat(messages.hasErrors(), is(true));
- assertThat(messages.hasWarnings(), is(false));
- assertThat(messages.hasInfos(), is(false));
- assertThat(messages.getErrors().size(), is(1));
- assertThat(messages.getErrors(), hasItem("my error"));
- assertThat(messages.toString(), containsString("my error"));
-
+ assertThat(messages.hasErrors()).isTrue();
+ assertThat(messages.hasWarnings()).isFalse();
+ assertThat(messages.hasInfos()).isFalse();
+ assertThat(messages.getErrors()).hasSize(1);
+ assertThat(messages.getErrors()).contains("my error");
+ assertThat(messages.toString()).contains("my error");
+
Logger logger = mock(Logger.class);
messages.log(logger);
verify(logger, times(1)).error("my error");
private File workDir;
@Before
- public void setUp() {
+ public void before() throws IOException {
workDir = tempFolder.newFolder(testName.getMethodName());
}
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.easytesting</groupId>
+ <artifactId>fest-assert</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
</resources>
</configuration>
</execution>
+ <execution>
+ <id>copy-generated-webapp</id>
+ <!-- must be after the execution of grunt -->
+ <phase>process-resources</phase>
+ <goals>
+ <goal>copy-resources</goal>
+ </goals>
+ <configuration>
+ <outputDirectory>${project.build.directory}/${project.build.finalName}</outputDirectory>
+ <overwrite>true</overwrite>
+ <resources>
+ <resource>
+ <directory>src/main/webapp/build</directory>
+ <filtering>false</filtering>
+ </resource>
+ </resources>
+ </configuration>
+ </execution>
</executions>
</plugin>
<plugin>
</execution>
</executions>
</plugin>
- <plugin>
- <artifactId>maven-resources-plugin</artifactId>
- <executions>
- <execution>
- <id>copy-generated-webapp</id>
- <!-- must be after the execution of grunt -->
- <phase>process-resources</phase>
- <goals>
- <goal>copy-resources</goal>
- </goals>
- <configuration>
- <outputDirectory>${project.build.directory}/${project.build.finalName}</outputDirectory>
- <overwrite>true</overwrite>
- <resources>
- <resource>
- <directory>src/main/webapp/build</directory>
- <filtering>false</filtering>
- </resource>
- </resources>
- </configuration>
- </execution>
- </executions>
- </plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
</executions>
</plugin>
<plugin>
+ <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<executions>
<execution>
*/
package org.sonar.wsclient.services;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-
import org.junit.Test;
+import static org.fest.assertions.Assertions.assertThat;
+
public class ServerSetupQueryTest extends QueryTestCase {
@Test
public void index() {
ServerSetupQuery query = new ServerSetupQuery();
- assertThat(query.getUrl(), is("/api/server/setup"));
- assertThat(query.getModelClass().getName(), is(ServerSetup.class.getName()));
+ assertThat(query.getUrl()).isEqualTo("/api/server/setup");
+ assertThat(query.getModelClass().getName()).isEqualTo(ServerSetup.class.getName());
}
}
import java.util.List;
-import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsNot.not;
import static org.junit.Assert.assertThat;
public class ResourceUnmarshallerTest extends UnmarshallerTestCase {
projects / sonarqube.git / commitdiff