/*******************************************************************************
 * Copyright (c) 2011 Broadcom and others.
 * 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:
 * Broadcom - Initial API and implementation
 * Nokia
 *******************************************************************************/

package org.eclipse.cdt.debug.edc.tests;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.cdt.core.IAddress;
import org.eclipse.cdt.core.IAddressFactory;
import org.eclipse.cdt.debug.edc.internal.symbols.ISection;
import org.eclipse.cdt.debug.edc.internal.symbols.LexicalBlockScope;
import org.eclipse.cdt.debug.edc.internal.symbols.Section;
import org.eclipse.cdt.debug.edc.internal.symbols.Symbol;
import org.eclipse.cdt.debug.edc.internal.symbols.files.ExecutableSection;
import org.eclipse.cdt.debug.edc.internal.symbols.files.SectionInfo;
import org.eclipse.cdt.debug.edc.symbols.IHasSize;
import org.eclipse.cdt.debug.edc.symbols.IAddressInterval;
import org.eclipse.cdt.debug.edc.symbols.IExecutableSection;
import org.eclipse.cdt.utils.Addr64Factory;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestIAddressInterval {

	private static IAddressInterval emptyExecutableSection;
	private static IExecutableSection fullExecutableSection;
	private static IAddressInterval emptyScope;
	private static IAddressInterval fullScope;
	private static IAddressInterval emptySection;
	private static ISection fullSection;
	private static IAddressInterval fullSymbol;
	private static IAddressInterval emptySymbol;
	private static IAddress twenty;
	private static IAddress fourty;
	private static IAddress twoFourty;
	private static IAddress oneFourty;

	@BeforeClass
	public static void setup() {
		IAddressFactory addrF = new Addr64Factory();

		// IAddress zero = addrF.createAddress("0x0");
		twenty = addrF.createAddress("0x20");
		fourty = addrF.createAddress("0x40");
		oneFourty = addrF.createAddress("0x140");
		twoFourty = addrF.createAddress("0x240");

		Map<String, Object> emptyMap = new HashMap<String, Object>();
		emptySection = new Section(0, 0, fourty, emptyMap);
		fullSection = new Section(1, 0x200, fourty, emptyMap);

		emptyExecutableSection
		  = new ExecutableSection(null, "emptyExecutableSection",
				  				  new SectionInfo(fourty, 0, 0));
		fullExecutableSection
		  = new ExecutableSection(null, "fullExecutableSection",
				  				  new SectionInfo(fourty, 0, 0x100));

		emptyScope = new LexicalBlockScope("emptyScope", null, twenty, twenty);
		fullScope = new LexicalBlockScope("fullScope", null, twenty, fourty);

		emptySymbol = new Symbol("emptySymbol", fourty, 0);
		fullSymbol = new Symbol("fullSymbol", twenty, 0x20);
	}

	@Test
	public void getName() {
		testName(emptySection, "0");
		testName(fullSection, "1");
		testName(emptyExecutableSection, "emptyExecutableSection");
		testName(fullExecutableSection, "fullExecutableSection");
		testName(emptyScope, "emptyScope");
		testName(fullScope, "fullScope");
		testName(emptySymbol, "emptySymbol");
		testName(fullSymbol, "fullSymbol");
	}

	private void testName(IAddressInterval interval, String name) {
		Assert.assertNotNull(interval.getName());
		Assert.assertEquals(name, interval.getName());
	}

	@Test
	public void hasEmptyRange() {
		testEmpty(emptySection, true);
		testEmpty(fullSection, false);
		testEmpty(emptyExecutableSection, true);
		testEmpty(fullExecutableSection, false);
		testEmpty(emptyScope, true);
		testEmpty(fullScope, false);
		testEmpty(emptySymbol, true);
		testEmpty(fullSymbol, false);
	}

	private void testEmpty(IAddressInterval interval, boolean empty) {
		Assert.assertEquals(empty, interval.hasEmptyRange());
	}

	@Test
	public void getLowAddress() {
		testLowAddress(emptySection, fourty);
		testLowAddress(fullSection, fourty);

		testLowAddress(emptyExecutableSection, fourty);
		testLowAddress(fullExecutableSection, fourty);

		testLowAddress(emptyScope, twenty);
		testLowAddress(fullScope, twenty);

		testLowAddress(emptySymbol, fourty);
		testLowAddress(fullSymbol, twenty);
	}

	private void testLowAddress(IAddressInterval interval, IAddress address) {
		Assert.assertEquals(address, interval.getLowAddress());
	}

	@Test
	public void getHighAddress() {
		testHighAddress(emptySection, fourty);
		testHighAddress(fullSection, twoFourty);

		testHighAddress(emptyExecutableSection, fourty);
		testHighAddress(fullExecutableSection, oneFourty);

		testHighAddress(emptyScope, twenty);
		testHighAddress(fullScope, fourty);

		testHighAddress(emptySymbol, fourty);
		testHighAddress(fullSymbol, fourty);
	}

	private void testHighAddress(IAddressInterval interval, IAddress address) {
		Assert.assertEquals(address, interval.getHighAddress());
	}

	@Test
	public void getSize() {
		testGetSize(emptySection, 0);
		testGetSize(fullSection, 0x200);

		testGetSize(emptyExecutableSection, 0);
		testGetSize(fullExecutableSection, 0x100);

		testGetSize(emptySymbol, 0);
		testGetSize(fullSymbol, 0x20);
	}

	private void testGetSize(IAddressInterval interval, int size) {
		Assert.assertTrue(interval instanceof IHasSize);
		Assert.assertEquals(size, ((IHasSize) interval).getSize());
	}
}