org.jacoco.report.test/src/org/jacoco/report/internal/html/table/TableTest.java

/*******************************************************************************
 * Copyright (c) 2009, 2018 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.internal.html.table;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

import org.jacoco.core.analysis.CounterComparator;
import org.jacoco.core.analysis.CoverageNodeImpl;
import org.jacoco.core.analysis.ICoverageNode;
import org.jacoco.core.analysis.ICoverageNode.CounterEntity;
import org.jacoco.core.analysis.ICoverageNode.ElementType;
import org.jacoco.core.internal.analysis.CounterImpl;
import org.jacoco.report.MemoryMultiReportOutput;
import org.jacoco.report.internal.ReportOutputFolder;
import org.jacoco.report.internal.html.HTMLDocument;
import org.jacoco.report.internal.html.HTMLElement;
import org.jacoco.report.internal.html.HTMLSupport;
import org.jacoco.report.internal.html.resources.Resources;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.w3c.dom.Document;

/**
 * Unit tests for {@link Table}.
 */
public class TableTest {

	private MemoryMultiReportOutput output;

	private ReportOutputFolder root;

	private Resources resources;

	private HTMLDocument doc;

	private HTMLElement body;

	private Table table;

	@Before
	public void setup() throws IOException {
		output = new MemoryMultiReportOutput();
		root = new ReportOutputFolder(output);
		resources = new Resources(root);
		doc = new HTMLDocument(root.createFile("Test.html"), "UTF-8");
		doc.head().title();
		body = doc.body();
		table = new Table();
	}

	@After
	public void teardown() throws IOException {
		output.close();
		output.assertAllClosed();
	}

	@Test
	public void testCallbackSequence() throws IOException {
		final IColumnRenderer recorder = new StubRenderer(
				CounterComparator.TOTALITEMS.on(CounterEntity.CLASS)) {

			private final StringBuilder store = new StringBuilder();

			@Override
			public boolean init(List<? extends ITableItem> items,
					ICoverageNode total) {
				store.append("init-");
				return true;
			}

			@Override
			public void footer(HTMLElement td, ICoverageNode total,
					Resources resources, ReportOutputFolder base) {
				store.append("footer-");
			}

			@Override
			public void item(HTMLElement td, ITableItem item,
					Resources resources, ReportOutputFolder base) {
				store.append("item").append(item.getLinkLabel()).append("-");
			}

			@Override
			public String toString() {
				return store.toString();
			}

		};
		final List<ITableItem> items = Arrays.asList(createItem("A", 1),
				createItem("B", 2), createItem("C", 3));
		table.add("Header", null, recorder, false);
		table.render(body, items, createTotal("Sum", 6), resources, root);
		doc.close();
		assertEquals("init-footer-itemA-itemB-itemC-", recorder.toString());
	}

	@Test
	public void testInvisible() throws IOException {
		final IColumnRenderer column = new StubRenderer(
				CounterComparator.TOTALITEMS.on(CounterEntity.CLASS)) {

			@Override
			public boolean init(List<? extends ITableItem> items,
					ICoverageNode total) {
				return false;
			}

			@Override
			public void footer(HTMLElement td, ICoverageNode total,
					Resources resources, ReportOutputFolder base) {
				fail();
			}

			@Override
			public void item(HTMLElement td, ITableItem item,
					Resources resources, ReportOutputFolder base) {
				fail();
			}
		};
		final List<ITableItem> items = Arrays.asList(createItem("A", 1));
		table.add("Header", null, column, false);
		table.render(body, items, createTotal("Sum", 1), resources, root);
		doc.close();
	}

	@Test(expected = IllegalStateException.class)
	public void testTwoDefaultSorts() throws IOException {
		doc.close();
		table.add("Header1", null, new StubRenderer(
				CounterComparator.TOTALITEMS.on(CounterEntity.CLASS)), true);
		table.add("Header2", null, new StubRenderer(
				CounterComparator.TOTALITEMS.on(CounterEntity.CLASS)), true);
	}

