2012-10-12  Jeff Johnston  <jjohnstn@redhat.com>

	* resources/basicTest/.cproject: New file.
	* resources/basicTest/.project: New file.
	* resources/basicTest/test\ suppfile.supp: New file.
	* resources/basicTest/test.c: New file.
	* resources/basicTest/testsuppfile.supp: New file.
	* resources/basicTest/testsuppfile2.supp: New file.
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/ShortcutTest.java: New file.
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/ValgrindTestMassifLaunchShortcut.java: New file.
	* META-INF/MANIFEST.MF: Add dependency on org.eclipse.ui. 
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/AllTests.java: Add launch shortcut test.
	
2011-05-20  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/ExportWizardTest.java (testExportNoLaunch): Move
	deletion of launch datas here and remove launch directory altogether.
	(testExportNoLaunch): Run test in Display thread.

2011-05-20  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/ChartTests.java (testEditorName): Be ready
	for the editor to have a numeric qualifier as other tests don't always close the editor properly.
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/ExportWizardTest.java (setUp): Remove
	the .metadata launches before running this test.

2011-03-29  Andrew Overholt  <overholt@redhat.com>

	* META-INF/MANIFEST.MF: Add requirements on
	org.eclipse.ui.ide.application and
	org.eclipse.cdt.managedbuilder.gnu.ui to make tests pass with only
	required bundles present.

2010-08-03  Elliott Baron  <ebaron@fedoraproject.org>

	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/ChartExportTest.java: Pass MassifViewPart. 

2010-07-26  Elliott Baron  <ebaron@fedoraproject.org>

	* META-INF/MANIFEST.MF: Bump version to 0.7.0.

2010-05-26  Elliott Baron  <ebaron@fedoraproject.org>

	Bug #314376
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/DoubleClickTest.java (doDoubleClick): Change access to TreeViewer.
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/ExpandCollapseTest.java (testExpand): Likewise.
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/TreeTest.java (testTreeNodes): Likewise.
	(testNoDetailed): Likewise.

2009-12-22  Roland Grunberg  <rgrunber@redhat.com>

	* META-INF/MANIFEST.MF: Make necessary changes for switch from JUnit 3 to JUnit 4.

2009-09-28  Elliott Baron  <ebaron@fedoraproject.org>

	* valgrindFiles: Regenerated.
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests/LaunchConfigTabTest.java: Alignment option changes.

2009-08-11  Elliott Baron  <ebaron@redhat.com>

	* src/org/eclipse/linuxtools/valgrind/massif: Removed.
	* META-INF/MANIFEST.MF: Bump version to 0.3.0.

2009-08-07  Andrew Overholt  <overholt@redhat.com>

	Bug #285861

	* plugin.properties: Change Provider to Eclipse.

2009-07-30  Elliott Baron  <ebaron@redhat.com>

	* src/org/eclipse/linuxtools/valgrind/massif/tests: Removed.
	* src/org/eclipse/linuxtools/internal/valgrind/massif/tests: New package.
	* .project: Added API analysis.
	* META-INF/MANIFEST.MF: Export internal package.
	* test.xml: Update class references. 

2009-06-23  Elliott Baron  <ebaron@redhat.com>

	* ChartExportTest.java (testChartExportSVG): Fix test name.
	* MassifTestToolPage.java: Removed.
	* AbstractMassifTest.java: Remove reference to TestToolPage.
	* ExportWizardTest.java (createWizard): Use actual ExportWizard.
	* LaunchConfigTabTest.java: Use actual ToolPage.

2009-06-22  Elliott Baron  <ebaron@redhat.com>

	* ChartExportTest.java: New file.
	* META-INF/MANIFEST.MF: New deps.
	* AllTests.java (suite): Added ChartExportTest.

2009-04-30  Elliott Baron  <ebaron@redhat.com>

	* MultiProcessTest.java: Delete referenced project.

2009-04-23  Elliott Baron  <ebaron@redhat.com>

	* SortTest.java: New file.
	* AllTests.java (suite): Added SortTest.

