org.sonar.duplications.statement.Statement.getValue java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 SimpleDateFormat s =String pattern;new SimpleDateFormat(pattern)
String template;Locale locale;new SimpleDateFormat(template, locale)
new SimpleDateFormat()
Smart code suggestions by Codota
}

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

@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)");
}

 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();
 blocks.add(block);
 hash -= power * firstStatement.getValue().hashCode();

@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)");
}

@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()");
}

@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
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
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");
}

/**
 * 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");
}

/**
 * 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}}");
}

@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()");
}

@Test
public void shouldHandleIf() {
 List<Statement> statements = chunk("if (a > b) { 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()).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()).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 shouldHandleTryFinnaly() {
 List<Statement> statements;
 statements = chunk("try { } finally { }");
 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()).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()).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()");
}

/**
 * Java 7.
 */
@Test
public void shouldHandleTryWithResource() {
 List<Statement> statements;
 statements = chunk("try (FileInputStream in = new FileInputStream()) {}");
 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()).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()).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()).isEqualTo(2);
 assertThat(statements.get(0).getValue()).isEqualTo("try(FileInputStreamin=newFileInputStream())");
 assertThat(statements.get(1).getValue()).isEqualTo("something()");
}

/**
 * Java 7.
 */
@Test
public void shouldHandleMultiCatch() {
 List<Statement> statements;
 statements = chunk("try { } catch (Exception1 | Exception2 e) { }");
 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()).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()).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()");
}

@Test
public void shouldHandleTryCatch() {
 List<Statement> statements;
 statements = chunk("try { } catch (Exception e) { }");
 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()).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()).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()).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 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 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));
}

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

 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();
 blocks.add(block);
 hash -= power * firstStatement.getValue().hashCode();

Popular methods of Statement

Popular in Java

Running tasks concurrently on multiple threads
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
setScale (BigDecimal)
Returns a BigDecimal whose scale is the specified value, and whose value is numerically equal to thi
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
File (java.io)
An "abstract" representation of a file system entity identified by a pathname. The pathname may be a
Hashtable (java.util)
Hashtable is a synchronized implementation of Map. All optional operations are supported.Neither key
SortedSet (java.util)
A Set that further provides a total ordering on its elements. The elements are ordered using their C
TimeZone (java.util)
TimeZone represents a time zone offset, and also figures out daylight savings. Typically, you get a
DateTimeFormat (org.joda.time.format)
Factory that creates instances of DateTimeFormatter from patterns and styles. Datetime formatting i

How to use getValuemethodin org.sonar.duplications.statement.Statement

Best Java code snippets using org.sonar.duplications.statement.Statement.getValue (Showing top 20 results out of 315)

How to use
getValue
method
in
org.sonar.duplications.statement.Statement