	@Test
	public void testSortIds() throws Exception {
		final List<ITableItem> items = Arrays.asList(createItem("C", 3),
				createItem("E", 4), createItem("A", 1), createItem("D", 2));
		table.add("Forward", null, new StubRenderer(
				CounterComparator.TOTALITEMS.on(CounterEntity.CLASS)), false);
		table.add(
				"Reverse",
				null,
				new StubRenderer(CounterComparator.TOTALITEMS.reverse().on(
						CounterEntity.CLASS)), false);
		table.render(body, items, createTotal("Sum", 6), resources, root);
		doc.close();

		final HTMLSupport support = new HTMLSupport();
		final Document doc = support.parse(output.getFile("Test.html"));

		// The elements in Column 1 are sorted in forward order:
		assertEquals("sortable",
				support.findStr(doc, "/html/body/table/thead/tr/td[1]/@class"));
		assertEquals("a",
				support.findStr(doc, "/html/body/table/thead/tr/td[1]/@id"));
		assertEquals("a2",
				support.findStr(doc, "/html/body/table/tbody/tr[1]/td[1]/@id"));
		assertEquals("a3",
				support.findStr(doc, "/html/body/table/tbody/tr[2]/td[1]/@id"));
		assertEquals("a0",
				support.findStr(doc, "/html/body/table/tbody/tr[3]/td[1]/@id"));
		assertEquals("a1",
				support.findStr(doc, "/html/body/table/tbody/tr[4]/td[1]/@id"));

		// The elements in Column 2 are sorted in reverse order:
		assertEquals("sortable",
				support.findStr(doc, "/html/body/table/thead/tr/td[2]/@class"));
		assertEquals("b",
				support.findStr(doc, "/html/body/table/thead/tr/td[2]/@id"));
		assertEquals("b1",
				support.findStr(doc, "/html/body/table/tbody/tr[1]/td[2]/@id"));
		assertEquals("b0",
				support.findStr(doc, "/html/body/table/tbody/tr[2]/td[2]/@id"));
		assertEquals("b3",
				support.findStr(doc, "/html/body/table/tbody/tr[3]/td[2]/@id"));
		assertEquals("b2",
				support.findStr(doc, "/html/body/table/tbody/tr[4]/td[2]/@id"));
	}

	@Test
	public void testDefaultSorting() throws Exception {
		final List<ITableItem> items = Arrays.asList(createItem("C", 3),
				createItem("E", 5), createItem("A", 1), createItem("D", 4),
				createItem("B", 2));
		table.add("Forward", null, new StubRenderer(
				CounterComparator.TOTALITEMS.on(CounterEntity.CLASS)), true);
		table.render(body, items, createTotal("Sum", 1), resources, root);
		doc.close();

		final HTMLSupport support = new HTMLSupport();
		final Document doc = support.parse(output.getFile("Test.html"));

		assertEquals("down sortable",
				support.findStr(doc, "/html/body/table/thead/tr/td[1]/@class"));
		assertEquals("A",
				support.findStr(doc, "/html/body/table/tbody/tr[1]/td[1]"));
		assertEquals("B",
				support.findStr(doc, "/html/body/table/tbody/tr[2]/td[1]"));
		assertEquals("C",
				support.findStr(doc, "/html/body/table/tbody/tr[3]/td[1]"));
		assertEquals("D",
				support.findStr(doc, "/html/body/table/tbody/tr[4]/td[1]"));
		assertEquals("E",
				support.findStr(doc, "/html/body/table/tbody/tr[5]/td[1]"));
	}

	private ITableItem createItem(final String name, final int count) {
		final ICoverageNode node = new CoverageNodeImpl(ElementType.GROUP, name) {
			{
				this.classCounter = CounterImpl.getInstance(count, 0);
			}
		};
		return new ITableItem() {
			public String getLinkLabel() {
				return name;
			}

			public String getLink(ReportOutputFolder base) {
				return name + ".html";
			}

			public String getLinkStyle() {
				return Resources.getElementStyle(node.getElementType());
			}

			public ICoverageNode getNode() {
				return node;
			}
		};
	}

	private ICoverageNode createTotal(final String name, final int count) {
		return new CoverageNodeImpl(ElementType.GROUP, name) {
			{
				this.classCounter = CounterImpl.getInstance(count, 0);
			}
		};
	}

	private static class StubRenderer implements IColumnRenderer {

		private final Comparator<ITableItem> comparator;

		StubRenderer(Comparator<ICoverageNode> comparator) {
			this.comparator = new TableItemComparator(comparator);
		}

		public boolean init(List<? extends ITableItem> items,
				ICoverageNode total) {
			return true;
		}

		public void footer(HTMLElement td, ICoverageNode total,
				Resources resources, ReportOutputFolder base) {
		}

		public void item(HTMLElement td, ITableItem item, Resources resources,
				ReportOutputFolder base) throws IOException {
			td.text(item.getLinkLabel());
		}

		public Comparator<ITableItem> getComparator() {
			return comparator;
		}

	}

}