/*******************************************************************************
* Copyright (c) 2009, 2017 Mountainminds GmbH & Co. KG and Contributors
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Marc R. Hoffmann - initial API and implementation
*
*******************************************************************************/
package org.jacoco.report.check;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import org.jacoco.core.analysis.CoverageNodeImpl;
import org.jacoco.core.analysis.ICounter.CounterValue;
import org.jacoco.core.analysis.ICoverageNode.CounterEntity;
import org.jacoco.core.internal.analysis.CounterImpl;
import org.junit.Before;
import org.junit.Test;
/**
* Unit tests for {@link Limit}.
*/
public class LimitTest {
private Limit limit;
@Before
public void setup() {
limit = new Limit();
}
@Test
public void testDefaults() {
assertNull(limit.getMinimum());
assertNull(limit.getMaximum());
assertEquals(CounterEntity.INSTRUCTION, limit.getEntity());
assertEquals(CounterValue.COVEREDRATIO, limit.getValue());
}
@Test
public void testTotalCount() {
limit.setValue(CounterValue.TOTALCOUNT.name());
limit.setMaximum("-1");
assertEquals(CounterValue.TOTALCOUNT, limit.getValue());
assertEquals(
"instructions total count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testMissedCount() {
limit.setValue(CounterValue.MISSEDCOUNT.name());
limit.setMaximum("-1");
assertEquals(CounterValue.MISSEDCOUNT, limit.getValue());
assertEquals(
"instructions missed count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testCoveredCount() {
limit.setValue(CounterValue.COVEREDCOUNT.name());
limit.setMaximum("-1");
assertEquals(CounterValue.COVEREDCOUNT, limit.getValue());
assertEquals(
"instructions covered count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testMissedRatio() {
limit.setValue(CounterValue.MISSEDRATIO.name());
limit.setMaximum("-1");
assertEquals(CounterValue.MISSEDRATIO, limit.getValue());
assertEquals(
"instructions missed ratio is 0, but expected maximum is -1",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.COUNTER_0_1;
}
}));
}
@Test
public void testCoveredRatio() {
limit.setValue(CounterValue.COVEREDRATIO.name());
limit.setMaximum("-1");
assertEquals(CounterValue.COVEREDRATIO, limit.getValue());
assertEquals(
"instructions covered ratio is 0, but expected maximum is -1",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.COUNTER_1_0;
}
}));
}
@Test
public void testInstruction() {
limit.setValue(CounterValue.TOTALCOUNT.name());
limit.setCounter(CounterEntity.INSTRUCTION.name());
limit.setMaximum("-1");
assertEquals(CounterEntity.INSTRUCTION, limit.getEntity());
assertEquals(
"instructions total count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testBranch() {
limit.setValue(CounterValue.TOTALCOUNT.name());
limit.setCounter(CounterEntity.BRANCH.name());
limit.setMaximum("-1");
assertEquals(CounterEntity.BRANCH, limit.getEntity());
assertEquals("branches total count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testLine() {
limit.setValue(CounterValue.TOTALCOUNT.name());
limit.setCounter(CounterEntity.LINE.name());
limit.setMaximum("-1");
assertEquals(CounterEntity.LINE, limit.getEntity());
assertEquals("lines total count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testComlexity() {
limit.setValue(CounterValue.TOTALCOUNT.name());
limit.setCounter(CounterEntity.COMPLEXITY.name());
limit.setMaximum("-1");
assertEquals(CounterEntity.COMPLEXITY, limit.getEntity());
assertEquals("complexity total count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testClass() {
limit.setValue(CounterValue.TOTALCOUNT.name());
limit.setCounter(CounterEntity.CLASS.name());
limit.setMaximum("-1");
assertEquals(CounterEntity.CLASS, limit.getEntity());
assertEquals("classes total count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testMethod() {
limit.setValue(CounterValue.TOTALCOUNT.name());
limit.setCounter(CounterEntity.METHOD.name());
limit.setMaximum("-1");
assertEquals(CounterEntity.METHOD, limit.getEntity());
assertEquals("methods total count is 0, but expected maximum is -1",
limit.check(new TestNode()));
}
@Test
public void testNoRatio() {
assertNull(limit.check(new TestNode() {
{
instructionCounter = CounterImpl.COUNTER_0_0;
}
}));
}
@Test
public void testNoLimits() {
assertNull(limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(1000, 0);
}
}));
}
@Test
public void testMin0() {
limit.setMinimum("0");
limit.setMinimum((String) null);
assertNull(limit.getMinimum());
}
@Test
public void testMin1() {
limit.setMinimum("0.35");
assertEquals("0.35", limit.getMinimum());
assertNull(limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(65, 35);
}
}));
}
@Test
public void testMin2() {
limit.setMinimum("0.35");
assertEquals("0.35", limit.getMinimum());
assertNull(limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(64, 36);
}
}));
}
@Test
public void testMin3() {
limit.setMinimum("0.3500");
assertEquals("0.3500", limit.getMinimum());
assertEquals(
"instructions covered ratio is 0.3400, but expected minimum is 0.3500",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(66, 34);
}
}));
}
@Test
public void testMin4() {
limit.setMinimum("0.35");
assertEquals("0.35", limit.getMinimum());
assertEquals(
"instructions covered ratio is 0.34, but expected minimum is 0.35",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(65001,
34999);
}
}));
}
@Test
public void testMin5() {
limit.setMinimum("10000");
limit.setValue(CounterValue.MISSEDCOUNT.name());
assertEquals("10000", limit.getMinimum());
assertEquals(
"instructions missed count is 9990, but expected minimum is 10000",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(9990, 0);
}
}));
}
@Test
public void testMin6() {
limit.setMinimum("12345");
assertEquals("12345", limit.getMinimum());
assertEquals(
"instructions covered ratio is 0, but expected minimum is 12345",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(1, 999);
}
}));
}
@Test
public void testMinPercent() {
limit.setMinimum("1.55%");
assertEquals("0.0155", limit.getMinimum());
limit.setMinimum("1.5%");
assertEquals("0.015", limit.getMinimum());
limit.setMinimum("1.00%");
assertEquals("0.0100", limit.getMinimum());
limit.setMinimum("1%");
assertEquals("0.01", limit.getMinimum());
}
@Test
public void testMax0() {
limit.setMaximum("0");
limit.setMaximum((String) null);
assertNull(limit.getMaximum());
}
@Test
public void testMax1() {
limit.setMaximum("12345678");
limit.setValue(CounterValue.MISSEDCOUNT.name());
assertEquals("12345678", limit.getMaximum());
assertNull(limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(12345678, 0);
}
}));
}
@Test
public void testMax2() {
limit.setMaximum("0.999");
assertEquals("0.999", limit.getMaximum());
assertNull(limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(1, 99);
}
}));
}
@Test
public void testMax3() {
limit.setMaximum("0.999");
assertEquals("0.999", limit.getMaximum());
assertEquals(
"instructions covered ratio is 1.000, but expected maximum is 0.999",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(0, 1);
}
}));
}
@Test
public void testMax4() {
limit.setMaximum("0.999");
assertEquals("0.999", limit.getMaximum());
assertEquals(
"instructions covered ratio is 1.000, but expected maximum is 0.999",
limit.check(new TestNode() {
{
instructionCounter = CounterImpl.getInstance(999,
999001);
}
}));
}
@Test
public void testMaxPercent() {
limit.setMaximum("1.55%");
assertEquals("0.0155", limit.getMaximum());
limit.setMaximum("1.5%");
assertEquals("0.015", limit.getMaximum());
limit.setMaximum("1.00%");
assertEquals("0.0100", limit.getMaximum());
limit.setMaximum("1%");
assertEquals("0.01", limit.getMaximum());
}
private static class TestNode extends CoverageNodeImpl {
public TestNode() {
super(ElementType.CLASS, "Foo");
}
}
}