/*
 * Copyright (c) 2010, 2011 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description: 
 *
 */

package org.eclipse.cdt.debug.edc.tests;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import org.eclipse.cdt.core.IAddress;
import org.eclipse.cdt.debug.edc.internal.HostOS;
import org.eclipse.cdt.debug.edc.internal.PathUtils;
import org.eclipse.cdt.debug.edc.internal.services.dsf.EDCSymbolReader;
import org.eclipse.cdt.debug.edc.internal.services.dsf.Symbols;
import org.eclipse.cdt.debug.edc.internal.symbols.ICompositeType;
import org.eclipse.cdt.debug.edc.internal.symbols.dwarf.DwarfDebugInfoProvider;
import org.eclipse.cdt.debug.edc.internal.symbols.dwarf.DwarfInfoReader;
import org.eclipse.cdt.debug.edc.symbols.ICompileUnitScope;
import org.eclipse.cdt.debug.edc.symbols.IDebugInfoProvider;
import org.eclipse.cdt.debug.edc.symbols.IEDCSymbolReader;
import org.eclipse.cdt.debug.edc.symbols.IFunctionScope;
import org.eclipse.cdt.debug.edc.symbols.IModuleScope;
import org.eclipse.cdt.debug.edc.symbols.IScope;
import org.eclipse.cdt.debug.edc.symbols.IType;
import org.eclipse.cdt.debug.edc.symbols.IVariable;
import org.eclipse.cdt.debug.edc.symbols.TypeUtils;
import org.eclipse.cdt.utils.Addr32;
import org.eclipse.core.runtime.IPath;
import org.junit.Before;

/**
 * 
 */
public abstract class AbstractDwarfReaderTest extends BaseDwarfTestCase {
	protected static final String[] symFilesToTest = {
		"BlackFlagMinGW.exe",
		"BlackFlag_gcce.sym",
		"BlackFlag_linuxgcc.exe",
		"BlackFlag_rvct.sym",
		"BlackFlag_gcce_343.sym",
		"HelloWorld_rvct_2_2.exe.sym",
		"HelloWorld_rvct_4_0.exe.sym",
		"QtConsole_gcce_343.sym",
		"SimpleCpp_rvct_22.sym",
		"SimpleCpp_rvct_40.sym",
		"SimpleCpp_gcce_432.sym",
		"SimpleCpp_gcc_x86.exe",
	};

	/** Bag of data for testing sym files.  The key is 'symFile' and other
	 * elements are used by specific tests.
	 */
	protected static class TestInfo {
		public IPath symFile;
		IPath exeFile;
		int numberOfSources;
		int numberOfModuleScopeChildren;
		int numberOfVariables;
		Map<String, Map<String, VariableInfo>> cuVarMap
		  = new HashMap<String, Map<String,VariableInfo>>();
		int numberOfTypes;
		IPath blackFlagMainFilePath;
		int numberOfSymbols;
		int numberOfPubFuncNames;
		int numberOfPubFuncEntries;
		int numberOfPubVarNames;
		int numberOfPubVarEntries;
		List<String> pubVars = new ArrayList<String>();
		List<String> pubFuncs = new ArrayList<String>();
		Map<String, List<ScopeInfo>> scopeInfos
		  = new LinkedHashMap<String, List<ScopeInfo>>();
		IAddress lowAddress;
		IAddress highAddress;
		Collection<SymbolInfo> symbols;
	}

	protected static Map<String, TestInfo> testInfos
	  = new LinkedHashMap<String, TestInfo>();

	static {
		for (String sym : symFilesToTest) {
			TestInfo info = new TestInfo();
			info.symFile = getFile(sym);
			testInfos.put(sym, info);
		}
	}

	protected  static TestInfo lookupInfo(String sym) {
		return testInfos.get(sym);
	}

	protected  static void setExe(String sym, String exe) {
		TestInfo info = lookupInfo(sym);
		if (info != null)
			info.exeFile = getFile(exe);
	}

