How to use

Statement

in

org.sonar.duplications.statement

public boolean consume(TokenQueue tokenQueue, List<Statement> output) {
 List<Token> matchedTokenList = new ArrayList<>();
 for (TokenMatcher tokenMatcher : tokenMatchers) {
  if (!tokenMatcher.matchToken(tokenQueue, matchedTokenList)) {
   tokenQueue.pushForward(matchedTokenList);
   return false;
  }
 }
 // all matchers were successful, so now build the statement
 // matchedTokenList.size() check is for case with ForgiveLastTokenMatcher
 if (!blackHole && !matchedTokenList.isEmpty()) {
  output.add(new Statement(matchedTokenList));
 }
 return true;
}

@Override
public String toString() {
 return "[" + getStartLine() + "-" + getEndLine() + "] [" + getValue() + "]";
}

@Test
public void shouldCreateStatementFromListOfTokens() {
 Statement statement = new Statement(Arrays.asList(new Token("a", 1, 1), new Token("b", 2, 1)));
 assertThat(statement.getValue(), is("ab"));
 assertThat(statement.getStartLine(), is(1));
 assertThat(statement.getEndLine(), is(2));
}

@Test
public void shouldHandleAnnotation() {
 List<Statement> statements = chunk("" +
  "@Entity" +
  "@Table(name = \"properties\")" +
  "@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 shouldHandleDoWhile() {
 List<Statement> statements = chunk("do { something(); } 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)");
}

 Statement first = statements.get(i);
 int j = i + 1;
 while (j < statements.size() && statements.get(j).getValue().equals(first.getValue())) {
  j++;
int last = 0;
for (; last < blockSize - 1; last++) {
 hash = hash * PRIME_BASE + statementsArr[last].getValue().hashCode();
 Statement lastStatement = statementsArr[last];
 hash = hash * PRIME_BASE + lastStatement.getValue().hashCode();
   .setLines(firstStatement.getStartLine(), lastStatement.getEndLine())
   .build();
 blocks.add(block);
 hash -= power * firstStatement.getValue().hashCode();

@Test
public void shouldHandleFor() {
 List<Statement> statements = chunk("for (int i = 0; i < 10; i++) { 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()).isEqualTo(2);
 assertThat(statements.get(0).getValue()).isEqualTo("for(Itemitem:items)");
 assertThat(statements.get(1).getValue()).isEqualTo("something()");
}

/**
 * Creates list of statements from Strings, each statement on a new line starting from 0.
 */
protected static List<Statement> createStatementsFromStrings(String... values) {
 List<Statement> result = new ArrayList<>();
 for (int i = 0; i < values.length; i++) {
  result.add(new Statement(i, i, values[i]));
 }
 return result;
}

@Test
public void shouldCreateStatement() {
 Token token = new Token("a", 1, 1);
 TokenQueue tokenQueue = spy(new TokenQueue(Arrays.asList(token)));
 TokenMatcher matcher = spy(new AnyTokenMatcher());
 StatementChannel channel = StatementChannel.create(matcher);
 List<Statement> output = mock(List.class);
 assertThat(channel.consume(tokenQueue, output), is(true));
 verify(matcher).matchToken(eq(tokenQueue), anyList());
 verifyNoMoreInteractions(matcher);
 ArgumentCaptor<Statement> statement = ArgumentCaptor.forClass(Statement.class);
 verify(output).add(statement.capture());
 assertThat(statement.getValue().getValue(), is("a"));
 assertThat(statement.getValue().getStartLine(), is(1));
 assertThat(statement.getValue().getEndLine(), is(1));
 verifyNoMoreInteractions(output);
}

@Test
public void shouldHandleWhile() {
 List<Statement> statements = chunk("while (i < args.length) { 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()).isEqualTo(1);
 assertThat(statements.get(0).getValue()).isEqualTo("while(true)");
}

@Test(expected = IllegalArgumentException.class)
public void shouldNotAcceptEmpty() {
 new Statement(new ArrayList<Token>());
}

@Override
public String toString() {
 return "[" + getStartLine() + "-" + getEndLine() + "] [" + getValue() + "]";
}

@Test
public void shouldHandleArray() {
 List<Statement> statements = chunk("new Integer[] { 1, 2, 3, 4 };");
 assertThat(statements.size()).isEqualTo(2);
 assertThat(statements.get(0).getValue()).isEqualTo("newInteger[]");
 assertThat(statements.get(1).getValue()).isEqualTo("{$NUMBER,$NUMBER,$NUMBER,$NUMBER}");
}

@Test(expected = IllegalArgumentException.class)
public void shouldNotAcceptNull() {
 new Statement(null);
}

 Statement first = statements.get(i);
 int j = i + 1;
 while (j < statements.size() && statements.get(j).getValue().equals(first.getValue())) {
  j++;
int last = 0;
for (; last < blockSize - 1; last++) {
 hash = hash * PRIME_BASE + statementsArr[last].getValue().hashCode();
 Statement lastStatement = statementsArr[last];
 hash = hash * PRIME_BASE + lastStatement.getValue().hashCode();
   .setLines(firstStatement.getStartLine(), lastStatement.getEndLine())
   .build();
 blocks.add(block);
 hash -= power * firstStatement.getValue().hashCode();

@Test
public void shouldHandleSwitch() {
 List<Statement> statements = chunk("" +
  "switch (month) {" +
  "  case 1 : monthString=\"January\"; break;" +
  "  case 2 : monthString=\"February\"; break;" +
  "  default: monthString=\"Invalid\";" +
  "}");
 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");
}

public boolean consume(TokenQueue tokenQueue, List<Statement> output) {
 List<Token> matchedTokenList = new ArrayList<Token>();
 for (TokenMatcher tokenMatcher : tokenMatchers) {
  if (!tokenMatcher.matchToken(tokenQueue, matchedTokenList)) {
   tokenQueue.pushForward(matchedTokenList);
   return false;
  }
 }
 // all matchers were successful, so now build the statement
 // matchedTokenList.size() check is for case with ForgiveLastTokenMatcher
 if (!blackHole && !matchedTokenList.isEmpty()) {
  output.add(new Statement(matchedTokenList));
 }
 return true;
}

/**
 * See SONAR-2837
 */
@Test
public void shouldHandleMultidimensionalArray() {
 List<Statement> statements = chunk("new Integer[][] { { 1, 2 }, {3, 4} };");
 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()).isEqualTo(2);
 assertThat(statements.get(0).getValue()).isEqualTo("newInteger[][]");
 assertThat(statements.get(1).getValue()).isEqualTo("{null,{$NUMBER,$NUMBER}}");
}

/**
 * See SONAR-2782
 */
@Test
public void shouldHandleNestedSwitch() {
 List<Statement> statements = chunk("" +
  "switch (a) {" +
  "  case 'a': case 'b': case 'c': something(); break;" +
  "  case 'd': case 'e': case 'f': somethingOther(); 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 shouldHandleTryCatchFinally() {
 List<Statement> statements;
 statements = chunk("try { } catch (Exception e) {} finally { }");
 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()).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()");
}