| /** |
| * Copyright (c) 2009-2010 Thales Corporate Services S.A.S. |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-v2.0 |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Thales Corporate Services S.A.S - initial API and implementation |
| */ |
| package org.eclipse.egf.core.test; |
| |
| import java.io.BufferedReader; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.io.PrintStream; |
| import java.io.StringReader; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.egf.core.producer.InvocationException; |
| import org.eclipse.egf.model.fcore.Activity; |
| import org.eclipse.egf.producer.EGFProducerPlugin; |
| import org.eclipse.egf.producer.manager.ActivityManagerProducer; |
| import org.eclipse.egf.producer.manager.IActivityManager; |
| import org.eclipse.emf.common.util.Diagnostic; |
| import org.eclipse.emf.ecore.util.Diagnostician; |
| |
| import test.ConsoleOutputTestResult; |
| import test.EGFTestCase; |
| import test.ExceptionTestResult; |
| import test.FileOutputTestResult; |
| import test.TestResult; |
| import test.ValidationErrorTestResult; |
| |
| /** |
| * @author Matthieu Helleboid |
| * |
| */ |
| public class ModelTestCase extends junit.framework.TestCase { |
| |
| private EGFTestCase testCase; |
| |
| public ModelTestCase(EGFTestCase testCase) { |
| super(testCase.getName()); |
| this.testCase = testCase; |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| @Override |
| protected void runTest() throws Throwable { |
| PrintStream out = System.out; |
| |
| ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); |
| System.setOut(new PrintStream(byteArrayOutputStream)); |
| |
| Activity activity = testCase.getActivity(); |
| TestResult result = testCase.getResult(); |
| |
| try { |
| runActivity(activity, result); |
| handleConsoleOutputTestResult(byteArrayOutputStream, result); |
| handleFileOutputTestResult(result); |
| } catch (Exception e) { |
| handleExceptionTestResult(result, e); |
| } finally { |
| System.setOut(out); |
| } |
| } |
| |
| private void handleFileOutputTestResult(TestResult result) { |
| if (result instanceof FileOutputTestResult) { |
| FileOutputTestResult fileOutputTestResult = (FileOutputTestResult) result; |
| |
| String expectedString = fileOutputTestResult.getText(); |
| String iFilePath = fileOutputTestResult.getIFilePath(); |
| IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(iFilePath)); |
| |
| if (!file.exists()) |
| fail("The expected file " + iFilePath + " should exist"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| long fileLength = new File(file.getRawLocationURI()).length(); |
| // If both are null, it's ok |
| if (expectedString == null && fileLength == 0) |
| return; |
| |
| // If one is not null, it's not ok |
| assertNotSame("The file " + iFilePath + " should not be empty.", fileLength, 0); //$NON-NLS-1$ //$NON-NLS-2$ |
| assertNotNull("The file " + iFilePath + " should be empty.", expectedString); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| try { |
| BufferedReader expectedReader = new BufferedReader(new StringReader(expectedString)); |
| BufferedReader resultReader = new BufferedReader(new InputStreamReader(file.getContents())); |
| compareContent(expectedReader, resultReader); |
| } catch (CoreException e) { |
| fail("The expected file " + iFilePath + " cannot be read : " + e.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| } |
| |
| private void handleConsoleOutputTestResult(ByteArrayOutputStream byteArrayOutputStream, TestResult result) { |
| if (result instanceof ConsoleOutputTestResult) { |
| ConsoleOutputTestResult consoleOutputTestResult = (ConsoleOutputTestResult) result; |
| |
| String expectedString = consoleOutputTestResult.getText(); |
| String resultString = byteArrayOutputStream.toString(); |
| |
| // If both are null, it's ok |
| if (expectedString == null && resultString == null) |
| return; |
| |
| // If one is not null, it's not ok |
| assertNotNull("There is no output but a result was expected <[" + expectedString + "]>", resultString); //$NON-NLS-1$ //$NON-NLS-2$ |
| assertNotNull("There is a output but no result was expected <[" + resultString + "]>", expectedString); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| BufferedReader expectedReader = new BufferedReader(new StringReader(expectedString)); |
| BufferedReader resultReader = new BufferedReader(new StringReader(resultString)); |
| |
| compareContent(expectedReader, resultReader); |
| } |
| } |
| |
| private void compareContent(BufferedReader expectedReader, BufferedReader resultReader) { |
| // will compare line by line |
| BufferedReader expectedStringReader = expectedReader; |
| BufferedReader resultStringReader = resultReader; |
| int line = 1; |
| try { |
| while (true) { |
| String expectedStringLine = expectedStringReader.readLine(); |
| String resultStringLine = resultStringReader.readLine(); |
| |
| // If both are null, it's ok |
| if (expectedStringLine == null && resultStringLine == null) |
| return; |
| |
| assertEquals("at line " + line++, expectedStringLine, resultStringLine); //$NON-NLS-1$ |
| } |
| } catch (Exception e) { |
| fail(e.getMessage()); |
| } finally { |
| try { |
| expectedStringReader.close(); |
| } catch (IOException e) { |
| fail(e.getMessage()); |
| } |
| try { |
| resultStringReader.close(); |
| } catch (IOException e) { |
| fail(e.getMessage()); |
| } |
| } |
| } |
| |
| private void handleExceptionTestResult(TestResult result, Exception e) { |
| if (result instanceof ExceptionTestResult) { |
| ExceptionTestResult exceptionTestResult = (ExceptionTestResult) result; |
| assertEquals(exceptionTestResult.getExceptionClass(), e.getClass()); |
| if (exceptionTestResult.getExceptionMessage() != null) |
| assertEquals(exceptionTestResult.getExceptionMessage(), e.getMessage()); |
| } else if (result != null) { |
| fail("No exceptionTestResult was attended : <[" + e.getClass().getName() + " " + e.getMessage() + "]>"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| } |
| |
| private void handleValidationErrorTestResult(TestResult result, Diagnostic diagnostic) { |
| if (result instanceof ValidationErrorTestResult) { |
| ValidationErrorTestResult validationErrorTestResult = (ValidationErrorTestResult) result; |
| assertEquals(validationErrorTestResult.getSeverity().getValue(), diagnostic.getSeverity()); |
| } else if (result != null) { |
| fail("No validationErrorTestResult was attended : <[" + diagnostic.toString() + "]>"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| |
| private void runActivity(Activity activity, TestResult result) throws CoreException, InvocationException { |
| Diagnostician diagnostician = new Diagnostician(); |
| if (activity == null) |
| fail("Cannot execute a test if the activity is null."); //$NON-NLS-1$ |
| Diagnostic diagnostic = diagnostician.validate(activity); |
| |
| if (diagnostic.getSeverity() != Diagnostic.OK) |
| handleValidationErrorTestResult(result, diagnostic); |
| |
| ActivityManagerProducer<Activity> producer = EGFProducerPlugin.getActivityManagerProducer(activity); |
| IActivityManager<Activity> manager = producer.createActivityManager(activity); |
| |
| try { |
| manager.initializeContext(); |
| manager.invoke(new NullProgressMonitor()); |
| } finally { |
| manager.dispose(); |
| } |
| } |
| |
| } |