	// not all the *.exes really exist; used to test mapping from *.exe to *.sym
	static {
		setExe("BlackFlagMinGW.exe", "BlackFlagMinGW.exe");
		setExe("BlackFlag_gcce.sym", "BlackFlag_gcce.exe");
		setExe("BlackFlag_linuxgcc.exe", "BlackFlag_linuxgcc.exe");
		setExe("BlackFlag_rvct.sym", "BlackFlag_rvct.exe");
		setExe("HelloWorld_rvct_2_2.exe.sym", "HelloWorld_rvct_2_2.exe");
		setExe("HelloWorld_rvct_4_0.exe.sym", "HelloWorld_rvct_4_0.exe");
		setExe("QtConsole_gcce_343.sym", "QtConsole_gcce_343.exe");
	}

	protected  static void setSources(String sym, int i) {
		TestInfo info = lookupInfo(sym);
		if (info != null)
			info.numberOfSources = i;
	}

	static {
		// TODO: this differs in Win and Lin
		
		setSources("BlackFlagMinGW.exe", 121);
		setSources("BlackFlag_gcce.sym", 108);
		setSources("BlackFlag_linuxgcc.exe", 139);
		setSources("BlackFlag_rvct.sym", HostOS.IS_WIN32 ? 207 : 172);
		setSources("HelloWorld_rvct_2_2.exe.sym", HostOS.IS_WIN32 ? 323 : 320);
		setSources("HelloWorld_rvct_4_0.exe.sym", 315);
		setSources("QtConsole_gcce_343.sym", 434);
	}

	protected  static void setModuleScopeChilden(String sym, int i) {
		TestInfo info = lookupInfo(sym);
		if (info != null)
			info.numberOfModuleScopeChildren = i;
	}

	static {
		setModuleScopeChilden("BlackFlagMinGW.exe", 29);
		setModuleScopeChilden("BlackFlag_gcce.sym", 27);
		setModuleScopeChilden("BlackFlag_linuxgcc.exe", 25);
		setModuleScopeChilden("BlackFlag_rvct.sym", 693);
		setModuleScopeChilden("HelloWorld_rvct_2_2.exe.sym", 1579);
		setModuleScopeChilden("HelloWorld_rvct_4_0.exe.sym", 1014);
		setModuleScopeChilden("QtConsole_gcce_343.sym", 3);
	}

	protected static void setStartEndAddress(String sym, IAddress startAddress, IAddress endAddress) {
		TestInfo info = lookupInfo(sym);
		assertNotNull(info);
		info.lowAddress = startAddress;
		info.highAddress = endAddress;
	}

	static {
		setStartEndAddress("BlackFlagMinGW.exe", new Addr32("0x00401000"), new Addr32("0x0046d2c0"));
		setStartEndAddress("BlackFlag_gcce.sym", new Addr32("0x00008000"), new Addr32("0x0040a028"));
		//start address for linuxgcc indicated only by program header not by sections or symbols
		setStartEndAddress("BlackFlag_linuxgcc.exe", new Addr32("0x08048000"), new Addr32("0x0805a01c"));
		setStartEndAddress("BlackFlag_rvct.sym", new Addr32("0x00008000"), new Addr32("0x0040a018"));
		setStartEndAddress("HelloWorld_rvct_2_2.exe.sym", new Addr32("0x00008000"), new Addr32("0x00400008"));
		setStartEndAddress("HelloWorld_rvct_4_0.exe.sym", new Addr32("0x00008000"), new Addr32("0x00400070"));
		setStartEndAddress("QtConsole_gcce_343.sym", new Addr32("0x00008000"), new Addr32("0x00400008"));
	}

	protected  static void setVariableCount(String sym, int i) {
		TestInfo info = lookupInfo(sym);
		if (info != null)
			info.numberOfVariables = i;
	}

	static {
		setVariableCount("BlackFlagMinGW.exe", 52);
		setVariableCount("BlackFlag_gcce.sym", 105);
		setVariableCount("BlackFlag_linuxgcc.exe", 48);
		setVariableCount("BlackFlag_rvct.sym", 61);
		setVariableCount("HelloWorld_rvct_2_2.exe.sym", 1);
		setVariableCount("HelloWorld_rvct_4_0.exe.sym", 1);
		setVariableCount("QtConsole_gcce_343.sym", 2);
	}

	static class VariableInfo {
		String name;
		String typeName;
		
		public VariableInfo(String name, String typeName) {
			this.name = name;
			this.typeName = typeName;
		}		
	}

