/*
* SonarQube, open source software quality management tool.
* Copyright (C) 2008-2014 SonarSource
* mailto:contact AT sonarsource DOT com
*
* SonarQube is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* SonarQube is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.sonar.duplications.block;
import com.google.common.collect.Lists;
import org.junit.Test;
import org.sonar.duplications.statement.Statement;
import java.util.Collections;
import java.util.List;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.assertThat;
/**
* Any implementation of {@link BlockChunker} should pass these test scenarios.
*/
public abstract class BlockChunkerTestCase {
/**
* Factory method.
*/
protected abstract BlockChunker createChunkerWithBlockSize(int blockSize);
/**
* Given:
* <pre>
* String[][] data = {
* {"a", "a"},
* {"a", "a"},
* {"a"},
* {"a", "a"},
* {"a", "a"}
* };
*
* Statements (where L - literal, C - comma): "LCL", "C", "LCL", "C", "L", "C", "LCL", "C", "LCL"
* Block size is 5.
* First block: "LCL", "C", "LCL", "C", "L"
* Last block: "L", "C", "LCL", "C", "LCL"
* </pre>
* Expected: different hashes for first and last blocks
*/
@Test
public void testSameChars() {
List<Statement> statements = createStatementsFromStrings("LCL", "C", "LCL", "C", "L", "C", "LCL", "C", "LCL");
BlockChunker chunker = createChunkerWithBlockSize(5);
List<Block> blocks = chunker.chunk("resource", statements);
assertThat("first and last block should have different hashes", blocks.get(0).getBlockHash(), not(equalTo(blocks.get(blocks.size() - 1).getBlockHash())));
}
/**
* TODO Godin: should we allow empty statements in general?
*/
@Test
public void testEmptyStatements() {
List<Statement> statements = createStatementsFromStrings("1", "", "1", "1", "");
BlockChunker chunker = createChunkerWithBlockSize(3);
List<Block> blocks = chunker.chunk("resource", statements);
assertThat("first and last block should have different hashes", blocks.get(0).getBlockHash(), not(equalTo(blocks.get(blocks.size() - 1).getBlockHash())));
}
/**
* Given: 5 statements, block size is 3
* Expected: 4 blocks with correct index and with line numbers
*/
@Test
public void shouldBuildBlocksFromStatements() {
List<Statement> statements = createStatementsFromStrings("1", "2", "3", "4", "5", "6");
BlockChunker chunker = createChunkerWithBlockSize(3);
List<Block> blocks = chunker.chunk("resource", statements);
assertThat(blocks.size(), is(4));
assertThat(blocks.get(0).getIndexInFile(), is(0));
assertThat(blocks.get(0).getStartLine(), is(0));
assertThat(blocks.get(0).getEndLine(), is(2));
assertThat(blocks.get(1).getIndexInFile(), is(1));
assertThat(blocks.get(1).getStartLine(), is(1));
assertThat(blocks.get(1).getEndLine(), is(3));
}
@Test
public void testHashes() {
List<Statement> statements = createStatementsFromStrings("1", "2", "1", "2");
BlockChunker chunker = createChunkerWithBlockSize(2);
List<Block> blocks = chunker.chunk("resource", statements);
assertThat("blocks 0 and 2 should have same hash", blocks.get(0).getBlockHash(), equalTo(blocks.get(2).getBlockHash()));
assertThat("blocks 0 and 1 should have different hash", blocks.get(0).getBlockHash(), not(equalTo(blocks.get(1).getBlockHash())));
}
/**
* Given: 0 statements
* Expected: 0 blocks
*/
@Test
public void shouldNotBuildBlocksWhenNoStatements() {
List<Statement> statements = Collections.emptyList();
BlockChunker blockChunker = createChunkerWithBlockSize(2);
List<Block> blocks = blockChunker.chunk("resource", statements);
assertThat(blocks, sameInstance(Collections.EMPTY_LIST));
}
/**
* Given: 1 statement, block size is 2
* Expected: 0 blocks
*/
@Test
public void shouldNotBuildBlocksWhenNotEnoughStatements() {
List<Statement> statements = createStatementsFromStrings("statement");
BlockChunker blockChunker = createChunkerWithBlockSize(2);
List<Block> blocks = blockChunker.chunk("resource", statements);
assertThat(blocks, sameInstance(Collections.EMPTY_LIST));
}
/**
* 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 = Lists.newArrayList();
for (int i = 0; i < values.length; i++) {
result.add(new Statement(i, i, values[i]));
}
return result;
}
}