2009-04-21  Elliott Baron  <ebaron@redhat.com>

	* BasicMassifTest.java (tearDown): Call super last.
	* ChartTests.java (tearDown): Likewise.
	* DoubleClickTest.java (tearDown): Likewise.
	* ExpandCollapseTest.java (tearDown): Likewise.
	* ExportWizardTest.java (tearDown): Likewise.
	* LaunchConfigTabTest.java (tearDown): Likewise.
	* MultiProcessTest.java (tearDown): Likewise.
	* TreeTest.java (tearDown): Likewise.
	* test.xml: Fix classname in cleanup target.

2009-04-03  Elliott Baron  <ebaron@redhat.com>

	* META-INF/MANIFEST.MF: 0.2.0 version.
	* AbstractMassifTest.java (checkFile): New helper.
	(checkLine): Likewise.
	* ChartTests.java (testChartLocationsDialog): New test. 
	* DoubleClickTest.java (testDoubleClickLine): Changes from refactoring.
	(testDoubleClickFile): Likewise.

2009-03-31  Elliott Baron  <ebaron@redhat.com>

	* ExpandCollapseTest.java: New file.
	* AllTests.java (suite): Added ExpandCollapseTest.

2009-03-26  Elliott Baron  <ebaron@redhat.com>

	* resources/multiProcTest: New test project.
	* MultiProcessTest.java: New file.
	* AllTests.java (suite): Added MultiProcessTest.

2009-03-25  Elliott Baron  <ebaron@redhat.com>

	* ExportWizardTest.java: New file.
	* AllTests.java (suite): Added ExportWizardTest.

2009-03-18  Elliott Baron  <ebaron@redhat.com>

	* BasicMassifTest.java (setUp): Refactoring from profiling.tests.
	* ChartTests.java (setUp): Likewise.
	* DoubleClickTest.java (setUp): Likewise.
	* LaunchConfigTabTest.java (setUp): Likewise.
	* TreeTest.java (setUp): Likewise.

2009-03-11  Elliott Baron  <ebaron@redhat.com>

	* AbstractMassifTest.java: Pass tool page to superclass.
	* AllTests.java: Added LaunchConfigTabTest to suite.
	* BasicMassifTest.java: Call super on setUp tearDown.
	* ChartTests.java: Likewise.
	* DoubleClickTest.java: Likewise.
	* TreeTest.java: Likewise.
	* LaunchConfigTabTest.java: New file.
	* MassifTestToolPage.java: New file.
	* META-INF/MANIFEST.MF: Added debug.core.model dependency.

2009-02-25  Elliott Baron  <ebaron@redhat.com>

	* valgrindFiles/: Saved output from actual valgrind run. Used for testing
	in environments without Valgrind.
	* build.properties: Added valgrindFiles.
	* META-INF/MANIFEST.MF: New dependencies.
	* AbstractMassifTest.java: Extracted superclass. 
	* BasicMassifTest.java: Use new launch method.
	* DoubleClickTest.java: Likewise.
	* TreeTest.java: Likewise.
	* ChartTests.java: Likewise. New interactivity test.

2009-02-12  Elliott Baron  <ebaron@redhat.com>

	* META-INF/MANIFEST.MF: Removed core.util import.
	* AbstractMassifTest.java: Refactoring.
	* ChartTests.java: Refactoring. 
	* DoubleClickTest.java: Modified file comparison.
	* TreeTest.java: Refactoring.

2009-02-03  Elliott Baron  <ebaron@redhat.com>

	* META-INF/MANIFEST.MF: Require-Bundle for JUnit < 4.0.0

2009-02-03  Andrew Overholt  <overholt@redhat.com>

	* META-INF/MANIFEST.MF: Move JUnit from Import-package to Require-bundle to see
	if this fixes the JUnit4 vs. JUnit 3.x issues.
	* test.xml: plugin-name -> massif-plugin-name.

2009-02-02  Andrew Overholt  <overholt@redhat.com>

	* build.properties: Add test.xml.
	* test.xml: Update.

2009-01-13  Elliott Baron  <ebaron@redhat.com>

	* AllTests: ChartTests added to suite.

2009-01-05  Elliott Baron  <ebaron@redhat.com>

	* META-INF/MANIFEST.MF: Changed version to 0.1.0.
	* build.properties: Include about.html.
	* about.html: Added.