	protected static void setCUVariableInfo(String sym, String cu, String var,
			String type) {
		TestInfo info = lookupInfo(sym);
		if (info != null) {
			VariableInfo vi = new VariableInfo(var, type);
			Map<String, VariableInfo> varMap = info.cuVarMap.get(cu);
			if (varMap == null) {
				varMap = new HashMap<String, VariableInfo>();
				info.cuVarMap.put(cu, varMap);
			}
			varMap.put(var, vi);
		}
	}

	static {
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/dbg_namespaceRealms.h", "KBase",
				"const class TLitC8");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/dbg_namespaceRealms.h", "KDer1",
				"const class TLitC8");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/dbg_namespaceRealms.h", "KDer2",
				"const class TLitC8");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/dbg_namespaceRealms.h", "KDerDer",
				"const class TLitC8");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/dbg_namespaceRealms.h", "KIFace1",
				"const class TLitC8");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/dbg_namespaceRealms.h", "KIFace2",
				"const class TLitC8");
		setCUVariableInfo(
				"BlackFlag_rvct.sym",
				"M:/sf/os/kernelhwsrv/kernel/eka/compsupp/symaehabi/callfirstprocessfn.cpp",
				"KLitUser", "const class TLitC");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/CommonFramework.h", "KTxtEPOC32EX",
				"const class TLitC");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/CommonFramework.h", "KTxtExampleCode",
				"const class TLitC");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/CommonFramework.h", "KFormatFailed",
				"const class TLitC");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/CommonFramework.h", "KTxtOK",
				"const class TLitC");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/CommonFramework.h", "KTxtPressAnyKey",
				"const class TLitC");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/INC/CommonFramework.h", "console",
				"class CConsoleBase *");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgchar", "char");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgdouble", "double");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgfloat", "float");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgint", "int");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sglong", "long");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sglongdouble",
				"long double");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgschar", "SCHAR");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgshort", "short");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgsint", "SINT");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgslong", "SLONG");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgslonglong",
				"SLONGLONG");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgsshort", "SSHORT");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sguchar", "UCHAR");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sguint", "UINT");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgulong", "ULONG");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgulonglong",
				"ULONGLONG");
		setCUVariableInfo("BlackFlag_rvct.sym",
				"/BlackFlag/SRC/dbg_simple_types.cpp", "sgushort", "USHORT");
		setCUVariableInfo(
				"HelloWorld_rvct_2_2.exe.sym",
				"/home/eswartz/source/runtime-New_configuration/ArmTest/inc/ArmTestApplication.h",
				"KUidArmTestApp", "const class TUid");
		setCUVariableInfo(
				"HelloWorld_rvct_2_2.exe.sym",
				"/src/cedar/generic/base/e32/compsupp/symaehabi/callfirstprocessfn.cpp",
				"KLitUser", "const class TLitC");
		setCUVariableInfo(
				"HelloWorld_rvct_2_2.exe.sym",
				"/home/eswartz/source/runtime-New_configuration/ArmTest/src/ArmTestAppUi.cpp",
				"KFileName", "const class TLitC");
		setCUVariableInfo(
				"HelloWorld_rvct_2_2.exe.sym",
				"/home/eswartz/source/runtime-New_configuration/ArmTest/src/ArmTestAppUi.cpp",
				"KText", "const class TLitC");
		setCUVariableInfo(
				"HelloWorld_rvct_4_0.exe.sym",
				"/home/eswartz/source/runtime-New_configuration/ArmTest/src/ArmTestApplication.cpp",
				"KUidArmTestApp", "const struct TUid");
		setCUVariableInfo(
				"HelloWorld_rvct_4_0.exe.sym",
				"/home/eswartz/source/runtime-New_configuration/ArmTest/src/ArmTestDocument.cpp",
				"mylit", "char[5]");
		setCUVariableInfo(
				"HelloWorld_rvct_4_0.exe.sym",
				"/home/eswartz/source/runtime-New_configuration/ArmTest/src/ArmTestAppUi.cpp",
				"KFileName", "const struct TLitC");
		setCUVariableInfo(
				"HelloWorld_rvct_4_0.exe.sym",
				"/home/eswartz/source/runtime-New_configuration/ArmTest/src/ArmTestAppUi.cpp",
				"KText", "const struct TLitC");
		setCUVariableInfo(
				"HelloWorld_rvct_4_0.exe.sym",
				"M:/dev2/sf/os/kernelhwsrv/kernel/eka/compsupp/symaehabi/callfirstprocessfn.cpp",
				"KLitUser", "const struct TLitC");
		setCUVariableInfo("QtConsole_gcce_343.sym",
				"/Source/GCCE3/GCCE3/main.cpp", "myGlobalInt", "int");
	}

	protected  static void setTypeCount(String sym, int i) {
		TestInfo info = lookupInfo(sym);
		if (info != null)
			info.numberOfTypes = i;
	}

	static {
		setTypeCount("BlackFlagMinGW.exe", 1378);
		setTypeCount("BlackFlag_gcce.sym", 3419);
		setTypeCount("BlackFlag_linuxgcc.exe", 1104);
		setTypeCount("BlackFlag_rvct.sym", 33708);
		setTypeCount("HelloWorld_rvct_2_2.exe.sym", 84689);
		setTypeCount("HelloWorld_rvct_4_0.exe.sym", 31565);
		setTypeCount("QtConsole_gcce_343.sym", 1434);
	}	

	protected  static void setMainBlackFlagFilePath(String sym, String path) {
		TestInfo info = lookupInfo(sym);
		if (info != null)
			info.blackFlagMainFilePath = PathUtils.createPath(path);
	}

	static {
		setMainBlackFlagFilePath("BlackFlagMinGW.exe",
				"C:/wascana/workspace/BlackFlagWascana/src/BlackFlagWascana.cpp");
		setMainBlackFlagFilePath("BlackFlag_gcce.sym",
				"/BlackFlag/SRC/main.cpp");
		setMainBlackFlagFilePath("BlackFlag_linuxgcc.exe",
				"/mydisk/myprog/BlackFlag/src/BlackFlagWascana.cpp");
		setMainBlackFlagFilePath("BlackFlag_rvct.sym",
				"\\BlackFlag\\SRC\\main.cpp");
	}

	private static void setSymbolCount(String sym, int i) {
		TestInfo info = lookupInfo(sym);
		if (info != null)
			info.numberOfSymbols = i;
	}

	static {
		setSymbolCount("BlackFlagMinGW.exe", 2520);
		setSymbolCount("BlackFlag_gcce.sym", 2941);
		setSymbolCount("BlackFlag_linuxgcc.exe", 469);
		setSymbolCount("BlackFlag_rvct.sym", 750);
		setSymbolCount("HelloWorld_rvct_2_2.exe.sym", 194);
		setSymbolCount("HelloWorld_rvct_4_0.exe.sym", 332);
		setSymbolCount("QtConsole_gcce_343.sym", 1008);
	}

	protected static void setPubCount(String sym, int funcnames,
			int funcentries, int varnames, int varentries) {
		TestInfo info = lookupInfo(sym);
		if (info != null) {
			info.numberOfPubFuncNames = funcnames;
			info.numberOfPubFuncEntries = funcentries;
			info.numberOfPubVarNames = varnames;
			info.numberOfPubVarEntries = varentries;
		}
	}

	static {
		setPubCount("BlackFlagMinGW.exe", 209, 241, 52, 52);
		setPubCount("BlackFlag_gcce.sym", 217, 286, 87, 105);
		setPubCount("BlackFlag_linuxgcc.exe", 174, 206, 48, 48);
		setPubCount("BlackFlag_rvct.sym", 100, 101, 51, 87);
		setPubCount("HelloWorld_rvct_2_2.exe.sym", 11, 14, 2, 4);
		setPubCount("HelloWorld_rvct_4_0.exe.sym", 958, 978, 1, 1);
	}

	protected static void addPubFuncs(String sym, Object... names) {
		TestInfo info = lookupInfo(sym);
		if (info != null) {
			for (Object o : names) {
				info.pubFuncs.add(o.toString());
			}
		}
	}

	static {
		addPubFuncs("BlackFlagMinGW.exe", "main", "dbg_watchpoints",
				"Base01::~Base01");
		addPubFuncs("BlackFlag_gcce.sym", "E32Main", "dbg_watchpoints",
				"Base01::~Base01");
		addPubFuncs("BlackFlag_gcce_343.sym", "E32Main", "dbg_watchpoints",
				"Base01::~Base01");
		addPubFuncs("BlackFlag_linuxgcc.exe", "main", "dbg_watchpoints",
				"Base01::~Base01");
		addPubFuncs("BlackFlag_rvct.sym", "E32Main", "dbg_watchpoints",
				"globalDestructorFunc");
		addPubFuncs("HelloWorld_rvct_2_2.exe.sym", "E32Main",
				"CallThrdProcEntry", "CleanupClosePushL");
		addPubFuncs("HelloWorld_rvct_4_0.exe.sym", "E32Main",
				"CallThrdProcEntry", "CleanupClosePushL");
		addPubFuncs("QtConsole_gcce_343.sym", "main", "__gxx_personality_v0",
				"__gnu_unwind_frame");
	}

	protected static void addPubVars(String sym, Object... names) {
		TestInfo info = lookupInfo(sym);
		if (info != null) {
			for (Object o : names) {
				info.pubVars.add(o.toString());
			}
		}
	}

	static {
		addPubVars("BlackFlagMinGW.exe", "vgushort", "gulong", "char_wp");
		addPubVars("BlackFlag_gcce.sym",  "vgushort", "gulong", "g_char");
		addPubVars("BlackFlag_gcce_343.sym",  "vgushort", "gulong", "g_char");
		addPubVars("BlackFlag_linuxgcc.exe", "vgushort", "gulong", "gchar");
		addPubVars("BlackFlag_rvct.sym", "vgushort", "gulong", "g_char");
		addPubVars("HelloWorld_rvct_2_2.exe.sym", "mylit");
		addPubVars("HelloWorld_rvct_4_0.exe.sym", "mylit");
		addPubVars("QtConsole_gcce_343.sym", "myGlobalInt");
	}
	
	@Before
	public void setup() throws Exception {
		// each test relies on starting from scratch
		Symbols.releaseReaderCache();
	}

	protected String getTypeName(IType type) {
		return TypeUtils.getFullTypeName(type);
	}

	/**
	 * Get a low-level DWARF reader for the symbol reader for testing
	 * @param symbolReader
	 * @return
	 */
	protected DwarfDebugInfoProvider getDwarfDebugInfoProvider(
			IEDCSymbolReader symbolReader) {

		if (!(symbolReader instanceof EDCSymbolReader)) 
			return null;
		
		IDebugInfoProvider debugInfoProvider
		  = ((EDCSymbolReader) symbolReader).getDebugInfoProvider();
		if (!(debugInfoProvider instanceof DwarfDebugInfoProvider))
			return null;
		
		DwarfDebugInfoProvider dip
		  = (DwarfDebugInfoProvider) debugInfoProvider;
		
		// do initial parse (so forward types are detected)
		DwarfInfoReader reader = new DwarfInfoReader(dip);
		dip.setParsedInitially();
		reader.parseInitial();
		dip.setParsedForAddresses();
		reader.parseForAddresses(true);
		
		return dip;
	}

	/**
	 * @param symbolReader
	 */
	protected void readFully(IEDCSymbolReader symbolReader) {
		IModuleScope moduleScope = symbolReader.getModuleScope();
		moduleScope.getChildren();
		moduleScope.getVariablesByName(null, false);
		moduleScope.getVariablesByName(null, true);
		moduleScope.getFunctionsByName(null);
		moduleScope.getFunctionByName(null);
	}

	/**
	 * @param symbolReader
	 */
	protected void readRandomly(IEDCSymbolReader symbolReader) {
		IModuleScope moduleScope = symbolReader.getModuleScope();
		IAddress low = moduleScope.getLowAddress();
		IAddress high = moduleScope.getHighAddress();
		
		long range = high.getValue().subtract(low.getValue()).longValue();
		assertTrue(range > 0);
		
		Random random = new Random(0x120044ff);
		
		for (int cnt = 0; cnt < 1000; cnt++) {
			switch (random.nextInt() % 4) {
			case 0: {
				IAddress addr = low.add(random.nextLong() % range);
				moduleScope.getScopeAtAddress(addr);
				break;
			}
			case 1: {
				ICompileUnitScope scope
				  = getRandomCU(symbolReader, random, true);
				if (scope != null) {
					long curange
					  = scope.getHighAddress()
					  		 .getValue()
					  		 .subtract(scope.getLowAddress().getValue())
					  		 .longValue();
					IAddress addr
					  = scope.getLowAddress()
					  		 .add(random.nextLong() % curange);
					scope.getFunctionAtAddress(addr);
				}
				break;
			}
			case 2: {
				ICompileUnitScope scope
				  = getRandomCU(symbolReader, random, false);
				if (scope != null) {
					scope.getVariables();
				}
				break;
			}
			case 3: {
				ICompileUnitScope scope
				  = getRandomCU(symbolReader, random, false);
				if (scope != null) {
					scope.getEnumerators();
				}
				break;
			}
			}
		}
	}
		
	/**
	 * @param symbolReader
	 * @return
	 */
	protected ICompileUnitScope getRandomCU(IEDCSymbolReader symbolReader,
			Random random, boolean withCode) {
		String[] srcs = symbolReader.getSourceFiles();
		int tries = 10;
		Collection<ICompileUnitScope> scopes = null;
		while (tries-- > 0) {
			IPath src
			  = PathUtils.createPath(srcs[(random.nextInt() & 0xfffff)
			                              % srcs.length]);
			scopes = symbolReader.getModuleScope().getCompileUnitsForFile(src);
			if (!scopes.isEmpty())
				break;
		}
		if (scopes == null)
			return null;
		
		ICompileUnitScope last = null;
		for (ICompileUnitScope scope : scopes) {
			if (withCode) {
				long curange
				  = scope.getHighAddress()
				  		 .getValue()
				  		 .subtract(scope.getLowAddress().getValue())
				  		 .longValue();
				if (curange > 0) {
					last = scope;
					if (random.nextBoolean()) {
						return scope;
					}
				}
			}
			else if (random.nextInt(5) == 0) {
				return scope;
			}
		}
		return last;
	}

	/**
	 * @return
	 */
	protected String describeScope(IScope scope) {
		if (scope == null)
			return "";
		String myscope
		  = scope.getClass().getSimpleName() + "["
				+ scope.getName() + "]";
		return describeScope(scope.getParent()) + ": " + myscope;
	}

	/**
	 * @param name
	 * @return
	 */
	protected String stripName(String name) {
		int idx = name.lastIndexOf(':');
		if (idx > 0)
			return name.substring(idx+1);
		else
			return name;
	}

	static class ScopeInfo {
		int address;
		String[] names;
		public ScopeInfo(int address, String[] names) {
			super();
			this.address = address;
			this.names = names;
		}
	}

	protected static void addScopeVars(String sym, String srcFile,
			String function, String className, int address, String... names) {
		TestInfo info = lookupInfo(sym);
		if (info != null) {
			ScopeInfo scope = new ScopeInfo(address, names);
			List<ScopeInfo> scopes;
			String key = srcFile + "|" + function + "|" + className;
			scopes = info.scopeInfos.get(key);
			if (scopes == null) {
				scopes = new ArrayList<ScopeInfo>();
				info.scopeInfos.put(key, scopes);
			}
			scopes.add(scope);
		}
	}

	static {
		/*
		 * The address information for the unit test is gathered like this:
		 * 
		 * 1) Find a function of interest, usually with DW_TAG_lexical_block
		 * entries inside DW_TAG_subroutine.
		 * 
		 * 2) Add a PC for the entry point (DW_AT_low_pc for that subroutine).
		 * Usually DW_TAG_formal_parameter entries are live here. Any
		 * DW_TAG_variable entries with DW_AT_scope==0 (or unspecified) are also
		 * live.
		 * 
		 * 3) Find some interesting points where lexical blocks open and add the
		 * variables from there.
		 * 
		 * 4) Referencing the original source code is useful too, to avoid
		 * getting confused.
		 * 
		 * 5) Finally, ALSO check the DW_AT_location entries for the variables.
		 * If it references a location list (rather than a static expression),
		 * then the compiler is indicating that the variable has a narrower
		 * scope than otherwise indicated. But, that location list may specify
		 * locations *outside* the advertised lexical block scope. So those
		 * should not be considered. Note that RVCT may have bogus lexical block
		 * ranges, but the location lists are useful. GCC-E, on the other hand,
		 * has better lexical block ranges, but never uses location lists.
		 */

		// RVCT has totally broken scope info; all lexical scopes go backwards,
		// so
		// we clamp them to the end of the function

		// entry to function
		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0xb3e0);

		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0xb3e4, "stackArray");
		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0xb3ee, "stackArray" /* , "pstackArray" */);
		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0xb3f0, "stackArray", "pstackArray");
		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0xb3f0 + 2, "stackArray", "pstackArray");
		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0xb3f4, "stackArray", "pstackArray", "i", "value");
		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0xb40a, "stackArray", "pstackArray", "pheapArray",
				"value");

		// GCCE has valid scope info

		// entry to function
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x10854);
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x1085a, "stackArray", "pstackArray", "value",
				"pheapArray", "objArray", "pobj");
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x10876, "stackArray", "pstackArray", "value",
				"pheapArray", "objArray", "pobj", "i");
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x108ac + 2, "stackArray", "pstackArray", "value",
				"pheapArray", "objArray", "pobj");
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x108b8 + 4, "stackArray", "pstackArray", "value",
				"pheapArray", "objArray", "pobj", "j");
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x108f2 + 2, "stackArray", "pstackArray", "value",
				"pheapArray", "objArray", "pobj", "k");
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x10970 + 2, "stackArray", "pstackArray", "value",
				"pheapArray", "objArray", "pobj", "m");
		// show all variables at end of function, but not variable of last for
		// loop scope
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x10a2a, "stackArray", "pstackArray", "value",
				"pheapArray", "objArray", "pobj");
		// but not past, in case instruction stepping at end of function
		addScopeVars("BlackFlag_gcce.sym", "dbg_pointers.cpp", "ptrToArray",
				null, 0x10a2a + 2);

		// entry to function
		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "arrayOfPtrs",
				null, 0xb802);

		addScopeVars("BlackFlag_rvct.sym", "dbg_pointers.cpp", "arrayOfPtrs",
				null, 0xb808, "parray", "pClass2", "i");

		// entry to function
		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"dlist", 0xa82a, "this", "k");

		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"dlist", 0xa82e, "this", "k");
		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"dlist", 0xa830, "this", "found", "k", "search_node");
		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"dlist", 0xa83c, "this", "found", "k", "search_node",
				"__result");

		// entry to function
		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"list", 0xa652, "this", "k");
		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"list", 0xa656, "this", "k");
		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"list", 0xa658, "this", "k", "found", "aux");
		addScopeVars("BlackFlag_rvct.sym", "dbg_linked_lists.cpp", "find",
				"list", 0xa666, "this", "k", "__result", "found", "aux");

		// good lexical scopes here

		// entry to function
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa07a, "this", "key");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa080, "this", "key",
				"direction", "previous");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa082, "this", "key",
				"direction", "previous");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa082, "this", "key",
				"direction", "previous");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa092, "this", "key",
				"direction", "previous", "theNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa098, "this", "key",
				"__result", "direction", "previous", "theNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa0f2, "this", "key",
				"direction", "previous", "theNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa0f8, "this", "key",
				"direction", "previous", "theNode", "subtree");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa11e, "this", "key",
				"direction", "previous", "theNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa138, "this", "key",
				"direction", "previous", "theNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa164, "this", "key",
				"direction", "previous", "theNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa166, "this", "key",
				"direction", "previous", "theNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa16c, "this", "key",
				"direction", "previous", "theNode", "pcurrentNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa1ea, "this", "key",
				"direction", "previous", "theNode", "next", "pcurrentNode");
		addScopeVars("BlackFlag_rvct.sym", "dbg_binary_tree.cpp",
				"DeleteFromTree", "binary_tree", 0xa21e, "this", "key",
				"direction", "previous", "theNode");

		// enty to function
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x8386, "this", "item");
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x8394, "this", "item");
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x8398, "this", "item", "newmax");
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x83a6, "this", "item", "newmax", "copy");
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x83a8, "this", "item", "newmax", "copy", "i");
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x83b0, "this", "item", "newmax", "copy", "i");
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x83bc, "this", "item", "newmax", "copy");
		addScopeVars("SimpleCpp_rvct_22.sym", "Templates.h", "add", "List",
				0x83cc);

		// enty to function
		addScopeVars("SimpleCpp_rvct_40.sym", "Templates.cpp", "add", "List",
				0x835a, "this", "item", "__result$$1$$_Znaj");
		addScopeVars("SimpleCpp_rvct_40.sym", "Templates.cpp", "add", "List",
				0x836c, "this", "item", "newmax", "__result$$1$$_Znaj");
		addScopeVars("SimpleCpp_rvct_40.sym", "Templates.cpp", "add", "List",
				0x837a, "this", "item", "newmax", "copy", "__result$$1$$_Znaj");
		addScopeVars("SimpleCpp_rvct_40.sym", "Templates.cpp", "add", "List",
				0x837c, "this", "item", "newmax", "copy", "i",
				"__result$$1$$_Znaj");
		addScopeVars("SimpleCpp_rvct_40.sym", "Templates.cpp", "add", "List",
				0x83a0, "this", "item", "__result$$1$$_Znaj");

		// entry to function
		addScopeVars("SimpleCpp_gcc_x86.exe", "Templates.cpp", "add", "List",
				0x80487a6, "this", "item");
		addScopeVars("SimpleCpp_gcc_x86.exe", "Templates.cpp", "add", "List",
				0x80487c0, "this", "item", "newmax", "copy");
		addScopeVars("SimpleCpp_gcc_x86.exe", "Templates.cpp", "add", "List",
				0x80487e9, "this", "item", "newmax", "copy", "i");
		addScopeVars("SimpleCpp_gcc_x86.exe", "Templates.cpp", "add", "List",
				0x804881e + 1, "this", "item", "newmax", "copy");
		// show all locals at end of function
		addScopeVars("SimpleCpp_gcc_x86.exe", "Templates.cpp", "add", "List",
				0x8048854, "this", "item", "newmax", "copy");
		// but not past
		addScopeVars("SimpleCpp_gcc_x86.exe", "Templates.cpp", "add", "List",
				0x8048854 + 1, "this", "item");
	}

	/**
	 * 
	 */
	protected static class SymbolInfo {
		public final String name;
		public final String address;
		public final long size;
		public SymbolInfo(String name, String string, long size){
			this.name = name;
			this.address = string;
			this.size = size;
		}
		@Override
		public String toString(){
			return name + ", " + address + ", " + size;
		}
	}

	/**
	 * @param sym
	 * @param symbols
	 */
	protected static void addSymbols(String sym,SymbolInfo... symbols){
		TestInfo info = lookupInfo(sym);
		assertNotNull(info);
		Collection<SymbolInfo> symInfos = info.symbols;
		if (symInfos == null){
			symInfos = new ArrayList<SymbolInfo>(symbols.length);
			info.symbols = symInfos;
		}
		for (SymbolInfo symInfo : symbols){
			symInfos.add(symInfo);
		}
	}

	static {
		addSymbols("BlackFlag_linuxgcc.exe",
				   new SymbolInfo("vgfloat", "08050300", 4),
				   new SymbolInfo("_Z6arraysv", "0804a09c", 629),
				   new SymbolInfo("_ZN4list14removeFromBackEv", "0804ac10", 102),
				   new SymbolInfo("_ZTI6DerDer", "0804dff4", 12),
				   new SymbolInfo("_GLOBAL__I_gchar", "08048864", 28));
		addSymbols("SimpleCpp_gcc_x86.exe",
				   new SymbolInfo("dtor_idx.6637","0804a024",4),
				   new SymbolInfo("_Z41__static_initialization_and_destruction_0ii","0804853f",35),
				   new SymbolInfo("main","080485be",31),
				   new SymbolInfo("__libc_csu_fini","08048860",5),
				   new SymbolInfo("_ZN4ListIcE3addEc","08048602",174));
		addSymbols("QtConsole_gcce_343.sym",
				   new SymbolInfo("KErrNone","00009188",4),
				   new SymbolInfo("KDriveAttRom","0000939c",4),
				   new SymbolInfo("_Z21base_of_encoded_valuehP15_Unwind_Context","00008290",116),
				   new SymbolInfo("next_unwind_byte","00008ae8",88),
				   new SymbolInfo("KLitUser","00009638",16),
				   //Address 14 rather than 15 due to ARM thumb bit
				   new SymbolInfo("RunThread","00008014",48));
	}

	/**
	 * @param scope
	 * @return
	 */
	protected String getClassFor(IFunctionScope scope) {
		for (IVariable arg : scope.getParameters()) {
			if (arg.getName().equals("this")) {
				ICompositeType ct
				  = (ICompositeType) TypeUtils.getBaseType(arg.getType());
				return ct.getName();
			}
		}
		return null;
	}
}